diff --git a/amazon-product-api/amazon-product-api-tests.ts b/amazon-product-api/amazon-product-api-tests.ts
new file mode 100644
index 0000000000..b98e15710f
--- /dev/null
+++ b/amazon-product-api/amazon-product-api-tests.ts
@@ -0,0 +1,84 @@
+/// <reference path="./amazon-product-api.d.ts" />
+/// <reference path="../node/node.d.ts"/>
+
+import amazon = require('amazon-product-api');
+
+var client = amazon.createClient({
+    awsId: process.env.AWS_ACCESS_KEY_ID,
+    awsSecret: process.env.AWS_SECRET,
+    awsTag: process.env.AWS_ASSOCIATE_TAG
+});
+
+
+// Item Search
+
+var searchQuery = {
+    director: 'Quentin Tarantino',
+    actor: 'Samuel L. Jackson',
+    searchIndex: 'DVD',
+    audienceRating: 'R',
+    responseGroup: 'ItemAttributes,Offers,Images'
+};
+
+client.itemSearch(searchQuery).then((results) => {
+    console.log(getResultCount(results) + " search results");
+}).catch(function(err){
+    console.log(err);
+});
+
+client.itemSearch(searchQuery, (err, results) => {
+    if(err) {
+        console.log(err);
+        return;
+    }
+    console.log(getResultCount(results) + " search results");
+});
+
+
+// Item Lookup
+
+var lookupQuery = {
+    itemId: 'B00008OE6I',
+    idType: 'ASIN',
+    responseGroup: 'OfferFull',
+    Condition: 'All'
+};
+
+client.itemLookup(lookupQuery).then((results) => {
+    console.log(getResultCount(results) + " lookup results");
+}).catch(function(err){
+    console.log(err);
+});
+
+client.itemLookup(lookupQuery, (err, results) => {
+    if(err) {
+        console.log(err);
+        return;
+    }
+    console.log(getResultCount(results) + " lookup results");
+});
+
+// Browse Node Lookup
+
+var nodeLookupQuery = {
+    browseNodeId: '2625373011'
+};
+
+client.browseNodeLookup(nodeLookupQuery).then((results) => {
+    console.log(getResultCount(results) + " node lookup results");
+}).catch(function(err){
+    console.log(err);
+});
+
+client.browseNodeLookup(nodeLookupQuery, (err, results) => {
+    if(err) {
+        console.log(err);
+        return;
+    }
+
+    console.log(getResultCount(results) + " node lookup results");
+});
+
+function getResultCount(results: Object[]) {
+    return results != undefined ? results.length : 0;
+}
\ No newline at end of file
diff --git a/amazon-product-api/amazon-product-api.d.ts b/amazon-product-api/amazon-product-api.d.ts
new file mode 100644
index 0000000000..fc84dcc090
--- /dev/null
+++ b/amazon-product-api/amazon-product-api.d.ts
@@ -0,0 +1,27 @@
+// Type definitions for amazon-product-api
+// Project: https://github.com/t3chnoboy/amazon-product-api
+// Definitions by: Matti Lehtinen <https://github.com/MattiLehtinen/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../es6-promise/es6-promise.d.ts"/>
+
+declare module "amazon-product-api" {
+
+    interface ICredentials {
+        awsId: string,
+        awsSecret: string,
+        awsTag: string
+    }
+
+    interface IAmazonProductQueryCallback {
+        (err: string, results: Object[]): void;
+    }
+
+    interface IAmazonProductClient {
+        itemSearch(query: any, callback?: IAmazonProductQueryCallback) : Promise<Object[]>;
+        itemLookup(query: any, callback?: IAmazonProductQueryCallback) : Promise<Object[]>;
+        browseNodeLookup(query: any, callback?: IAmazonProductQueryCallback) : Promise<Object[]>;
+    }
+
+    export function createClient(credentials:ICredentials) : IAmazonProductClient;
+}
diff --git a/amplify-deferred/amplify-deferred-tests.ts b/amplify-deferred/amplify-deferred-tests.ts
new file mode 100644
index 0000000000..957941cd29
--- /dev/null
+++ b/amplify-deferred/amplify-deferred-tests.ts
@@ -0,0 +1,265 @@
+/// <reference path="amplify-deferred.d.ts" />
+/// <reference path="../jquery/jquery.d.ts" />
+
+// Copied examples directly from AmplifyJs site
+
+// Subscribe and publish with no data
+
+amplify.subscribe("nodataexample", function () {
+    alert("nodataexample topic published!");
+});
+
+// Subscribe and publish with data
+
+amplify.publish("nodataexample");
+
+amplify.subscribe("dataexample", function (data) {
+    alert(data.foo); // bar
+});
+
+
+amplify.publish("dataexample", { foo: "bar" });
+
+amplify.subscribe("dataexample2", function (param1, param2) {
+    alert(param1 + param2); // barbaz
+});
+
+//...
+
+amplify.publish("dataexample2", "bar", "baz");
+
+// Subscribe and publish with context and data
+
+amplify.subscribe("datacontextexample", $("p:first"), function (data) {
+    this.text(data.exampleText); // first p element would have "foo bar baz" as text
+});
+
+amplify.publish("datacontextexample", { exampleText: "foo bar baz" });
+
+// Subscribe to a topic with high priority
+
+amplify.subscribe("priorityexample", function (data) {
+    alert(data.foo);
+});
+
+amplify.subscribe("priorityexample", function (data) {
+    if (data.foo === "oops") {
+        return false;
+    }
+}, 1);
+
+
+// Store data with amplify storage picking the default storage technology:
+
+amplify.publish("priorityexample", { foo: "bar" });
+amplify.publish("priorityexample", { foo: "oops" });
+
+amplify.store("storeExample1", { foo: "bar" });
+amplify.store("storeExample2", "baz");
+// retrieve the data later via the key
+var myStoredValue = amplify.store("storeExample1"),
+    myStoredValue2 = amplify.store("storeExample2"),
+    myStoredValues = amplify.store();
+myStoredValue.foo; // bar
+myStoredValue2; // baz
+myStoredValues.storeExample1.foo; // bar
+myStoredValues.storeExample2; // baz
+
+// Store data explicitly with session storage
+
+amplify.store.sessionStorage("explicitExample", { foo2: "baz" });
+// retrieve the data later via the key
+var myStoredValue2 = amplify.store.sessionStorage("explicitExample");
+myStoredValue2.foo2; // baz
+
+
+// REQUEST
+
+// Set up and use a request utilizing Ajax
+
+
+amplify.request.define("ajaxExample1", "ajax", {
+    url: "/myApiUrl",
+    dataType: "json",
+    type: "GET"
+});
+
+// later in code
+amplify.request("ajaxExample1", function (data) {
+    data.foo; // bar
+});
+
+// Set up and use a request utilizing Ajax and Caching
+
+amplify.request.define("ajaxExample2", "ajax", {
+    url: "/myApiUrl",
+    dataType: "json",
+    type: "GET",
+    cache: "persist"
+});
+
+// later in code
+amplify.request("ajaxExample2", function (data) {
+    data.foo; // bar
+});
+
+// a second call will result in pulling from the cache
+amplify.request("ajaxExample2", function (data) {
+    data.baz; // qux
+})
+
+// Set up and use a RESTful request utilizing Ajax
+
+amplify.request.define("ajaxRESTFulExample", "ajax", {
+    url: "/myRestFulApi/{type}/{id}",
+    type: "GET"
+})
+
+// later in code
+amplify.request("ajaxRESTFulExample",
+    {
+        type: "foo",
+        id: "bar"
+    },
+    function (data) {
+        // /myRESTFulApi/foo/bar was the URL used
+        data.foo; // bar
+    }
+    );
+
+// POST data with Ajax
+
+amplify.request.define("ajaxPostExample", "ajax", {
+    url: "/myRestFulApi",
+    type: "POST"
+})
+
+// later in code
+amplify.request("ajaxPostExample",
+    {
+        type: "foo",
+        id: "bar"
+    },
+    function (data) {
+        data.foo; // bar
+    }
+    );
+// Using data maps
+
+//  When searching Twitter, the key for the search phrase is q.If we want a more descriptive name, such as term, we can use a data map:
+
+amplify.request.define("twitter-search", "ajax", {
+    url: "http://search.twitter.com/search.json",
+    dataType: "jsonp",
+    dataMap: {
+        term: "q"
+    }
+});
+
+amplify.request("twitter-search", { term: "amplifyjs" });
+
+// Similarly, we can create a request that searches for mentions, by accepting a username:
+
+amplify.request.define("twitter-mentions", "ajax", {
+    url: "http://search.twitter.com/search.json",
+    dataType: "jsonp",
+    dataMap: function (data) {
+        return {
+            q: "@" + data.user
+        };
+    }
+});
+
+amplify.request("twitter-mentions", { user: "amplifyjs" });
+
+// Setting up and using decoders
+
+//Example:
+
+var appEnvelopeDecoder: amplifyDecoder = function (data, status, xhr, success, error) {
+    if (data.status === "success") {
+        success(data.data);
+    } else if (data.status === "fail" || data.status === "error") {
+        error(data.message, data.status);
+    } else {
+        error(data.message, "fatal");
+    }
+};
+
+//a new decoder can be added to the amplifyDecoders interface
+interface amplifyDecoders {
+    appEnvelope: amplifyDecoder;
+}
+
+amplify.request.decoders.appEnvelope = appEnvelopeDecoder;
+
+//but you can also just add it via an index
+amplify.request.decoders['appEnvelopeStr'] = appEnvelopeDecoder;
+
+
+amplify.request.define("decoderExample", "ajax", {
+    url: "/myAjaxUrl",
+    type: "POST",
+    decoder: "appEnvelope"
+});
+
+amplify.request({
+    resourceId: "decoderExample",
+    success: function (data) {
+        data.foo; // bar
+    },
+    error: function (message, level) {
+        alert("always handle errors with alerts.");
+    }
+});
+
+// POST with caching and single - use decoder
+
+// Example:
+
+amplify.request.define("decoderSingleExample", "ajax", {
+    url: "/myAjaxUrl",
+    type: "POST",
+    decoder: function (data, status, xhr, success, error) {
+        if (data.status === "success") {
+            success(data.data);
+        } else if (data.status === "fail" || data.status === "error") {
+            error(data.message, data.status);
+        } else {
+            error(data.message, "fatal");
+        }
+    }
+});
+
+amplify.request({
+    resourceId: "decoderSingleExample",
+    success: function (data) {
+        data.foo; // bar
+    },
+    error: function (message, level) {
+        alert("always handle errors with alerts.");
+    }
+});
+// Handling Status
+// Status in Success and Error Callbacks
+
+// amplify.request comes with built in support for status.The status parameter appears in the default success or error callbacks when using an ajax definition.
+
+amplify.request.define("statusExample1", "ajax", {
+    //...
+});
+
+amplify.request({
+    resourceId: "statusExample1",
+    success: function (data, status) {
+    },
+    error: function (data, status) {
+    }
+});
+
+amplify.request({
+    resourceId: "statusExample1"
+}).done(function (data, status) {
+}).fail(function (data, status) {
+}).always(function (data, status) { });
+
diff --git a/socket.io/legacy/socket.io-0.9-tests.ts.tscparams b/amplify-deferred/amplify-deferred-tests.ts.tscparams
similarity index 100%
rename from socket.io/legacy/socket.io-0.9-tests.ts.tscparams
rename to amplify-deferred/amplify-deferred-tests.ts.tscparams
diff --git a/amplify-deferred/amplify-deferred.d.ts b/amplify-deferred/amplify-deferred.d.ts
new file mode 100644
index 0000000000..11e6d05e0f
--- /dev/null
+++ b/amplify-deferred/amplify-deferred.d.ts
@@ -0,0 +1,182 @@
+// Type definitions for AmplifyJs 1.1.0 using JQuery Deferred
+// Project: http://amplifyjs.com/
+// Definitions by: Jonas Eriksson <https://github.com/joeriks/>, Laurentiu Stamate <https://github.com/laurentiustamate94>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../jquery/jquery.d.ts" />
+
+interface amplifyRequestSettings {
+    resourceId: string;
+    data?: any;
+    success?: (...args: any[]) => void;
+    error?: (...args: any[]) => void;
+}
+
+interface amplifyDecoder {
+    (
+        data?: any,
+        status?: string,
+        xhr?: JQueryXHR,
+        success?: (...args: any[]) => void,
+        error?: (...args: any[]) => void
+        ): void
+}
+
+interface amplifyDecoders {
+    [decoderName: string]: amplifyDecoder;
+    jsSend: amplifyDecoder;
+}
+
+interface amplifyAjaxSettings extends JQueryAjaxSettings {
+    cache?: any;
+    dataMap?: {} | ((data: any) => {});
+    decoder?: any /* string or amplifyDecoder */;
+}
+
+interface amplifyRequest {
+
+    /***
+    * Request a resource.
+    * resourceId: Identifier string for the resource.
+    * data: A set of key/value pairs of data to be sent to the resource.
+    * callback: A function to invoke if the resource is retrieved successfully.
+    */
+    (resourceId: string, hash?: any, callback?: Function): JQueryPromise<any>;
+
+    /***
+    * Request a resource.
+    * settings: A set of key/value pairs of settings for the request.
+    *   resourceId: Identifier string for the resource.
+    *   data (optional): Data associated with the request.
+    *   success (optional): Function to invoke on success.
+    *   error (optional): Function to invoke on error.
+    */
+    (settings: amplifyRequestSettings): JQueryPromise<any>;
+
+    /***
+    * Define a resource.
+    * resourceId: Identifier string for the resource.
+    * requestType: The type of data retrieval method from the server. See the request types sections for more information.
+    * settings: A set of key/value pairs that relate to the server communication technology. The following settings are available:
+    *   Any settings found in jQuery.ajax().
+    *   cache: See the cache section for more details.
+    *   decoder: See the decoder section for more details.
+    */
+    define(resourceId: string, requestType: string, settings?: amplifyAjaxSettings): void;
+
+    /***
+    * Define a custom request.
+    * resourceId: Identifier string for the resource.
+    * resource: Function to handle requests. Receives a hash with the following properties:
+    *   resourceId: Identifier string for the resource.
+    *   data: Data provided by the user.
+    *   success: Callback to invoke on success.
+    *   error: Callback to invoke on error.
+    */
+    define(resourceId: string, resource: (settings: amplifyRequestSettings) => void): void;
+
+    decoders: amplifyDecoders;
+    cache: any;
+}
+
+interface amplifySubscribe {
+    /***
+    * Subscribe to a message.
+    * topic: Name of the message to subscribe to.
+    * callback: Function to invoke when the message is published.
+    */
+    (topic: string, callback: Function): void;
+    /***
+    * Subscribe to a message.
+    * topic: Name of the message to subscribe to.
+    * context: What this will be when the callback is invoked.
+    * callback: Function to invoke when the message is published.
+    * [priority]: Priority relative to other subscriptions for the same message. Lower values have higher priority. Default is 10.
+    */
+    (topic: string, context: any, callback: Function, priority?: number): void;
+    /***
+    * Subscribe to a message.
+    * topic: Name of the message to subscribe to.
+    * callback: Function to invoke when the message is published.
+    * [priority]: Priority relative to other subscriptions for the same message. Lower values have higher priority. Default is 10.
+    */
+    (topic: string, callback: Function, priority?: number): void;
+}
+interface amplifyStorageTypeStore {
+    /***
+    * Stores a value for a given key using the default storage type.
+    * 
+    * key: Identifier for the value being stored.
+    * value: The value to store. The value can be anything that can be serialized as JSON.
+    * [options]: A set of key/value pairs that relate to settings for storing the value.
+    */
+    (key: string, value: any, options?: any): void;
+
+    /***
+    * Gets a stored value based on the key.
+    */
+    (key: string): any;
+
+    /***
+    * Gets a hash of all stored values.
+    */
+    (): any;
+}
+
+interface amplifyStore extends amplifyStorageTypeStore {
+
+    /*** 
+    * IE 8+, Firefox 3.5+, Safari 4+, Chrome, Opera 10.5+, iPhone 2+, Android 2+
+    */
+    localStorage: amplifyStorageTypeStore;
+
+    /*** 
+    * IE 8+, Firefox 2+, Safari 4+, Chrome, Opera 10.5+, iPhone 2+, Android 2+
+    */
+    sessionStorage: amplifyStorageTypeStore;
+
+    /***
+    * Firefox 2+
+    */
+    globalStorage: amplifyStorageTypeStore;
+    
+    /***
+    * IE 5 - 7
+    */
+    userData: amplifyStorageTypeStore;
+
+    /***
+    * An in-memory store is provided as a fallback if none of the other storage types are available.
+    */
+    memory: amplifyStorageTypeStore;
+
+
+}
+
+interface amplifyStatic {
+
+    subscribe: amplifySubscribe;
+
+    /***
+    * Remove a subscription.
+    * topic: The topic being unsubscribed from.
+    * callback: The callback that was originally subscribed.
+    */
+    unsubscribe(topic: string, callback: Function): void;
+
+    /***
+    * Publish a message.
+    * topic: The name of the message to publish.
+    * Any additional parameters will be passed to the subscriptions.
+    * amplify.publish returns a boolean indicating whether any subscriptions returned false. The return value is true if none of the subscriptions returned false, and false otherwise. Note that only one subscription can return false because doing so will prevent additional subscriptions from being invoked.
+    */
+    publish(topic: string, ...args: any[]): boolean;
+
+    store: amplifyStore;
+
+    request: amplifyRequest;
+
+}
+
+declare var amplify: amplifyStatic;
+
diff --git a/angular-growl-v2/angular-growl-v2.d.ts b/angular-growl-v2/angular-growl-v2.d.ts
index 1c324723f6..81338aaca9 100644
--- a/angular-growl-v2/angular-growl-v2.d.ts
+++ b/angular-growl-v2/angular-growl-v2.d.ts
@@ -45,7 +45,7 @@ declare module angular.growl {
         /**
          * Pre-defined server error interceptor.
          */
-        serverMessagesInterceptor: (string|Function)[];
+        serverMessagesInterceptor: (string|IHttpInterceptorFactory)[];
 
         /**
          * Set default TTL settings.
diff --git a/angular-localForage/angular-localForage.d.ts b/angular-localForage/angular-localForage.d.ts
index 6186d79d34..d9c9ad5adf 100644
--- a/angular-localForage/angular-localForage.d.ts
+++ b/angular-localForage/angular-localForage.d.ts
@@ -22,8 +22,8 @@ declare module angular.localForage {
     }
 
     interface ILocalForageService {
-        setDriver(driver:string):angular.IPromise<void>;
-        driver<T>():lf.ILocalForage<T>;
+        driver(): LocalForageDriver;
+        setDriver(name: string | string[]): angular.IPromise<void>;
 
         setItem(key:string, value:any):angular.IPromise<void>;
         setItem(keys:Array<string>, values:Array<any>):angular.IPromise<void>;
diff --git a/angular-ui-bootstrap/angular-ui-bootstrap.d.ts b/angular-ui-bootstrap/angular-ui-bootstrap.d.ts
index 1a36d21a2d..8ebfdb6c24 100644
--- a/angular-ui-bootstrap/angular-ui-bootstrap.d.ts
+++ b/angular-ui-bootstrap/angular-ui-bootstrap.d.ts
@@ -5,6 +5,9 @@
 
 /// <reference path="../angularjs/angular.d.ts" />
 
+// Support for AMD require
+declare module 'angular-bootstrap' {}
+
 declare module angular.ui.bootstrap {
 
     interface IAccordionConfig {
diff --git a/angular-ui-router/angular-ui-router-tests.ts b/angular-ui-router/angular-ui-router-tests.ts
index dccd8f7b19..7a1bc2d006 100644
--- a/angular-ui-router/angular-ui-router-tests.ts
+++ b/angular-ui-router/angular-ui-router-tests.ts
@@ -158,7 +158,9 @@ class UrlLocatorTestService implements IUrlLocatorTestService {
 
     private stateServiceTest() {
         this.$state.go("myState");
+        this.$state.go(this.$state.current);
         this.$state.transitionTo("myState");
+        this.$state.transitionTo(this.$state.current);
         if (this.$state.includes("myState") === true) {
           //
         }
diff --git a/angular-ui-router/angular-ui-router.d.ts b/angular-ui-router/angular-ui-router.d.ts
index febe1c0907..ff0d6ce7e2 100644
--- a/angular-ui-router/angular-ui-router.d.ts
+++ b/angular-ui-router/angular-ui-router.d.ts
@@ -228,8 +228,11 @@ declare module angular.ui {
          * @param options Options object.
          */
         go(to: string, params?: {}, options?: IStateOptions): angular.IPromise<any>;
+        go(to: IState, params?: {}, options?: IStateOptions): angular.IPromise<any>;
         transitionTo(state: string, params?: {}, updateLocation?: boolean): void;
+        transitionTo(state: IState, params?: {}, updateLocation?: boolean): void;
         transitionTo(state: string, params?: {}, options?: IStateOptions): void;
+        transitionTo(state: IState, params?: {}, options?: IStateOptions): void;
         includes(state: string, params?: {}): boolean;
         is(state:string, params?: {}): boolean;
         is(state: IState, params?: {}): boolean;
diff --git a/angular2/angular2-2.0.0-alpha.37.d.ts b/angular2/angular2-2.0.0-alpha.37.d.ts
new file mode 100644
index 0000000000..733c9e8eff
--- /dev/null
+++ b/angular2/angular2-2.0.0-alpha.37.d.ts
@@ -0,0 +1,12214 @@
+// Type definitions for Angular v2.0.0-alpha.37
+// Project: http://angular.io/
+// Definitions by: angular team <https://github.com/angular/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// ***********************************************************
+// This file is generated by the Angular build process.
+// Please do not create manual edits or send pull requests
+// modifying this file.
+// ***********************************************************
+
+// angular2/angular2 depends transitively on these libraries.
+// If you don't have them installed you can install them using TSD
+// https://github.com/DefinitelyTyped/tsd
+
+///<reference path="../es6-promise/es6-promise.d.ts"/>
+///<reference path="../rx/rx.d.ts"/>
+// angular2/web_worker/worker depends transitively on these libraries.
+// If you don't have them installed you can install them using TSD
+// https://github.com/DefinitelyTyped/tsd
+
+///<reference path="../es6-promise/es6-promise.d.ts"/>
+///<reference path="../rx/rx.d.ts"/>
+// angular2/web_worker/ui depends transitively on these libraries.
+// If you don't have them installed you can install them using TSD
+// https://github.com/DefinitelyTyped/tsd
+
+///<reference path="../es6-promise/es6-promise.d.ts"/>
+///<reference path="../rx/rx.d.ts"/>
+
+
+interface Map<K,V> {}
+interface StringMap<K,V> extends Map<K,V> {}
+
+
+declare module ng {
+  // See https://github.com/Microsoft/TypeScript/issues/1168
+  class BaseException /* extends Error */ {
+    message: string;
+    stack: string;
+    toString(): string;
+  }
+  interface InjectableReference {}
+}
+
+declare module ngWorker {
+  // See https://github.com/Microsoft/TypeScript/issues/1168
+  class BaseException /* extends Error */ {
+    message: string;
+    stack: string;
+    toString(): string;
+  }
+  interface InjectableReference {}
+}
+
+declare module ngUi {
+  // See https://github.com/Microsoft/TypeScript/issues/1168
+  class BaseException /* extends Error */ {
+    message: string;
+    stack: string;
+    toString(): string;
+  }
+  interface InjectableReference {}
+}
+
+
+
+
+
+/**
+ * The `angular2` is the single place to import all of the individual types.
+ */
+declare module ng {
+
+  /**
+   * Bootstrapping for Angular applications.
+   *
+   * You instantiate an Angular application by explicitly specifying a component to use as the root
+   * component for your
+   * application via the `bootstrap()` method.
+   *
+   * ## Simple Example
+   *
+   * Assuming this `index.html`:
+   *
+   * ```html
+   * <html>
+   *   <!-- load Angular script tags here. -->
+   *   <body>
+   *     <my-app>loading...</my-app>
+   *   </body>
+   * </html>
+   * ```
+   *
+   * An application is bootstrapped inside an existing browser DOM, typically `index.html`. Unlike
+   * Angular 1, Angular 2
+   * does not compile/process bindings in `index.html`. This is mainly for security reasons, as well
+   * as architectural
+   * changes in Angular 2. This means that `index.html` can safely be processed using server-side
+   * technologies such as
+   * bindings. Bindings can thus use double-curly `{{ syntax }}` without collision from Angular 2
+   * component double-curly
+   * `{{ syntax }}`.
+   *
+   * We can use this script code:
+   *
+   * ```
+   * @Component({
+   *    selector: 'my-app'
+   * })
+   * @View({
+   *    template: 'Hello {{ name }}!'
+   * })
+   * class MyApp {
+   *   name:string;
+   *
+   *   constructor() {
+   *     this.name = 'World';
+   *   }
+   * }
+   *
+   * main() {
+   *   return bootstrap(MyApp);
+   * }
+   * ```
+   *
+   * When the app developer invokes `bootstrap()` with the root component `MyApp` as its argument,
+   * Angular performs the
+   * following tasks:
+   *
+   *  1. It uses the component's `selector` property to locate the DOM element which needs to be
+   * upgraded into
+   *     the angular component.
+   *  2. It creates a new child injector (from the platform injector). Optionally, you can also
+   * override the injector configuration for an app by
+   * invoking `bootstrap` with the `componentInjectableBindings` argument.
+   *  3. It creates a new `Zone` and connects it to the angular application's change detection domain
+   * instance.
+   *  4. It creates a shadow DOM on the selected component's host element and loads the template into
+   * it.
+   *  5. It instantiates the specified component.
+   *  6. Finally, Angular performs change detection to apply the initial data bindings for the
+   * application.
+   *
+   *
+   * ## Instantiating Multiple Applications on a Single Page
+   *
+   * There are two ways to do this.
+   *
+   *
+   * ### Isolated Applications
+   *
+   * Angular creates a new application each time that the `bootstrap()` method is invoked. When
+   * multiple applications
+   * are created for a page, Angular treats each application as independent within an isolated change
+   * detection and
+   * `Zone` domain. If you need to share data between applications, use the strategy described in the
+   * next
+   * section, "Applications That Share Change Detection."
+   *
+   *
+   * ### Applications That Share Change Detection
+   *
+   * If you need to bootstrap multiple applications that share common data, the applications must
+   * share a common
+   * change detection and zone. To do that, create a meta-component that lists the application
+   * components in its template.
+   * By only invoking the `bootstrap()` method once, with the meta-component as its argument, you
+   * ensure that only a
+   * single change detection zone is created and therefore data can be shared across the applications.
+   *
+   *
+   * ## Platform Injector
+   *
+   * When working within a browser window, there are many singleton resources: cookies, title,
+   * location, and others.
+   * Angular services that represent these resources must likewise be shared across all Angular
+   * applications that
+   * occupy the same browser window.  For this reason, Angular creates exactly one global platform
+   * injector which stores
+   * all shared services, and each angular application injector has the platform injector as its
+   * parent.
+   *
+   * Each application has its own private injector as well. When there are multiple applications on a
+   * page, Angular treats
+   * each application injector's services as private to that application.
+   *
+   *
+   * # API
+   * - `appComponentType`: The root component which should act as the application. This is a reference
+   * to a `Type`
+   *   which is annotated with `@Component(...)`.
+   * - `componentInjectableBindings`: An additional set of bindings that can be added to the app
+   * injector
+   * to override default injection behavior.
+   * - `errorReporter`: `function(exception:any, stackTrace:string)` a default error reporter for
+   * unhandled exceptions.
+   *
+   * Returns a `Promise` of {@link ApplicationRef}.
+   */
+  function bootstrap(appComponentType: /*Type*/ any, componentInjectableBindings?: Array<Type | Binding | any[]>) : Promise<ApplicationRef> ;
+
+
+  /**
+   * Declare reusable UI building blocks for an application.
+   *
+   * Each Angular component requires a single `@Component` and at least one `@View` annotation. The
+   * `@Component`
+   * annotation specifies when a component is instantiated, and which properties and hostListeners it
+   * binds to.
+   *
+   * When a component is instantiated, Angular
+   * - creates a shadow DOM for the component.
+   * - loads the selected template into the shadow DOM.
+   * - creates all the injectable objects configured with `bindings` and `viewBindings`.
+   *
+   * All template expressions and statements are then evaluated against the component instance.
+   *
+   * For details on the `@View` annotation, see {@link ViewMetadata}.
+   *
+   * ## Example
+   *
+   * ```
+   * @Component({
+   *   selector: 'greet'
+   * })
+   * @View({
+   *   template: 'Hello {{name}}!'
+   * })
+   * class Greet {
+   *   name: string;
+   *
+   *   constructor() {
+   *     this.name = 'World';
+   *   }
+   * }
+   * ```
+   */
+  class ComponentMetadata extends DirectiveMetadata {
+
+
+    /**
+     * Defines the used change detection strategy.
+     *
+     * When a component is instantiated, Angular creates a change detector, which is responsible for
+     * propagating the component's bindings.
+     *
+     * The `changeDetection` property defines, whether the change detection will be checked every time
+     * or only when the component tells it to do so.
+     */
+     changeDetection: ChangeDetectionStrategy;
+
+
+    /**
+     * Defines the set of injectable objects that are visible to its view dom children.
+     *
+     * ## Simple Example
+     *
+     * Here is an example of a class that can be injected:
+     *
+     * ```
+     * class Greeter {
+     *    greet(name:string) {
+     *      return 'Hello ' + name + '!';
+     *    }
+     * }
+     *
+     * @Directive({
+     *   selector: 'needs-greeter'
+     * })
+     * class NeedsGreeter {
+     *   greeter:Greeter;
+     *
+     *   constructor(greeter:Greeter) {
+     *     this.greeter = greeter;
+     *   }
+     * }
+     *
+     * @Component({
+     *   selector: 'greet',
+     *   viewBindings: [
+     *     Greeter
+     *   ]
+     * })
+     * @View({
+     *   template: `<needs-greeter></needs-greeter>`,
+     *   directives: [NeedsGreeter]
+     * })
+     * class HelloWorld {
+     * }
+     *
+     * ```
+     */
+     viewBindings: any[];
+  }
+
+
+  /**
+   * Directives allow you to attach behavior to elements in the DOM.
+   *
+   * {@link DirectiveMetadata}s with an embedded view are called {@link ComponentMetadata}s.
+   *
+   * A directive consists of a single directive annotation and a controller class. When the
+   * directive's `selector` matches
+   * elements in the DOM, the following steps occur:
+   *
+   * 1. For each directive, the `ElementInjector` attempts to resolve the directive's constructor
+   * arguments.
+   * 2. Angular instantiates directives for each matched element using `ElementInjector` in a
+   * depth-first order,
+   *    as declared in the HTML.
+   *
+   * ## Understanding How Injection Works
+   *
+   * There are three stages of injection resolution.
+   * - *Pre-existing Injectors*:
+   *   - The terminal {@link Injector} cannot resolve dependencies. It either throws an error or, if
+   * the dependency was
+   *     specified as `@Optional`, returns `null`.
+   *   - The platform injector resolves browser singleton resources, such as: cookies, title,
+   * location, and others.
+   * - *Component Injectors*: Each component instance has its own {@link Injector}, and they follow
+   * the same parent-child hierarchy
+   *     as the component instances in the DOM.
+   * - *Element Injectors*: Each component instance has a Shadow DOM. Within the Shadow DOM each
+   * element has an `ElementInjector`
+   *     which follow the same parent-child hierarchy as the DOM elements themselves.
+   *
+   * When a template is instantiated, it also must instantiate the corresponding directives in a
+   * depth-first order. The
+   * current `ElementInjector` resolves the constructor dependencies for each directive.
+   *
+   * Angular then resolves dependencies as follows, according to the order in which they appear in the
+   * {@link ViewMetadata}:
+   *
+   * 1. Dependencies on the current element
+   * 2. Dependencies on element injectors and their parents until it encounters a Shadow DOM boundary
+   * 3. Dependencies on component injectors and their parents until it encounters the root component
+   * 4. Dependencies on pre-existing injectors
+   *
+   *
+   * The `ElementInjector` can inject other directives, element-specific special objects, or it can
+   * delegate to the parent
+   * injector.
+   *
+   * To inject other directives, declare the constructor parameter as:
+   * - `directive:DirectiveType`: a directive on the current element only
+   * - `@Host() directive:DirectiveType`: any directive that matches the type between the current
+   * element and the
+   *    Shadow DOM root.
+   * - `@Query(DirectiveType) query:QueryList<DirectiveType>`: A live collection of direct child
+   * directives.
+   * - `@QueryDescendants(DirectiveType) query:QueryList<DirectiveType>`: A live collection of any
+   * child directives.
+   *
+   * To inject element-specific special objects, declare the constructor parameter as:
+   * - `element: ElementRef` to obtain a reference to logical element in the view.
+   * - `viewContainer: ViewContainerRef` to control child template instantiation, for
+   * {@link DirectiveMetadata} directives only
+   * - `bindingPropagation: BindingPropagation` to control change detection in a more granular way.
+   *
+   * ## Example
+   *
+   * The following example demonstrates how dependency injection resolves constructor arguments in
+   * practice.
+   *
+   *
+   * Assume this HTML template:
+   *
+   * ```
+   * <div dependency="1">
+   *   <div dependency="2">
+   *     <div dependency="3" my-directive>
+   *       <div dependency="4">
+   *         <div dependency="5"></div>
+   *       </div>
+   *       <div dependency="6"></div>
+   *     </div>
+   *   </div>
+   * </div>
+   * ```
+   *
+   * With the following `dependency` decorator and `SomeService` injectable class.
+   *
+   * ```
+   * @Injectable()
+   * class SomeService {
+   * }
+   *
+   * @Directive({
+   *   selector: '[dependency]',
+   *   properties: [
+   *     'id: dependency'
+   *   ]
+   * })
+   * class Dependency {
+   *   id:string;
+   * }
+   * ```
+   *
+   * Let's step through the different ways in which `MyDirective` could be declared...
+   *
+   *
+   * ### No injection
+   *
+   * Here the constructor is declared with no arguments, therefore nothing is injected into
+   * `MyDirective`.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor() {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with no dependencies.
+   *
+   *
+   * ### Component-level injection
+   *
+   * Directives can inject any injectable instance from the closest component injector or any of its
+   * parents.
+   *
+   * Here, the constructor declares a parameter, `someService`, and injects the `SomeService` type
+   * from the parent
+   * component's injector.
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(someService: SomeService) {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with a dependency on `SomeService`.
+   *
+   *
+   * ### Injecting a directive from the current element
+   *
+   * Directives can inject other directives declared on the current element.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(dependency: Dependency) {
+   *     expect(dependency.id).toEqual(3);
+   *   }
+   * }
+   * ```
+   * This directive would be instantiated with `Dependency` declared at the same element, in this case
+   * `dependency="3"`.
+   *
+   * ### Injecting a directive from any ancestor elements
+   *
+   * Directives can inject other directives declared on any ancestor element (in the current Shadow
+   * DOM), i.e. on the current element, the
+   * parent element, or its parents.
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(@Host() dependency: Dependency) {
+   *     expect(dependency.id).toEqual(2);
+   *   }
+   * }
+   * ```
+   *
+   * `@Host` checks the current element, the parent, as well as its parents recursively. If
+   * `dependency="2"` didn't
+   * exist on the direct parent, this injection would
+   * have returned
+   * `dependency="1"`.
+   *
+   *
+   * ### Injecting a live collection of direct child directives
+   *
+   *
+   * A directive can also query for other child directives. Since parent directives are instantiated
+   * before child directives, a directive can't simply inject the list of child directives. Instead,
+   * the directive injects a {@link QueryList}, which updates its contents as children are added,
+   * removed, or moved by a directive that uses a {@link ViewContainerRef} such as a `ng-for`, an
+   * `ng-if`, or an `ng-switch`.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(@Query(Dependency) dependencies:QueryList<Dependency>) {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with a {@link QueryList} which contains `Dependency` 4 and
+   * 6. Here, `Dependency` 5 would not be included, because it is not a direct child.
+   *
+   * ### Injecting a live collection of descendant directives
+   *
+   * By passing the descendant flag to `@Query` above, we can include the children of the child
+   * elements.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(@Query(Dependency, {descendants: true}) dependencies:QueryList<Dependency>) {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with a Query which would contain `Dependency` 4, 5 and 6.
+   *
+   * ### Optional injection
+   *
+   * The normal behavior of directives is to return an error when a specified dependency cannot be
+   * resolved. If you
+   * would like to inject `null` on unresolved dependency instead, you can annotate that dependency
+   * with `@Optional()`.
+   * This explicitly permits the author of a template to treat some of the surrounding directives as
+   * optional.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(@Optional() dependency:Dependency) {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with a `Dependency` directive found on the current element.
+   * If none can be
+   * found, the injector supplies `null` instead of throwing an error.
+   *
+   * ## Example
+   *
+   * Here we use a decorator directive to simply define basic tool-tip behavior.
+   *
+   * ```
+   * @Directive({
+   *   selector: '[tooltip]',
+   *   properties: [
+   *     'text: tooltip'
+   *   ],
+   *   host: {
+   *     '(mouseenter)': 'onMouseEnter()',
+   *     '(mouseleave)': 'onMouseLeave()'
+   *   }
+   * })
+   * class Tooltip{
+   *   text:string;
+   *   overlay:Overlay; // NOT YET IMPLEMENTED
+   *   overlayManager:OverlayManager; // NOT YET IMPLEMENTED
+   *
+   *   constructor(overlayManager:OverlayManager) {
+   *     this.overlay = overlay;
+   *   }
+   *
+   *   onMouseEnter() {
+   *     // exact signature to be determined
+   *     this.overlay = this.overlayManager.open(text, ...);
+   *   }
+   *
+   *   onMouseLeave() {
+   *     this.overlay.close();
+   *     this.overlay = null;
+   *   }
+   * }
+   * ```
+   * In our HTML template, we can then add this behavior to a `<div>` or any other element with the
+   * `tooltip` selector,
+   * like so:
+   *
+   * ```
+   * <div tooltip="some text here"></div>
+   * ```
+   *
+   * Directives can also control the instantiation, destruction, and positioning of inline template
+   * elements:
+   *
+   * A directive uses a {@link ViewContainerRef} to instantiate, insert, move, and destroy views at
+   * runtime.
+   * The {@link ViewContainerRef} is created as a result of `<template>` element, and represents a
+   * location in the current view
+   * where these actions are performed.
+   *
+   * Views are always created as children of the current {@link ViewMetadata}, and as siblings of the
+   * `<template>` element. Thus a
+   * directive in a child view cannot inject the directive that created it.
+   *
+   * Since directives that create views via ViewContainers are common in Angular, and using the full
+   * `<template>` element syntax is wordy, Angular
+   * also supports a shorthand notation: `<li *foo="bar">` and `<li template="foo: bar">` are
+   * equivalent.
+   *
+   * Thus,
+   *
+   * ```
+   * <ul>
+   *   <li *foo="bar" title="text"></li>
+   * </ul>
+   * ```
+   *
+   * Expands in use to:
+   *
+   * ```
+   * <ul>
+   *   <template [foo]="bar">
+   *     <li title="text"></li>
+   *   </template>
+   * </ul>
+   * ```
+   *
+   * Notice that although the shorthand places `*foo="bar"` within the `<li>` element, the binding for
+   * the directive
+   * controller is correctly instantiated on the `<template>` element rather than the `<li>` element.
+   *
+   *
+   * ## Example
+   *
+   * Let's suppose we want to implement the `unless` behavior, to conditionally include a template.
+   *
+   * Here is a simple directive that triggers on an `unless` selector:
+   *
+   * ```
+   * @Directive({
+   *   selector: '[unless]',
+   *   properties: ['unless']
+   * })
+   * export class Unless {
+   *   viewContainer: ViewContainerRef;
+   *   templateRef: TemplateRef;
+   *   prevCondition: boolean;
+   *
+   *   constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef) {
+   *     this.viewContainer = viewContainer;
+   *     this.templateRef = templateRef;
+   *     this.prevCondition = null;
+   *   }
+   *
+   *   set unless(newCondition) {
+   *     if (newCondition && (isBlank(this.prevCondition) || !this.prevCondition)) {
+   *       this.prevCondition = true;
+   *       this.viewContainer.clear();
+   *     } else if (!newCondition && (isBlank(this.prevCondition) || this.prevCondition)) {
+   *       this.prevCondition = false;
+   *       this.viewContainer.create(this.templateRef);
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * We can then use this `unless` selector in a template:
+   * ```
+   * <ul>
+   *   <li *unless="expr"></li>
+   * </ul>
+   * ```
+   *
+   * Once the directive instantiates the child view, the shorthand notation for the template expands
+   * and the result is:
+   *
+   * ```
+   * <ul>
+   *   <template [unless]="exp">
+   *     <li></li>
+   *   </template>
+   *   <li></li>
+   * </ul>
+   * ```
+   *
+   * Note also that although the `<li></li>` template still exists inside the `<template></template>`,
+   * the instantiated
+   * view occurs on the second `<li></li>` which is a sibling to the `<template>` element.
+   */
+  class DirectiveMetadata extends InjectableMetadata {
+
+
+    /**
+     * The CSS selector that triggers the instantiation of a directive.
+     *
+     * Angular only allows directives to trigger on CSS selectors that do not cross element
+     * boundaries.
+     *
+     * `selector` may be declared as one of the following:
+     *
+     * - `element-name`: select by element name.
+     * - `.class`: select by class name.
+     * - `[attribute]`: select by attribute name.
+     * - `[attribute=value]`: select by attribute name and value.
+     * - `:not(sub_selector)`: select only if the element does not match the `sub_selector`.
+     * - `selector1, selector2`: select if either `selector1` or `selector2` matches.
+     *
+     *
+     * ## Example
+     *
+     * Suppose we have a directive with an `input[type=text]` selector.
+     *
+     * And the following HTML:
+     *
+     * ```html
+     * <form>
+     *   <input type="text">
+     *   <input type="radio">
+     * <form>
+     * ```
+     *
+     * The directive would only be instantiated on the `<input type="text">` element.
+     */
+     selector: string;
+
+
+    /**
+     * Enumerates the set of properties that accept data binding for a directive.
+     *
+     * The `properties` property defines a set of `directiveProperty` to `bindingProperty`
+     * configuration:
+     *
+     * - `directiveProperty` specifies the component property where the value is written.
+     * - `bindingProperty` specifies the DOM property where the value is read from.
+     *
+     * You can include a {@link PipeMetadata} when specifying a `bindingProperty` to allow for data
+     * transformation and structural change detection of the value. These pipes will be evaluated in
+     * the context of this component.
+     *
+     * ## Syntax
+     *
+     * There is no need to specify both `directiveProperty` and `bindingProperty` when they both have
+     * the same value.
+     *
+     * ```
+     * @Directive({
+     *   properties: [
+     *     'propertyName', // shorthand notation for 'propertyName: propertyName'
+     *     'directiveProperty1: bindingProperty1',
+     *     'directiveProperty2: bindingProperty2 | pipe1 | ...',
+     *     ...
+     *   ]
+     * }
+     * ```
+     *
+     *
+     * ## Basic Property Binding
+     *
+     * We can easily build a simple `Tooltip` directive that exposes a `tooltip` property, which can
+     * be used in templates with standard Angular syntax. For example:
+     *
+     * ```
+     * @Directive({
+     *   selector: '[tooltip]',
+     *   properties: [
+     *     'text: tooltip'
+     *   ]
+     * })
+     * class Tooltip {
+     *   set text(value: string) {
+     *     // This will get called every time with the new value when the 'tooltip' property changes
+     *   }
+     * }
+     * ```
+     *
+     * We can then bind to the `tooltip' property as either an expression (`someExpression`) or as a
+     * string literal, as shown in the HTML template below:
+     *
+     * ```html
+     * <div [tooltip]="someExpression">...</div>
+     * <div tooltip="Some Text">...</div>
+     * ```
+     *
+     * Whenever the `someExpression` expression changes, the `properties` declaration instructs
+     * Angular to update the `Tooltip`'s `text` property.
+     *
+     * ### Bindings With Pipes
+     *
+     * You can use pipes in bindings, as follows:
+     *
+     * ```html
+     * <div [class-set]="someExpression | somePipe">
+     * ```
+     */
+     properties: string[];
+
+
+    /**
+     * Enumerates the set of emitted events.
+     *
+     * ## Syntax
+     *
+     * ```
+     * @Component({
+     *   events: ['statusChange']
+     * })
+     * class TaskComponent {
+     *   statusChange: EventEmitter;
+     *
+     *   constructor() {
+     *     this.statusChange = new EventEmitter();
+     *   }
+     *
+     *   onComplete() {
+     *     this.statusChange.next('completed');
+     *   }
+     * }
+     * ```
+     *
+     * Use `propertyName: eventName` when the event emitter property name is different from the name
+     * of the emitted event:
+     *
+     * ```
+     * @Component({
+     *   events: ['status: statusChange']
+     * })
+     * class TaskComponent {
+     *   status: EventEmitter;
+     *
+     *   constructor() {
+     *     this.status = new EventEmitter();
+     *   }
+     *
+     *   onComplete() {
+     *     this.status.next('completed');
+     *   }
+     * }
+     * ```
+     */
+     events: string[];
+
+
+    /**
+     * Specifiy the events, actions, properties and attributes related to the host element.
+     *
+     * ## Events
+     *
+     * Specifies which DOM hostListeners a directive listens to via a set of `(event)` to `method`
+     * key-value pairs:
+     *
+     * - `event1`: the DOM event that the directive listens to.
+     * - `statement`: the statement to execute when the event occurs.
+     * If the evalutation of the statement returns `false`, then `preventDefault`is applied on the DOM
+     * event.
+     *
+     * To listen to global events, a target must be added to the event name.
+     * The target can be `window`, `document` or `body`.
+     *
+     * When writing a directive event binding, you can also refer to the following local variables:
+     * - `$event`: Current event object which triggered the event.
+     * - `$target`: The source of the event. This will be either a DOM element or an Angular
+     * directive. (will be implemented in later release)
+     *
+     * ## Syntax
+     *
+     * ```
+     * @Directive({
+     *   host: {
+     *     '(event1)': 'onMethod1(arguments)',
+     *     '(target:event2)': 'onMethod2(arguments)',
+     *     ...
+     *   }
+     * }
+     * ```
+     *
+     * ## Basic Event Binding:
+     *
+     * Suppose you want to write a directive that reacts to `change` events in the DOM and on
+     * `resize` events in window.
+     * You would define the event binding as follows:
+     *
+     * ```
+     * @Directive({
+     *   selector: 'input',
+     *   host: {
+     *     '(change)': 'onChange($event)',
+     *     '(window:resize)': 'onResize($event)'
+     *   }
+     * })
+     * class InputDirective {
+     *   onChange(event:Event) {
+     *     // invoked when the input element fires the 'change' event
+     *   }
+     *   onResize(event:Event) {
+     *     // invoked when the window fires the 'resize' event
+     *   }
+     * }
+     * ```
+     *
+     * ## Properties
+     *
+     * Specifies which DOM properties a directives updates.
+     *
+     * ## Syntax
+     *
+     * ```
+     * @Directive({
+     *   selector: 'input',
+     *   host: {
+     *     '[prop]': 'expression'
+     *   }
+     * })
+     * class InputDirective {
+     *   value:string;
+     * }
+     * ```
+     *
+     * In this example the prop property of the host element is updated with the expression value
+     * every time it changes.
+     *
+     * ## Attributes
+     *
+     * Specifies static attributes that should be propagated to a host element. Attributes specified
+     * in `hostAttributes` are propagated only if a given attribute is not present on a host element.
+     *
+     * ## Syntax
+     *
+     * ```
+     * @Directive({
+     *   selector: '[my-button]',
+     *   host: {
+     *     'role': 'button'
+     *   }
+     * })
+     * class MyButton {
+     * }
+     * ```
+     *
+     * In this example using `my-button` directive (ex.: `<div my-button></div>`) on a host element
+     * (here: `<div>` ) will ensure that this element will get the "button" role.
+     */
+     host: StringMap<string, string>;
+
+
+    /**
+     * Specifies which lifecycle should be notified to the directive.
+     *
+     * See {@link LifecycleEvent} for details.
+     */
+     lifecycle: LifecycleEvent[];
+
+
+    /**
+     * If set to false the compiler does not compile the children of this directive.
+     */
+     compileChildren: boolean;
+
+
+    /**
+     * Defines the set of injectable objects that are visible to a Directive and its light dom
+     * children.
+     *
+     * ## Simple Example
+     *
+     * Here is an example of a class that can be injected:
+     *
+     * ```
+     * class Greeter {
+     *    greet(name:string) {
+     *      return 'Hello ' + name + '!';
+     *    }
+     * }
+     *
+     * @Directive({
+     *   selector: 'greet',
+     *   bindings: [
+     *     Greeter
+     *   ]
+     * })
+     * class HelloWorld {
+     *   greeter:Greeter;
+     *
+     *   constructor(greeter:Greeter) {
+     *     this.greeter = greeter;
+     *   }
+     * }
+     * ```
+     */
+     bindings: any[];
+
+
+    /**
+     * Defines the name that can be used in the template to assign this directive to a variable.
+     *
+     * ## Simple Example
+     *
+     * ```
+     * @Directive({
+     *   selector: 'child-dir',
+     *   exportAs: 'child'
+     * })
+     * class ChildDir {
+     * }
+     *
+     * @Component({
+     *   selector: 'main',
+     * })
+     * @View({
+     *   template: `<child-dir #c="child"></child-dir>`,
+     *   directives: [ChildDir]
+     * })
+     * class MainComponent {
+     * }
+     *
+     * ```
+     */
+     exportAs: string;
+  }
+
+
+  /**
+   * Declare reusable pipe function.
+   *
+   * ## Example
+   *
+   * ```
+   * @Pipe({
+   *   name: 'lowercase'
+   * })
+   * class Lowercase {
+   *   transform(v, args) { return v.toLowerCase(); }
+   * }
+   * ```
+   */
+  class PipeMetadata extends InjectableMetadata {
+
+     name: string;
+  }
+
+
+  /**
+   * Lifecycle events are guaranteed to be called in the following order:
+   * - `OnChanges` (if any bindings have changed),
+   * - `OnInit` (after the first check only),
+   * - `DoCheck`,
+   * - `AfterContentChecked`
+   * - `AfterContentChecked`
+   * - `OnDestroy` (at the very end before destruction)
+   */
+  enum LifecycleEvent {
+
+
+    /**
+     * Notify a directive when it has been checked the first time.
+     *
+     * This method is called right after the directive's bindings have been checked,
+     * and before any of its children's bindings have been checked.
+     *
+     * It is invoked only once.
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.OnInit]
+     * })
+     * class ClassSet {
+     *   onInit() {
+     *   }
+     * }
+     *  ```
+     */
+     OnInit,
+
+
+    /**
+     * Notify a directive whenever a {@link ViewMetadata} that contains it is destroyed.
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   ...,
+     *   lifecycle: [LifecycleEvent.OnDestroy]
+     * })
+     * class ClassSet {
+     *   onDestroy() {
+     *     // invoked to notify directive of the containing view destruction.
+     *   }
+     * }
+     * ```
+     */
+     OnDestroy,
+
+
+    /**
+     * Notify a directive when any of its bindings have changed.
+     *
+     * This method is called right after the directive's bindings have been checked,
+     * and before any of its children's bindings have been checked.
+     *
+     * It is invoked only if at least one of the directive's bindings has changed.
+     *
+     * ## Example:
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   properties: [
+     *     'propA',
+     *     'propB'
+     *   ],
+     *   lifecycle: [LifecycleEvent.OnChanges]
+     * })
+     * class ClassSet {
+     *   propA;
+     *   propB;
+     *   onChanges(changes:{[idx: string, PropertyUpdate]}) {
+     *     // This will get called after any of the properties have been updated.
+     *     if (changes['propA']) {
+     *       // if propA was updated
+     *     }
+     *     if (changes['propA']) {
+     *       // if propB was updated
+     *     }
+     *   }
+     * }
+     *  ```
+     */
+     OnChanges,
+
+
+    /**
+     * Notify a directive when it has been checked.
+     *
+     * This method is called right after the directive's bindings have been checked,
+     * and before any of its children's bindings have been checked.
+     *
+     * It is invoked every time even when none of the directive's bindings has changed.
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.DoCheck]
+     * })
+     * class ClassSet {
+     *   doCheck() {
+     *   }
+     * }
+     *  ```
+     */
+     DoCheck,
+
+
+    /**
+     * Notify a directive when the bindings of all its content children have been checked the first
+     * time (whether they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterContentInit]
+     * })
+     * class ClassSet {
+     *
+     *   afterContentInit() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterContentInit,
+
+
+    /**
+     * Notify a directive when the bindings of all its content children have been checked (whether
+     * they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterContentChecked]
+     * })
+     * class ClassSet {
+     *
+     *   afterContentChecked() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterContentChecked,
+
+
+    /**
+     * Notify a directive when the bindings of all its view children have been checked the first time
+     * (whether they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterViewInit]
+     * })
+     * class ClassSet {
+     *
+     *   afterViewInit() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterViewInit,
+
+
+    /**
+     * Notify a directive when the bindings of all its view children have been checked (whether they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterViewChecked]
+     * })
+     * class ClassSet {
+     *
+     *   afterViewChecked() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterViewChecked
+  }
+
+
+  /**
+   * Declares the available HTML templates for an application.
+   *
+   * Each angular component requires a single `@Component` and at least one `@View` annotation. The
+   * `@View` annotation specifies the HTML template to use, and lists the directives that are active
+   * within the template.
+   *
+   * When a component is instantiated, the template is loaded into the component's shadow root, and
+   * the expressions and statements in the template are evaluated against the component.
+   *
+   * For details on the `@Component` annotation, see {@link ComponentMetadata}.
+   *
+   * ## Example
+   *
+   * ```
+   * @Component({
+   *   selector: 'greet'
+   * })
+   * @View({
+   *   template: 'Hello {{name}}!',
+   *   directives: [GreetUser, Bold]
+   * })
+   * class Greet {
+   *   name: string;
+   *
+   *   constructor() {
+   *     this.name = 'World';
+   *   }
+   * }
+   * ```
+   */
+  class ViewMetadata {
+
+
+    /**
+     * Specifies a template URL for an angular component.
+     *
+     * NOTE: either `templateUrl` or `template` should be used, but not both.
+     */
+     templateUrl: string;
+
+
+    /**
+     * Specifies an inline template for an angular component.
+     *
+     * NOTE: either `templateUrl` or `template` should be used, but not both.
+     */
+     template: string;
+
+
+    /**
+     * Specifies stylesheet URLs for an angular component.
+     */
+     styleUrls: string[];
+
+
+    /**
+     * Specifies an inline stylesheet for an angular component.
+     */
+     styles: string[];
+
+
+    /**
+     * Specifies a list of directives that can be used within a template.
+     *
+     * Directives must be listed explicitly to provide proper component encapsulation.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * @Component({
+     *     selector: 'my-component'
+     *   })
+     * @View({
+     *   directives: [For]
+     *   template: '
+     *   <ul>
+     *     <li *ng-for="#item of items">{{item}}</li>
+     *   </ul>'
+     * })
+     * class MyComponent {
+     * }
+     * ```
+     */
+     directives: Array<Type | any | any[]>;
+
+     pipes: Array<Type | any | any[]>;
+
+
+    /**
+     * Specify how the template and the styles should be encapsulated.
+     * The default is {@link ViewEncapsulation#Emulated `ViewEncapsulation.Emulated`} if the view
+     * has styles,
+     * otherwise {@link ViewEncapsulation#None `ViewEncapsulation.None`}.
+     */
+     encapsulation: ViewEncapsulation;
+  }
+
+
+  /**
+   * How the template and styles of a view should be encapsulated.
+   */
+  enum ViewEncapsulation {
+
+
+    /**
+     * Emulate scoping of styles by preprocessing the style rules
+     * and adding additional attributes to elements. This is the default.
+     */
+     Emulated,
+
+
+    /**
+     * Uses the native mechanism of the renderer. For the DOM this means creating a ShadowRoot.
+     */
+     Native,
+
+
+    /**
+     * Don't scope the template nor the styles.
+     */
+     None
+  }
+
+
+  /**
+   * Specifies that a {@link QueryList} should be injected.
+   *
+   * See {@link QueryList} for usage and example.
+   */
+  class QueryMetadata extends DependencyMetadata {
+
+     descendants: boolean;
+
+     isViewQuery: any;
+
+     selector: any;
+
+     isVarBindingQuery: boolean;
+
+     varBindings: string[];
+
+     toString(): string;
+  }
+
+
+  /**
+   * Specifies that a constant attribute value should be injected.
+   *
+   * The directive can inject constant string literals of host element attributes.
+   *
+   * ## Example
+   *
+   * Suppose we have an `<input>` element and want to know its `type`.
+   *
+   * ```html
+   * <input type="text">
+   * ```
+   *
+   * A decorator can inject string literal `text` like so:
+   *
+   * ```javascript
+   * @Directive({
+   *   selector: `input'
+   * })
+   * class InputDirective {
+   *   constructor(@Attribute('type') type) {
+   *     // type would be `text` in this example
+   *   }
+   * }
+   * ```
+   */
+  class AttributeMetadata extends DependencyMetadata {
+
+     attributeName: string;
+
+     token: any;
+
+     toString(): string;
+  }
+
+
+  /**
+   * {@link AttributeMetadata} factory function.
+   */
+  var Attribute : AttributeFactory ;
+
+
+  /**
+   * {@link AttributeMetadata} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Attribute, Component, View} from "angular2/angular2";
+   *
+   * @Component({...})
+   * @View({...})
+   * class MyComponent {
+   *   constructor(@Attribute('title') title: string) {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyComponent = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({
+   *     constructor: [new ng.Attribute('title'), function(title) {
+   *       ...
+   *     }]
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyComponent = function(title) {
+   *   ...
+   * };
+   *
+   * MyComponent.annotations = [
+   *   new ng.Component({...}),
+   *   new ng.View({...})
+   * ]
+   * MyComponent.parameters = [
+   *   [new ng.Attribute('title')]
+   * ]
+   * ```
+   */
+  interface AttributeFactory {
+
+     new(name: string): AttributeMetadata;
+
+
+     (name: string): TypeDecorator;
+
+  }
+
+
+  /**
+   * {@link ComponentMetadata} factory function.
+   */
+  var Component : ComponentFactory ;
+
+
+  /**
+   * Interface for the {@link ComponentMetadata} decorator function.
+   *
+   * See {@link ComponentFactory}.
+   */
+  interface ComponentDecorator extends TypeDecorator {
+
+
+    /**
+     * Chain {@link ViewMetadata} annotation.
+     */
+     View(obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: Array<Type | any | any[]>,
+    pipes?: Array<Type | any | any[]>,
+    renderer?: string,
+    styles?: string[],
+    styleUrls?: string[],
+  }): ViewDecorator;
+  }
+
+
+  /**
+   * {@link ComponentAnnotation} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Component, View} from "angular2/angular2";
+   *
+   * @Component({...})
+   * @View({...})
+   * class MyComponent {
+   *   constructor() {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyComponent = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({
+   *     constructor: function() {
+   *       ...
+   *     }
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyComponent = function() {
+   *   ...
+   * };
+   *
+   * MyComponent.annotations = [
+   *   new ng.Component({...}),
+   *   new ng.View({...})
+   * ]
+   * ```
+   */
+  interface ComponentFactory {
+
+     new(obj: {
+    selector?: string,
+    properties?: string[],
+    events?: string[],
+    host?: StringMap<string, string>,
+    lifecycle?: LifecycleEvent[],
+    bindings?: any[],
+    exportAs?: string,
+    compileChildren?: boolean,
+    viewBindings?: any[],
+    changeDetection?: ChangeDetectionStrategy,
+  }): ComponentMetadata;
+
+
+     (obj: {
+    selector?: string,
+    properties?: string[],
+    events?: string[],
+    host?: StringMap<string, string>,
+    lifecycle?: LifecycleEvent[],
+    bindings?: any[],
+    exportAs?: string,
+    compileChildren?: boolean,
+    viewBindings?: any[],
+    changeDetection?: ChangeDetectionStrategy,
+  }): ComponentDecorator;
+
+  }
+
+
+  /**
+   * {@link DirectiveMetadata} factory function.
+   */
+  var Directive : DirectiveFactory ;
+
+
+  /**
+   * Interface for the {@link DirectiveMetadata} decorator function.
+   *
+   * See {@link DirectiveFactory}.
+   */
+  interface DirectiveDecorator extends TypeDecorator {
+  }
+
+
+  /**
+   * {@link DirectiveMetadata} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Directive} from "angular2/angular2";
+   *
+   * @Directive({...})
+   * class MyDirective {
+   *   constructor() {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyDirective = ng
+   *   .Directive({...})
+   *   .Class({
+   *     constructor: function() {
+   *       ...
+   *     }
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyDirective = function() {
+   *   ...
+   * };
+   *
+   * MyDirective.annotations = [
+   *   new ng.Directive({...})
+   * ]
+   * ```
+   */
+  interface DirectiveFactory {
+
+     new(obj: {
+    selector?: string, properties?: string[], events?: string[], host?: StringMap<string, string>,
+        lifecycle?: LifecycleEvent[], bindings?: any[], exportAs?: string,
+        compileChildren?: boolean;
+  }): DirectiveMetadata;
+
+
+     (obj: {
+    selector?: string, properties?: string[], events?: string[], host?: StringMap<string, string>,
+        lifecycle?: LifecycleEvent[], bindings?: any[], exportAs?: string,
+        compileChildren?: boolean;
+  }): DirectiveDecorator;
+
+  }
+
+
+  /**
+   * {@link ViewMetadata} factory function.
+   */
+  var View : ViewFactory ;
+
+
+  /**
+   * Interface for the {@link ViewMetadata} decorator function.
+   *
+   * See {@link ViewFactory}.
+   */
+  interface ViewDecorator extends TypeDecorator {
+
+
+    /**
+     * Chain {@link ViewMetadata} annotation.
+     */
+     View(obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: Array<Type | any | any[]>,
+    pipes?: Array<Type | any | any[]>,
+    renderer?: string,
+    styles?: string[],
+    styleUrls?: string[],
+  }): ViewDecorator;
+  }
+
+
+  /**
+   * {@link ViewAnnotation} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Component, View} from "angular2/angular2";
+   *
+   * @Component({...})
+   * @View({...})
+   * class MyComponent {
+   *   constructor() {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyComponent = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({
+   *     constructor: function() {
+   *       ...
+   *     }
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyComponent = function() {
+   *   ...
+   * };
+   *
+   * MyComponent.annotations = [
+   *   new ng.Component({...}),
+   *   new ng.View({...})
+   * ]
+   * ```
+   */
+  interface ViewFactory {
+
+     new(obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: Array<Type | any | any[]>,
+    encapsulation?: ViewEncapsulation,
+    styles?: string[],
+    styleUrls?: string[],
+  }): ViewMetadata;
+
+
+     (obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: Array<Type | any | any[]>,
+    encapsulation?: ViewEncapsulation,
+    styles?: string[],
+    styleUrls?: string[],
+  }): ViewDecorator;
+
+  }
+
+
+  /**
+   * {@link QueryMetadata} factory function.
+   */
+  var Query : QueryFactory ;
+
+
+  /**
+   * {@link QueryMetadata} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Query, QueryList, Component, View} from "angular2/angular2";
+   *
+   * @Component({...})
+   * @View({...})
+   * class MyComponent {
+   *   constructor(@Query(SomeType) queryList: QueryList) {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyComponent = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({
+   *     constructor: [new ng.Query(SomeType), function(queryList) {
+   *       ...
+   *     }]
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyComponent = function(queryList) {
+   *   ...
+   * };
+   *
+   * MyComponent.annotations = [
+   *   new ng.Component({...}),
+   *   new ng.View({...})
+   * ]
+   * MyComponent.parameters = [
+   *   [new ng.Query(SomeType)]
+   * ]
+   * ```
+   */
+  interface QueryFactory {
+
+     new(selector: Type | string, {descendants}?: {descendants?: boolean}): QueryMetadata;
+
+
+     (selector: Type | string, {descendants}?: {descendants?: boolean}): ParameterDecorator;
+
+  }
+
+
+  /**
+   * {@link di/ViewQueryMetadata} factory function.
+   */
+  var ViewQuery : QueryFactory ;
+
+
+  /**
+   * {@link PipeMetadata} factory function.
+   */
+  var Pipe : PipeFactory ;
+
+
+  /**
+   * {@link PipeMetadata} factory for creating decorators.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Pipe} from "angular2/angular2";
+   *
+   * @Pipe({...})
+   * class MyPipe {
+   *   constructor() {
+   *     ...
+   *   }
+   *
+   *   transform(v, args) {}
+   * }
+   * ```
+   */
+  interface PipeFactory {
+
+     new(obj: {
+    name: string,
+  }): any;
+
+
+     (obj: {name: string}): any;
+
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterContentInit `LifeCycleEvent.afterContentInit`}
+   * called when the bindings of all its content children have been checked the first time.
+   */
+  interface AfterContentInit {
+
+     afterContentInit(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterContentChecked `LifeCycleEvent.afterContentChecked`}
+   * called when the bindings of all its content children have been checked.
+   */
+  interface AfterContentChecked {
+
+     afterContentChecked(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterViewInit `LifeCycleEvent.afterViewInit`}
+   * called when the bindings of all its view children have been checked the first time.
+   */
+  interface AfterViewInit {
+
+     afterViewInit(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterViewChecked `LifeCycleEvent.afterViewChecked`}
+   * called when the bindings of all its view children have been checked.
+   */
+  interface AfterViewChecked {
+
+     afterViewChecked(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#OnChanges `LifeCycleEvent.OnChanges`}
+   * called after all of component's bound properties are updated.
+   */
+  interface OnChanges {
+
+     onChanges(changes: StringMap<string, any>): void;
+  }
+
+
+  /**
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#OnDestroy `LifeCycleEvent.OnDestroy`}
+   * called when a directive is being destroyed.
+   */
+  interface OnDestroy {
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#OnInit `LifeCycleEvent.OnInit`}
+   * called when a directive is being checked the first time.
+   */
+  interface OnInit {
+
+     onInit(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#DoCheck `LifeCycleEvent.DoCheck`}
+   * called when a directive is being checked.
+   */
+  interface DoCheck {
+
+     doCheck(): boolean;
+  }
+
+
+  /**
+   * Provides a way for expressing ES6 classes with parameter annotations in ES5.
+   *
+   * ## Basic Example
+   *
+   * ```
+   * var Greeter = ng.Class({
+   *   constructor: function(name) {
+   *     this.name = name;
+   *   },
+   *
+   *   greet: function() {
+   *     alert('Hello ' + this.name + '!');
+   *   }
+   * });
+   * ```
+   *
+   * is equivalent to ES6:
+   *
+   * ```
+   * class Greeter {
+   *   constructor(name) {
+   *     this.name = name;
+   *   }
+   *
+   *   greet() {
+   *     alert('Hello ' + this.name + '!');
+   *   }
+   * }
+   * ```
+   *
+   * or equivalent to ES5:
+   *
+   * ```
+   * var Greeter = function (name) {
+   *   this.name = name;
+   * }
+   *
+   * Greeter.prototype.greet = function () {
+   *   alert('Hello ' + this.name + '!');
+   * }
+   * ```
+   *
+   * ## Example with parameter annotations
+   *
+   * ```
+   * var MyService = neg.Class({
+   *   constructor: [String, [new Query(), QueryList], function(name, queryList) {
+   *     ...
+   *   }];
+   * });
+   * ```
+   *
+   * is equivalent to ES6:
+   *
+   * ```
+   * class MyService {
+   *   constructor(name: string, @Query() queryList: QueryList) {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example with inheritance
+   *
+   * ```
+   * var Shape = ng.Class({
+   *   constructor: (color) {
+   *     this.color = color;
+   *   }
+   * });
+   *
+   * var Square = ng.Class({
+   *   extends: Shape,
+   *   constructor: function(color, size) {
+   *     Shape.call(this, color);
+   *     this.size = size;
+   *   }
+   * });
+   * ```
+   */
+  function Class(clsDef: ClassDefinition) : Type ;
+
+
+  /**
+   * Declares the interface to be used with {@link Class}.
+   */
+  interface ClassDefinition {
+
+
+    /**
+     * Optional argument for specifying the superclass.
+     */
+     extends?: Type;
+
+
+    /**
+     * Required constructor function for a class.
+     *
+     * The function may be optionally wrapped in an `Array`, in which case additional parameter
+     * annotations may be specified.
+     * The number of arguments and the number of parameter annotations must match.
+     *
+     * See {@link Class} for example of usage.
+     */
+     constructor: (Function | any[]);
+  }
+
+
+  /**
+   * An interface implemented by all Angular type decorators, which allows them to be used as ES7
+   * decorators as well as
+   * Angular DSL syntax.
+   *
+   * DSL syntax:
+   *
+   * ```
+   * var MyClass = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({...});
+   * ```
+   *
+   * ES7 syntax:
+   *
+   * ```
+   * @ng.Component({...})
+   * @ng.View({...})
+   * class MyClass {...}
+   * ```
+   */
+  interface TypeDecorator {
+
+
+    /**
+     * Invoke as ES7 decorator.
+     */
+     <T extends Type>(type: T): T;
+
+
+
+    /**
+     * Storage for the accumulated annotations so far used by the DSL syntax.
+     *
+     * Used by {@link Class} to annotate the generated class.
+     */
+     annotations: any[];
+
+
+    /**
+     * Generate a class from the definition and annotate it with {@link TypeDecorator#annotations}.
+     */
+     Class(obj: ClassDefinition): Type;
+  }
+
+  enum ChangeDetectionStrategy {
+
+
+    /**
+     * `CheckedOnce` means that after calling detectChanges the mode of the change detector
+     * will become `Checked`.
+     */
+     CheckOnce,
+
+
+    /**
+     * `Checked` means that the change detector should be skipped until its mode changes to
+     * `CheckOnce`.
+     */
+     Checked,
+
+
+    /**
+     * `CheckAlways` means that after calling detectChanges the mode of the change detector
+     * will remain `CheckAlways`.
+     */
+     CheckAlways,
+
+
+    /**
+     * `Detached` means that the change detector sub tree is not a part of the main tree and
+     * should be skipped.
+     */
+     Detached,
+
+
+    /**
+     * `OnPush` means that the change detector's mode will be set to `CheckOnce` during hydration.
+     */
+     OnPush,
+
+
+    /**
+     * `Default` means that the change detector's mode will be set to `CheckAlways` during hydration.
+     */
+     Default,
+
+
+    /**
+     * This is an experimental feature. Works only in Dart.
+     */
+     OnPushObserve
+  }
+
+
+  /**
+   * An error thrown if application changes model breaking the top-down data flow.
+   *
+   * Angular expects that the data flows from top (root) component to child (leaf) components.
+   * This is known as directed acyclic graph. This allows Angular to only execute change detection
+   * once and prevents loops in change detection data flow.
+   *
+   * This exception is only thrown in dev mode.
+   */
+  class ExpressionChangedAfterItHasBeenCheckedException extends BaseException {
+  }
+
+
+  /**
+   * Thrown when an expression evaluation raises an exception.
+   *
+   * This error wraps the original exception, this is done to attach expression location information.
+   */
+  class ChangeDetectionError extends BaseException {
+
+
+    /**
+     * Location of the expression.
+     */
+     location: string;
+  }
+
+  interface ChangeDetector {
+
+     parent: ChangeDetector;
+
+     mode: ChangeDetectionStrategy;
+
+     ref: ChangeDetectorRef;
+
+     addChild(cd: ChangeDetector): void;
+
+     addShadowDomChild(cd: ChangeDetector): void;
+
+     removeChild(cd: ChangeDetector): void;
+
+     removeShadowDomChild(cd: ChangeDetector): void;
+
+     remove(): void;
+
+     hydrate(context: any, locals: Locals, directives: any, pipes: any): void;
+
+     dehydrate(): void;
+
+     markPathToRootAsCheckOnce(): void;
+
+     handleEvent(eventName: string, elIndex: number, locals: Locals): void;
+
+     detectChanges(): void;
+
+     checkNoChanges(): void;
+  }
+
+  class Locals {
+
+     parent: Locals;
+
+     current: Map<any, any>;
+
+     contains(name: string): boolean;
+
+     get(name: string): any;
+
+     set(name: string, value: any): void;
+
+     clearValues(): void;
+  }
+
+
+  /**
+   * Controls change detection.
+   *
+   * {@link ChangeDetectorRef} allows requesting checks for detectors that rely on observables. It
+   * also allows detaching and attaching change detector subtrees.
+   */
+  interface ChangeDetectorRef {
+
+
+    /**
+     * Request to check all OnPush ancestors.
+     */
+     markForCheck(): void;
+
+
+    /**
+     * Detaches the change detector from the change detector tree.
+     *
+     * The detached change detector will not be checked until it is reattached.
+     */
+     detach(): void;
+
+
+    /**
+     * Reattach the change detector to the change detector tree.
+     *
+     * This also requests a check of this change detector. This reattached change detector will be
+     * checked during the next change detection run.
+     */
+     reattach(): void;
+  }
+
+
+  /**
+   * Indicates that the result of a {@link PipeMetadata} transformation has changed even though the
+   * reference
+   * has not changed.
+   *
+   * The wrapped value will be unwrapped by change detection, and the unwrapped value will be stored.
+   *
+   * Example:
+   *
+   * ```
+   * if (this._latestValue === this._latestReturnedValue) {
+   *    return this._latestReturnedValue;
+   *  } else {
+   *    this._latestReturnedValue = this._latestValue;
+   *    return WrappedValue.wrap(this._latestValue); // this will force update
+   *  }
+   * ```
+   */
+  class WrappedValue {
+
+     static wrap(value: any): WrappedValue;
+
+     wrapped: any;
+  }
+
+
+  /**
+   * An interface which all pipes must implement.
+   *
+   * #Example
+   *
+   * ```
+   * class DoublePipe implements PipeTransform {
+   *  transform(value, args = []) {
+   *    return `${value}${value}`;
+   *  }
+   * }
+   * ```
+   */
+  interface PipeTransform {
+
+     transform(value: any, args: any[]): any;
+  }
+
+
+  /**
+   * An interface that stateful pipes should implement.
+   *
+   * #Example
+   *
+   * ```
+   * class StatefulPipe implements PipeTransform, PipeOnDestroy {
+   *  connection;
+   *
+   *  onDestroy() {
+   *    this.connection.release();
+   *  }
+   *
+   *  transform(value, args = []) {
+   *    this.connection = createConnection();
+   *    // ...
+   *    return someValue;
+   *  }
+   * }
+   * ```
+   */
+  interface PipeOnDestroy {
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * A repository of different iterable diffing strategies used by NgFor, NgClass, and others.
+   */
+  class IterableDiffers {
+
+     static create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers;
+
+
+    /**
+     * Takes an array of {@link IterableDifferFactory} and returns a binding used to extend the
+     * inherited {@link IterableDiffers} instance with the provided factories and return a new
+     * {@link IterableDiffers} instance.
+     *
+     * The following example shows how to extend an existing list of factories,
+     * which will only be applied to the injector for this component and its children.
+     * This step is all that's required to make a new {@link IterableDiffer} available.
+     *
+     * # Example
+     *
+     * ```
+     * @Component({
+     *   viewBindings: [
+     *     IterableDiffers.extend([new ImmutableListDiffer()])
+     *   ]
+     * })
+     * ```
+     */
+     static extend(factories: IterableDifferFactory[]): Binding;
+
+     factories: IterableDifferFactory[];
+
+     find(iterable: Object): IterableDifferFactory;
+  }
+
+  interface IterableDiffer {
+
+     diff(object: Object): any;
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * Provides a factory for {@link IterableDiffer}.
+   */
+  interface IterableDifferFactory {
+
+     supports(objects: Object): boolean;
+
+     create(cdRef: ChangeDetectorRef): IterableDiffer;
+  }
+
+
+  /**
+   * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.
+   */
+  class KeyValueDiffers {
+
+     static create(factories: KeyValueDifferFactory[], parent?: KeyValueDiffers): KeyValueDiffers;
+
+
+    /**
+     * Takes an array of {@link KeyValueDifferFactory} and returns a binding used to extend the
+     * inherited {@link KeyValueDiffers} instance with the provided factories and return a new
+     * {@link KeyValueDiffers} instance.
+     *
+     * The following example shows how to extend an existing list of factories,
+     * which will only be applied to the injector for this component and its children.
+     * This step is all that's required to make a new {@link KeyValueDiffer} available.
+     *
+     * # Example
+     *
+     * ```
+     * @Component({
+     *   viewBindings: [
+     *     KeyValueDiffers.extend([new ImmutableMapDiffer()])
+     *   ]
+     * })
+     * ```
+     */
+     static extend(factories: KeyValueDifferFactory[]): Binding;
+
+     factories: KeyValueDifferFactory[];
+
+     find(kv: Object): KeyValueDifferFactory;
+  }
+
+  interface KeyValueDiffer {
+
+     diff(object: Object): void;
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * Provides a factory for {@link KeyValueDiffer}.
+   */
+  interface KeyValueDifferFactory {
+
+     supports(objects: Object): boolean;
+
+     create(cdRef: ChangeDetectorRef): KeyValueDiffer;
+  }
+
+
+  /**
+   * An opaque token representing the application root type in the {@link Injector}.
+   *
+   * ```
+   * @Component(...)
+   * @View(...)
+   * class MyApp {
+   *   ...
+   * }
+   *
+   * bootstrap(MyApp).then((appRef:ApplicationRef) {
+   *   expect(appRef.injector.get(appComponentTypeToken)).toEqual(MyApp);
+   * });
+   *
+   * ```
+   */
+  const APP_COMPONENT : OpaqueToken ;
+
+
+  /**
+   * Runtime representation of a type.
+   *
+   * In JavaScript a Type is a constructor function.
+   */
+  interface Type extends Function {
+
+     new(...args: any[]): any;
+
+  }
+
+
+  /**
+   * Represents a Angular's representation of an Application.
+   *
+   * `ApplicationRef` represents a running application instance. Use it to retrieve the host
+   * component, injector,
+   * or dispose of an application.
+   */
+  interface ApplicationRef {
+
+
+    /**
+     * Returns the current {@link ComponentMetadata} type.
+     */
+     hostComponentType: Type;
+
+
+    /**
+     * Returns the current {@link ComponentMetadata} instance.
+     */
+     hostComponent: any;
+
+
+    /**
+     * Dispose (un-load) the application.
+     */
+     dispose(): void;
+
+
+    /**
+     * Returns the root application {@link Injector}.
+     */
+     injector: Injector;
+  }
+
+
+  /**
+   * Specifies app root url for the application.
+   *
+   * Used by the {@link Compiler} when resolving HTML and CSS template URLs.
+   *
+   * This interface can be overridden by the application developer to create custom behavior.
+   *
+   * See {@link Compiler}
+   */
+  class AppRootUrl {
+
+
+    /**
+     * Returns the base URL of the currently running application.
+     */
+     value: any;
+  }
+
+
+  /**
+   * Used by the {@link Compiler} when resolving HTML and CSS template URLs.
+   *
+   * This interface can be overridden by the application developer to create custom behavior.
+   *
+   * See {@link Compiler}
+   */
+  class UrlResolver {
+
+
+    /**
+     * Resolves the `url` given the `baseUrl`:
+     * - when the `url` is null, the `baseUrl` is returned,
+     * - if `url` is relative ('path/to/here', './path/to/here'), the resolved url is a combination of
+     * `baseUrl` and `url`,
+     * - if `url` is absolute (it has a scheme: 'http://', 'https://' or start with '/'), the `url` is
+     * returned as is (ignoring the `baseUrl`)
+     *
+     * @param {string} baseUrl
+     * @param {string} url
+     * @returns {string} the resolved URL
+     */
+     resolve(baseUrl: string, url: string): string;
+  }
+
+
+  /**
+   * Resolve a `Type` from a {@link ComponentMetadata} into a URL.
+   *
+   * This interface can be overridden by the application developer to create custom behavior.
+   *
+   * See {@link Compiler}
+   */
+  class ComponentUrlMapper {
+
+
+    /**
+     * Returns the base URL to the component source file.
+     * The returned URL could be:
+     * - an absolute URL,
+     * - a path relative to the application
+     */
+     getUrl(component: Type): string;
+  }
+
+
+  /**
+   * Resolve a `Type` for {@link DirectiveMetadata}.
+   *
+   * This interface can be overridden by the application developer to create custom behavior.
+   *
+   * See {@link Compiler}
+   */
+  class DirectiveResolver {
+
+
+    /**
+     * Return {@link DirectiveMetadata} for a given `Type`.
+     */
+     resolve(type: Type): DirectiveMetadata;
+  }
+
+
+  /**
+   * ## URL Resolution
+   *
+   * ```
+   * var appRootUrl: AppRootUrl = ...;
+   * var componentUrlMapper: ComponentUrlMapper = ...;
+   * var urlResolver: UrlResolver = ...;
+   *
+   * var componentType: Type = ...;
+   * var componentAnnotation: ComponentAnnotation = ...;
+   * var viewAnnotation: ViewAnnotation = ...;
+   *
+   * // Resolving a URL
+   *
+   * var url = viewAnnotation.templateUrl;
+   * var componentUrl = componentUrlMapper.getUrl(componentType);
+   * var componentResolvedUrl = urlResolver.resolve(appRootUrl.value, componentUrl);
+   * var templateResolvedUrl = urlResolver.resolve(componetResolvedUrl, url);
+   * ```
+   */
+  interface Compiler {
+
+     compileInHost(componentTypeOrBinding: Type | Binding): Promise<ProtoViewRef>;
+  }
+
+
+  /**
+   * Entry point for creating, moving views in the view hierarchy and destroying views.
+   * This manager contains all recursion and delegates to helper methods
+   * in AppViewManagerUtils and the Renderer, so unit tests get simpler.
+   */
+  interface AppViewManager {
+
+
+    /**
+     * Returns a {@link ViewContainerRef} at the {@link ElementRef} location.
+     */
+     getViewContainer(location: ElementRef): ViewContainerRef;
+
+
+    /**
+     * Return the first child element of the host element view.
+     */
+     getHostElement(hostViewRef: HostViewRef): ElementRef;
+
+
+    /**
+     * Returns an ElementRef for the element with the given variable name
+     * in the current view.
+     *
+     * - `hostLocation`: {@link ElementRef} of any element in the View which defines the scope of
+     *   search.
+     * - `variableName`: Name of the variable to locate.
+     * - Returns {@link ElementRef} of the found element or null. (Throws if not found.)
+     */
+     getNamedElementInComponentView(hostLocation: ElementRef, variableName: string): ElementRef;
+
+
+    /**
+     * Returns the component instance for a given element.
+     *
+     * The component is the execution context as seen by an expression at that {@link ElementRef}
+     * location.
+     */
+     getComponent(hostLocation: ElementRef): any;
+
+
+    /**
+     * Load component view into existing element.
+     *
+     * Use this if a host element is already in the DOM and it is necessary to upgrade
+     * the element into Angular component by attaching a view but reusing the existing element.
+     *
+     * - `hostProtoViewRef`: {@link ProtoViewRef} Proto view to use in creating a view for this
+     *   component.
+     * - `overrideSelector`: (optional) selector to use in locating the existing element to load
+     *   the view into. If not specified use the selector in the component definition of the
+     *   `hostProtoView`.
+     * - injector: {@link Injector} to use as parent injector for the view.
+     *
+     * See {@link AppViewManager#destroyRootHostView}.
+     *
+     * ## Example
+     *
+     * ```
+     * @ng.Component({
+     *   selector: 'child-component'
+     * })
+     * @ng.View({
+     *   template: 'Child'
+     * })
+     * class ChildComponent {
+     *
+     * }
+     *
+     * @ng.Component({
+     *   selector: 'my-app'
+     * })
+     * @ng.View({
+     *   template: `
+     *     Parent (<some-component></some-component>)
+     *   `
+     * })
+     * class MyApp {
+     *   viewRef: ng.ViewRef;
+     *
+     *   constructor(public appViewManager: ng.AppViewManager, compiler: ng.Compiler) {
+     *     compiler.compileInHost(ChildComponent).then((protoView: ng.ProtoViewRef) => {
+     *       this.viewRef = appViewManager.createRootHostView(protoView, 'some-component', null);
+     *     })
+     *   }
+     *
+     *   onDestroy() {
+     *     this.appViewManager.destroyRootHostView(this.viewRef);
+     *     this.viewRef = null;
+     *   }
+     * }
+     *
+     * ng.bootstrap(MyApp);
+     * ```
+     */
+     createRootHostView(hostProtoViewRef: ProtoViewRef, overrideSelector: string, injector: Injector): HostViewRef;
+
+
+    /**
+     * Remove the View created with {@link AppViewManager#createRootHostView}.
+     */
+     destroyRootHostView(hostViewRef: HostViewRef): void;
+
+
+    /**
+     * See {@link AppViewManager#destroyViewInContainer}.
+     */
+     createEmbeddedViewInContainer(viewContainerLocation: ElementRef, atIndex: number, templateRef: TemplateRef): ViewRef;
+
+
+    /**
+     * See {@link AppViewManager#destroyViewInContainer}.
+     */
+     createHostViewInContainer(viewContainerLocation: ElementRef, atIndex: number, protoViewRef: ProtoViewRef, imperativelyCreatedInjector: ResolvedBinding[]): HostViewRef;
+
+
+    /**
+     * See {@link AppViewManager#createViewInContainer}.
+     */
+     destroyViewInContainer(viewContainerLocation: ElementRef, atIndex: number): void;
+
+
+    /**
+     * See {@link AppViewManager#detachViewInContainer}.
+     */
+     attachViewInContainer(viewContainerLocation: ElementRef, atIndex: number, viewRef: ViewRef): ViewRef;
+
+
+    /**
+     * See {@link AppViewManager#attachViewInContainer}.
+     */
+     detachViewInContainer(viewContainerLocation: ElementRef, atIndex: number): ViewRef;
+  }
+
+
+  /**
+   * An iterable and observable live list of components in the DOM.
+   *
+   * A QueryList contains a live list of child directives in the DOM of a directive.
+   * The directives are kept in depth-first pre-order traversal of the DOM.
+   *
+   * The `QueryList` is iterable, therefore it can be used in both javascript code with `for..of` loop
+   * as well as in template with `*ng-for="of"` directive.
+   *
+   * QueryList is updated as part of the change-detection cycle of a directive. Since change detection
+   * happens after construction of a directive, QueryList will always be empty when observed in the
+   * constructor.
+   *
+   *
+   * NOTE: In the future this class will implement an `Observable` interface. For now it uses a plain
+   * list of observable callbacks.
+   *
+   * # Example:
+   *
+   * Assume that `<tabs>` component would like to get a list its children which are `<pane>`
+   * components as shown in this example:
+   *
+   * ```html
+   * <tabs>
+   *   <pane title="Overview">...</pane>
+   *   <pane *ng-for="#o of objects" [title]="o.title">{{o.text}}</pane>
+   * </tabs>
+   * ```
+   *
+   * In the above example the list of `<tabs>` elements needs to get a list of `<pane>` elements so
+   * that it could render tabs with the correct titles and in the correct order.
+   *
+   * A possible solution would be for a `<pane>` to inject `<tabs>` component and then register itself
+   * with `<tabs>` component's on `hydrate` and deregister on `dehydrate` event. While a reasonable
+   * approach, this would only work partialy since `*ng-for` could rearrange the list of `<pane>`
+   * components which would not be reported to `<tabs>` component and thus the list of `<pane>`
+   * components would be out of sync with respect to the list of `<pane>` elements.
+   *
+   * A preferred solution is to inject a `QueryList` which is a live list of directives in the
+   * component`s light DOM.
+   *
+   * ```javascript
+   * @Component({
+   *   selector: 'tabs'
+   * })
+   * @View({
+   *  template: `
+   *    <ul>
+   *      <li *ng-for="#pane of panes">{{pane.title}}</li>
+   *    </ul>
+   *    <content></content>
+   *  `
+   * })
+   * class Tabs {
+   *   panes: QueryList<Pane>
+   *
+   *   constructor(@Query(Pane) panes:QueryList<Pane>) {
+   *     this.panes = panes;
+   *   }
+   * }
+   *
+   * @Component({
+   *   selector: 'pane',
+   *   properties: ['title']
+   * })
+   * @View(...)
+   * class Pane {
+   *   title:string;
+   * }
+   * ```
+   */
+  class QueryList<T> {
+
+     reset(newList: T[]): void;
+
+     add(obj: T): void;
+
+     fireCallbacks(): void;
+
+     onChange(callback: () => void): void;
+
+     removeCallback(callback: () => void): void;
+
+     toString(): string;
+
+     length: number;
+
+     first: T;
+
+     last: T;
+
+     map<U>(fn: (item: T) => U): U[];
+  }
+
+
+  /**
+   * Service for dynamically loading a Component into an arbitrary position in the internal Angular
+   * application tree.
+   */
+  class DynamicComponentLoader {
+
+
+    /**
+     * Loads a root component that is placed at the first element that matches the component's
+     * selector.
+     *
+     * - `typeOrBinding` `Type` \ {@link Binding} - representing the component to load.
+     * - `overrideSelector` (optional) selector to load the component at (or use
+     *   `@Component.selector`) The selector can be anywhere (i.e. outside the current component.)
+     * - `injector` {@link Injector} - optional injector to use for the component.
+     *
+     * The loaded component receives injection normally as a hosted view.
+     *
+     *
+     * ## Example
+     *
+     * ```
+     * @ng.Component({
+     *   selector: 'child-component'
+     * })
+     * @ng.View({
+     *   template: 'Child'
+     * })
+     * class ChildComponent {
+     * }
+     *
+     *
+     *
+     * @ng.Component({
+     *   selector: 'my-app'
+     * })
+     * @ng.View({
+     *   template: `
+     *     Parent (<child id="child"></child>)
+     *   `
+     * })
+     * class MyApp {
+     *   constructor(dynamicComponentLoader: ng.DynamicComponentLoader, injector: ng.Injector) {
+     *     dynamicComponentLoader.loadAsRoot(ChildComponent, '#child', injector);
+     *   }
+     * }
+     *
+     * ng.bootstrap(MyApp);
+     * ```
+     *
+     * Resulting DOM:
+     *
+     * ```
+     * <my-app>
+     *   Parent (
+     *     <child id="child">
+     *        Child
+     *     </child>
+     *   )
+     * </my-app>
+     * ```
+     */
+     loadAsRoot(typeOrBinding: Type | Binding, overrideSelector: string, injector: Injector): Promise<ComponentRef>;
+
+
+    /**
+     * Loads a component into the component view of the provided ElementRef next to the element
+     * with the given name.
+     *
+     * The loaded component receives injection normally as a hosted view.
+     *
+     * ## Example
+     *
+     * ```
+     * @ng.Component({
+     *   selector: 'child-component'
+     * })
+     * @ng.View({
+     *   template: 'Child'
+     * })
+     * class ChildComponent {
+     * }
+     *
+     *
+     * @ng.Component({
+     *   selector: 'my-app'
+     * })
+     * @ng.View({
+     *   template: `
+     *     Parent (<div #child></div>)
+     *   `
+     * })
+     * class MyApp {
+     *   constructor(dynamicComponentLoader: ng.DynamicComponentLoader, elementRef: ng.ElementRef) {
+     *     dynamicComponentLoader.loadIntoLocation(ChildComponent, elementRef, 'child');
+     *   }
+     * }
+     *
+     * ng.bootstrap(MyApp);
+     * ```
+     *
+     * Resulting DOM:
+     *
+     * ```
+     * <my-app>
+     *    Parent (
+     *      <div #child="" class="ng-binding"></div>
+     *      <child-component class="ng-binding">Child</child-component>
+     *    )
+     * </my-app>
+     * ```
+     */
+     loadIntoLocation(typeOrBinding: Type | Binding, hostLocation: ElementRef, anchorName: string, bindings?: ResolvedBinding[]): Promise<ComponentRef>;
+
+
+    /**
+     * Loads a component next to the provided ElementRef.
+     *
+     * The loaded component receives injection normally as a hosted view.
+     *
+     *
+     * ## Example
+     *
+     * ```
+     * @ng.Component({
+     *   selector: 'child-component'
+     * })
+     * @ng.View({
+     *   template: 'Child'
+     * })
+     * class ChildComponent {
+     * }
+     *
+     *
+     * @ng.Component({
+     *   selector: 'my-app'
+     * })
+     * @ng.View({
+     *   template: `Parent`
+     * })
+     * class MyApp {
+     *   constructor(dynamicComponentLoader: ng.DynamicComponentLoader, elementRef: ng.ElementRef) {
+     *     dynamicComponentLoader.loadIntoLocation(ChildComponent, elementRef, 'child');
+     *   }
+     * }
+     *
+     * ng.bootstrap(MyApp);
+     * ```
+     *
+     * Resulting DOM:
+     *
+     * ```
+     * <my-app>Parent</my-app>
+     * <child-component>Child</child-component>
+     * ```
+     */
+     loadNextToLocation(typeOrBinding: Type | Binding, location: ElementRef, bindings?: ResolvedBinding[]): Promise<ComponentRef>;
+  }
+
+
+  /**
+   * Provides access to explicitly trigger change detection in an application.
+   *
+   * By default, `Zone` triggers change detection in Angular on each virtual machine (VM) turn. When
+   * testing, or in some
+   * limited application use cases, a developer can also trigger change detection with the
+   * `lifecycle.tick()` method.
+   *
+   * Each Angular application has a single `LifeCycle` instance.
+   *
+   * # Example
+   *
+   * This is a contrived example, since the bootstrap automatically runs inside of the `Zone`, which
+   * invokes
+   * `lifecycle.tick()` on your behalf.
+   *
+   * ```javascript
+   * bootstrap(MyApp).then((ref:ComponentRef) => {
+   *   var lifeCycle = ref.injector.get(LifeCycle);
+   *   var myApp = ref.instance;
+   *
+   *   ref.doSomething();
+   *   lifecycle.tick();
+   * });
+   * ```
+   */
+  class LifeCycle {
+
+
+    /**
+     * @private
+     */
+     registerWith(zone: NgZone, changeDetector?: ChangeDetector): void;
+
+
+    /**
+     * Invoke this method to explicitly process change detection and its side-effects.
+     *
+     *  In development mode, `tick()` also performs a second change detection cycle to ensure that no
+     * further
+     *  changes are detected. If additional changes are picked up during this second cycle, bindings
+     * in
+     * the app have
+     *  side-effects that cannot be resolved in a single change detection pass. In this case, Angular
+     * throws an error,
+     *  since an Angular application can only have one change detection pass during which all change
+     * detection must
+     *  complete.
+     */
+     tick(): void;
+  }
+
+
+  /**
+   * Reference to the element.
+   *
+   * Represents an opaque reference to the underlying element. The element is a DOM ELement in
+   * a Browser, but may represent other types on other rendering platforms. In the browser the
+   * `ElementRef` can be sent to the web-worker. Web Workers can not have references to the
+   * DOM Elements.
+   */
+  class ElementRef implements RenderElementRef {
+
+
+    /**
+     * Reference to the {@link ViewRef} where the `ElementRef` is inside of.
+     */
+     parentView: ViewRef;
+
+
+    /**
+     * Index of the element inside the {@link ViewRef}.
+     *
+     * This is used internally by the Angular framework to locate elements.
+     */
+     boundElementIndex: number;
+
+
+    /**
+     * Index of the element inside the `RenderViewRef`.
+     *
+     * This is used internally by the Angular framework to locate elements.
+     */
+     renderBoundElementIndex: number;
+
+     renderView: RenderViewRef;
+
+
+    /**
+     * Returns the native Element implementation.
+     *
+     * In the browser this represents the DOM Element.
+     *
+     * The `nativeElement` can be used as an escape hatch when direct DOM manipulation is needed. Use
+     * this with caution, as it creates tight coupling between your application and the Browser, which
+     * will not work in WebWorkers.
+     *
+     * NOTE: This method will return null in the webworker scenario!
+     */
+     nativeElement: any;
+  }
+
+
+  /**
+   * Reference to a template within a component.
+   *
+   * Represents an opaque reference to the underlying template that can
+   * be instantiated using the {@link ViewContainerRef}.
+   */
+  class TemplateRef {
+
+
+    /**
+     * The location of the template
+     */
+     elementRef: ElementRef;
+
+     protoViewRef: ProtoViewRef;
+
+
+    /**
+     * Whether this template has a local variable with the given name
+     */
+     hasLocal(name: string): boolean;
+  }
+
+
+  /**
+   * A reference to an Angular View.
+   *
+   * A View is a fundamental building block of Application UI. A View is the smallest set of
+   * elements which are created and destroyed together. A View can change properties on the elements
+   * within the view, but it can not change the structure of those elements.
+   *
+   * To change structure of the elements, the Views can contain zero or more {@link ViewContainerRef}s
+   * which allow the views to be nested.
+   *
+   * ## Example
+   *
+   * Given this template
+   *
+   * ```
+   * Count: {{items.length}}
+   * <ul>
+   *   <li *ng-for="var item of items">{{item}}</li>
+   * </ul>
+   * ```
+   *
+   * The above example we have two {@link ProtoViewRef}s:
+   *
+   * Outter {@link ProtoViewRef}:
+   * ```
+   * Count: {{items.length}}
+   * <ul>
+   *   <template ng-for var-item [ng-for-of]="items"></template>
+   * </ul>
+   * ```
+   *
+   * Inner {@link ProtoViewRef}:
+   * ```
+   *   <li>{{item}}</li>
+   * ```
+   *
+   * Notice that the original template is broken down into two separate {@link ProtoViewRef}s.
+   *
+   * The outter/inner {@link ProtoViewRef}s are then assembled into views like so:
+   *
+   * ```
+   * <!-- ViewRef: outer-0 -->
+   * Count: 2
+   * <ul>
+   *   <template view-container-ref></template>
+   *   <!-- ViewRef: inner-1 --><li>first</li><!-- /ViewRef: inner-1 -->
+   *   <!-- ViewRef: inner-2 --><li>second</li><!-- /ViewRef: inner-2 -->
+   * </ul>
+   * <!-- /ViewRef: outer-0 -->
+   * ```
+   */
+  interface ViewRef extends HostViewRef {
+
+
+    /**
+     * Return `RenderViewRef`
+     */
+     render: RenderViewRef;
+
+
+    /**
+     * Return `RenderFragmentRef`
+     */
+     renderFragment: RenderFragmentRef;
+
+
+    /**
+     * Set local variable in a view.
+     *
+     * - `contextName` - Name of the local variable in a view.
+     * - `value` - Value for the local variable in a view.
+     */
+     setLocal(contextName: string, value: any): void;
+  }
+
+  interface HostViewRef {
+  }
+
+
+  /**
+   * A reference to an Angular ProtoView.
+   *
+   * A ProtoView is a reference to a template for easy creation of views.
+   * (See {@link AppViewManager#createViewInContainer `AppViewManager#createViewInContainer`} and
+   * {@link AppViewManager#createRootHostView `AppViewManager#createRootHostView`}).
+   *
+   * A `ProtoView` is a factory for creating `View`s.
+   *
+   * ## Example
+   *
+   * Given this template
+   *
+   * ```
+   * Count: {{items.length}}
+   * <ul>
+   *   <li *ng-for="var item of items">{{item}}</li>
+   * </ul>
+   * ```
+   *
+   * The above example we have two {@link ProtoViewRef}s:
+   *
+   * Outter {@link ProtoViewRef}:
+   * ```
+   * Count: {{items.length}}
+   * <ul>
+   *   <template ng-for var-item [ng-for-of]="items"></template>
+   * </ul>
+   * ```
+   *
+   * Inner {@link ProtoViewRef}:
+   * ```
+   *   <li>{{item}}</li>
+   * ```
+   *
+   * Notice that the original template is broken down into two separate {@link ProtoViewRef}s.
+   */
+  interface ProtoViewRef {
+  }
+
+
+  /**
+   * A location where {@link ViewRef}s can be attached.
+   *
+   * A `ViewContainerRef` represents a location in a {@link ViewRef} where other child
+   * {@link ViewRef}s can be inserted. Adding and removing views is the only way of structurally
+   * changing the rendered DOM of the application.
+   */
+  interface ViewContainerRef {
+
+     viewManager: AppViewManager;
+
+     element: ElementRef;
+
+
+    /**
+     * Remove all {@link ViewRef}s at current location.
+     */
+     clear(): void;
+
+
+    /**
+     * Return a {@link ViewRef} at specific index.
+     */
+     get(index: number): ViewRef;
+
+
+    /**
+     * Returns number of {@link ViewRef}s currently attached at this location.
+     */
+     length: number;
+
+
+    /**
+     * Create and insert a {@link ViewRef} into the view-container.
+     *
+     * - `protoViewRef` (optional) {@link ProtoViewRef} - The `ProtoView` to use for creating
+     *   `View` to be inserted at this location. If `ViewContainer` is created at a location
+     *   of inline template, then `protoViewRef` is the `ProtoView` of the template.
+     * - `atIndex` (optional) `number` - location of insertion point. (Or at the end if unspecified.)
+     * - `context` (optional) {@link ElementRef} - Context (for expression evaluation) from the
+     *   {@link ElementRef} location. (Or current context if unspecified.)
+     * - `bindings` (optional) Array of {@link ResolvedBinding} - Used for configuring
+     *   `ElementInjector`.
+     *
+     * Returns newly created {@link ViewRef}.
+     */
+     createEmbeddedView(templateRef: TemplateRef, atIndex?: number): ViewRef;
+
+     createHostView(protoViewRef?: ProtoViewRef, atIndex?: number, dynamicallyCreatedBindings?: ResolvedBinding[]): HostViewRef;
+
+
+    /**
+     * Insert a {@link ViewRef} at specefic index.
+     *
+     * The index is location at which the {@link ViewRef} should be attached. If omitted it is
+     * inserted at the end.
+     *
+     * Returns the inserted {@link ViewRef}.
+     */
+     insert(viewRef: ViewRef, atIndex?: number): ViewRef;
+
+
+    /**
+     * Return the index of already inserted {@link ViewRef}.
+     */
+     indexOf(viewRef: ViewRef): number;
+
+
+    /**
+     * Remove a {@link ViewRef} at specific index.
+     *
+     * If the index is omitted last {@link ViewRef} is removed.
+     */
+     remove(atIndex?: number): void;
+
+
+    /**
+     * The method can be used together with insert to implement a view move, i.e.
+     * moving the dom nodes while the directives in the view stay intact.
+     */
+     detach(atIndex?: number): ViewRef;
+  }
+
+
+  /**
+   * Angular's reference to a component instance.
+   *
+   * `ComponentRef` represents a component instance lifecycle and meta information.
+   */
+  interface ComponentRef {
+
+
+    /**
+     * Location of the component host element.
+     */
+     location: ElementRef;
+
+
+    /**
+     * Instance of component.
+     */
+     instance: any;
+
+
+    /**
+     * Returns the host {@link ViewRef}.
+     */
+     hostView: HostViewRef;
+
+
+    /**
+     * Dispose of the component instance.
+     */
+     dispose(): void;
+  }
+
+
+  /**
+   * A wrapper around zones that lets you schedule tasks after it has executed a task.
+   *
+   * The wrapper maintains an "inner" and an "mount" `Zone`. The application code will executes
+   * in the "inner" zone unless `runOutsideAngular` is explicitely called.
+   *
+   * A typical application will create a singleton `NgZone`. The outer `Zone` is a fork of the root
+   * `Zone`. The default `onTurnDone` runs the Angular change detection.
+   */
+  class NgZone {
+
+
+    /**
+     * Sets the zone hook that is called just before Angular event turn starts.
+     * It is called once per browser event.
+     */
+     overrideOnTurnStart(onTurnStartFn: Function): void;
+
+
+    /**
+     * Sets the zone hook that is called immediately after Angular processes
+     * all pending microtasks.
+     */
+     overrideOnTurnDone(onTurnDoneFn: Function): void;
+
+
+    /**
+     * Sets the zone hook that is called immediately after the last turn in
+     * an event completes. At this point Angular will no longer attempt to
+     * sync the UI. Any changes to the data model will not be reflected in the
+     * DOM. `onEventDoneFn` is executed outside Angular zone.
+     *
+     * This hook is useful for validating application state (e.g. in a test).
+     */
+     overrideOnEventDone(onEventDoneFn: Function, opt_waitForAsync: boolean): void;
+
+
+    /**
+     * Sets the zone hook that is called when an error is uncaught in the
+     * Angular zone. The first argument is the error. The second argument is
+     * the stack trace.
+     */
+     overrideOnErrorHandler(errorHandlingFn: Function): void;
+
+
+    /**
+     * Runs `fn` in the inner zone and returns whatever it returns.
+     *
+     * In a typical app where the inner zone is the Angular zone, this allows one to make use of the
+     * Angular's auto digest mechanism.
+     *
+     * ```
+     * var zone: NgZone = [ref to the application zone];
+     *
+     * zone.run(() => {
+     *   // the change detection will run after this function and the microtasks it enqueues have
+     * executed.
+     * });
+     * ```
+     */
+     run(fn: () => any): any;
+
+
+    /**
+     * Runs `fn` in the outer zone and returns whatever it returns.
+     *
+     * In a typical app where the inner zone is the Angular zone, this allows one to escape Angular's
+     * auto-digest mechanism.
+     *
+     * ```
+     * var zone: NgZone = [ref to the application zone];
+     *
+     * zone.runOutsideAngular(() => {
+     *   element.onClick(() => {
+     *     // Clicking on the element would not trigger the change detection
+     *   });
+     * });
+     * ```
+     */
+     runOutsideAngular(fn: () => any): any;
+  }
+
+  class Observable {
+
+     observer(generator: any): Object;
+  }
+
+
+  /**
+   * Use Rx.Observable but provides an adapter to make it work as specified here:
+   * https://github.com/jhusain/observable-spec
+   *
+   * Once a reference implementation of the spec is available, switch to it.
+   */
+  class EventEmitter extends Observable {
+
+     observer(generator: any): Rx.IDisposable;
+
+     toRx(): Rx.Observable<any>;
+
+     next(value: any): void;
+
+     throw(error: any): void;
+
+     return(value?: any): void;
+  }
+
+
+  /**
+   * A parameter metadata that specifies a dependency.
+   *
+   * ```
+   * class AComponent {
+   *   constructor(@Inject(MyService) aService:MyService) {}
+   * }
+   * ```
+   */
+  class InjectMetadata {
+
+     token: any;
+
+     toString(): string;
+  }
+
+
+  /**
+   * A parameter metadata that marks a dependency as optional. {@link Injector} provides `null` if
+   * the dependency is not found.
+   *
+   * ```
+   * class AComponent {
+   *   constructor(@Optional() aService:MyService) {
+   *     this.aService = aService;
+   *   }
+   * }
+   * ```
+   */
+  class OptionalMetadata {
+
+     toString(): string;
+  }
+
+
+  /**
+   * A marker metadata that marks a class as available to `Injector` for creation. Used by tooling
+   * for generating constructor stubs.
+   *
+   * ```
+   * class NeedsService {
+   *   constructor(svc:UsefulService) {}
+   * }
+   *
+   * @Injectable
+   * class UsefulService {}
+   * ```
+   */
+  class InjectableMetadata {
+  }
+
+
+  /**
+   * Specifies that an injector should retrieve a dependency from itself.
+   *
+   * ## Example
+   *
+   * ```
+   * class Dependency {
+   * }
+   *
+   * class NeedsDependency {
+   *   constructor(public @Self() dependency:Dependency) {}
+   * }
+   *
+   * var inj = Injector.resolveAndCreate([Dependency, NeedsDependency]);
+   * var nd = inj.get(NeedsDependency);
+   * expect(nd.dependency).toBeAnInstanceOf(Dependency);
+   * ```
+   */
+  class SelfMetadata {
+
+     toString(): string;
+  }
+
+
+  /**
+   * Specifies that an injector should retrieve a dependency from any injector until reaching the
+   * closest host.
+   *
+   * ## Example
+   *
+   * ```
+   * class Dependency {
+   * }
+   *
+   * class NeedsDependency {
+   *   constructor(public @Host() dependency:Dependency) {}
+   * }
+   *
+   * var parent = Injector.resolveAndCreate([
+   *   bind(Dependency).toClass(HostDependency)
+   * ]);
+   * var child = parent.resolveAndCreateChild([]);
+   * var grandChild = child.resolveAndCreateChild([NeedsDependency, Depedency]);
+   * var nd = grandChild.get(NeedsDependency);
+   * expect(nd.dependency).toBeAnInstanceOf(HostDependency);
+   * ```
+   */
+  class HostMetadata {
+
+     toString(): string;
+  }
+
+
+  /**
+   * Specifies that the dependency resolution should start from the parent injector.
+   *
+   * ## Example
+   *
+   *
+   * ```
+   * class Service {}
+   *
+   * class ParentService implements Service {
+   * }
+   *
+   * class ChildService implements Service {
+   *   constructor(public @SkipSelf() parentService:Service) {}
+   * }
+   *
+   * var parent = Injector.resolveAndCreate([
+   *   bind(Service).toClass(ParentService)
+   * ]);
+   * var child = parent.resolveAndCreateChild([
+   *   bind(Service).toClass(ChildSerice)
+   * ]);
+   * var s = child.get(Service);
+   * expect(s).toBeAnInstanceOf(ChildService);
+   * expect(s.parentService).toBeAnInstanceOf(ParentService);
+   * ```
+   */
+  class SkipSelfMetadata {
+
+     toString(): string;
+  }
+
+
+  /**
+   * `DependencyMetadata is used by the framework to extend DI.
+   *
+   * Only metadata implementing `DependencyMetadata` are added to the list of dependency
+   * properties.
+   *
+   * For example:
+   *
+   * ```
+   * class Exclude extends DependencyMetadata {}
+   * class NotDependencyProperty {}
+   *
+   * class AComponent {
+   *   constructor(@Exclude @NotDependencyProperty aService:AService) {}
+   * }
+   * ```
+   *
+   * will create the following dependency:
+   *
+   * ```
+   * new Dependency(Key.get(AService), [new Exclude()])
+   * ```
+   *
+   * The framework can use `new Exclude()` to handle the `aService` dependency
+   * in a specific way.
+   */
+  class DependencyMetadata {
+
+     token: any;
+  }
+
+
+  /**
+   * Allows to refer to references which are not yet defined.
+   *
+   * This situation arises when the key which we need te refer to for the purposes of DI is declared,
+   * but not yet defined.
+   *
+   * ## Example:
+   *
+   * ```
+   * class Door {
+   *   // Incorrect way to refer to a reference which is defined later.
+   *   // This fails because `Lock` is undefined at this point.
+   *   constructor(lock:Lock) { }
+   *
+   *   // Correct way to refer to a reference which is defined later.
+   *   // The reference needs to be captured in a closure.
+   *   constructor(@Inject(forwardRef(() => Lock)) lock:Lock) { }
+   * }
+   *
+   * // Only at this point the lock is defined.
+   * class Lock {
+   * }
+   * ```
+   */
+  function forwardRef(forwardRefFn: ForwardRefFn) : Type ;
+
+
+  /**
+   * Lazily retrieve the reference value.
+   *
+   * See: {@link forwardRef}
+   */
+  function resolveForwardRef(type: any) : any ;
+
+  interface ForwardRefFn {
+
+     (): any;
+
+  }
+
+
+  /**
+   * A dependency injection container used for resolving dependencies.
+   *
+   * An `Injector` is a replacement for a `new` operator, which can automatically resolve the
+   * constructor dependencies.
+   * In typical use, application code asks for the dependencies in the constructor and they are
+   * resolved by the `Injector`.
+   *
+   * ## Example:
+   *
+   * Suppose that we want to inject an `Engine` into class `Car`, we would define it like this:
+   *
+   * ```javascript
+   * class Engine {
+   * }
+   *
+   * class Car {
+   *   constructor(@Inject(Engine) engine) {
+   *   }
+   * }
+   *
+   * ```
+   *
+   * Next we need to write the code that creates and instantiates the `Injector`. We then ask for the
+   * `root` object, `Car`, so that the `Injector` can recursively build all of that object's
+   * dependencies.
+   *
+   * ```javascript
+   * main() {
+   *   var injector = Injector.resolveAndCreate([Car, Engine]);
+   *
+   *   // Get a reference to the `root` object, which will recursively instantiate the tree.
+   *   var car = injector.get(Car);
+   * }
+   * ```
+   * Notice that we don't use the `new` operator because we explicitly want to have the `Injector`
+   * resolve all of the object's dependencies automatically.
+   */
+  class Injector {
+
+
+    /**
+     * Turns a list of binding definitions into an internal resolved list of resolved bindings.
+     *
+     * A resolution is a process of flattening multiple nested lists and converting individual
+     * bindings into a list of {@link ResolvedBinding}s. The resolution can be cached by `resolve`
+     * for the {@link Injector} for performance-sensitive code.
+     *
+     * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
+     * recursive list of more bindings.
+     *
+     * The returned list is sparse, indexed by `id` for the {@link Key}. It is generally not useful to
+     * application code
+     * other than for passing it to {@link Injector} functions that require resolved binding lists,
+     * such as
+     * `fromResolvedBindings` and `createChildFromResolved`.
+     */
+     static resolve(bindings: Array<Type | Binding | any[]>): ResolvedBinding[];
+
+
+    /**
+     * Resolves bindings and creates an injector based on those bindings. This function is slower than
+     * the corresponding `fromResolvedBindings` because it needs to resolve bindings first. See
+     * `resolve`
+     * for the {@link Injector}.
+     *
+     * Prefer `fromResolvedBindings` in performance-critical code that creates lots of injectors.
+     *
+     * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
+     * recursive list of more
+     * bindings.
+     * @param `depProvider`
+     */
+     static resolveAndCreate(bindings: Array<Type | Binding | any[]>, depProvider?: DependencyProvider): Injector;
+
+
+    /**
+     * Creates an injector from previously resolved bindings. This bypasses resolution and flattening.
+     * This API is the recommended way to construct injectors in performance-sensitive parts.
+     *
+     * @param `bindings` A sparse list of {@link ResolvedBinding}s. See `resolve` for the
+     * {@link Injector}.
+     * @param `depProvider`
+     */
+     static fromResolvedBindings(bindings: ResolvedBinding[], depProvider?: DependencyProvider): Injector;
+
+
+    /**
+     * Returns debug information about the injector.
+     *
+     * This information is included into exceptions thrown by the injector.
+     */
+     debugContext(): any;
+
+
+    /**
+     * Retrieves an instance from the injector.
+     *
+     * @param `token`: usually the `Type` of an object. (Same as the token used while setting up a
+     * binding).
+     * @returns an instance represented by the token. Throws if not found.
+     */
+     get(token: any): any;
+
+
+    /**
+     * Retrieves an instance from the injector.
+     *
+     * @param `token`: usually a `Type`. (Same as the token used while setting up a binding).
+     * @returns an instance represented by the token. Returns `null` if not found.
+     */
+     getOptional(token: any): any;
+
+
+    /**
+     * Retrieves an instance from the injector.
+     *
+     * @param `index`: index of an instance.
+     * @returns an instance represented by the index. Throws if not found.
+     */
+     getAt(index: number): any;
+
+
+    /**
+     * Direct parent of this injector.
+     */
+     parent: Injector;
+
+
+    /**
+     * Internal. Do not use.
+     *
+     * We return `any` not to export the InjectorStrategy type.
+     */
+     internalStrategy: any;
+
+
+    /**
+     * Creates a child injector and loads a new set of bindings into it.
+     *
+     * A resolution is a process of flattening multiple nested lists and converting individual
+     * bindings into a list of {@link ResolvedBinding}s. The resolution can be cached by `resolve`
+     * for the {@link Injector} for performance-sensitive code.
+     *
+     * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
+     * recursive list of more bindings.
+     * @param `depProvider`
+     */
+     resolveAndCreateChild(bindings: Array<Type | Binding | any[]>, depProvider?: DependencyProvider): Injector;
+
+
+    /**
+     * Creates a child injector and loads a new set of {@link ResolvedBinding}s into it.
+     *
+     * @param `bindings`: A sparse list of {@link ResolvedBinding}s.
+     * See `resolve` for the {@link Injector}.
+     * @param `depProvider`
+     * @returns a new child {@link Injector}.
+     */
+     createChildFromResolved(bindings: ResolvedBinding[], depProvider?: DependencyProvider): Injector;
+
+
+    /**
+     * Resolves a binding and instantiates an object in the context of the injector.
+     *
+     * @param `binding`: either a type or a binding.
+     * @returns an object created using binding.
+     */
+     resolveAndInstantiate(binding: Type | Binding): any;
+
+
+    /**
+     * Instantiates an object using a resolved bindin in the context of the injector.
+     *
+     * @param `binding`: a resolved binding
+     * @returns an object created using binding.
+     */
+     instantiateResolved(binding: ResolvedBinding): any;
+
+     displayName: string;
+
+     toString(): string;
+  }
+
+  class ProtoInjector {
+
+     numberOfBindings: number;
+
+     getBindingAtIndex(index: number): any;
+  }
+
+  class BindingWithVisibility {
+
+     binding: ResolvedBinding;
+
+     visibility: Visibility;
+
+     getKeyId(): number;
+  }
+
+
+  /**
+   * Used to provide dependencies that cannot be easily expressed as bindings.
+   */
+  interface DependencyProvider {
+
+     getDependency(injector: Injector, binding: ResolvedBinding, dependency: Dependency): any;
+  }
+
+  enum Visibility {
+
+     Public,
+
+     Private,
+
+     PublicAndPrivate
+  }
+
+  const UNDEFINED : Object ;
+
+
+  /**
+   * Describes how_ the {@link Injector} should instantiate a given token.
+   *
+   * See {@link bind}.
+   *
+   * ## Example
+   *
+   * ```javascript
+   * var injector = Injector.resolveAndCreate([
+   *   new Binding(String, { toValue: 'Hello' })
+   * ]);
+   *
+   * expect(injector.get(String)).toEqual('Hello');
+   * ```
+   */
+  class Binding {
+
+
+    /**
+     * Token used when retrieving this binding. Usually the `Type`.
+     */
+     token: any;
+
+
+    /**
+     * Binds an interface to an implementation / subclass.
+     *
+     * ## Example
+     *
+     * Becuse `toAlias` and `toClass` are often confused, the example contains both use cases for easy
+     * comparison.
+     *
+     * ```javascript
+     *
+     * class Vehicle {}
+     *
+     * class Car extends Vehicle {}
+     *
+     * var injectorClass = Injector.resolveAndCreate([
+     *   Car,
+     *   new Binding(Vehicle, { toClass: Car })
+     * ]);
+     * var injectorAlias = Injector.resolveAndCreate([
+     *   Car,
+     *   new Binding(Vehicle, { toAlias: Car })
+     * ]);
+     *
+     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+     *
+     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+     * ```
+     */
+     toClass: Type;
+
+
+    /**
+     * Binds a key to a value.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   new Binding(String, { toValue: 'Hello' })
+     * ]);
+     *
+     * expect(injector.get(String)).toEqual('Hello');
+     * ```
+     */
+     toValue: any;
+
+
+    /**
+     * Binds a key to the alias for an existing key.
+     *
+     * An alias means that {@link Injector} returns the same instance as if the alias token was used.
+     * This is in contrast to `toClass` where a separate instance of `toClass` is returned.
+     *
+     * ## Example
+     *
+     * Becuse `toAlias` and `toClass` are often confused the example contains both use cases for easy
+     * comparison.
+     *
+     * ```javascript
+     *
+     * class Vehicle {}
+     *
+     * class Car extends Vehicle {}
+     *
+     * var injectorAlias = Injector.resolveAndCreate([
+     *   Car,
+     *   new Binding(Vehicle, { toAlias: Car })
+     * ]);
+     * var injectorClass = Injector.resolveAndCreate([
+     *   Car,
+     *   new Binding(Vehicle, { toClass: Car })
+     * ]);
+     *
+     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+     *
+     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+     * ```
+     */
+     toAlias: any;
+
+
+    /**
+     * Binds a key to a function which computes the value.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   new Binding(Number, { toFactory: () => { return 1+2; }}),
+     *   new Binding(String, { toFactory: (value) => { return "Value: " + value; },
+     *                         dependencies: [Number] })
+     * ]);
+     *
+     * expect(injector.get(Number)).toEqual(3);
+     * expect(injector.get(String)).toEqual('Value: 3');
+     * ```
+     */
+     toFactory: Function;
+
+
+    /**
+     * Used in conjunction with `toFactory` and specifies a set of dependencies
+     * (as `token`s) which should be injected into the factory function.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   new Binding(Number, { toFactory: () => { return 1+2; }}),
+     *   new Binding(String, { toFactory: (value) => { return "Value: " + value; },
+     *                         dependencies: [Number] })
+     * ]);
+     *
+     * expect(injector.get(Number)).toEqual(3);
+     * expect(injector.get(String)).toEqual('Value: 3');
+     * ```
+     */
+     dependencies: any[];
+
+
+    /**
+     * Converts the {@link Binding} into {@link ResolvedBinding}.
+     *
+     * {@link Injector} internally only uses {@link ResolvedBinding}, {@link Binding} contains
+     * convenience binding syntax.
+     */
+     resolve(): ResolvedBinding;
+  }
+
+
+  /**
+   * Helper class for the {@link bind} function.
+   */
+  class BindingBuilder {
+
+     token: any;
+
+
+    /**
+     * Binds an interface to an implementation / subclass.
+     *
+     * ## Example
+     *
+     * Because `toAlias` and `toClass` are often confused, the example contains both use cases for
+     * easy comparison.
+     *
+     * ```javascript
+     *
+     * class Vehicle {}
+     *
+     * class Car extends Vehicle {}
+     *
+     * var injectorClass = Injector.resolveAndCreate([
+     *   Car,
+     *   bind(Vehicle).toClass(Car)
+     * ]);
+     * var injectorAlias = Injector.resolveAndCreate([
+     *   Car,
+     *   bind(Vehicle).toAlias(Car)
+     * ]);
+     *
+     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+     *
+     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+     * ```
+     */
+     toClass(type: Type): Binding;
+
+
+    /**
+     * Binds a key to a value.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   bind(String).toValue('Hello')
+     * ]);
+     *
+     * expect(injector.get(String)).toEqual('Hello');
+     * ```
+     */
+     toValue(value: any): Binding;
+
+
+    /**
+     * Binds a key to the alias for an existing key.
+     *
+     * An alias means that we will return the same instance as if the alias token was used. (This is
+     * in contrast to `toClass` where a separate instance of `toClass` will be returned.)
+     *
+     * ## Example
+     *
+     * Becuse `toAlias` and `toClass` are often confused, the example contains both use cases for easy
+     * comparison.
+     *
+     * ```javascript
+     *
+     * class Vehicle {}
+     *
+     * class Car extends Vehicle {}
+     *
+     * var injectorAlias = Injector.resolveAndCreate([
+     *   Car,
+     *   bind(Vehicle).toAlias(Car)
+     * ]);
+     * var injectorClass = Injector.resolveAndCreate([
+     *   Car,
+     *   bind(Vehicle).toClass(Car)
+     * ]);
+     *
+     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+     *
+     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+     * ```
+     */
+     toAlias(aliasToken: /*Type*/ any): Binding;
+
+
+    /**
+     * Binds a key to a function which computes the value.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   bind(Number).toFactory(() => { return 1+2; }),
+     *   bind(String).toFactory((v) => { return "Value: " + v; }, [Number])
+     * ]);
+     *
+     * expect(injector.get(Number)).toEqual(3);
+     * expect(injector.get(String)).toEqual('Value: 3');
+     * ```
+     */
+     toFactory(factoryFunction: Function, dependencies?: any[]): Binding;
+  }
+
+
+  /**
+   * An internal resolved representation of a {@link Binding} used by the {@link Injector}.
+   *
+   * A {@link Binding} is resolved when it has a factory function. Binding to a class, alias, or
+   * value, are just convenience methods, as {@link Injector} only operates on calling factory
+   * functions.
+   */
+  class ResolvedBinding {
+
+
+    /**
+     * A key, usually a `Type`.
+     */
+     key: Key;
+
+
+    /**
+     * Factory function which can return an instance of an object represented by a key.
+     */
+     factory: Function;
+
+
+    /**
+     * Arguments (dependencies) to the `factory` function.
+     */
+     dependencies: Dependency[];
+  }
+
+
+  /**
+   * @private
+   */
+  class Dependency {
+
+     static fromKey(key: Key): Dependency;
+
+     key: Key;
+
+     optional: boolean;
+
+     lowerBoundVisibility: any;
+
+     upperBoundVisibility: any;
+
+     properties: any[];
+  }
+
+
+  /**
+   * Provides an API for imperatively constructing {@link Binding}s.
+   *
+   * This is only relevant for JavaScript. See {@link BindingBuilder}.
+   *
+   * ## Example
+   *
+   * ```javascript
+   * bind(MyInterface).toClass(MyClass)
+   *
+   * ```
+   */
+  function bind(token: any) : BindingBuilder ;
+
+
+  /**
+   * A unique object used for retrieving items from the {@link Injector}.
+   *
+   * Keys have:
+   * - a system-wide unique `id`.
+   * - a `token`, usually the `Type` of the instance.
+   *
+   * Keys are used internally by the {@link Injector} because their system-wide unique `id`s allow the
+   * injector to index in arrays rather than looking up items in maps.
+   */
+  class Key {
+
+
+    /**
+     * Retrieves a `Key` for a token.
+     */
+     static get(token: Object): Key;
+
+
+    /**
+     * @returns the number of keys registered in the system.
+     */
+     static numberOfKeys: number;
+
+     token: Object;
+
+     id: number;
+
+     displayName: string;
+  }
+
+
+  /**
+   * @private
+   */
+  class KeyRegistry {
+
+     get(token: Object): Key;
+
+     numberOfKeys: number;
+  }
+
+
+  /**
+   * Type literals is a Dart-only feature. This is here only so we can x-compile
+   * to multiple languages.
+   */
+  class TypeLiteral {
+
+     type: any;
+  }
+
+
+  /**
+   * Thrown when trying to retrieve a dependency by `Key` from {@link Injector}, but the
+   * {@link Injector} does not have a {@link Binding} for {@link Key}.
+   */
+  class NoBindingError extends AbstractBindingError {
+  }
+
+
+  /**
+   * Base class for all errors arising from misconfigured bindings.
+   */
+  class AbstractBindingError extends BaseException {
+
+     name: string;
+
+     message: string;
+
+     keys: Key[];
+
+     injectors: Injector[];
+
+     constructResolvingMessage: Function;
+
+     addKey(injector: Injector, key: Key): void;
+
+     context: any;
+
+     toString(): string;
+  }
+
+
+  /**
+   * Thrown when dependencies form a cycle.
+   *
+   * ## Example:
+   *
+   * ```javascript
+   * class A {
+   *   constructor(b:B) {}
+   * }
+   * class B {
+   *   constructor(a:A) {}
+   * }
+   * ```
+   *
+   * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.
+   */
+  class CyclicDependencyError extends AbstractBindingError {
+  }
+
+
+  /**
+   * Thrown when a constructing type returns with an Error.
+   *
+   * The `InstantiationError` class contains the original error plus the dependency graph which caused
+   * this object to be instantiated.
+   */
+  class InstantiationError extends AbstractBindingError {
+
+     causeKey: Key;
+  }
+
+
+  /**
+   * Thrown when an object other then {@link Binding} (or `Type`) is passed to {@link Injector}
+   * creation.
+   */
+  class InvalidBindingError extends BaseException {
+
+     message: string;
+
+     toString(): string;
+  }
+
+
+  /**
+   * Thrown when the class has no annotation information.
+   *
+   * Lack of annotation information prevents the {@link Injector} from determining which dependencies
+   * need to be injected into the constructor.
+   */
+  class NoAnnotationError extends BaseException {
+
+     name: string;
+
+     message: string;
+
+     toString(): string;
+  }
+
+
+  /**
+   * Thrown when getting an object by index.
+   */
+  class OutOfBoundsError extends BaseException {
+
+     message: string;
+
+     toString(): string;
+  }
+
+  class OpaqueToken {
+
+     toString(): string;
+  }
+
+
+  /**
+   * Factory for creating {@link InjectMetadata}.
+   */
+  interface InjectFactory {
+
+     new(token: any): InjectMetadata;
+
+
+     (token: any): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link OptionalMetadata}.
+   */
+  interface OptionalFactory {
+
+     new(): OptionalMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link InjectableMetadata}.
+   */
+  interface InjectableFactory {
+
+     new(): InjectableMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link SelfMetadata}.
+   */
+  interface SelfFactory {
+
+     new(): SelfMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link HostMetadata}.
+   */
+  interface HostFactory {
+
+     new(): HostMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link SkipSelfMetadata}.
+   */
+  interface SkipSelfFactory {
+
+     new(): SkipSelfMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link InjectMetadata}.
+   */
+  var Inject : InjectFactory ;
+
+
+  /**
+   * Factory for creating {@link OptionalMetadata}.
+   */
+  var Optional : OptionalFactory ;
+
+
+  /**
+   * Factory for creating {@link InjectableMetadata}.
+   */
+  var Injectable : InjectableFactory ;
+
+
+  /**
+   * Factory for creating {@link SelfMetadata}.
+   */
+  var Self : SelfFactory ;
+
+
+  /**
+   * Factory for creating {@link HostMetadata}.
+   */
+  var Host : HostFactory ;
+
+
+  /**
+   * Factory for creating {@link SkipSelfMetadata}.
+   */
+  var SkipSelf : SkipSelfFactory ;
+
+
+  /**
+   * A collection of the Angular core directives that are likely to be used in each and every Angular
+   * application.
+   *
+   * This collection can be used to quickly enumerate all the built-in directives in the `@View`
+   * annotation. For example,
+   * instead of writing:
+   *
+   * ```
+   * import {NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault} from 'angular2/angular2';
+   * import {OtherDirective} from 'myDirectives';
+   *
+   * @Component({
+   *  selector: 'my-component'
+   * })
+   * @View({
+   *   templateUrl: 'myComponent.html',
+   *   directives: [NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault, OtherDirective]
+   * })
+   * export class MyComponent {
+   *   ...
+   * }
+   * ```
+   * one could import all the core directives at once:
+   *
+   * ```
+   * import {CORE_DIRECTIVES} from 'angular2/angular2';
+   * import {OtherDirective} from 'myDirectives';
+   *
+   * @Component({
+   *  selector: 'my-component'
+   * })
+   * @View({
+   *   templateUrl: 'myComponent.html',
+   *   directives: [CORE_DIRECTIVES, OtherDirective]
+   * })
+   * export class MyComponent {
+   *   ...
+   * }
+   * ```
+   */
+  const CORE_DIRECTIVES : Type[] ;
+
+
+  /**
+   * Adds and removes CSS classes based on an {expression} value.
+   *
+   * The result of expression is used to add and remove CSS classes using the following logic,
+   * based on expression's value type:
+   * - {string} - all the CSS classes (space - separated) are added
+   * - {Array} - all the CSS classes (Array elements) are added
+   * - {Object} - each key corresponds to a CSS class name while values
+   * are interpreted as {boolean} expression. If a given expression
+   * evaluates to {true} a corresponding CSS class is added - otherwise
+   * it is removed.
+   *
+   * # Example:
+   *
+   * ```
+   * <div class="message" [ng-class]="{error: errorCount > 0}">
+   *     Please check errors.
+   * </div>
+   * ```
+   */
+  class NgClass {
+
+     initialClasses: any;
+
+     rawClass: any;
+
+     doCheck(): void;
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * The `NgFor` directive instantiates a template once per item from an iterable. The context for
+   * each instantiated template inherits from the outer context with the given loop variable set
+   * to the current item from the iterable.
+   *
+   * It is possible to alias the `index` to a local variable that will be set to the current loop
+   * iteration in the template context.
+   *
+   * When the contents of the iterator changes, `NgFor` makes the corresponding changes to the DOM:
+   *
+   * * When an item is added, a new instance of the template is added to the DOM.
+   * * When an item is removed, its template instance is removed from the DOM.
+   * * When items are reordered, their respective templates are reordered in the DOM.
+   *
+   * # Example
+   *
+   * ```
+   * <ul>
+   *   <li *ng-for="#error of errors; #i = index">
+   *     Error {{i}} of {{errors.length}}: {{error.message}}
+   *   </li>
+   * </ul>
+   * ```
+   *
+   * # Syntax
+   *
+   * - `<li *ng-for="#item of items; #i = index">...</li>`
+   * - `<li template="ng-for #item of items; #i = index">...</li>`
+   * - `<template ng-for #item [ng-for-of]="items" #i="index"><li>...</li></template>`
+   */
+  class NgFor {
+
+     static bulkRemove(tuples: RecordViewTuple[], viewContainer: ViewContainerRef): RecordViewTuple[];
+
+     static bulkInsert(tuples: RecordViewTuple[], viewContainer: ViewContainerRef, templateRef: TemplateRef): RecordViewTuple[];
+
+     viewContainer: ViewContainerRef;
+
+     templateRef: TemplateRef;
+
+     iterableDiffers: IterableDiffers;
+
+     cdr: ChangeDetectorRef;
+
+     ngForOf: any;
+
+     doCheck(): void;
+  }
+
+  class RecordViewTuple {
+
+     view: ViewRef;
+
+     record: any;
+  }
+
+
+  /**
+   * Removes or recreates a portion of the DOM tree based on an {expression}.
+   *
+   * If the expression assigned to `ng-if` evaluates to a false value then the element
+   * is removed from the DOM, otherwise a clone of the element is reinserted into the DOM.
+   *
+   * # Example:
+   *
+   * ```
+   * <div *ng-if="errorCount > 0" class="error">
+   *   <!-- Error message displayed when the errorCount property on the current context is greater
+   * than 0. -->
+   *   {{errorCount}} errors detected
+   * </div>
+   * ```
+   *
+   * # Syntax
+   *
+   * - `<div *ng-if="condition">...</div>`
+   * - `<div template="ng-if condition">...</div>`
+   * - `<template [ng-if]="condition"><div>...</div></template>`
+   */
+  class NgIf {
+
+     ngIf: any;
+  }
+
+
+  /**
+   * The `NgNonBindable` directive tells Angular not to compile or bind the contents of the current
+   * DOM element. This is useful if the element contains what appears to be Angular directives and
+   * bindings but which should be ignored by Angular. This could be the case if you have a site that
+   * displays snippets of code, for instance.
+   *
+   * Example:
+   *
+   * ```
+   * <div>Normal: {{1 + 2}}</div> // output "Normal: 3"
+   * <div ng-non-bindable>Ignored: {{1 + 2}}</div> // output "Ignored: {{1 + 2}}"
+   * ```
+   */
+  class NgNonBindable {
+  }
+
+
+  /**
+   * Adds or removes styles based on an {expression}.
+   *
+   * When the expression assigned to `ng-style` evaluates to an object, the corresponding element
+   * styles are updated. Style names to update are taken from the object keys and values - from the
+   * corresponding object values.
+   *
+   * # Example:
+   *
+   * ```
+   * <div [ng-style]="{'text-align': alignExp}"></div>
+   * ```
+   *
+   * In the above example the `text-align` style will be updated based on the `alignExp` value
+   * changes.
+   *
+   * # Syntax
+   *
+   * - `<div [ng-style]="{'text-align': alignExp}"></div>`
+   * - `<div [ng-style]="styleExp"></div>`
+   */
+  class NgStyle {
+
+     rawStyle: any;
+
+     doCheck(): void;
+  }
+
+  class SwitchView {
+
+     create(): void;
+
+     destroy(): void;
+  }
+
+
+  /**
+   * The `NgSwitch` directive is used to conditionally swap DOM structure on your template based on a
+   * scope expression.
+   * Elements within `NgSwitch` but without `NgSwitchWhen` or `NgSwitchDefault` directives will be
+   * preserved at the location as specified in the template.
+   *
+   * `NgSwitch` simply chooses nested elements and makes them visible based on which element matches
+   * the value obtained from the evaluated expression. In other words, you define a container element
+   * (where you place the directive), place an expression on the **`[ng-switch]="..."` attribute**),
+   * define any inner elements inside of the directive and place a `[ng-switch-when]` attribute per
+   * element.
+   * The when attribute is used to inform NgSwitch which element to display when the expression is
+   * evaluated. If a matching expression is not found via a when attribute then an element with the
+   * default attribute is displayed.
+   *
+   * # Example:
+   *
+   * ```
+   * <ANY [ng-switch]="expression">
+   *   <template [ng-switch-when]="whenExpression1">...</template>
+   *   <template [ng-switch-when]="whenExpression1">...</template>
+   *   <template ng-switch-default>...</template>
+   * </ANY>
+   * ```
+   */
+  class NgSwitch {
+
+     ngSwitch: any;
+  }
+
+
+  /**
+   * Defines a case statement as an expression.
+   *
+   * If multiple `NgSwitchWhen` match the `NgSwitch` value, all of them are displayed.
+   *
+   * Example:
+   *
+   * ```
+   * // match against a context variable
+   * <template [ng-switch-when]="contextVariable">...</template>
+   *
+   * // match against a constant string
+   * <template ng-switch-when="stringValue">...</template>
+   * ```
+   */
+  class NgSwitchWhen {
+
+     ngSwitchWhen: any;
+  }
+
+
+  /**
+   * Defines a default case statement.
+   *
+   * Default case statements are displayed when no `NgSwitchWhen` match the `ng-switch` value.
+   *
+   * Example:
+   *
+   * ```
+   * <template ng-switch-default>...</template>
+   * ```
+   */
+  class NgSwitchDefault {
+  }
+
+
+  /**
+   * Omitting from external API doc as this is really an abstract internal concept.
+   */
+  class AbstractControl {
+
+     validator: Function;
+
+     value: any;
+
+     status: string;
+
+     valid: boolean;
+
+     errors: StringMap<string, any>;
+
+     pristine: boolean;
+
+     dirty: boolean;
+
+     touched: boolean;
+
+     untouched: boolean;
+
+     valueChanges: Observable;
+
+     markAsTouched(): void;
+
+     markAsDirty({onlySelf}?: {onlySelf?: boolean}): void;
+
+     setParent(parent: ControlGroup | ControlArray): void;
+
+     updateValidity({onlySelf}?: {onlySelf?: boolean}): void;
+
+     updateValueAndValidity({onlySelf, emitEvent}?: {onlySelf?: boolean, emitEvent?: boolean}): void;
+
+     find(path: Array<string | number>| string): AbstractControl;
+
+     getError(errorCode: string, path?: string[]): any;
+
+     hasError(errorCode: string, path?: string[]): boolean;
+  }
+
+
+  /**
+   * Defines a part of a form that cannot be divided into other controls.
+   *
+   * `Control` is one of the three fundamental building blocks used to define forms in Angular, along
+   * with
+   * {@link ControlGroup} and {@link ControlArray}.
+   */
+  class Control extends AbstractControl {
+
+     updateValue(value: any, {onlySelf, emitEvent, emitModelToViewChange}?:
+                  {onlySelf?: boolean, emitEvent?: boolean, emitModelToViewChange?: boolean}): void;
+
+     registerOnChange(fn: Function): void;
+  }
+
+
+  /**
+   * Defines a part of a form, of fixed length, that can contain other controls.
+   *
+   * A ControlGroup aggregates the values and errors of each {@link Control} in the group. Thus, if
+   * one of the controls
+   * in a group is invalid, the entire group is invalid. Similarly, if a control changes its value,
+   * the entire group
+   * changes as well.
+   *
+   * `ControlGroup` is one of the three fundamental building blocks used to define forms in Angular,
+   * along with
+   * {@link Control} and {@link ControlArray}. {@link ControlArray} can also contain other controls,
+   * but is of variable
+   * length.
+   */
+  class ControlGroup extends AbstractControl {
+
+     controls: StringMap<string, AbstractControl>;
+
+     addControl(name: string, c: AbstractControl): void;
+
+     removeControl(name: string): void;
+
+     include(controlName: string): void;
+
+     exclude(controlName: string): void;
+
+     contains(controlName: string): boolean;
+  }
+
+
+  /**
+   * Defines a part of a form, of variable length, that can contain other controls.
+   *
+   * A `ControlArray` aggregates the values and errors of each {@link Control} in the group. Thus, if
+   * one of the controls
+   * in a group is invalid, the entire group is invalid. Similarly, if a control changes its value,
+   * the entire group
+   * changes as well.
+   *
+   * `ControlArray` is one of the three fundamental building blocks used to define forms in Angular,
+   * along with {@link Control} and {@link ControlGroup}. {@link ControlGroup} can also contain
+   * other controls, but is of fixed length.
+   */
+  class ControlArray extends AbstractControl {
+
+     controls: AbstractControl[];
+
+     at(index: number): AbstractControl;
+
+     push(control: AbstractControl): void;
+
+     insert(index: number, control: AbstractControl): void;
+
+     removeAt(index: number): void;
+
+     length: number;
+  }
+
+  class AbstractControlDirective {
+
+     control: AbstractControl;
+
+     value: any;
+
+     valid: boolean;
+
+     errors: StringMap<string, any>;
+
+     pristine: boolean;
+
+     dirty: boolean;
+
+     touched: boolean;
+
+     untouched: boolean;
+  }
+
+
+  /**
+   * An interface that {@link NgFormModel} and {@link NgForm} implement.
+   *
+   * Only used by the forms module.
+   */
+  interface Form {
+
+     addControl(dir: NgControl): void;
+
+     removeControl(dir: NgControl): void;
+
+     getControl(dir: NgControl): Control;
+
+     addControlGroup(dir: NgControlGroup): void;
+
+     removeControlGroup(dir: NgControlGroup): void;
+
+     getControlGroup(dir: NgControlGroup): ControlGroup;
+
+     updateModel(dir: NgControl, value: any): void;
+  }
+
+
+  /**
+   * A directive that contains a group of [NgControl].
+   *
+   * Only used by the forms module.
+   */
+  class ControlContainer extends AbstractControlDirective {
+
+     name: string;
+
+     formDirective: Form;
+
+     path: string[];
+  }
+
+
+  /**
+   * Creates and binds a control with a specified name to a DOM element.
+   *
+   * This directive can only be used as a child of {@link NgForm} or {@link NgFormModel}.
+   *
+   * # Example
+   *
+   * In this example, we create the login and password controls.
+   * We can work with each control separately: check its validity, get its value, listen to its
+   *  changes.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *              <form #f="form" (submit)='onLogIn(f.value)'>
+   *                Login <input type='text' ng-control='login' #l="form">
+   *                <div *ng-if="!l.valid">Login is invalid</div>
+   *
+   *                Password <input type='password' ng-control='password'>
+   *
+   *                <button type='submit'>Log in!</button>
+   *              </form>
+   *      `})
+   * class LoginComp {
+   *  onLogIn(value) {
+   *    // value === {login: 'some login', password: 'some password'}
+   *  }
+   * }
+   *  ```
+   *
+   * We can also use ng-model to bind a domain model to the form.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *              <form (submit)='onLogIn()'>
+   *                Login <input type='text' ng-control='login' [(ng-model)]="credentials.login">
+   *                Password <input type='password' ng-control='password'
+   *  [(ng-model)]="credentials.password">
+   *                <button type='submit'>Log in!</button>
+   *              </form>
+   *      `})
+   * class LoginComp {
+   *  credentials: {login:string, password:string};
+   *
+   *  onLogIn() {
+   *    // this.credentials.login === "some login"
+   *    // this.credentials.password === "some password"
+   *  }
+   * }
+   *  ```
+   */
+  class NgControlName extends NgControl {
+
+     update: any;
+
+     model: any;
+
+     viewModel: any;
+
+     ngValidators: QueryList<NgValidator>;
+
+     onChanges(c: StringMap<string, any>): void;
+
+     onDestroy(): void;
+
+     viewToModelUpdate(newValue: any): void;
+
+     path: string[];
+
+     formDirective: any;
+
+     control: Control;
+
+     validator: Function;
+  }
+
+
+  /**
+   * Binds an existing control to a DOM element.
+   *
+   * # Example
+   *
+   * In this example, we bind the control to an input element. When the value of the input element
+   * changes, the value of
+   * the control will reflect that change. Likewise, if the value of the control changes, the input
+   * element reflects that
+   * change.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: "<input type='text' [ng-form-control]='loginControl'>"
+   *      })
+   * class LoginComp {
+   *  loginControl:Control;
+   *
+   *  constructor() {
+   *    this.loginControl = new Control('');
+   *  }
+   * }
+   *
+   *  ```
+   *
+   * We can also use ng-model to bind a domain model to the form.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: "<input type='text' [ng-form-control]='loginControl' [(ng-model)]='login'>"
+   *      })
+   * class LoginComp {
+   *  loginControl:Control;
+   *  login:string;
+   *
+   *  constructor() {
+   *    this.loginControl = new Control('');
+   *  }
+   * }
+   *  ```
+   */
+  class NgFormControl extends NgControl {
+
+     form: Control;
+
+     update: any;
+
+     model: any;
+
+     viewModel: any;
+
+     ngValidators: QueryList<NgValidator>;
+
+     onChanges(c: StringMap<string, any>): void;
+
+     path: string[];
+
+     control: Control;
+
+     validator: Function;
+
+     viewToModelUpdate(newValue: any): void;
+  }
+
+
+  /**
+   * Binds a domain model to the form.
+   *
+   * # Example
+   *  ```
+   * @Component({selector: "search-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *               <input type='text' [(ng-model)]="searchQuery">
+   *      `})
+   * class SearchComp {
+   *  searchQuery: string;
+   * }
+   *  ```
+   */
+  class NgModel extends NgControl {
+
+     update: any;
+
+     model: any;
+
+     viewModel: any;
+
+     ngValidators: QueryList<NgValidator>;
+
+     onChanges(c: StringMap<string, any>): void;
+
+     control: Control;
+
+     path: string[];
+
+     validator: Function;
+
+     viewToModelUpdate(newValue: any): void;
+  }
+
+
+  /**
+   * An abstract class that all control directive extend.
+   *
+   * It binds a {@link Control} object to a DOM element.
+   */
+  class NgControl extends AbstractControlDirective {
+
+     name: string;
+
+     valueAccessor: ControlValueAccessor;
+
+     validator: Function;
+
+     path: string[];
+
+     viewToModelUpdate(newValue: any): void;
+  }
+
+
+  /**
+   * Creates and binds a control group to a DOM element.
+   *
+   * This directive can only be used as a child of {@link NgForm} or {@link NgFormModel}.
+   *
+   * # Example
+   *
+   * In this example, we create the credentials and personal control groups.
+   * We can work with each group separately: check its validity, get its value, listen to its changes.
+   *
+   *  ```
+   * @Component({selector: "signup-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *              <form #f="form" (submit)='onSignUp(f.value)'>
+   *                <div ng-control-group='credentials' #credentials="form">
+   *                  Login <input type='text' ng-control='login'>
+   *                  Password <input type='password' ng-control='password'>
+   *                </div>
+   *                <div *ng-if="!credentials.valid">Credentials are invalid</div>
+   *
+   *                <div ng-control-group='personal'>
+   *                  Name <input type='text' ng-control='name'>
+   *                </div>
+   *                <button type='submit'>Sign Up!</button>
+   *              </form>
+   *      `})
+   * class SignupComp {
+   *  onSignUp(value) {
+   *    // value === {personal: {name: 'some name'},
+   *    //  credentials: {login: 'some login', password: 'some password'}}
+   *  }
+   * }
+   *
+   *  ```
+   */
+  class NgControlGroup extends ControlContainer {
+
+     onInit(): void;
+
+     onDestroy(): void;
+
+     control: ControlGroup;
+
+     path: string[];
+
+     formDirective: Form;
+  }
+
+
+  /**
+   * Binds an existing control group to a DOM element.
+   *
+   * # Example
+   *
+   * In this example, we bind the control group to the form element, and we bind the login and
+   * password controls to the
+   * login and password elements.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: "<form [ng-form-model]='loginForm'>" +
+   *              "Login <input type='text' ng-control='login'>" +
+   *              "Password <input type='password' ng-control='password'>" +
+   *              "<button (click)="onLogin()">Login</button>" +
+   *              "</form>"
+   *      })
+   * class LoginComp {
+   *  loginForm:ControlGroup;
+   *
+   *  constructor() {
+   *    this.loginForm = new ControlGroup({
+   *      login: new Control(""),
+   *      password: new Control("")
+   *    });
+   *  }
+   *
+   *  onLogin() {
+   *    // this.loginForm.value
+   *  }
+   * }
+   *
+   *  ```
+   *
+   * We can also use ng-model to bind a domain model to the form.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: "<form [ng-form-model]='loginForm'>" +
+   *              "Login <input type='text' ng-control='login' [(ng-model)]='login'>" +
+   *              "Password <input type='password' ng-control='password' [(ng-model)]='password'>" +
+   *              "<button (click)="onLogin()">Login</button>" +
+   *              "</form>"
+   *      })
+   * class LoginComp {
+   *  credentials:{login:string, password:string}
+   *  loginForm:ControlGroup;
+   *
+   *  constructor() {
+   *    this.loginForm = new ControlGroup({
+   *      login: new Control(""),
+   *      password: new Control("")
+   *    });
+   *  }
+   *
+   *  onLogin() {
+   *    // this.credentials.login === 'some login'
+   *    // this.credentials.password === 'some password'
+   *  }
+   * }
+   *  ```
+   */
+  class NgFormModel extends ControlContainer implements Form {
+
+     form: ControlGroup;
+
+     directives: NgControl[];
+
+     ngSubmit: any;
+
+     onChanges(_: any): void;
+
+     formDirective: Form;
+
+     control: ControlGroup;
+
+     path: string[];
+
+     addControl(dir: NgControl): void;
+
+     getControl(dir: NgControl): Control;
+
+     removeControl(dir: NgControl): void;
+
+     addControlGroup(dir: NgControlGroup): void;
+
+     removeControlGroup(dir: NgControlGroup): void;
+
+     getControlGroup(dir: NgControlGroup): ControlGroup;
+
+     updateModel(dir: NgControl, value: any): void;
+
+     onSubmit(): boolean;
+  }
+
+
+  /**
+   * Creates and binds a form object to a DOM element.
+   *
+   * # Example
+   *
+   *  ```
+   * @Component({selector: "signup-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *              <form #f="form" (submit)='onSignUp(f.value)'>
+   *                <div ng-control-group='credentials' #credentials="form">
+   *                  Login <input type='text' ng-control='login'>
+   *                  Password <input type='password' ng-control='password'>
+   *                </div>
+   *                <div *ng-if="!credentials.valid">Credentials are invalid</div>
+   *
+   *                <div ng-control-group='personal'>
+   *                  Name <input type='text' ng-control='name'>
+   *                </div>
+   *                <button type='submit'>Sign Up!</button>
+   *              </form>
+   *      `})
+   * class SignupComp {
+   *  onSignUp(value) {
+   *    // value === {personal: {name: 'some name'},
+   *    //  credentials: {login: 'some login', password: 'some password'}}
+   *  }
+   * }
+   *
+   *  ```
+   */
+  class NgForm extends ControlContainer implements Form {
+
+     form: ControlGroup;
+
+     ngSubmit: any;
+
+     formDirective: Form;
+
+     control: ControlGroup;
+
+     path: string[];
+
+     controls: StringMap<string, AbstractControl>;
+
+     addControl(dir: NgControl): void;
+
+     getControl(dir: NgControl): Control;
+
+     removeControl(dir: NgControl): void;
+
+     addControlGroup(dir: NgControlGroup): void;
+
+     removeControlGroup(dir: NgControlGroup): void;
+
+     getControlGroup(dir: NgControlGroup): ControlGroup;
+
+     updateModel(dir: NgControl, value: any): void;
+
+     onSubmit(): boolean;
+  }
+
+
+  /**
+   * A bridge between a control and a native element.
+   *
+   * Please see {@link DefaultValueAccessor} for more information.
+   */
+  interface ControlValueAccessor {
+
+     writeValue(obj: any): void;
+
+     registerOnChange(fn: any): void;
+
+     registerOnTouched(fn: any): void;
+  }
+
+
+  /**
+   * The default accessor for writing a value and listening to changes that is used by the
+   * {@link NgModel}, {@link NgFormControl}, and {@link NgControlName} directives.
+   *
+   *  # Example
+   *  ```
+   *  <input type="text" [(ng-model)]="searchQuery">
+   *  ```
+   */
+  class DefaultValueAccessor implements ControlValueAccessor {
+
+     cd: NgControl;
+
+     onChange: any;
+
+     onTouched: any;
+
+     renderer: Renderer;
+
+     elementRef: ElementRef;
+
+     writeValue(value: any): void;
+
+     ngClassUntouched: boolean;
+
+     ngClassTouched: boolean;
+
+     ngClassPristine: boolean;
+
+     ngClassDirty: boolean;
+
+     ngClassValid: boolean;
+
+     ngClassInvalid: boolean;
+
+     registerOnChange(fn: (_: any) => void): void;
+
+     registerOnTouched(fn: () => void): void;
+  }
+
+
+  /**
+   * The accessor for writing a value and listening to changes on a checkbox input element.
+   *
+   *  # Example
+   *  ```
+   *  <input type="checkbox" [ng-control]="rememberLogin">
+   *  ```
+   */
+  class CheckboxControlValueAccessor implements ControlValueAccessor {
+
+     cd: NgControl;
+
+     onChange: any;
+
+     onTouched: any;
+
+     renderer: Renderer;
+
+     elementRef: ElementRef;
+
+     writeValue(value: any): void;
+
+     ngClassUntouched: boolean;
+
+     ngClassTouched: boolean;
+
+     ngClassPristine: boolean;
+
+     ngClassDirty: boolean;
+
+     ngClassValid: boolean;
+
+     ngClassInvalid: boolean;
+
+     registerOnChange(fn: (_: any) => {}): void;
+
+     registerOnTouched(fn: () => {}): void;
+  }
+
+
+  /**
+   * Marks <option> as dynamic, so Angular can be notified when options change.
+   *
+   * #Example:
+   *
+   * ```
+   * <select ng-control="city">
+   *   <option *ng-for="#c of cities" [value]="c"></option>
+   * </select>
+   * ```
+   */
+  class NgSelectOption {
+  }
+
+
+  /**
+   * The accessor for writing a value and listening to changes on a select element.
+   */
+  class SelectControlValueAccessor implements ControlValueAccessor {
+
+     cd: NgControl;
+
+     value: string;
+
+     onChange: any;
+
+     onTouched: any;
+
+     renderer: Renderer;
+
+     elementRef: ElementRef;
+
+     writeValue(value: any): void;
+
+     ngClassUntouched: boolean;
+
+     ngClassTouched: boolean;
+
+     ngClassPristine: boolean;
+
+     ngClassDirty: boolean;
+
+     ngClassValid: boolean;
+
+     ngClassInvalid: boolean;
+
+     registerOnChange(fn: () => any): void;
+
+     registerOnTouched(fn: () => any): void;
+  }
+
+
+  /**
+   * A list of all the form directives used as part of a `@View` annotation.
+   *
+   *  This is a shorthand for importing them each individually.
+   */
+  const FORM_DIRECTIVES : Type[] ;
+
+
+  /**
+   * Provides a set of validators used by form controls.
+   *
+   * # Example
+   *
+   * ```
+   * var loginControl = new Control("", Validators.required)
+   * ```
+   */
+  class Validators {
+
+     static required(c:Control): StringMap<string, boolean>;
+
+     static nullValidator(c: any): StringMap<string, boolean>;
+
+     static compose(validators: Function[]): Function;
+
+     static group(c:ControlGroup): StringMap<string, boolean>;
+
+     static array(c:ControlArray): StringMap<string, boolean>;
+  }
+
+  class NgValidator {
+
+     validator: Function;
+  }
+
+  class NgRequiredValidator extends NgValidator {
+
+     validator: Function;
+  }
+
+
+  /**
+   * Creates a form object from a user-specified configuration.
+   *
+   * # Example
+   *
+   * ```
+   * import {Component, View, bootstrap} from 'angular2/angular2';
+   * import {FormBuilder, Validators, FORM_DIRECTIVES, ControlGroup} from 'angular2/forms';
+   *
+   * @Component({
+   *   selector: 'login-comp',
+   *   viewBindings: [
+   *     FormBuilder
+   *   ]
+   * })
+   * @View({
+   *   template: `
+   *     <form [control-group]="loginForm">
+   *       Login <input control="login">
+   *
+   *       <div control-group="passwordRetry">
+   *         Password <input type="password" control="password">
+   *         Confirm password <input type="password" control="passwordConfirmation">
+   *       </div>
+   *     </form>
+   *   `,
+   *   directives: [
+   *     FORM_DIRECTIVES
+   *   ]
+   * })
+   * class LoginComp {
+   *   loginForm: ControlGroup;
+   *
+   *   constructor(builder: FormBuilder) {
+   *     this.loginForm = builder.group({
+   *       login: ["", Validators.required],
+   *
+   *       passwordRetry: builder.group({
+   *         password: ["", Validators.required],
+   *         passwordConfirmation: ["", Validators.required]
+   *       })
+   *     });
+   *   }
+   * }
+   *
+   * bootstrap(LoginComp)
+   * ```
+   *
+   * This example creates a {@link ControlGroup} that consists of a `login` {@link Control}, and a
+   * nested
+   * {@link ControlGroup} that defines a `password` and a `passwordConfirmation` {@link Control}:
+   *
+   * ```
+   *  var loginForm = builder.group({
+   *    login: ["", Validators.required],
+   *
+   *    passwordRetry: builder.group({
+   *      password: ["", Validators.required],
+   *      passwordConfirmation: ["", Validators.required]
+   *    })
+   *  });
+   *
+   *  ```
+   */
+  class FormBuilder {
+
+     group(controlsConfig: StringMap<string, any>, extra?: StringMap<string, any>): ControlGroup;
+
+     control(value: Object, validator?: Function): Control;
+
+     array(controlsConfig: any[], validator?: Function): ControlArray;
+  }
+
+  const FORM_BINDINGS : Type[] ;
+
+  class RenderDirectiveMetadata {
+
+     static DIRECTIVE_TYPE: any;
+
+     static COMPONENT_TYPE: any;
+
+     static create({id, selector, compileChildren, events, host, properties, readAttributes, type,
+                 callOnDestroy, callOnChanges, callDoCheck, callOnInit, callAfterContentInit,
+                 callAfterContentChecked, callAfterViewInit, callAfterViewChecked, changeDetection,
+                 exportAs}: {
+    id?: string,
+    selector?: string,
+    compileChildren?: boolean,
+    events?: string[],
+    host?: Map<string, string>,
+    properties?: string[],
+    readAttributes?: string[],
+    type?: number,
+    callOnDestroy?: boolean,
+    callOnChanges?: boolean,
+    callDoCheck?: boolean,
+    callOnInit?: boolean,
+    callAfterContentInit?: boolean,
+    callAfterContentChecked?: boolean,
+    callAfterViewInit?: boolean,
+    callAfterViewChecked?: boolean,
+    changeDetection?: ChangeDetectionStrategy,
+    exportAs?: string
+  }): RenderDirectiveMetadata;
+
+     id: any;
+
+     selector: string;
+
+     compileChildren: boolean;
+
+     events: string[];
+
+     properties: string[];
+
+     readAttributes: string[];
+
+     type: number;
+
+     callOnDestroy: boolean;
+
+     callOnChanges: boolean;
+
+     callDoCheck: boolean;
+
+     callOnInit: boolean;
+
+     callAfterContentInit: boolean;
+
+     callAfterContentChecked: boolean;
+
+     callAfterViewInit: boolean;
+
+     callAfterViewChecked: boolean;
+
+     changeDetection: ChangeDetectionStrategy;
+
+     exportAs: string;
+
+     hostListeners: Map<string, string>;
+
+     hostProperties: Map<string, string>;
+
+     hostAttributes: Map<string, string>;
+  }
+
+  class DomRenderer extends Renderer {
+
+     createRootHostView(hostProtoViewRef: RenderProtoViewRef, fragmentCount: number, hostElementSelector: string): RenderViewWithFragments;
+
+     createView(protoViewRef: RenderProtoViewRef, fragmentCount: number): RenderViewWithFragments;
+
+     destroyView(viewRef: RenderViewRef): void;
+
+     getNativeElementSync(location: RenderElementRef): any;
+
+     getRootNodes(fragment: RenderFragmentRef): Node[];
+
+     attachFragmentAfterFragment(previousFragmentRef: RenderFragmentRef, fragmentRef: RenderFragmentRef): void;
+
+     attachFragmentAfterElement(elementRef: RenderElementRef, fragmentRef: RenderFragmentRef): void;
+
+     detachFragment(fragmentRef: RenderFragmentRef): void;
+
+     hydrateView(viewRef: RenderViewRef): void;
+
+     dehydrateView(viewRef: RenderViewRef): void;
+
+     setElementProperty(location: RenderElementRef, propertyName: string, propertyValue: any): void;
+
+     setElementAttribute(location: RenderElementRef, attributeName: string, attributeValue: string): void;
+
+     setElementClass(location: RenderElementRef, className: string, isAdd: boolean): void;
+
+     setElementStyle(location: RenderElementRef, styleName: string, styleValue: string): void;
+
+     invokeElementMethod(location: RenderElementRef, methodName: string, args: any[]): void;
+
+     setText(viewRef: RenderViewRef, textNodeIndex: number, text: string): void;
+
+     setEventDispatcher(viewRef: RenderViewRef, dispatcher: any): void;
+  }
+
+
+  /**
+   * A dispatcher for all events happening in a view.
+   */
+  interface RenderEventDispatcher {
+
+
+    /**
+     * Called when an event was triggered for a on-* attribute on an element.
+     * @param {Map<string, any>} locals Locals to be used to evaluate the
+     *   event expressions
+     * @return {boolean} False if `preventDefault` should be called on the DOM event.
+     */
+     dispatchRenderEvent(elementIndex: number, eventName: string, locals: Map<string, any>): boolean;
+  }
+
+  class Renderer {
+
+
+    /**
+     * Creates a root host view that includes the given element.
+     * Note that the fragmentCount needs to be passed in so that we can create a result
+     * synchronously even when dealing with webworkers!
+     *
+     * @param {RenderProtoViewRef} hostProtoViewRef a RenderProtoViewRef of type
+     * ProtoViewDto.HOST_VIEW_TYPE
+     * @param {any} hostElementSelector css selector for the host element (will be queried against the
+     * main document)
+     * @return {RenderViewWithFragments} the created view including fragments
+     */
+     createRootHostView(hostProtoViewRef: RenderProtoViewRef, fragmentCount: number, hostElementSelector: string): RenderViewWithFragments;
+
+
+    /**
+     * Creates a regular view out of the given ProtoView.
+     * Note that the fragmentCount needs to be passed in so that we can create a result
+     * synchronously even when dealing with webworkers!
+     */
+     createView(protoViewRef: RenderProtoViewRef, fragmentCount: number): RenderViewWithFragments;
+
+
+    /**
+     * Destroys the given view after it has been dehydrated and detached
+     */
+     destroyView(viewRef: RenderViewRef): void;
+
+
+    /**
+     * Attaches a fragment after another fragment.
+     */
+     attachFragmentAfterFragment(previousFragmentRef: RenderFragmentRef, fragmentRef: RenderFragmentRef): void;
+
+
+    /**
+     * Attaches a fragment after an element.
+     */
+     attachFragmentAfterElement(elementRef: RenderElementRef, fragmentRef: RenderFragmentRef): void;
+
+
+    /**
+     * Detaches a fragment.
+     */
+     detachFragment(fragmentRef: RenderFragmentRef): void;
+
+
+    /**
+     * Hydrates a view after it has been attached. Hydration/dehydration is used for reusing views
+     * inside of the view pool.
+     */
+     hydrateView(viewRef: RenderViewRef): void;
+
+
+    /**
+     * Dehydrates a view after it has been attached. Hydration/dehydration is used for reusing views
+     * inside of the view pool.
+     */
+     dehydrateView(viewRef: RenderViewRef): void;
+
+
+    /**
+     * Returns the native element at the given location.
+     * Attention: In a WebWorker scenario, this should always return null!
+     */
+     getNativeElementSync(location: RenderElementRef): any;
+
+
+    /**
+     * Sets a property on an element.
+     */
+     setElementProperty(location: RenderElementRef, propertyName: string, propertyValue: any): void;
+
+
+    /**
+     * Sets an attribute on an element.
+     */
+     setElementAttribute(location: RenderElementRef, attributeName: string, attributeValue: string): void;
+
+
+    /**
+     * Sets a class on an element.
+     */
+     setElementClass(location: RenderElementRef, className: string, isAdd: boolean): void;
+
+
+    /**
+     * Sets a style on an element.
+     */
+     setElementStyle(location: RenderElementRef, styleName: string, styleValue: string): void;
+
+
+    /**
+     * Calls a method on an element.
+     */
+     invokeElementMethod(location: RenderElementRef, methodName: string, args: any[]): void;
+
+
+    /**
+     * Sets the value of a text node.
+     */
+     setText(viewRef: RenderViewRef, textNodeIndex: number, text: string): void;
+
+
+    /**
+     * Sets the dispatcher for all events of the given view
+     */
+     setEventDispatcher(viewRef: RenderViewRef, dispatcher: RenderEventDispatcher): void;
+  }
+
+
+  /**
+   * Abstract reference to the element which can be marshaled across web-worker boundary.
+   *
+   * This interface is used by the Renderer API.
+   */
+  interface RenderElementRef {
+
+
+    /**
+     * Reference to the `RenderViewRef` where the `RenderElementRef` is inside of.
+     */
+     renderView: RenderViewRef;
+
+
+    /**
+     * Index of the element inside the `RenderViewRef`.
+     *
+     * This is used internally by the Angular framework to locate elements.
+     */
+     renderBoundElementIndex: number;
+  }
+
+  class RenderViewRef {
+  }
+
+  class RenderProtoViewRef {
+  }
+
+  class RenderFragmentRef {
+  }
+
+  class RenderViewWithFragments {
+
+     viewRef: RenderViewRef;
+
+     fragmentRefs: RenderFragmentRef[];
+  }
+
+  class ViewDefinition {
+
+     componentId: string;
+
+     templateAbsUrl: string;
+
+     template: string;
+
+     directives: RenderDirectiveMetadata[];
+
+     styleAbsUrls: string[];
+
+     styles: string[];
+
+     encapsulation: ViewEncapsulation;
+  }
+
+  const DOCUMENT : OpaqueToken ;
+
+
+  /**
+   * A unique id (string) for an angular application.
+   */
+  const APP_ID : OpaqueToken ;
+
+
+  /**
+   * Defines when a compiled template should be stored as a string
+   * rather than keeping its Nodes to preserve memory.
+   */
+  const MAX_IN_MEMORY_ELEMENTS_PER_TEMPLATE : OpaqueToken ;
+
+
+  /**
+   * Create trace scope.
+   *
+   * Scopes must be strictly nested and are analogous to stack frames, but
+   * do not have to follow the stack frames. Instead it is recommended that they follow logical
+   * nesting. You may want to use
+   * [Event
+   * Signatures](http://google.github.io/tracing-framework/instrumenting-code.html#custom-events)
+   * as they are defined in WTF.
+   *
+   * Used to mark scope entry. The return value is used to leave the scope.
+   *
+   *     var myScope = wtfCreateScope('MyClass#myMethod(ascii someVal)');
+   *
+   *     someMethod() {
+   *        var s = myScope('Foo'); // 'Foo' gets stored in tracing UI
+   *        // DO SOME WORK HERE
+   *        return wtfLeave(s, 123); // Return value 123
+   *     }
+   *
+   * Note, adding try-finally block around the work to ensure that `wtfLeave` gets called can
+   * negatively impact the performance of your application. For this reason we recommend that
+   * you don't add them to ensure that `wtfLeave` gets called. In production `wtfLeave` is a noop and
+   * so try-finally block has no value. When debugging perf issues, skipping `wtfLeave`, do to
+   * exception, will produce incorrect trace, but presence of exception signifies logic error which
+   * needs to be fixed before the app should be profiled. Add try-finally only when you expect that
+   * an exception is expected during normal execution while profiling.
+   */
+  var wtfCreateScope : WtfScopeFn ;
+
+
+  /**
+   * Used to mark end of Scope.
+   *
+   * - `scope` to end.
+   * - `returnValue` (optional) to be passed to the WTF.
+   *
+   * Returns the `returnValue for easy chaining.
+   */
+  var wtfLeave : <T>(scope: any, returnValue?: T) => T ;
+
+
+  /**
+   * Used to mark Async start. Async are similar to scope but they don't have to be strictly nested.
+   * The return value is used in the call to [endAsync]. Async ranges only work if WTF has been
+   * enabled.
+   *
+   *     someMethod() {
+   *        var s = wtfStartTimeRange('HTTP:GET', 'some.url');
+   *        var future = new Future.delay(5).then((_) {
+   *          wtfEndTimeRange(s);
+   *        });
+   *     }
+   */
+  var wtfStartTimeRange : (rangeType: string, action: string) => any ;
+
+
+  /**
+   * Ends a async time range operation.
+   * [range] is the return value from [wtfStartTimeRange] Async ranges only work if WTF has been
+   * enabled.
+   */
+  var wtfEndTimeRange : (range: any) => void ;
+
+  interface WtfScopeFn {
+
+     (arg0?: any, arg1?: any): any;
+
+  }
+
+  var ChangeDetectorRef: InjectableReference;
+
+  var ApplicationRef: InjectableReference;
+
+  var Compiler: InjectableReference;
+
+  var AppViewManager: InjectableReference;
+
+  var ViewRef: InjectableReference;
+
+  var ProtoViewRef: InjectableReference;
+
+  var ViewContainerRef: InjectableReference;
+
+  var ComponentRef: InjectableReference;
+
+}
+
+declare module "angular2/angular2" {
+  export = ng;
+}
+
+
+
+declare module ngWorker {
+
+  /**
+   * Declare reusable UI building blocks for an application.
+   *
+   * Each Angular component requires a single `@Component` and at least one `@View` annotation. The
+   * `@Component`
+   * annotation specifies when a component is instantiated, and which properties and hostListeners it
+   * binds to.
+   *
+   * When a component is instantiated, Angular
+   * - creates a shadow DOM for the component.
+   * - loads the selected template into the shadow DOM.
+   * - creates all the injectable objects configured with `bindings` and `viewBindings`.
+   *
+   * All template expressions and statements are then evaluated against the component instance.
+   *
+   * For details on the `@View` annotation, see {@link ViewMetadata}.
+   *
+   * ## Example
+   *
+   * ```
+   * @Component({
+   *   selector: 'greet'
+   * })
+   * @View({
+   *   template: 'Hello {{name}}!'
+   * })
+   * class Greet {
+   *   name: string;
+   *
+   *   constructor() {
+   *     this.name = 'World';
+   *   }
+   * }
+   * ```
+   */
+  class ComponentMetadata extends DirectiveMetadata {
+
+
+    /**
+     * Defines the used change detection strategy.
+     *
+     * When a component is instantiated, Angular creates a change detector, which is responsible for
+     * propagating the component's bindings.
+     *
+     * The `changeDetection` property defines, whether the change detection will be checked every time
+     * or only when the component tells it to do so.
+     */
+     changeDetection: ChangeDetectionStrategy;
+
+
+    /**
+     * Defines the set of injectable objects that are visible to its view dom children.
+     *
+     * ## Simple Example
+     *
+     * Here is an example of a class that can be injected:
+     *
+     * ```
+     * class Greeter {
+     *    greet(name:string) {
+     *      return 'Hello ' + name + '!';
+     *    }
+     * }
+     *
+     * @Directive({
+     *   selector: 'needs-greeter'
+     * })
+     * class NeedsGreeter {
+     *   greeter:Greeter;
+     *
+     *   constructor(greeter:Greeter) {
+     *     this.greeter = greeter;
+     *   }
+     * }
+     *
+     * @Component({
+     *   selector: 'greet',
+     *   viewBindings: [
+     *     Greeter
+     *   ]
+     * })
+     * @View({
+     *   template: `<needs-greeter></needs-greeter>`,
+     *   directives: [NeedsGreeter]
+     * })
+     * class HelloWorld {
+     * }
+     *
+     * ```
+     */
+     viewBindings: any[];
+  }
+
+
+  /**
+   * Directives allow you to attach behavior to elements in the DOM.
+   *
+   * {@link DirectiveMetadata}s with an embedded view are called {@link ComponentMetadata}s.
+   *
+   * A directive consists of a single directive annotation and a controller class. When the
+   * directive's `selector` matches
+   * elements in the DOM, the following steps occur:
+   *
+   * 1. For each directive, the `ElementInjector` attempts to resolve the directive's constructor
+   * arguments.
+   * 2. Angular instantiates directives for each matched element using `ElementInjector` in a
+   * depth-first order,
+   *    as declared in the HTML.
+   *
+   * ## Understanding How Injection Works
+   *
+   * There are three stages of injection resolution.
+   * - *Pre-existing Injectors*:
+   *   - The terminal {@link Injector} cannot resolve dependencies. It either throws an error or, if
+   * the dependency was
+   *     specified as `@Optional`, returns `null`.
+   *   - The platform injector resolves browser singleton resources, such as: cookies, title,
+   * location, and others.
+   * - *Component Injectors*: Each component instance has its own {@link Injector}, and they follow
+   * the same parent-child hierarchy
+   *     as the component instances in the DOM.
+   * - *Element Injectors*: Each component instance has a Shadow DOM. Within the Shadow DOM each
+   * element has an `ElementInjector`
+   *     which follow the same parent-child hierarchy as the DOM elements themselves.
+   *
+   * When a template is instantiated, it also must instantiate the corresponding directives in a
+   * depth-first order. The
+   * current `ElementInjector` resolves the constructor dependencies for each directive.
+   *
+   * Angular then resolves dependencies as follows, according to the order in which they appear in the
+   * {@link ViewMetadata}:
+   *
+   * 1. Dependencies on the current element
+   * 2. Dependencies on element injectors and their parents until it encounters a Shadow DOM boundary
+   * 3. Dependencies on component injectors and their parents until it encounters the root component
+   * 4. Dependencies on pre-existing injectors
+   *
+   *
+   * The `ElementInjector` can inject other directives, element-specific special objects, or it can
+   * delegate to the parent
+   * injector.
+   *
+   * To inject other directives, declare the constructor parameter as:
+   * - `directive:DirectiveType`: a directive on the current element only
+   * - `@Host() directive:DirectiveType`: any directive that matches the type between the current
+   * element and the
+   *    Shadow DOM root.
+   * - `@Query(DirectiveType) query:QueryList<DirectiveType>`: A live collection of direct child
+   * directives.
+   * - `@QueryDescendants(DirectiveType) query:QueryList<DirectiveType>`: A live collection of any
+   * child directives.
+   *
+   * To inject element-specific special objects, declare the constructor parameter as:
+   * - `element: ElementRef` to obtain a reference to logical element in the view.
+   * - `viewContainer: ViewContainerRef` to control child template instantiation, for
+   * {@link DirectiveMetadata} directives only
+   * - `bindingPropagation: BindingPropagation` to control change detection in a more granular way.
+   *
+   * ## Example
+   *
+   * The following example demonstrates how dependency injection resolves constructor arguments in
+   * practice.
+   *
+   *
+   * Assume this HTML template:
+   *
+   * ```
+   * <div dependency="1">
+   *   <div dependency="2">
+   *     <div dependency="3" my-directive>
+   *       <div dependency="4">
+   *         <div dependency="5"></div>
+   *       </div>
+   *       <div dependency="6"></div>
+   *     </div>
+   *   </div>
+   * </div>
+   * ```
+   *
+   * With the following `dependency` decorator and `SomeService` injectable class.
+   *
+   * ```
+   * @Injectable()
+   * class SomeService {
+   * }
+   *
+   * @Directive({
+   *   selector: '[dependency]',
+   *   properties: [
+   *     'id: dependency'
+   *   ]
+   * })
+   * class Dependency {
+   *   id:string;
+   * }
+   * ```
+   *
+   * Let's step through the different ways in which `MyDirective` could be declared...
+   *
+   *
+   * ### No injection
+   *
+   * Here the constructor is declared with no arguments, therefore nothing is injected into
+   * `MyDirective`.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor() {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with no dependencies.
+   *
+   *
+   * ### Component-level injection
+   *
+   * Directives can inject any injectable instance from the closest component injector or any of its
+   * parents.
+   *
+   * Here, the constructor declares a parameter, `someService`, and injects the `SomeService` type
+   * from the parent
+   * component's injector.
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(someService: SomeService) {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with a dependency on `SomeService`.
+   *
+   *
+   * ### Injecting a directive from the current element
+   *
+   * Directives can inject other directives declared on the current element.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(dependency: Dependency) {
+   *     expect(dependency.id).toEqual(3);
+   *   }
+   * }
+   * ```
+   * This directive would be instantiated with `Dependency` declared at the same element, in this case
+   * `dependency="3"`.
+   *
+   * ### Injecting a directive from any ancestor elements
+   *
+   * Directives can inject other directives declared on any ancestor element (in the current Shadow
+   * DOM), i.e. on the current element, the
+   * parent element, or its parents.
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(@Host() dependency: Dependency) {
+   *     expect(dependency.id).toEqual(2);
+   *   }
+   * }
+   * ```
+   *
+   * `@Host` checks the current element, the parent, as well as its parents recursively. If
+   * `dependency="2"` didn't
+   * exist on the direct parent, this injection would
+   * have returned
+   * `dependency="1"`.
+   *
+   *
+   * ### Injecting a live collection of direct child directives
+   *
+   *
+   * A directive can also query for other child directives. Since parent directives are instantiated
+   * before child directives, a directive can't simply inject the list of child directives. Instead,
+   * the directive injects a {@link QueryList}, which updates its contents as children are added,
+   * removed, or moved by a directive that uses a {@link ViewContainerRef} such as a `ng-for`, an
+   * `ng-if`, or an `ng-switch`.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(@Query(Dependency) dependencies:QueryList<Dependency>) {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with a {@link QueryList} which contains `Dependency` 4 and
+   * 6. Here, `Dependency` 5 would not be included, because it is not a direct child.
+   *
+   * ### Injecting a live collection of descendant directives
+   *
+   * By passing the descendant flag to `@Query` above, we can include the children of the child
+   * elements.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(@Query(Dependency, {descendants: true}) dependencies:QueryList<Dependency>) {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with a Query which would contain `Dependency` 4, 5 and 6.
+   *
+   * ### Optional injection
+   *
+   * The normal behavior of directives is to return an error when a specified dependency cannot be
+   * resolved. If you
+   * would like to inject `null` on unresolved dependency instead, you can annotate that dependency
+   * with `@Optional()`.
+   * This explicitly permits the author of a template to treat some of the surrounding directives as
+   * optional.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(@Optional() dependency:Dependency) {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with a `Dependency` directive found on the current element.
+   * If none can be
+   * found, the injector supplies `null` instead of throwing an error.
+   *
+   * ## Example
+   *
+   * Here we use a decorator directive to simply define basic tool-tip behavior.
+   *
+   * ```
+   * @Directive({
+   *   selector: '[tooltip]',
+   *   properties: [
+   *     'text: tooltip'
+   *   ],
+   *   host: {
+   *     '(mouseenter)': 'onMouseEnter()',
+   *     '(mouseleave)': 'onMouseLeave()'
+   *   }
+   * })
+   * class Tooltip{
+   *   text:string;
+   *   overlay:Overlay; // NOT YET IMPLEMENTED
+   *   overlayManager:OverlayManager; // NOT YET IMPLEMENTED
+   *
+   *   constructor(overlayManager:OverlayManager) {
+   *     this.overlay = overlay;
+   *   }
+   *
+   *   onMouseEnter() {
+   *     // exact signature to be determined
+   *     this.overlay = this.overlayManager.open(text, ...);
+   *   }
+   *
+   *   onMouseLeave() {
+   *     this.overlay.close();
+   *     this.overlay = null;
+   *   }
+   * }
+   * ```
+   * In our HTML template, we can then add this behavior to a `<div>` or any other element with the
+   * `tooltip` selector,
+   * like so:
+   *
+   * ```
+   * <div tooltip="some text here"></div>
+   * ```
+   *
+   * Directives can also control the instantiation, destruction, and positioning of inline template
+   * elements:
+   *
+   * A directive uses a {@link ViewContainerRef} to instantiate, insert, move, and destroy views at
+   * runtime.
+   * The {@link ViewContainerRef} is created as a result of `<template>` element, and represents a
+   * location in the current view
+   * where these actions are performed.
+   *
+   * Views are always created as children of the current {@link ViewMetadata}, and as siblings of the
+   * `<template>` element. Thus a
+   * directive in a child view cannot inject the directive that created it.
+   *
+   * Since directives that create views via ViewContainers are common in Angular, and using the full
+   * `<template>` element syntax is wordy, Angular
+   * also supports a shorthand notation: `<li *foo="bar">` and `<li template="foo: bar">` are
+   * equivalent.
+   *
+   * Thus,
+   *
+   * ```
+   * <ul>
+   *   <li *foo="bar" title="text"></li>
+   * </ul>
+   * ```
+   *
+   * Expands in use to:
+   *
+   * ```
+   * <ul>
+   *   <template [foo]="bar">
+   *     <li title="text"></li>
+   *   </template>
+   * </ul>
+   * ```
+   *
+   * Notice that although the shorthand places `*foo="bar"` within the `<li>` element, the binding for
+   * the directive
+   * controller is correctly instantiated on the `<template>` element rather than the `<li>` element.
+   *
+   *
+   * ## Example
+   *
+   * Let's suppose we want to implement the `unless` behavior, to conditionally include a template.
+   *
+   * Here is a simple directive that triggers on an `unless` selector:
+   *
+   * ```
+   * @Directive({
+   *   selector: '[unless]',
+   *   properties: ['unless']
+   * })
+   * export class Unless {
+   *   viewContainer: ViewContainerRef;
+   *   templateRef: TemplateRef;
+   *   prevCondition: boolean;
+   *
+   *   constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef) {
+   *     this.viewContainer = viewContainer;
+   *     this.templateRef = templateRef;
+   *     this.prevCondition = null;
+   *   }
+   *
+   *   set unless(newCondition) {
+   *     if (newCondition && (isBlank(this.prevCondition) || !this.prevCondition)) {
+   *       this.prevCondition = true;
+   *       this.viewContainer.clear();
+   *     } else if (!newCondition && (isBlank(this.prevCondition) || this.prevCondition)) {
+   *       this.prevCondition = false;
+   *       this.viewContainer.create(this.templateRef);
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * We can then use this `unless` selector in a template:
+   * ```
+   * <ul>
+   *   <li *unless="expr"></li>
+   * </ul>
+   * ```
+   *
+   * Once the directive instantiates the child view, the shorthand notation for the template expands
+   * and the result is:
+   *
+   * ```
+   * <ul>
+   *   <template [unless]="exp">
+   *     <li></li>
+   *   </template>
+   *   <li></li>
+   * </ul>
+   * ```
+   *
+   * Note also that although the `<li></li>` template still exists inside the `<template></template>`,
+   * the instantiated
+   * view occurs on the second `<li></li>` which is a sibling to the `<template>` element.
+   */
+  class DirectiveMetadata extends InjectableMetadata {
+
+
+    /**
+     * The CSS selector that triggers the instantiation of a directive.
+     *
+     * Angular only allows directives to trigger on CSS selectors that do not cross element
+     * boundaries.
+     *
+     * `selector` may be declared as one of the following:
+     *
+     * - `element-name`: select by element name.
+     * - `.class`: select by class name.
+     * - `[attribute]`: select by attribute name.
+     * - `[attribute=value]`: select by attribute name and value.
+     * - `:not(sub_selector)`: select only if the element does not match the `sub_selector`.
+     * - `selector1, selector2`: select if either `selector1` or `selector2` matches.
+     *
+     *
+     * ## Example
+     *
+     * Suppose we have a directive with an `input[type=text]` selector.
+     *
+     * And the following HTML:
+     *
+     * ```html
+     * <form>
+     *   <input type="text">
+     *   <input type="radio">
+     * <form>
+     * ```
+     *
+     * The directive would only be instantiated on the `<input type="text">` element.
+     */
+     selector: string;
+
+
+    /**
+     * Enumerates the set of properties that accept data binding for a directive.
+     *
+     * The `properties` property defines a set of `directiveProperty` to `bindingProperty`
+     * configuration:
+     *
+     * - `directiveProperty` specifies the component property where the value is written.
+     * - `bindingProperty` specifies the DOM property where the value is read from.
+     *
+     * You can include a {@link PipeMetadata} when specifying a `bindingProperty` to allow for data
+     * transformation and structural change detection of the value. These pipes will be evaluated in
+     * the context of this component.
+     *
+     * ## Syntax
+     *
+     * There is no need to specify both `directiveProperty` and `bindingProperty` when they both have
+     * the same value.
+     *
+     * ```
+     * @Directive({
+     *   properties: [
+     *     'propertyName', // shorthand notation for 'propertyName: propertyName'
+     *     'directiveProperty1: bindingProperty1',
+     *     'directiveProperty2: bindingProperty2 | pipe1 | ...',
+     *     ...
+     *   ]
+     * }
+     * ```
+     *
+     *
+     * ## Basic Property Binding
+     *
+     * We can easily build a simple `Tooltip` directive that exposes a `tooltip` property, which can
+     * be used in templates with standard Angular syntax. For example:
+     *
+     * ```
+     * @Directive({
+     *   selector: '[tooltip]',
+     *   properties: [
+     *     'text: tooltip'
+     *   ]
+     * })
+     * class Tooltip {
+     *   set text(value: string) {
+     *     // This will get called every time with the new value when the 'tooltip' property changes
+     *   }
+     * }
+     * ```
+     *
+     * We can then bind to the `tooltip' property as either an expression (`someExpression`) or as a
+     * string literal, as shown in the HTML template below:
+     *
+     * ```html
+     * <div [tooltip]="someExpression">...</div>
+     * <div tooltip="Some Text">...</div>
+     * ```
+     *
+     * Whenever the `someExpression` expression changes, the `properties` declaration instructs
+     * Angular to update the `Tooltip`'s `text` property.
+     *
+     * ### Bindings With Pipes
+     *
+     * You can use pipes in bindings, as follows:
+     *
+     * ```html
+     * <div [class-set]="someExpression | somePipe">
+     * ```
+     */
+     properties: string[];
+
+
+    /**
+     * Enumerates the set of emitted events.
+     *
+     * ## Syntax
+     *
+     * ```
+     * @Component({
+     *   events: ['statusChange']
+     * })
+     * class TaskComponent {
+     *   statusChange: EventEmitter;
+     *
+     *   constructor() {
+     *     this.statusChange = new EventEmitter();
+     *   }
+     *
+     *   onComplete() {
+     *     this.statusChange.next('completed');
+     *   }
+     * }
+     * ```
+     *
+     * Use `propertyName: eventName` when the event emitter property name is different from the name
+     * of the emitted event:
+     *
+     * ```
+     * @Component({
+     *   events: ['status: statusChange']
+     * })
+     * class TaskComponent {
+     *   status: EventEmitter;
+     *
+     *   constructor() {
+     *     this.status = new EventEmitter();
+     *   }
+     *
+     *   onComplete() {
+     *     this.status.next('completed');
+     *   }
+     * }
+     * ```
+     */
+     events: string[];
+
+
+    /**
+     * Specifiy the events, actions, properties and attributes related to the host element.
+     *
+     * ## Events
+     *
+     * Specifies which DOM hostListeners a directive listens to via a set of `(event)` to `method`
+     * key-value pairs:
+     *
+     * - `event1`: the DOM event that the directive listens to.
+     * - `statement`: the statement to execute when the event occurs.
+     * If the evalutation of the statement returns `false`, then `preventDefault`is applied on the DOM
+     * event.
+     *
+     * To listen to global events, a target must be added to the event name.
+     * The target can be `window`, `document` or `body`.
+     *
+     * When writing a directive event binding, you can also refer to the following local variables:
+     * - `$event`: Current event object which triggered the event.
+     * - `$target`: The source of the event. This will be either a DOM element or an Angular
+     * directive. (will be implemented in later release)
+     *
+     * ## Syntax
+     *
+     * ```
+     * @Directive({
+     *   host: {
+     *     '(event1)': 'onMethod1(arguments)',
+     *     '(target:event2)': 'onMethod2(arguments)',
+     *     ...
+     *   }
+     * }
+     * ```
+     *
+     * ## Basic Event Binding:
+     *
+     * Suppose you want to write a directive that reacts to `change` events in the DOM and on
+     * `resize` events in window.
+     * You would define the event binding as follows:
+     *
+     * ```
+     * @Directive({
+     *   selector: 'input',
+     *   host: {
+     *     '(change)': 'onChange($event)',
+     *     '(window:resize)': 'onResize($event)'
+     *   }
+     * })
+     * class InputDirective {
+     *   onChange(event:Event) {
+     *     // invoked when the input element fires the 'change' event
+     *   }
+     *   onResize(event:Event) {
+     *     // invoked when the window fires the 'resize' event
+     *   }
+     * }
+     * ```
+     *
+     * ## Properties
+     *
+     * Specifies which DOM properties a directives updates.
+     *
+     * ## Syntax
+     *
+     * ```
+     * @Directive({
+     *   selector: 'input',
+     *   host: {
+     *     '[prop]': 'expression'
+     *   }
+     * })
+     * class InputDirective {
+     *   value:string;
+     * }
+     * ```
+     *
+     * In this example the prop property of the host element is updated with the expression value
+     * every time it changes.
+     *
+     * ## Attributes
+     *
+     * Specifies static attributes that should be propagated to a host element. Attributes specified
+     * in `hostAttributes` are propagated only if a given attribute is not present on a host element.
+     *
+     * ## Syntax
+     *
+     * ```
+     * @Directive({
+     *   selector: '[my-button]',
+     *   host: {
+     *     'role': 'button'
+     *   }
+     * })
+     * class MyButton {
+     * }
+     * ```
+     *
+     * In this example using `my-button` directive (ex.: `<div my-button></div>`) on a host element
+     * (here: `<div>` ) will ensure that this element will get the "button" role.
+     */
+     host: StringMap<string, string>;
+
+
+    /**
+     * Specifies which lifecycle should be notified to the directive.
+     *
+     * See {@link LifecycleEvent} for details.
+     */
+     lifecycle: LifecycleEvent[];
+
+
+    /**
+     * If set to false the compiler does not compile the children of this directive.
+     */
+     compileChildren: boolean;
+
+
+    /**
+     * Defines the set of injectable objects that are visible to a Directive and its light dom
+     * children.
+     *
+     * ## Simple Example
+     *
+     * Here is an example of a class that can be injected:
+     *
+     * ```
+     * class Greeter {
+     *    greet(name:string) {
+     *      return 'Hello ' + name + '!';
+     *    }
+     * }
+     *
+     * @Directive({
+     *   selector: 'greet',
+     *   bindings: [
+     *     Greeter
+     *   ]
+     * })
+     * class HelloWorld {
+     *   greeter:Greeter;
+     *
+     *   constructor(greeter:Greeter) {
+     *     this.greeter = greeter;
+     *   }
+     * }
+     * ```
+     */
+     bindings: any[];
+
+
+    /**
+     * Defines the name that can be used in the template to assign this directive to a variable.
+     *
+     * ## Simple Example
+     *
+     * ```
+     * @Directive({
+     *   selector: 'child-dir',
+     *   exportAs: 'child'
+     * })
+     * class ChildDir {
+     * }
+     *
+     * @Component({
+     *   selector: 'main',
+     * })
+     * @View({
+     *   template: `<child-dir #c="child"></child-dir>`,
+     *   directives: [ChildDir]
+     * })
+     * class MainComponent {
+     * }
+     *
+     * ```
+     */
+     exportAs: string;
+  }
+
+
+  /**
+   * Declare reusable pipe function.
+   *
+   * ## Example
+   *
+   * ```
+   * @Pipe({
+   *   name: 'lowercase'
+   * })
+   * class Lowercase {
+   *   transform(v, args) { return v.toLowerCase(); }
+   * }
+   * ```
+   */
+  class PipeMetadata extends InjectableMetadata {
+
+     name: string;
+  }
+
+
+  /**
+   * Lifecycle events are guaranteed to be called in the following order:
+   * - `OnChanges` (if any bindings have changed),
+   * - `OnInit` (after the first check only),
+   * - `DoCheck`,
+   * - `AfterContentChecked`
+   * - `AfterContentChecked`
+   * - `OnDestroy` (at the very end before destruction)
+   */
+  enum LifecycleEvent {
+
+
+    /**
+     * Notify a directive when it has been checked the first time.
+     *
+     * This method is called right after the directive's bindings have been checked,
+     * and before any of its children's bindings have been checked.
+     *
+     * It is invoked only once.
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.OnInit]
+     * })
+     * class ClassSet {
+     *   onInit() {
+     *   }
+     * }
+     *  ```
+     */
+     OnInit,
+
+
+    /**
+     * Notify a directive whenever a {@link ViewMetadata} that contains it is destroyed.
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   ...,
+     *   lifecycle: [LifecycleEvent.OnDestroy]
+     * })
+     * class ClassSet {
+     *   onDestroy() {
+     *     // invoked to notify directive of the containing view destruction.
+     *   }
+     * }
+     * ```
+     */
+     OnDestroy,
+
+
+    /**
+     * Notify a directive when any of its bindings have changed.
+     *
+     * This method is called right after the directive's bindings have been checked,
+     * and before any of its children's bindings have been checked.
+     *
+     * It is invoked only if at least one of the directive's bindings has changed.
+     *
+     * ## Example:
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   properties: [
+     *     'propA',
+     *     'propB'
+     *   ],
+     *   lifecycle: [LifecycleEvent.OnChanges]
+     * })
+     * class ClassSet {
+     *   propA;
+     *   propB;
+     *   onChanges(changes:{[idx: string, PropertyUpdate]}) {
+     *     // This will get called after any of the properties have been updated.
+     *     if (changes['propA']) {
+     *       // if propA was updated
+     *     }
+     *     if (changes['propA']) {
+     *       // if propB was updated
+     *     }
+     *   }
+     * }
+     *  ```
+     */
+     OnChanges,
+
+
+    /**
+     * Notify a directive when it has been checked.
+     *
+     * This method is called right after the directive's bindings have been checked,
+     * and before any of its children's bindings have been checked.
+     *
+     * It is invoked every time even when none of the directive's bindings has changed.
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.DoCheck]
+     * })
+     * class ClassSet {
+     *   doCheck() {
+     *   }
+     * }
+     *  ```
+     */
+     DoCheck,
+
+
+    /**
+     * Notify a directive when the bindings of all its content children have been checked the first
+     * time (whether they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterContentInit]
+     * })
+     * class ClassSet {
+     *
+     *   afterContentInit() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterContentInit,
+
+
+    /**
+     * Notify a directive when the bindings of all its content children have been checked (whether
+     * they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterContentChecked]
+     * })
+     * class ClassSet {
+     *
+     *   afterContentChecked() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterContentChecked,
+
+
+    /**
+     * Notify a directive when the bindings of all its view children have been checked the first time
+     * (whether they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterViewInit]
+     * })
+     * class ClassSet {
+     *
+     *   afterViewInit() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterViewInit,
+
+
+    /**
+     * Notify a directive when the bindings of all its view children have been checked (whether they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterViewChecked]
+     * })
+     * class ClassSet {
+     *
+     *   afterViewChecked() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterViewChecked
+  }
+
+
+  /**
+   * Declares the available HTML templates for an application.
+   *
+   * Each angular component requires a single `@Component` and at least one `@View` annotation. The
+   * `@View` annotation specifies the HTML template to use, and lists the directives that are active
+   * within the template.
+   *
+   * When a component is instantiated, the template is loaded into the component's shadow root, and
+   * the expressions and statements in the template are evaluated against the component.
+   *
+   * For details on the `@Component` annotation, see {@link ComponentMetadata}.
+   *
+   * ## Example
+   *
+   * ```
+   * @Component({
+   *   selector: 'greet'
+   * })
+   * @View({
+   *   template: 'Hello {{name}}!',
+   *   directives: [GreetUser, Bold]
+   * })
+   * class Greet {
+   *   name: string;
+   *
+   *   constructor() {
+   *     this.name = 'World';
+   *   }
+   * }
+   * ```
+   */
+  class ViewMetadata {
+
+
+    /**
+     * Specifies a template URL for an angular component.
+     *
+     * NOTE: either `templateUrl` or `template` should be used, but not both.
+     */
+     templateUrl: string;
+
+
+    /**
+     * Specifies an inline template for an angular component.
+     *
+     * NOTE: either `templateUrl` or `template` should be used, but not both.
+     */
+     template: string;
+
+
+    /**
+     * Specifies stylesheet URLs for an angular component.
+     */
+     styleUrls: string[];
+
+
+    /**
+     * Specifies an inline stylesheet for an angular component.
+     */
+     styles: string[];
+
+
+    /**
+     * Specifies a list of directives that can be used within a template.
+     *
+     * Directives must be listed explicitly to provide proper component encapsulation.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * @Component({
+     *     selector: 'my-component'
+     *   })
+     * @View({
+     *   directives: [For]
+     *   template: '
+     *   <ul>
+     *     <li *ng-for="#item of items">{{item}}</li>
+     *   </ul>'
+     * })
+     * class MyComponent {
+     * }
+     * ```
+     */
+     directives: Array<Type | any | any[]>;
+
+     pipes: Array<Type | any | any[]>;
+
+
+    /**
+     * Specify how the template and the styles should be encapsulated.
+     * The default is {@link ViewEncapsulation#Emulated `ViewEncapsulation.Emulated`} if the view
+     * has styles,
+     * otherwise {@link ViewEncapsulation#None `ViewEncapsulation.None`}.
+     */
+     encapsulation: ViewEncapsulation;
+  }
+
+
+  /**
+   * How the template and styles of a view should be encapsulated.
+   */
+  enum ViewEncapsulation {
+
+
+    /**
+     * Emulate scoping of styles by preprocessing the style rules
+     * and adding additional attributes to elements. This is the default.
+     */
+     Emulated,
+
+
+    /**
+     * Uses the native mechanism of the renderer. For the DOM this means creating a ShadowRoot.
+     */
+     Native,
+
+
+    /**
+     * Don't scope the template nor the styles.
+     */
+     None
+  }
+
+
+  /**
+   * Specifies that a {@link QueryList} should be injected.
+   *
+   * See {@link QueryList} for usage and example.
+   */
+  class QueryMetadata extends DependencyMetadata {
+
+     descendants: boolean;
+
+     isViewQuery: any;
+
+     selector: any;
+
+     isVarBindingQuery: boolean;
+
+     varBindings: string[];
+
+     toString(): string;
+  }
+
+
+  /**
+   * Specifies that a constant attribute value should be injected.
+   *
+   * The directive can inject constant string literals of host element attributes.
+   *
+   * ## Example
+   *
+   * Suppose we have an `<input>` element and want to know its `type`.
+   *
+   * ```html
+   * <input type="text">
+   * ```
+   *
+   * A decorator can inject string literal `text` like so:
+   *
+   * ```javascript
+   * @Directive({
+   *   selector: `input'
+   * })
+   * class InputDirective {
+   *   constructor(@Attribute('type') type) {
+   *     // type would be `text` in this example
+   *   }
+   * }
+   * ```
+   */
+  class AttributeMetadata extends DependencyMetadata {
+
+     attributeName: string;
+
+     token: any;
+
+     toString(): string;
+  }
+
+
+  /**
+   * {@link AttributeMetadata} factory function.
+   */
+  var Attribute : AttributeFactory ;
+
+
+  /**
+   * {@link AttributeMetadata} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Attribute, Component, View} from "angular2/angular2";
+   *
+   * @Component({...})
+   * @View({...})
+   * class MyComponent {
+   *   constructor(@Attribute('title') title: string) {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyComponent = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({
+   *     constructor: [new ng.Attribute('title'), function(title) {
+   *       ...
+   *     }]
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyComponent = function(title) {
+   *   ...
+   * };
+   *
+   * MyComponent.annotations = [
+   *   new ng.Component({...}),
+   *   new ng.View({...})
+   * ]
+   * MyComponent.parameters = [
+   *   [new ng.Attribute('title')]
+   * ]
+   * ```
+   */
+  interface AttributeFactory {
+
+     new(name: string): AttributeMetadata;
+
+
+     (name: string): TypeDecorator;
+
+  }
+
+
+  /**
+   * {@link ComponentMetadata} factory function.
+   */
+  var Component : ComponentFactory ;
+
+
+  /**
+   * Interface for the {@link ComponentMetadata} decorator function.
+   *
+   * See {@link ComponentFactory}.
+   */
+  interface ComponentDecorator extends TypeDecorator {
+
+
+    /**
+     * Chain {@link ViewMetadata} annotation.
+     */
+     View(obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: Array<Type | any | any[]>,
+    pipes?: Array<Type | any | any[]>,
+    renderer?: string,
+    styles?: string[],
+    styleUrls?: string[],
+  }): ViewDecorator;
+  }
+
+
+  /**
+   * {@link ComponentAnnotation} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Component, View} from "angular2/angular2";
+   *
+   * @Component({...})
+   * @View({...})
+   * class MyComponent {
+   *   constructor() {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyComponent = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({
+   *     constructor: function() {
+   *       ...
+   *     }
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyComponent = function() {
+   *   ...
+   * };
+   *
+   * MyComponent.annotations = [
+   *   new ng.Component({...}),
+   *   new ng.View({...})
+   * ]
+   * ```
+   */
+  interface ComponentFactory {
+
+     new(obj: {
+    selector?: string,
+    properties?: string[],
+    events?: string[],
+    host?: StringMap<string, string>,
+    lifecycle?: LifecycleEvent[],
+    bindings?: any[],
+    exportAs?: string,
+    compileChildren?: boolean,
+    viewBindings?: any[],
+    changeDetection?: ChangeDetectionStrategy,
+  }): ComponentMetadata;
+
+
+     (obj: {
+    selector?: string,
+    properties?: string[],
+    events?: string[],
+    host?: StringMap<string, string>,
+    lifecycle?: LifecycleEvent[],
+    bindings?: any[],
+    exportAs?: string,
+    compileChildren?: boolean,
+    viewBindings?: any[],
+    changeDetection?: ChangeDetectionStrategy,
+  }): ComponentDecorator;
+
+  }
+
+
+  /**
+   * {@link DirectiveMetadata} factory function.
+   */
+  var Directive : DirectiveFactory ;
+
+
+  /**
+   * Interface for the {@link DirectiveMetadata} decorator function.
+   *
+   * See {@link DirectiveFactory}.
+   */
+  interface DirectiveDecorator extends TypeDecorator {
+  }
+
+
+  /**
+   * {@link DirectiveMetadata} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Directive} from "angular2/angular2";
+   *
+   * @Directive({...})
+   * class MyDirective {
+   *   constructor() {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyDirective = ng
+   *   .Directive({...})
+   *   .Class({
+   *     constructor: function() {
+   *       ...
+   *     }
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyDirective = function() {
+   *   ...
+   * };
+   *
+   * MyDirective.annotations = [
+   *   new ng.Directive({...})
+   * ]
+   * ```
+   */
+  interface DirectiveFactory {
+
+     new(obj: {
+    selector?: string, properties?: string[], events?: string[], host?: StringMap<string, string>,
+        lifecycle?: LifecycleEvent[], bindings?: any[], exportAs?: string,
+        compileChildren?: boolean;
+  }): DirectiveMetadata;
+
+
+     (obj: {
+    selector?: string, properties?: string[], events?: string[], host?: StringMap<string, string>,
+        lifecycle?: LifecycleEvent[], bindings?: any[], exportAs?: string,
+        compileChildren?: boolean;
+  }): DirectiveDecorator;
+
+  }
+
+
+  /**
+   * {@link ViewMetadata} factory function.
+   */
+  var View : ViewFactory ;
+
+
+  /**
+   * Interface for the {@link ViewMetadata} decorator function.
+   *
+   * See {@link ViewFactory}.
+   */
+  interface ViewDecorator extends TypeDecorator {
+
+
+    /**
+     * Chain {@link ViewMetadata} annotation.
+     */
+     View(obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: Array<Type | any | any[]>,
+    pipes?: Array<Type | any | any[]>,
+    renderer?: string,
+    styles?: string[],
+    styleUrls?: string[],
+  }): ViewDecorator;
+  }
+
+
+  /**
+   * {@link ViewAnnotation} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Component, View} from "angular2/angular2";
+   *
+   * @Component({...})
+   * @View({...})
+   * class MyComponent {
+   *   constructor() {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyComponent = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({
+   *     constructor: function() {
+   *       ...
+   *     }
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyComponent = function() {
+   *   ...
+   * };
+   *
+   * MyComponent.annotations = [
+   *   new ng.Component({...}),
+   *   new ng.View({...})
+   * ]
+   * ```
+   */
+  interface ViewFactory {
+
+     new(obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: Array<Type | any | any[]>,
+    encapsulation?: ViewEncapsulation,
+    styles?: string[],
+    styleUrls?: string[],
+  }): ViewMetadata;
+
+
+     (obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: Array<Type | any | any[]>,
+    encapsulation?: ViewEncapsulation,
+    styles?: string[],
+    styleUrls?: string[],
+  }): ViewDecorator;
+
+  }
+
+
+  /**
+   * {@link QueryMetadata} factory function.
+   */
+  var Query : QueryFactory ;
+
+
+  /**
+   * {@link QueryMetadata} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Query, QueryList, Component, View} from "angular2/angular2";
+   *
+   * @Component({...})
+   * @View({...})
+   * class MyComponent {
+   *   constructor(@Query(SomeType) queryList: QueryList) {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyComponent = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({
+   *     constructor: [new ng.Query(SomeType), function(queryList) {
+   *       ...
+   *     }]
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyComponent = function(queryList) {
+   *   ...
+   * };
+   *
+   * MyComponent.annotations = [
+   *   new ng.Component({...}),
+   *   new ng.View({...})
+   * ]
+   * MyComponent.parameters = [
+   *   [new ng.Query(SomeType)]
+   * ]
+   * ```
+   */
+  interface QueryFactory {
+
+     new(selector: Type | string, {descendants}?: {descendants?: boolean}): QueryMetadata;
+
+
+     (selector: Type | string, {descendants}?: {descendants?: boolean}): ParameterDecorator;
+
+  }
+
+
+  /**
+   * {@link di/ViewQueryMetadata} factory function.
+   */
+  var ViewQuery : QueryFactory ;
+
+
+  /**
+   * {@link PipeMetadata} factory function.
+   */
+  var Pipe : PipeFactory ;
+
+
+  /**
+   * {@link PipeMetadata} factory for creating decorators.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Pipe} from "angular2/angular2";
+   *
+   * @Pipe({...})
+   * class MyPipe {
+   *   constructor() {
+   *     ...
+   *   }
+   *
+   *   transform(v, args) {}
+   * }
+   * ```
+   */
+  interface PipeFactory {
+
+     new(obj: {
+    name: string,
+  }): any;
+
+
+     (obj: {name: string}): any;
+
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterContentInit `LifeCycleEvent.afterContentInit`}
+   * called when the bindings of all its content children have been checked the first time.
+   */
+  interface AfterContentInit {
+
+     afterContentInit(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterContentChecked `LifeCycleEvent.afterContentChecked`}
+   * called when the bindings of all its content children have been checked.
+   */
+  interface AfterContentChecked {
+
+     afterContentChecked(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterViewInit `LifeCycleEvent.afterViewInit`}
+   * called when the bindings of all its view children have been checked the first time.
+   */
+  interface AfterViewInit {
+
+     afterViewInit(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterViewChecked `LifeCycleEvent.afterViewChecked`}
+   * called when the bindings of all its view children have been checked.
+   */
+  interface AfterViewChecked {
+
+     afterViewChecked(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#OnChanges `LifeCycleEvent.OnChanges`}
+   * called after all of component's bound properties are updated.
+   */
+  interface OnChanges {
+
+     onChanges(changes: StringMap<string, any>): void;
+  }
+
+
+  /**
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#OnDestroy `LifeCycleEvent.OnDestroy`}
+   * called when a directive is being destroyed.
+   */
+  interface OnDestroy {
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#OnInit `LifeCycleEvent.OnInit`}
+   * called when a directive is being checked the first time.
+   */
+  interface OnInit {
+
+     onInit(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#DoCheck `LifeCycleEvent.DoCheck`}
+   * called when a directive is being checked.
+   */
+  interface DoCheck {
+
+     doCheck(): boolean;
+  }
+
+
+  /**
+   * Provides a way for expressing ES6 classes with parameter annotations in ES5.
+   *
+   * ## Basic Example
+   *
+   * ```
+   * var Greeter = ng.Class({
+   *   constructor: function(name) {
+   *     this.name = name;
+   *   },
+   *
+   *   greet: function() {
+   *     alert('Hello ' + this.name + '!');
+   *   }
+   * });
+   * ```
+   *
+   * is equivalent to ES6:
+   *
+   * ```
+   * class Greeter {
+   *   constructor(name) {
+   *     this.name = name;
+   *   }
+   *
+   *   greet() {
+   *     alert('Hello ' + this.name + '!');
+   *   }
+   * }
+   * ```
+   *
+   * or equivalent to ES5:
+   *
+   * ```
+   * var Greeter = function (name) {
+   *   this.name = name;
+   * }
+   *
+   * Greeter.prototype.greet = function () {
+   *   alert('Hello ' + this.name + '!');
+   * }
+   * ```
+   *
+   * ## Example with parameter annotations
+   *
+   * ```
+   * var MyService = neg.Class({
+   *   constructor: [String, [new Query(), QueryList], function(name, queryList) {
+   *     ...
+   *   }];
+   * });
+   * ```
+   *
+   * is equivalent to ES6:
+   *
+   * ```
+   * class MyService {
+   *   constructor(name: string, @Query() queryList: QueryList) {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example with inheritance
+   *
+   * ```
+   * var Shape = ng.Class({
+   *   constructor: (color) {
+   *     this.color = color;
+   *   }
+   * });
+   *
+   * var Square = ng.Class({
+   *   extends: Shape,
+   *   constructor: function(color, size) {
+   *     Shape.call(this, color);
+   *     this.size = size;
+   *   }
+   * });
+   * ```
+   */
+  function Class(clsDef: ClassDefinition) : Type ;
+
+
+  /**
+   * Declares the interface to be used with {@link Class}.
+   */
+  interface ClassDefinition {
+
+
+    /**
+     * Optional argument for specifying the superclass.
+     */
+     extends?: Type;
+
+
+    /**
+     * Required constructor function for a class.
+     *
+     * The function may be optionally wrapped in an `Array`, in which case additional parameter
+     * annotations may be specified.
+     * The number of arguments and the number of parameter annotations must match.
+     *
+     * See {@link Class} for example of usage.
+     */
+     constructor: (Function | any[]);
+  }
+
+
+  /**
+   * An interface implemented by all Angular type decorators, which allows them to be used as ES7
+   * decorators as well as
+   * Angular DSL syntax.
+   *
+   * DSL syntax:
+   *
+   * ```
+   * var MyClass = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({...});
+   * ```
+   *
+   * ES7 syntax:
+   *
+   * ```
+   * @ng.Component({...})
+   * @ng.View({...})
+   * class MyClass {...}
+   * ```
+   */
+  interface TypeDecorator {
+
+
+    /**
+     * Invoke as ES7 decorator.
+     */
+     <T extends Type>(type: T): T;
+
+
+
+    /**
+     * Storage for the accumulated annotations so far used by the DSL syntax.
+     *
+     * Used by {@link Class} to annotate the generated class.
+     */
+     annotations: any[];
+
+
+    /**
+     * Generate a class from the definition and annotate it with {@link TypeDecorator#annotations}.
+     */
+     Class(obj: ClassDefinition): Type;
+  }
+
+  enum ChangeDetectionStrategy {
+
+
+    /**
+     * `CheckedOnce` means that after calling detectChanges the mode of the change detector
+     * will become `Checked`.
+     */
+     CheckOnce,
+
+
+    /**
+     * `Checked` means that the change detector should be skipped until its mode changes to
+     * `CheckOnce`.
+     */
+     Checked,
+
+
+    /**
+     * `CheckAlways` means that after calling detectChanges the mode of the change detector
+     * will remain `CheckAlways`.
+     */
+     CheckAlways,
+
+
+    /**
+     * `Detached` means that the change detector sub tree is not a part of the main tree and
+     * should be skipped.
+     */
+     Detached,
+
+
+    /**
+     * `OnPush` means that the change detector's mode will be set to `CheckOnce` during hydration.
+     */
+     OnPush,
+
+
+    /**
+     * `Default` means that the change detector's mode will be set to `CheckAlways` during hydration.
+     */
+     Default,
+
+
+    /**
+     * This is an experimental feature. Works only in Dart.
+     */
+     OnPushObserve
+  }
+
+
+  /**
+   * An error thrown if application changes model breaking the top-down data flow.
+   *
+   * Angular expects that the data flows from top (root) component to child (leaf) components.
+   * This is known as directed acyclic graph. This allows Angular to only execute change detection
+   * once and prevents loops in change detection data flow.
+   *
+   * This exception is only thrown in dev mode.
+   */
+  class ExpressionChangedAfterItHasBeenCheckedException extends BaseException {
+  }
+
+
+  /**
+   * Thrown when an expression evaluation raises an exception.
+   *
+   * This error wraps the original exception, this is done to attach expression location information.
+   */
+  class ChangeDetectionError extends BaseException {
+
+
+    /**
+     * Location of the expression.
+     */
+     location: string;
+  }
+
+  interface ChangeDetector {
+
+     parent: ChangeDetector;
+
+     mode: ChangeDetectionStrategy;
+
+     ref: ChangeDetectorRef;
+
+     addChild(cd: ChangeDetector): void;
+
+     addShadowDomChild(cd: ChangeDetector): void;
+
+     removeChild(cd: ChangeDetector): void;
+
+     removeShadowDomChild(cd: ChangeDetector): void;
+
+     remove(): void;
+
+     hydrate(context: any, locals: Locals, directives: any, pipes: any): void;
+
+     dehydrate(): void;
+
+     markPathToRootAsCheckOnce(): void;
+
+     handleEvent(eventName: string, elIndex: number, locals: Locals): void;
+
+     detectChanges(): void;
+
+     checkNoChanges(): void;
+  }
+
+  class Locals {
+
+     parent: Locals;
+
+     current: Map<any, any>;
+
+     contains(name: string): boolean;
+
+     get(name: string): any;
+
+     set(name: string, value: any): void;
+
+     clearValues(): void;
+  }
+
+
+  /**
+   * Controls change detection.
+   *
+   * {@link ChangeDetectorRef} allows requesting checks for detectors that rely on observables. It
+   * also allows detaching and attaching change detector subtrees.
+   */
+  interface ChangeDetectorRef {
+
+
+    /**
+     * Request to check all OnPush ancestors.
+     */
+     markForCheck(): void;
+
+
+    /**
+     * Detaches the change detector from the change detector tree.
+     *
+     * The detached change detector will not be checked until it is reattached.
+     */
+     detach(): void;
+
+
+    /**
+     * Reattach the change detector to the change detector tree.
+     *
+     * This also requests a check of this change detector. This reattached change detector will be
+     * checked during the next change detection run.
+     */
+     reattach(): void;
+  }
+
+
+  /**
+   * Indicates that the result of a {@link PipeMetadata} transformation has changed even though the
+   * reference
+   * has not changed.
+   *
+   * The wrapped value will be unwrapped by change detection, and the unwrapped value will be stored.
+   *
+   * Example:
+   *
+   * ```
+   * if (this._latestValue === this._latestReturnedValue) {
+   *    return this._latestReturnedValue;
+   *  } else {
+   *    this._latestReturnedValue = this._latestValue;
+   *    return WrappedValue.wrap(this._latestValue); // this will force update
+   *  }
+   * ```
+   */
+  class WrappedValue {
+
+     static wrap(value: any): WrappedValue;
+
+     wrapped: any;
+  }
+
+
+  /**
+   * An interface which all pipes must implement.
+   *
+   * #Example
+   *
+   * ```
+   * class DoublePipe implements PipeTransform {
+   *  transform(value, args = []) {
+   *    return `${value}${value}`;
+   *  }
+   * }
+   * ```
+   */
+  interface PipeTransform {
+
+     transform(value: any, args: any[]): any;
+  }
+
+
+  /**
+   * An interface that stateful pipes should implement.
+   *
+   * #Example
+   *
+   * ```
+   * class StatefulPipe implements PipeTransform, PipeOnDestroy {
+   *  connection;
+   *
+   *  onDestroy() {
+   *    this.connection.release();
+   *  }
+   *
+   *  transform(value, args = []) {
+   *    this.connection = createConnection();
+   *    // ...
+   *    return someValue;
+   *  }
+   * }
+   * ```
+   */
+  interface PipeOnDestroy {
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * A repository of different iterable diffing strategies used by NgFor, NgClass, and others.
+   */
+  class IterableDiffers {
+
+     static create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers;
+
+
+    /**
+     * Takes an array of {@link IterableDifferFactory} and returns a binding used to extend the
+     * inherited {@link IterableDiffers} instance with the provided factories and return a new
+     * {@link IterableDiffers} instance.
+     *
+     * The following example shows how to extend an existing list of factories,
+     * which will only be applied to the injector for this component and its children.
+     * This step is all that's required to make a new {@link IterableDiffer} available.
+     *
+     * # Example
+     *
+     * ```
+     * @Component({
+     *   viewBindings: [
+     *     IterableDiffers.extend([new ImmutableListDiffer()])
+     *   ]
+     * })
+     * ```
+     */
+     static extend(factories: IterableDifferFactory[]): Binding;
+
+     factories: IterableDifferFactory[];
+
+     find(iterable: Object): IterableDifferFactory;
+  }
+
+  interface IterableDiffer {
+
+     diff(object: Object): any;
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * Provides a factory for {@link IterableDiffer}.
+   */
+  interface IterableDifferFactory {
+
+     supports(objects: Object): boolean;
+
+     create(cdRef: ChangeDetectorRef): IterableDiffer;
+  }
+
+
+  /**
+   * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.
+   */
+  class KeyValueDiffers {
+
+     static create(factories: KeyValueDifferFactory[], parent?: KeyValueDiffers): KeyValueDiffers;
+
+
+    /**
+     * Takes an array of {@link KeyValueDifferFactory} and returns a binding used to extend the
+     * inherited {@link KeyValueDiffers} instance with the provided factories and return a new
+     * {@link KeyValueDiffers} instance.
+     *
+     * The following example shows how to extend an existing list of factories,
+     * which will only be applied to the injector for this component and its children.
+     * This step is all that's required to make a new {@link KeyValueDiffer} available.
+     *
+     * # Example
+     *
+     * ```
+     * @Component({
+     *   viewBindings: [
+     *     KeyValueDiffers.extend([new ImmutableMapDiffer()])
+     *   ]
+     * })
+     * ```
+     */
+     static extend(factories: KeyValueDifferFactory[]): Binding;
+
+     factories: KeyValueDifferFactory[];
+
+     find(kv: Object): KeyValueDifferFactory;
+  }
+
+  interface KeyValueDiffer {
+
+     diff(object: Object): void;
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * Provides a factory for {@link KeyValueDiffer}.
+   */
+  interface KeyValueDifferFactory {
+
+     supports(objects: Object): boolean;
+
+     create(cdRef: ChangeDetectorRef): KeyValueDiffer;
+  }
+
+
+  /**
+   * An opaque token representing the application root type in the {@link Injector}.
+   *
+   * ```
+   * @Component(...)
+   * @View(...)
+   * class MyApp {
+   *   ...
+   * }
+   *
+   * bootstrap(MyApp).then((appRef:ApplicationRef) {
+   *   expect(appRef.injector.get(appComponentTypeToken)).toEqual(MyApp);
+   * });
+   *
+   * ```
+   */
+  const APP_COMPONENT : OpaqueToken ;
+
+
+  /**
+   * Runtime representation of a type.
+   *
+   * In JavaScript a Type is a constructor function.
+   */
+  interface Type extends Function {
+
+     new(...args: any[]): any;
+
+  }
+
+
+  /**
+   * Represents a Angular's representation of an Application.
+   *
+   * `ApplicationRef` represents a running application instance. Use it to retrieve the host
+   * component, injector,
+   * or dispose of an application.
+   */
+  interface ApplicationRef {
+
+
+    /**
+     * Returns the current {@link ComponentMetadata} type.
+     */
+     hostComponentType: Type;
+
+
+    /**
+     * Returns the current {@link ComponentMetadata} instance.
+     */
+     hostComponent: any;
+
+
+    /**
+     * Dispose (un-load) the application.
+     */
+     dispose(): void;
+
+
+    /**
+     * Returns the root application {@link Injector}.
+     */
+     injector: Injector;
+  }
+
+
+  /**
+   * Specifies app root url for the application.
+   *
+   * Used by the {@link Compiler} when resolving HTML and CSS template URLs.
+   *
+   * This interface can be overridden by the application developer to create custom behavior.
+   *
+   * See {@link Compiler}
+   */
+  class AppRootUrl {
+
+
+    /**
+     * Returns the base URL of the currently running application.
+     */
+     value: any;
+  }
+
+
+  /**
+   * Used by the {@link Compiler} when resolving HTML and CSS template URLs.
+   *
+   * This interface can be overridden by the application developer to create custom behavior.
+   *
+   * See {@link Compiler}
+   */
+  class UrlResolver {
+
+
+    /**
+     * Resolves the `url` given the `baseUrl`:
+     * - when the `url` is null, the `baseUrl` is returned,
+     * - if `url` is relative ('path/to/here', './path/to/here'), the resolved url is a combination of
+     * `baseUrl` and `url`,
+     * - if `url` is absolute (it has a scheme: 'http://', 'https://' or start with '/'), the `url` is
+     * returned as is (ignoring the `baseUrl`)
+     *
+     * @param {string} baseUrl
+     * @param {string} url
+     * @returns {string} the resolved URL
+     */
+     resolve(baseUrl: string, url: string): string;
+  }
+
+
+  /**
+   * Resolve a `Type` from a {@link ComponentMetadata} into a URL.
+   *
+   * This interface can be overridden by the application developer to create custom behavior.
+   *
+   * See {@link Compiler}
+   */
+  class ComponentUrlMapper {
+
+
+    /**
+     * Returns the base URL to the component source file.
+     * The returned URL could be:
+     * - an absolute URL,
+     * - a path relative to the application
+     */
+     getUrl(component: Type): string;
+  }
+
+
+  /**
+   * Resolve a `Type` for {@link DirectiveMetadata}.
+   *
+   * This interface can be overridden by the application developer to create custom behavior.
+   *
+   * See {@link Compiler}
+   */
+  class DirectiveResolver {
+
+
+    /**
+     * Return {@link DirectiveMetadata} for a given `Type`.
+     */
+     resolve(type: Type): DirectiveMetadata;
+  }
+
+
+  /**
+   * ## URL Resolution
+   *
+   * ```
+   * var appRootUrl: AppRootUrl = ...;
+   * var componentUrlMapper: ComponentUrlMapper = ...;
+   * var urlResolver: UrlResolver = ...;
+   *
+   * var componentType: Type = ...;
+   * var componentAnnotation: ComponentAnnotation = ...;
+   * var viewAnnotation: ViewAnnotation = ...;
+   *
+   * // Resolving a URL
+   *
+   * var url = viewAnnotation.templateUrl;
+   * var componentUrl = componentUrlMapper.getUrl(componentType);
+   * var componentResolvedUrl = urlResolver.resolve(appRootUrl.value, componentUrl);
+   * var templateResolvedUrl = urlResolver.resolve(componetResolvedUrl, url);
+   * ```
+   */
+  interface Compiler {
+
+     compileInHost(componentTypeOrBinding: Type | Binding): Promise<ProtoViewRef>;
+  }
+
+
+  /**
+   * Entry point for creating, moving views in the view hierarchy and destroying views.
+   * This manager contains all recursion and delegates to helper methods
+   * in AppViewManagerUtils and the Renderer, so unit tests get simpler.
+   */
+  interface AppViewManager {
+
+
+    /**
+     * Returns a {@link ViewContainerRef} at the {@link ElementRef} location.
+     */
+     getViewContainer(location: ElementRef): ViewContainerRef;
+
+
+    /**
+     * Return the first child element of the host element view.
+     */
+     getHostElement(hostViewRef: HostViewRef): ElementRef;
+
+
+    /**
+     * Returns an ElementRef for the element with the given variable name
+     * in the current view.
+     *
+     * - `hostLocation`: {@link ElementRef} of any element in the View which defines the scope of
+     *   search.
+     * - `variableName`: Name of the variable to locate.
+     * - Returns {@link ElementRef} of the found element or null. (Throws if not found.)
+     */
+     getNamedElementInComponentView(hostLocation: ElementRef, variableName: string): ElementRef;
+
+
+    /**
+     * Returns the component instance for a given element.
+     *
+     * The component is the execution context as seen by an expression at that {@link ElementRef}
+     * location.
+     */
+     getComponent(hostLocation: ElementRef): any;
+
+
+    /**
+     * Load component view into existing element.
+     *
+     * Use this if a host element is already in the DOM and it is necessary to upgrade
+     * the element into Angular component by attaching a view but reusing the existing element.
+     *
+     * - `hostProtoViewRef`: {@link ProtoViewRef} Proto view to use in creating a view for this
+     *   component.
+     * - `overrideSelector`: (optional) selector to use in locating the existing element to load
+     *   the view into. If not specified use the selector in the component definition of the
+     *   `hostProtoView`.
+     * - injector: {@link Injector} to use as parent injector for the view.
+     *
+     * See {@link AppViewManager#destroyRootHostView}.
+     *
+     * ## Example
+     *
+     * ```
+     * @ng.Component({
+     *   selector: 'child-component'
+     * })
+     * @ng.View({
+     *   template: 'Child'
+     * })
+     * class ChildComponent {
+     *
+     * }
+     *
+     * @ng.Component({
+     *   selector: 'my-app'
+     * })
+     * @ng.View({
+     *   template: `
+     *     Parent (<some-component></some-component>)
+     *   `
+     * })
+     * class MyApp {
+     *   viewRef: ng.ViewRef;
+     *
+     *   constructor(public appViewManager: ng.AppViewManager, compiler: ng.Compiler) {
+     *     compiler.compileInHost(ChildComponent).then((protoView: ng.ProtoViewRef) => {
+     *       this.viewRef = appViewManager.createRootHostView(protoView, 'some-component', null);
+     *     })
+     *   }
+     *
+     *   onDestroy() {
+     *     this.appViewManager.destroyRootHostView(this.viewRef);
+     *     this.viewRef = null;
+     *   }
+     * }
+     *
+     * ng.bootstrap(MyApp);
+     * ```
+     */
+     createRootHostView(hostProtoViewRef: ProtoViewRef, overrideSelector: string, injector: Injector): HostViewRef;
+
+
+    /**
+     * Remove the View created with {@link AppViewManager#createRootHostView}.
+     */
+     destroyRootHostView(hostViewRef: HostViewRef): void;
+
+
+    /**
+     * See {@link AppViewManager#destroyViewInContainer}.
+     */
+     createEmbeddedViewInContainer(viewContainerLocation: ElementRef, atIndex: number, templateRef: TemplateRef): ViewRef;
+
+
+    /**
+     * See {@link AppViewManager#destroyViewInContainer}.
+     */
+     createHostViewInContainer(viewContainerLocation: ElementRef, atIndex: number, protoViewRef: ProtoViewRef, imperativelyCreatedInjector: ResolvedBinding[]): HostViewRef;
+
+
+    /**
+     * See {@link AppViewManager#createViewInContainer}.
+     */
+     destroyViewInContainer(viewContainerLocation: ElementRef, atIndex: number): void;
+
+
+    /**
+     * See {@link AppViewManager#detachViewInContainer}.
+     */
+     attachViewInContainer(viewContainerLocation: ElementRef, atIndex: number, viewRef: ViewRef): ViewRef;
+
+
+    /**
+     * See {@link AppViewManager#attachViewInContainer}.
+     */
+     detachViewInContainer(viewContainerLocation: ElementRef, atIndex: number): ViewRef;
+  }
+
+
+  /**
+   * An iterable and observable live list of components in the DOM.
+   *
+   * A QueryList contains a live list of child directives in the DOM of a directive.
+   * The directives are kept in depth-first pre-order traversal of the DOM.
+   *
+   * The `QueryList` is iterable, therefore it can be used in both javascript code with `for..of` loop
+   * as well as in template with `*ng-for="of"` directive.
+   *
+   * QueryList is updated as part of the change-detection cycle of a directive. Since change detection
+   * happens after construction of a directive, QueryList will always be empty when observed in the
+   * constructor.
+   *
+   *
+   * NOTE: In the future this class will implement an `Observable` interface. For now it uses a plain
+   * list of observable callbacks.
+   *
+   * # Example:
+   *
+   * Assume that `<tabs>` component would like to get a list its children which are `<pane>`
+   * components as shown in this example:
+   *
+   * ```html
+   * <tabs>
+   *   <pane title="Overview">...</pane>
+   *   <pane *ng-for="#o of objects" [title]="o.title">{{o.text}}</pane>
+   * </tabs>
+   * ```
+   *
+   * In the above example the list of `<tabs>` elements needs to get a list of `<pane>` elements so
+   * that it could render tabs with the correct titles and in the correct order.
+   *
+   * A possible solution would be for a `<pane>` to inject `<tabs>` component and then register itself
+   * with `<tabs>` component's on `hydrate` and deregister on `dehydrate` event. While a reasonable
+   * approach, this would only work partialy since `*ng-for` could rearrange the list of `<pane>`
+   * components which would not be reported to `<tabs>` component and thus the list of `<pane>`
+   * components would be out of sync with respect to the list of `<pane>` elements.
+   *
+   * A preferred solution is to inject a `QueryList` which is a live list of directives in the
+   * component`s light DOM.
+   *
+   * ```javascript
+   * @Component({
+   *   selector: 'tabs'
+   * })
+   * @View({
+   *  template: `
+   *    <ul>
+   *      <li *ng-for="#pane of panes">{{pane.title}}</li>
+   *    </ul>
+   *    <content></content>
+   *  `
+   * })
+   * class Tabs {
+   *   panes: QueryList<Pane>
+   *
+   *   constructor(@Query(Pane) panes:QueryList<Pane>) {
+   *     this.panes = panes;
+   *   }
+   * }
+   *
+   * @Component({
+   *   selector: 'pane',
+   *   properties: ['title']
+   * })
+   * @View(...)
+   * class Pane {
+   *   title:string;
+   * }
+   * ```
+   */
+  class QueryList<T> {
+
+     reset(newList: T[]): void;
+
+     add(obj: T): void;
+
+     fireCallbacks(): void;
+
+     onChange(callback: () => void): void;
+
+     removeCallback(callback: () => void): void;
+
+     toString(): string;
+
+     length: number;
+
+     first: T;
+
+     last: T;
+
+     map<U>(fn: (item: T) => U): U[];
+  }
+
+
+  /**
+   * Service for dynamically loading a Component into an arbitrary position in the internal Angular
+   * application tree.
+   */
+  class DynamicComponentLoader {
+
+
+    /**
+     * Loads a root component that is placed at the first element that matches the component's
+     * selector.
+     *
+     * - `typeOrBinding` `Type` \ {@link Binding} - representing the component to load.
+     * - `overrideSelector` (optional) selector to load the component at (or use
+     *   `@Component.selector`) The selector can be anywhere (i.e. outside the current component.)
+     * - `injector` {@link Injector} - optional injector to use for the component.
+     *
+     * The loaded component receives injection normally as a hosted view.
+     *
+     *
+     * ## Example
+     *
+     * ```
+     * @ng.Component({
+     *   selector: 'child-component'
+     * })
+     * @ng.View({
+     *   template: 'Child'
+     * })
+     * class ChildComponent {
+     * }
+     *
+     *
+     *
+     * @ng.Component({
+     *   selector: 'my-app'
+     * })
+     * @ng.View({
+     *   template: `
+     *     Parent (<child id="child"></child>)
+     *   `
+     * })
+     * class MyApp {
+     *   constructor(dynamicComponentLoader: ng.DynamicComponentLoader, injector: ng.Injector) {
+     *     dynamicComponentLoader.loadAsRoot(ChildComponent, '#child', injector);
+     *   }
+     * }
+     *
+     * ng.bootstrap(MyApp);
+     * ```
+     *
+     * Resulting DOM:
+     *
+     * ```
+     * <my-app>
+     *   Parent (
+     *     <child id="child">
+     *        Child
+     *     </child>
+     *   )
+     * </my-app>
+     * ```
+     */
+     loadAsRoot(typeOrBinding: Type | Binding, overrideSelector: string, injector: Injector): Promise<ComponentRef>;
+
+
+    /**
+     * Loads a component into the component view of the provided ElementRef next to the element
+     * with the given name.
+     *
+     * The loaded component receives injection normally as a hosted view.
+     *
+     * ## Example
+     *
+     * ```
+     * @ng.Component({
+     *   selector: 'child-component'
+     * })
+     * @ng.View({
+     *   template: 'Child'
+     * })
+     * class ChildComponent {
+     * }
+     *
+     *
+     * @ng.Component({
+     *   selector: 'my-app'
+     * })
+     * @ng.View({
+     *   template: `
+     *     Parent (<div #child></div>)
+     *   `
+     * })
+     * class MyApp {
+     *   constructor(dynamicComponentLoader: ng.DynamicComponentLoader, elementRef: ng.ElementRef) {
+     *     dynamicComponentLoader.loadIntoLocation(ChildComponent, elementRef, 'child');
+     *   }
+     * }
+     *
+     * ng.bootstrap(MyApp);
+     * ```
+     *
+     * Resulting DOM:
+     *
+     * ```
+     * <my-app>
+     *    Parent (
+     *      <div #child="" class="ng-binding"></div>
+     *      <child-component class="ng-binding">Child</child-component>
+     *    )
+     * </my-app>
+     * ```
+     */
+     loadIntoLocation(typeOrBinding: Type | Binding, hostLocation: ElementRef, anchorName: string, bindings?: ResolvedBinding[]): Promise<ComponentRef>;
+
+
+    /**
+     * Loads a component next to the provided ElementRef.
+     *
+     * The loaded component receives injection normally as a hosted view.
+     *
+     *
+     * ## Example
+     *
+     * ```
+     * @ng.Component({
+     *   selector: 'child-component'
+     * })
+     * @ng.View({
+     *   template: 'Child'
+     * })
+     * class ChildComponent {
+     * }
+     *
+     *
+     * @ng.Component({
+     *   selector: 'my-app'
+     * })
+     * @ng.View({
+     *   template: `Parent`
+     * })
+     * class MyApp {
+     *   constructor(dynamicComponentLoader: ng.DynamicComponentLoader, elementRef: ng.ElementRef) {
+     *     dynamicComponentLoader.loadIntoLocation(ChildComponent, elementRef, 'child');
+     *   }
+     * }
+     *
+     * ng.bootstrap(MyApp);
+     * ```
+     *
+     * Resulting DOM:
+     *
+     * ```
+     * <my-app>Parent</my-app>
+     * <child-component>Child</child-component>
+     * ```
+     */
+     loadNextToLocation(typeOrBinding: Type | Binding, location: ElementRef, bindings?: ResolvedBinding[]): Promise<ComponentRef>;
+  }
+
+
+  /**
+   * Provides access to explicitly trigger change detection in an application.
+   *
+   * By default, `Zone` triggers change detection in Angular on each virtual machine (VM) turn. When
+   * testing, or in some
+   * limited application use cases, a developer can also trigger change detection with the
+   * `lifecycle.tick()` method.
+   *
+   * Each Angular application has a single `LifeCycle` instance.
+   *
+   * # Example
+   *
+   * This is a contrived example, since the bootstrap automatically runs inside of the `Zone`, which
+   * invokes
+   * `lifecycle.tick()` on your behalf.
+   *
+   * ```javascript
+   * bootstrap(MyApp).then((ref:ComponentRef) => {
+   *   var lifeCycle = ref.injector.get(LifeCycle);
+   *   var myApp = ref.instance;
+   *
+   *   ref.doSomething();
+   *   lifecycle.tick();
+   * });
+   * ```
+   */
+  class LifeCycle {
+
+
+    /**
+     * @private
+     */
+     registerWith(zone: NgZone, changeDetector?: ChangeDetector): void;
+
+
+    /**
+     * Invoke this method to explicitly process change detection and its side-effects.
+     *
+     *  In development mode, `tick()` also performs a second change detection cycle to ensure that no
+     * further
+     *  changes are detected. If additional changes are picked up during this second cycle, bindings
+     * in
+     * the app have
+     *  side-effects that cannot be resolved in a single change detection pass. In this case, Angular
+     * throws an error,
+     *  since an Angular application can only have one change detection pass during which all change
+     * detection must
+     *  complete.
+     */
+     tick(): void;
+  }
+
+
+  /**
+   * Reference to the element.
+   *
+   * Represents an opaque reference to the underlying element. The element is a DOM ELement in
+   * a Browser, but may represent other types on other rendering platforms. In the browser the
+   * `ElementRef` can be sent to the web-worker. Web Workers can not have references to the
+   * DOM Elements.
+   */
+  class ElementRef implements RenderElementRef {
+
+
+    /**
+     * Reference to the {@link ViewRef} where the `ElementRef` is inside of.
+     */
+     parentView: ViewRef;
+
+
+    /**
+     * Index of the element inside the {@link ViewRef}.
+     *
+     * This is used internally by the Angular framework to locate elements.
+     */
+     boundElementIndex: number;
+
+
+    /**
+     * Index of the element inside the `RenderViewRef`.
+     *
+     * This is used internally by the Angular framework to locate elements.
+     */
+     renderBoundElementIndex: number;
+
+     renderView: RenderViewRef;
+
+
+    /**
+     * Returns the native Element implementation.
+     *
+     * In the browser this represents the DOM Element.
+     *
+     * The `nativeElement` can be used as an escape hatch when direct DOM manipulation is needed. Use
+     * this with caution, as it creates tight coupling between your application and the Browser, which
+     * will not work in WebWorkers.
+     *
+     * NOTE: This method will return null in the webworker scenario!
+     */
+     nativeElement: any;
+  }
+
+
+  /**
+   * Reference to a template within a component.
+   *
+   * Represents an opaque reference to the underlying template that can
+   * be instantiated using the {@link ViewContainerRef}.
+   */
+  class TemplateRef {
+
+
+    /**
+     * The location of the template
+     */
+     elementRef: ElementRef;
+
+     protoViewRef: ProtoViewRef;
+
+
+    /**
+     * Whether this template has a local variable with the given name
+     */
+     hasLocal(name: string): boolean;
+  }
+
+
+  /**
+   * A reference to an Angular View.
+   *
+   * A View is a fundamental building block of Application UI. A View is the smallest set of
+   * elements which are created and destroyed together. A View can change properties on the elements
+   * within the view, but it can not change the structure of those elements.
+   *
+   * To change structure of the elements, the Views can contain zero or more {@link ViewContainerRef}s
+   * which allow the views to be nested.
+   *
+   * ## Example
+   *
+   * Given this template
+   *
+   * ```
+   * Count: {{items.length}}
+   * <ul>
+   *   <li *ng-for="var item of items">{{item}}</li>
+   * </ul>
+   * ```
+   *
+   * The above example we have two {@link ProtoViewRef}s:
+   *
+   * Outter {@link ProtoViewRef}:
+   * ```
+   * Count: {{items.length}}
+   * <ul>
+   *   <template ng-for var-item [ng-for-of]="items"></template>
+   * </ul>
+   * ```
+   *
+   * Inner {@link ProtoViewRef}:
+   * ```
+   *   <li>{{item}}</li>
+   * ```
+   *
+   * Notice that the original template is broken down into two separate {@link ProtoViewRef}s.
+   *
+   * The outter/inner {@link ProtoViewRef}s are then assembled into views like so:
+   *
+   * ```
+   * <!-- ViewRef: outer-0 -->
+   * Count: 2
+   * <ul>
+   *   <template view-container-ref></template>
+   *   <!-- ViewRef: inner-1 --><li>first</li><!-- /ViewRef: inner-1 -->
+   *   <!-- ViewRef: inner-2 --><li>second</li><!-- /ViewRef: inner-2 -->
+   * </ul>
+   * <!-- /ViewRef: outer-0 -->
+   * ```
+   */
+  interface ViewRef extends HostViewRef {
+
+
+    /**
+     * Return `RenderViewRef`
+     */
+     render: RenderViewRef;
+
+
+    /**
+     * Return `RenderFragmentRef`
+     */
+     renderFragment: RenderFragmentRef;
+
+
+    /**
+     * Set local variable in a view.
+     *
+     * - `contextName` - Name of the local variable in a view.
+     * - `value` - Value for the local variable in a view.
+     */
+     setLocal(contextName: string, value: any): void;
+  }
+
+  interface HostViewRef {
+  }
+
+
+  /**
+   * A reference to an Angular ProtoView.
+   *
+   * A ProtoView is a reference to a template for easy creation of views.
+   * (See {@link AppViewManager#createViewInContainer `AppViewManager#createViewInContainer`} and
+   * {@link AppViewManager#createRootHostView `AppViewManager#createRootHostView`}).
+   *
+   * A `ProtoView` is a factory for creating `View`s.
+   *
+   * ## Example
+   *
+   * Given this template
+   *
+   * ```
+   * Count: {{items.length}}
+   * <ul>
+   *   <li *ng-for="var item of items">{{item}}</li>
+   * </ul>
+   * ```
+   *
+   * The above example we have two {@link ProtoViewRef}s:
+   *
+   * Outter {@link ProtoViewRef}:
+   * ```
+   * Count: {{items.length}}
+   * <ul>
+   *   <template ng-for var-item [ng-for-of]="items"></template>
+   * </ul>
+   * ```
+   *
+   * Inner {@link ProtoViewRef}:
+   * ```
+   *   <li>{{item}}</li>
+   * ```
+   *
+   * Notice that the original template is broken down into two separate {@link ProtoViewRef}s.
+   */
+  interface ProtoViewRef {
+  }
+
+
+  /**
+   * A location where {@link ViewRef}s can be attached.
+   *
+   * A `ViewContainerRef` represents a location in a {@link ViewRef} where other child
+   * {@link ViewRef}s can be inserted. Adding and removing views is the only way of structurally
+   * changing the rendered DOM of the application.
+   */
+  interface ViewContainerRef {
+
+     viewManager: AppViewManager;
+
+     element: ElementRef;
+
+
+    /**
+     * Remove all {@link ViewRef}s at current location.
+     */
+     clear(): void;
+
+
+    /**
+     * Return a {@link ViewRef} at specific index.
+     */
+     get(index: number): ViewRef;
+
+
+    /**
+     * Returns number of {@link ViewRef}s currently attached at this location.
+     */
+     length: number;
+
+
+    /**
+     * Create and insert a {@link ViewRef} into the view-container.
+     *
+     * - `protoViewRef` (optional) {@link ProtoViewRef} - The `ProtoView` to use for creating
+     *   `View` to be inserted at this location. If `ViewContainer` is created at a location
+     *   of inline template, then `protoViewRef` is the `ProtoView` of the template.
+     * - `atIndex` (optional) `number` - location of insertion point. (Or at the end if unspecified.)
+     * - `context` (optional) {@link ElementRef} - Context (for expression evaluation) from the
+     *   {@link ElementRef} location. (Or current context if unspecified.)
+     * - `bindings` (optional) Array of {@link ResolvedBinding} - Used for configuring
+     *   `ElementInjector`.
+     *
+     * Returns newly created {@link ViewRef}.
+     */
+     createEmbeddedView(templateRef: TemplateRef, atIndex?: number): ViewRef;
+
+     createHostView(protoViewRef?: ProtoViewRef, atIndex?: number, dynamicallyCreatedBindings?: ResolvedBinding[]): HostViewRef;
+
+
+    /**
+     * Insert a {@link ViewRef} at specefic index.
+     *
+     * The index is location at which the {@link ViewRef} should be attached. If omitted it is
+     * inserted at the end.
+     *
+     * Returns the inserted {@link ViewRef}.
+     */
+     insert(viewRef: ViewRef, atIndex?: number): ViewRef;
+
+
+    /**
+     * Return the index of already inserted {@link ViewRef}.
+     */
+     indexOf(viewRef: ViewRef): number;
+
+
+    /**
+     * Remove a {@link ViewRef} at specific index.
+     *
+     * If the index is omitted last {@link ViewRef} is removed.
+     */
+     remove(atIndex?: number): void;
+
+
+    /**
+     * The method can be used together with insert to implement a view move, i.e.
+     * moving the dom nodes while the directives in the view stay intact.
+     */
+     detach(atIndex?: number): ViewRef;
+  }
+
+
+  /**
+   * Angular's reference to a component instance.
+   *
+   * `ComponentRef` represents a component instance lifecycle and meta information.
+   */
+  interface ComponentRef {
+
+
+    /**
+     * Location of the component host element.
+     */
+     location: ElementRef;
+
+
+    /**
+     * Instance of component.
+     */
+     instance: any;
+
+
+    /**
+     * Returns the host {@link ViewRef}.
+     */
+     hostView: HostViewRef;
+
+
+    /**
+     * Dispose of the component instance.
+     */
+     dispose(): void;
+  }
+
+
+  /**
+   * A wrapper around zones that lets you schedule tasks after it has executed a task.
+   *
+   * The wrapper maintains an "inner" and an "mount" `Zone`. The application code will executes
+   * in the "inner" zone unless `runOutsideAngular` is explicitely called.
+   *
+   * A typical application will create a singleton `NgZone`. The outer `Zone` is a fork of the root
+   * `Zone`. The default `onTurnDone` runs the Angular change detection.
+   */
+  class NgZone {
+
+
+    /**
+     * Sets the zone hook that is called just before Angular event turn starts.
+     * It is called once per browser event.
+     */
+     overrideOnTurnStart(onTurnStartFn: Function): void;
+
+
+    /**
+     * Sets the zone hook that is called immediately after Angular processes
+     * all pending microtasks.
+     */
+     overrideOnTurnDone(onTurnDoneFn: Function): void;
+
+
+    /**
+     * Sets the zone hook that is called immediately after the last turn in
+     * an event completes. At this point Angular will no longer attempt to
+     * sync the UI. Any changes to the data model will not be reflected in the
+     * DOM. `onEventDoneFn` is executed outside Angular zone.
+     *
+     * This hook is useful for validating application state (e.g. in a test).
+     */
+     overrideOnEventDone(onEventDoneFn: Function, opt_waitForAsync: boolean): void;
+
+
+    /**
+     * Sets the zone hook that is called when an error is uncaught in the
+     * Angular zone. The first argument is the error. The second argument is
+     * the stack trace.
+     */
+     overrideOnErrorHandler(errorHandlingFn: Function): void;
+
+
+    /**
+     * Runs `fn` in the inner zone and returns whatever it returns.
+     *
+     * In a typical app where the inner zone is the Angular zone, this allows one to make use of the
+     * Angular's auto digest mechanism.
+     *
+     * ```
+     * var zone: NgZone = [ref to the application zone];
+     *
+     * zone.run(() => {
+     *   // the change detection will run after this function and the microtasks it enqueues have
+     * executed.
+     * });
+     * ```
+     */
+     run(fn: () => any): any;
+
+
+    /**
+     * Runs `fn` in the outer zone and returns whatever it returns.
+     *
+     * In a typical app where the inner zone is the Angular zone, this allows one to escape Angular's
+     * auto-digest mechanism.
+     *
+     * ```
+     * var zone: NgZone = [ref to the application zone];
+     *
+     * zone.runOutsideAngular(() => {
+     *   element.onClick(() => {
+     *     // Clicking on the element would not trigger the change detection
+     *   });
+     * });
+     * ```
+     */
+     runOutsideAngular(fn: () => any): any;
+  }
+
+  class Observable {
+
+     observer(generator: any): Object;
+  }
+
+
+  /**
+   * Use Rx.Observable but provides an adapter to make it work as specified here:
+   * https://github.com/jhusain/observable-spec
+   *
+   * Once a reference implementation of the spec is available, switch to it.
+   */
+  class EventEmitter extends Observable {
+
+     observer(generator: any): Rx.IDisposable;
+
+     toRx(): Rx.Observable<any>;
+
+     next(value: any): void;
+
+     throw(error: any): void;
+
+     return(value?: any): void;
+  }
+
+
+  /**
+   * A parameter metadata that specifies a dependency.
+   *
+   * ```
+   * class AComponent {
+   *   constructor(@Inject(MyService) aService:MyService) {}
+   * }
+   * ```
+   */
+  class InjectMetadata {
+
+     token: any;
+
+     toString(): string;
+  }
+
+
+  /**
+   * A parameter metadata that marks a dependency as optional. {@link Injector} provides `null` if
+   * the dependency is not found.
+   *
+   * ```
+   * class AComponent {
+   *   constructor(@Optional() aService:MyService) {
+   *     this.aService = aService;
+   *   }
+   * }
+   * ```
+   */
+  class OptionalMetadata {
+
+     toString(): string;
+  }
+
+
+  /**
+   * A marker metadata that marks a class as available to `Injector` for creation. Used by tooling
+   * for generating constructor stubs.
+   *
+   * ```
+   * class NeedsService {
+   *   constructor(svc:UsefulService) {}
+   * }
+   *
+   * @Injectable
+   * class UsefulService {}
+   * ```
+   */
+  class InjectableMetadata {
+  }
+
+
+  /**
+   * Specifies that an injector should retrieve a dependency from itself.
+   *
+   * ## Example
+   *
+   * ```
+   * class Dependency {
+   * }
+   *
+   * class NeedsDependency {
+   *   constructor(public @Self() dependency:Dependency) {}
+   * }
+   *
+   * var inj = Injector.resolveAndCreate([Dependency, NeedsDependency]);
+   * var nd = inj.get(NeedsDependency);
+   * expect(nd.dependency).toBeAnInstanceOf(Dependency);
+   * ```
+   */
+  class SelfMetadata {
+
+     toString(): string;
+  }
+
+
+  /**
+   * Specifies that an injector should retrieve a dependency from any injector until reaching the
+   * closest host.
+   *
+   * ## Example
+   *
+   * ```
+   * class Dependency {
+   * }
+   *
+   * class NeedsDependency {
+   *   constructor(public @Host() dependency:Dependency) {}
+   * }
+   *
+   * var parent = Injector.resolveAndCreate([
+   *   bind(Dependency).toClass(HostDependency)
+   * ]);
+   * var child = parent.resolveAndCreateChild([]);
+   * var grandChild = child.resolveAndCreateChild([NeedsDependency, Depedency]);
+   * var nd = grandChild.get(NeedsDependency);
+   * expect(nd.dependency).toBeAnInstanceOf(HostDependency);
+   * ```
+   */
+  class HostMetadata {
+
+     toString(): string;
+  }
+
+
+  /**
+   * Specifies that the dependency resolution should start from the parent injector.
+   *
+   * ## Example
+   *
+   *
+   * ```
+   * class Service {}
+   *
+   * class ParentService implements Service {
+   * }
+   *
+   * class ChildService implements Service {
+   *   constructor(public @SkipSelf() parentService:Service) {}
+   * }
+   *
+   * var parent = Injector.resolveAndCreate([
+   *   bind(Service).toClass(ParentService)
+   * ]);
+   * var child = parent.resolveAndCreateChild([
+   *   bind(Service).toClass(ChildSerice)
+   * ]);
+   * var s = child.get(Service);
+   * expect(s).toBeAnInstanceOf(ChildService);
+   * expect(s.parentService).toBeAnInstanceOf(ParentService);
+   * ```
+   */
+  class SkipSelfMetadata {
+
+     toString(): string;
+  }
+
+
+  /**
+   * `DependencyMetadata is used by the framework to extend DI.
+   *
+   * Only metadata implementing `DependencyMetadata` are added to the list of dependency
+   * properties.
+   *
+   * For example:
+   *
+   * ```
+   * class Exclude extends DependencyMetadata {}
+   * class NotDependencyProperty {}
+   *
+   * class AComponent {
+   *   constructor(@Exclude @NotDependencyProperty aService:AService) {}
+   * }
+   * ```
+   *
+   * will create the following dependency:
+   *
+   * ```
+   * new Dependency(Key.get(AService), [new Exclude()])
+   * ```
+   *
+   * The framework can use `new Exclude()` to handle the `aService` dependency
+   * in a specific way.
+   */
+  class DependencyMetadata {
+
+     token: any;
+  }
+
+
+  /**
+   * Allows to refer to references which are not yet defined.
+   *
+   * This situation arises when the key which we need te refer to for the purposes of DI is declared,
+   * but not yet defined.
+   *
+   * ## Example:
+   *
+   * ```
+   * class Door {
+   *   // Incorrect way to refer to a reference which is defined later.
+   *   // This fails because `Lock` is undefined at this point.
+   *   constructor(lock:Lock) { }
+   *
+   *   // Correct way to refer to a reference which is defined later.
+   *   // The reference needs to be captured in a closure.
+   *   constructor(@Inject(forwardRef(() => Lock)) lock:Lock) { }
+   * }
+   *
+   * // Only at this point the lock is defined.
+   * class Lock {
+   * }
+   * ```
+   */
+  function forwardRef(forwardRefFn: ForwardRefFn) : Type ;
+
+
+  /**
+   * Lazily retrieve the reference value.
+   *
+   * See: {@link forwardRef}
+   */
+  function resolveForwardRef(type: any) : any ;
+
+  interface ForwardRefFn {
+
+     (): any;
+
+  }
+
+
+  /**
+   * A dependency injection container used for resolving dependencies.
+   *
+   * An `Injector` is a replacement for a `new` operator, which can automatically resolve the
+   * constructor dependencies.
+   * In typical use, application code asks for the dependencies in the constructor and they are
+   * resolved by the `Injector`.
+   *
+   * ## Example:
+   *
+   * Suppose that we want to inject an `Engine` into class `Car`, we would define it like this:
+   *
+   * ```javascript
+   * class Engine {
+   * }
+   *
+   * class Car {
+   *   constructor(@Inject(Engine) engine) {
+   *   }
+   * }
+   *
+   * ```
+   *
+   * Next we need to write the code that creates and instantiates the `Injector`. We then ask for the
+   * `root` object, `Car`, so that the `Injector` can recursively build all of that object's
+   * dependencies.
+   *
+   * ```javascript
+   * main() {
+   *   var injector = Injector.resolveAndCreate([Car, Engine]);
+   *
+   *   // Get a reference to the `root` object, which will recursively instantiate the tree.
+   *   var car = injector.get(Car);
+   * }
+   * ```
+   * Notice that we don't use the `new` operator because we explicitly want to have the `Injector`
+   * resolve all of the object's dependencies automatically.
+   */
+  class Injector {
+
+
+    /**
+     * Turns a list of binding definitions into an internal resolved list of resolved bindings.
+     *
+     * A resolution is a process of flattening multiple nested lists and converting individual
+     * bindings into a list of {@link ResolvedBinding}s. The resolution can be cached by `resolve`
+     * for the {@link Injector} for performance-sensitive code.
+     *
+     * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
+     * recursive list of more bindings.
+     *
+     * The returned list is sparse, indexed by `id` for the {@link Key}. It is generally not useful to
+     * application code
+     * other than for passing it to {@link Injector} functions that require resolved binding lists,
+     * such as
+     * `fromResolvedBindings` and `createChildFromResolved`.
+     */
+     static resolve(bindings: Array<Type | Binding | any[]>): ResolvedBinding[];
+
+
+    /**
+     * Resolves bindings and creates an injector based on those bindings. This function is slower than
+     * the corresponding `fromResolvedBindings` because it needs to resolve bindings first. See
+     * `resolve`
+     * for the {@link Injector}.
+     *
+     * Prefer `fromResolvedBindings` in performance-critical code that creates lots of injectors.
+     *
+     * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
+     * recursive list of more
+     * bindings.
+     * @param `depProvider`
+     */
+     static resolveAndCreate(bindings: Array<Type | Binding | any[]>, depProvider?: DependencyProvider): Injector;
+
+
+    /**
+     * Creates an injector from previously resolved bindings. This bypasses resolution and flattening.
+     * This API is the recommended way to construct injectors in performance-sensitive parts.
+     *
+     * @param `bindings` A sparse list of {@link ResolvedBinding}s. See `resolve` for the
+     * {@link Injector}.
+     * @param `depProvider`
+     */
+     static fromResolvedBindings(bindings: ResolvedBinding[], depProvider?: DependencyProvider): Injector;
+
+
+    /**
+     * Returns debug information about the injector.
+     *
+     * This information is included into exceptions thrown by the injector.
+     */
+     debugContext(): any;
+
+
+    /**
+     * Retrieves an instance from the injector.
+     *
+     * @param `token`: usually the `Type` of an object. (Same as the token used while setting up a
+     * binding).
+     * @returns an instance represented by the token. Throws if not found.
+     */
+     get(token: any): any;
+
+
+    /**
+     * Retrieves an instance from the injector.
+     *
+     * @param `token`: usually a `Type`. (Same as the token used while setting up a binding).
+     * @returns an instance represented by the token. Returns `null` if not found.
+     */
+     getOptional(token: any): any;
+
+
+    /**
+     * Retrieves an instance from the injector.
+     *
+     * @param `index`: index of an instance.
+     * @returns an instance represented by the index. Throws if not found.
+     */
+     getAt(index: number): any;
+
+
+    /**
+     * Direct parent of this injector.
+     */
+     parent: Injector;
+
+
+    /**
+     * Internal. Do not use.
+     *
+     * We return `any` not to export the InjectorStrategy type.
+     */
+     internalStrategy: any;
+
+
+    /**
+     * Creates a child injector and loads a new set of bindings into it.
+     *
+     * A resolution is a process of flattening multiple nested lists and converting individual
+     * bindings into a list of {@link ResolvedBinding}s. The resolution can be cached by `resolve`
+     * for the {@link Injector} for performance-sensitive code.
+     *
+     * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
+     * recursive list of more bindings.
+     * @param `depProvider`
+     */
+     resolveAndCreateChild(bindings: Array<Type | Binding | any[]>, depProvider?: DependencyProvider): Injector;
+
+
+    /**
+     * Creates a child injector and loads a new set of {@link ResolvedBinding}s into it.
+     *
+     * @param `bindings`: A sparse list of {@link ResolvedBinding}s.
+     * See `resolve` for the {@link Injector}.
+     * @param `depProvider`
+     * @returns a new child {@link Injector}.
+     */
+     createChildFromResolved(bindings: ResolvedBinding[], depProvider?: DependencyProvider): Injector;
+
+
+    /**
+     * Resolves a binding and instantiates an object in the context of the injector.
+     *
+     * @param `binding`: either a type or a binding.
+     * @returns an object created using binding.
+     */
+     resolveAndInstantiate(binding: Type | Binding): any;
+
+
+    /**
+     * Instantiates an object using a resolved bindin in the context of the injector.
+     *
+     * @param `binding`: a resolved binding
+     * @returns an object created using binding.
+     */
+     instantiateResolved(binding: ResolvedBinding): any;
+
+     displayName: string;
+
+     toString(): string;
+  }
+
+  class ProtoInjector {
+
+     numberOfBindings: number;
+
+     getBindingAtIndex(index: number): any;
+  }
+
+  class BindingWithVisibility {
+
+     binding: ResolvedBinding;
+
+     visibility: Visibility;
+
+     getKeyId(): number;
+  }
+
+
+  /**
+   * Used to provide dependencies that cannot be easily expressed as bindings.
+   */
+  interface DependencyProvider {
+
+     getDependency(injector: Injector, binding: ResolvedBinding, dependency: Dependency): any;
+  }
+
+  enum Visibility {
+
+     Public,
+
+     Private,
+
+     PublicAndPrivate
+  }
+
+  const UNDEFINED : Object ;
+
+
+  /**
+   * Describes how_ the {@link Injector} should instantiate a given token.
+   *
+   * See {@link bind}.
+   *
+   * ## Example
+   *
+   * ```javascript
+   * var injector = Injector.resolveAndCreate([
+   *   new Binding(String, { toValue: 'Hello' })
+   * ]);
+   *
+   * expect(injector.get(String)).toEqual('Hello');
+   * ```
+   */
+  class Binding {
+
+
+    /**
+     * Token used when retrieving this binding. Usually the `Type`.
+     */
+     token: any;
+
+
+    /**
+     * Binds an interface to an implementation / subclass.
+     *
+     * ## Example
+     *
+     * Becuse `toAlias` and `toClass` are often confused, the example contains both use cases for easy
+     * comparison.
+     *
+     * ```javascript
+     *
+     * class Vehicle {}
+     *
+     * class Car extends Vehicle {}
+     *
+     * var injectorClass = Injector.resolveAndCreate([
+     *   Car,
+     *   new Binding(Vehicle, { toClass: Car })
+     * ]);
+     * var injectorAlias = Injector.resolveAndCreate([
+     *   Car,
+     *   new Binding(Vehicle, { toAlias: Car })
+     * ]);
+     *
+     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+     *
+     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+     * ```
+     */
+     toClass: Type;
+
+
+    /**
+     * Binds a key to a value.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   new Binding(String, { toValue: 'Hello' })
+     * ]);
+     *
+     * expect(injector.get(String)).toEqual('Hello');
+     * ```
+     */
+     toValue: any;
+
+
+    /**
+     * Binds a key to the alias for an existing key.
+     *
+     * An alias means that {@link Injector} returns the same instance as if the alias token was used.
+     * This is in contrast to `toClass` where a separate instance of `toClass` is returned.
+     *
+     * ## Example
+     *
+     * Becuse `toAlias` and `toClass` are often confused the example contains both use cases for easy
+     * comparison.
+     *
+     * ```javascript
+     *
+     * class Vehicle {}
+     *
+     * class Car extends Vehicle {}
+     *
+     * var injectorAlias = Injector.resolveAndCreate([
+     *   Car,
+     *   new Binding(Vehicle, { toAlias: Car })
+     * ]);
+     * var injectorClass = Injector.resolveAndCreate([
+     *   Car,
+     *   new Binding(Vehicle, { toClass: Car })
+     * ]);
+     *
+     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+     *
+     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+     * ```
+     */
+     toAlias: any;
+
+
+    /**
+     * Binds a key to a function which computes the value.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   new Binding(Number, { toFactory: () => { return 1+2; }}),
+     *   new Binding(String, { toFactory: (value) => { return "Value: " + value; },
+     *                         dependencies: [Number] })
+     * ]);
+     *
+     * expect(injector.get(Number)).toEqual(3);
+     * expect(injector.get(String)).toEqual('Value: 3');
+     * ```
+     */
+     toFactory: Function;
+
+
+    /**
+     * Used in conjunction with `toFactory` and specifies a set of dependencies
+     * (as `token`s) which should be injected into the factory function.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   new Binding(Number, { toFactory: () => { return 1+2; }}),
+     *   new Binding(String, { toFactory: (value) => { return "Value: " + value; },
+     *                         dependencies: [Number] })
+     * ]);
+     *
+     * expect(injector.get(Number)).toEqual(3);
+     * expect(injector.get(String)).toEqual('Value: 3');
+     * ```
+     */
+     dependencies: any[];
+
+
+    /**
+     * Converts the {@link Binding} into {@link ResolvedBinding}.
+     *
+     * {@link Injector} internally only uses {@link ResolvedBinding}, {@link Binding} contains
+     * convenience binding syntax.
+     */
+     resolve(): ResolvedBinding;
+  }
+
+
+  /**
+   * Helper class for the {@link bind} function.
+   */
+  class BindingBuilder {
+
+     token: any;
+
+
+    /**
+     * Binds an interface to an implementation / subclass.
+     *
+     * ## Example
+     *
+     * Because `toAlias` and `toClass` are often confused, the example contains both use cases for
+     * easy comparison.
+     *
+     * ```javascript
+     *
+     * class Vehicle {}
+     *
+     * class Car extends Vehicle {}
+     *
+     * var injectorClass = Injector.resolveAndCreate([
+     *   Car,
+     *   bind(Vehicle).toClass(Car)
+     * ]);
+     * var injectorAlias = Injector.resolveAndCreate([
+     *   Car,
+     *   bind(Vehicle).toAlias(Car)
+     * ]);
+     *
+     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+     *
+     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+     * ```
+     */
+     toClass(type: Type): Binding;
+
+
+    /**
+     * Binds a key to a value.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   bind(String).toValue('Hello')
+     * ]);
+     *
+     * expect(injector.get(String)).toEqual('Hello');
+     * ```
+     */
+     toValue(value: any): Binding;
+
+
+    /**
+     * Binds a key to the alias for an existing key.
+     *
+     * An alias means that we will return the same instance as if the alias token was used. (This is
+     * in contrast to `toClass` where a separate instance of `toClass` will be returned.)
+     *
+     * ## Example
+     *
+     * Becuse `toAlias` and `toClass` are often confused, the example contains both use cases for easy
+     * comparison.
+     *
+     * ```javascript
+     *
+     * class Vehicle {}
+     *
+     * class Car extends Vehicle {}
+     *
+     * var injectorAlias = Injector.resolveAndCreate([
+     *   Car,
+     *   bind(Vehicle).toAlias(Car)
+     * ]);
+     * var injectorClass = Injector.resolveAndCreate([
+     *   Car,
+     *   bind(Vehicle).toClass(Car)
+     * ]);
+     *
+     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+     *
+     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+     * ```
+     */
+     toAlias(aliasToken: /*Type*/ any): Binding;
+
+
+    /**
+     * Binds a key to a function which computes the value.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   bind(Number).toFactory(() => { return 1+2; }),
+     *   bind(String).toFactory((v) => { return "Value: " + v; }, [Number])
+     * ]);
+     *
+     * expect(injector.get(Number)).toEqual(3);
+     * expect(injector.get(String)).toEqual('Value: 3');
+     * ```
+     */
+     toFactory(factoryFunction: Function, dependencies?: any[]): Binding;
+  }
+
+
+  /**
+   * An internal resolved representation of a {@link Binding} used by the {@link Injector}.
+   *
+   * A {@link Binding} is resolved when it has a factory function. Binding to a class, alias, or
+   * value, are just convenience methods, as {@link Injector} only operates on calling factory
+   * functions.
+   */
+  class ResolvedBinding {
+
+
+    /**
+     * A key, usually a `Type`.
+     */
+     key: Key;
+
+
+    /**
+     * Factory function which can return an instance of an object represented by a key.
+     */
+     factory: Function;
+
+
+    /**
+     * Arguments (dependencies) to the `factory` function.
+     */
+     dependencies: Dependency[];
+  }
+
+
+  /**
+   * @private
+   */
+  class Dependency {
+
+     static fromKey(key: Key): Dependency;
+
+     key: Key;
+
+     optional: boolean;
+
+     lowerBoundVisibility: any;
+
+     upperBoundVisibility: any;
+
+     properties: any[];
+  }
+
+
+  /**
+   * Provides an API for imperatively constructing {@link Binding}s.
+   *
+   * This is only relevant for JavaScript. See {@link BindingBuilder}.
+   *
+   * ## Example
+   *
+   * ```javascript
+   * bind(MyInterface).toClass(MyClass)
+   *
+   * ```
+   */
+  function bind(token: any) : BindingBuilder ;
+
+
+  /**
+   * A unique object used for retrieving items from the {@link Injector}.
+   *
+   * Keys have:
+   * - a system-wide unique `id`.
+   * - a `token`, usually the `Type` of the instance.
+   *
+   * Keys are used internally by the {@link Injector} because their system-wide unique `id`s allow the
+   * injector to index in arrays rather than looking up items in maps.
+   */
+  class Key {
+
+
+    /**
+     * Retrieves a `Key` for a token.
+     */
+     static get(token: Object): Key;
+
+
+    /**
+     * @returns the number of keys registered in the system.
+     */
+     static numberOfKeys: number;
+
+     token: Object;
+
+     id: number;
+
+     displayName: string;
+  }
+
+
+  /**
+   * @private
+   */
+  class KeyRegistry {
+
+     get(token: Object): Key;
+
+     numberOfKeys: number;
+  }
+
+
+  /**
+   * Type literals is a Dart-only feature. This is here only so we can x-compile
+   * to multiple languages.
+   */
+  class TypeLiteral {
+
+     type: any;
+  }
+
+
+  /**
+   * Thrown when trying to retrieve a dependency by `Key` from {@link Injector}, but the
+   * {@link Injector} does not have a {@link Binding} for {@link Key}.
+   */
+  class NoBindingError extends AbstractBindingError {
+  }
+
+
+  /**
+   * Base class for all errors arising from misconfigured bindings.
+   */
+  class AbstractBindingError extends BaseException {
+
+     name: string;
+
+     message: string;
+
+     keys: Key[];
+
+     injectors: Injector[];
+
+     constructResolvingMessage: Function;
+
+     addKey(injector: Injector, key: Key): void;
+
+     context: any;
+
+     toString(): string;
+  }
+
+
+  /**
+   * Thrown when dependencies form a cycle.
+   *
+   * ## Example:
+   *
+   * ```javascript
+   * class A {
+   *   constructor(b:B) {}
+   * }
+   * class B {
+   *   constructor(a:A) {}
+   * }
+   * ```
+   *
+   * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.
+   */
+  class CyclicDependencyError extends AbstractBindingError {
+  }
+
+
+  /**
+   * Thrown when a constructing type returns with an Error.
+   *
+   * The `InstantiationError` class contains the original error plus the dependency graph which caused
+   * this object to be instantiated.
+   */
+  class InstantiationError extends AbstractBindingError {
+
+     causeKey: Key;
+  }
+
+
+  /**
+   * Thrown when an object other then {@link Binding} (or `Type`) is passed to {@link Injector}
+   * creation.
+   */
+  class InvalidBindingError extends BaseException {
+
+     message: string;
+
+     toString(): string;
+  }
+
+
+  /**
+   * Thrown when the class has no annotation information.
+   *
+   * Lack of annotation information prevents the {@link Injector} from determining which dependencies
+   * need to be injected into the constructor.
+   */
+  class NoAnnotationError extends BaseException {
+
+     name: string;
+
+     message: string;
+
+     toString(): string;
+  }
+
+
+  /**
+   * Thrown when getting an object by index.
+   */
+  class OutOfBoundsError extends BaseException {
+
+     message: string;
+
+     toString(): string;
+  }
+
+  class OpaqueToken {
+
+     toString(): string;
+  }
+
+
+  /**
+   * Factory for creating {@link InjectMetadata}.
+   */
+  interface InjectFactory {
+
+     new(token: any): InjectMetadata;
+
+
+     (token: any): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link OptionalMetadata}.
+   */
+  interface OptionalFactory {
+
+     new(): OptionalMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link InjectableMetadata}.
+   */
+  interface InjectableFactory {
+
+     new(): InjectableMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link SelfMetadata}.
+   */
+  interface SelfFactory {
+
+     new(): SelfMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link HostMetadata}.
+   */
+  interface HostFactory {
+
+     new(): HostMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link SkipSelfMetadata}.
+   */
+  interface SkipSelfFactory {
+
+     new(): SkipSelfMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link InjectMetadata}.
+   */
+  var Inject : InjectFactory ;
+
+
+  /**
+   * Factory for creating {@link OptionalMetadata}.
+   */
+  var Optional : OptionalFactory ;
+
+
+  /**
+   * Factory for creating {@link InjectableMetadata}.
+   */
+  var Injectable : InjectableFactory ;
+
+
+  /**
+   * Factory for creating {@link SelfMetadata}.
+   */
+  var Self : SelfFactory ;
+
+
+  /**
+   * Factory for creating {@link HostMetadata}.
+   */
+  var Host : HostFactory ;
+
+
+  /**
+   * Factory for creating {@link SkipSelfMetadata}.
+   */
+  var SkipSelf : SkipSelfFactory ;
+
+
+  /**
+   * A collection of the Angular core directives that are likely to be used in each and every Angular
+   * application.
+   *
+   * This collection can be used to quickly enumerate all the built-in directives in the `@View`
+   * annotation. For example,
+   * instead of writing:
+   *
+   * ```
+   * import {NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault} from 'angular2/angular2';
+   * import {OtherDirective} from 'myDirectives';
+   *
+   * @Component({
+   *  selector: 'my-component'
+   * })
+   * @View({
+   *   templateUrl: 'myComponent.html',
+   *   directives: [NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault, OtherDirective]
+   * })
+   * export class MyComponent {
+   *   ...
+   * }
+   * ```
+   * one could import all the core directives at once:
+   *
+   * ```
+   * import {CORE_DIRECTIVES} from 'angular2/angular2';
+   * import {OtherDirective} from 'myDirectives';
+   *
+   * @Component({
+   *  selector: 'my-component'
+   * })
+   * @View({
+   *   templateUrl: 'myComponent.html',
+   *   directives: [CORE_DIRECTIVES, OtherDirective]
+   * })
+   * export class MyComponent {
+   *   ...
+   * }
+   * ```
+   */
+  const CORE_DIRECTIVES : Type[] ;
+
+
+  /**
+   * Adds and removes CSS classes based on an {expression} value.
+   *
+   * The result of expression is used to add and remove CSS classes using the following logic,
+   * based on expression's value type:
+   * - {string} - all the CSS classes (space - separated) are added
+   * - {Array} - all the CSS classes (Array elements) are added
+   * - {Object} - each key corresponds to a CSS class name while values
+   * are interpreted as {boolean} expression. If a given expression
+   * evaluates to {true} a corresponding CSS class is added - otherwise
+   * it is removed.
+   *
+   * # Example:
+   *
+   * ```
+   * <div class="message" [ng-class]="{error: errorCount > 0}">
+   *     Please check errors.
+   * </div>
+   * ```
+   */
+  class NgClass {
+
+     initialClasses: any;
+
+     rawClass: any;
+
+     doCheck(): void;
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * The `NgFor` directive instantiates a template once per item from an iterable. The context for
+   * each instantiated template inherits from the outer context with the given loop variable set
+   * to the current item from the iterable.
+   *
+   * It is possible to alias the `index` to a local variable that will be set to the current loop
+   * iteration in the template context.
+   *
+   * When the contents of the iterator changes, `NgFor` makes the corresponding changes to the DOM:
+   *
+   * * When an item is added, a new instance of the template is added to the DOM.
+   * * When an item is removed, its template instance is removed from the DOM.
+   * * When items are reordered, their respective templates are reordered in the DOM.
+   *
+   * # Example
+   *
+   * ```
+   * <ul>
+   *   <li *ng-for="#error of errors; #i = index">
+   *     Error {{i}} of {{errors.length}}: {{error.message}}
+   *   </li>
+   * </ul>
+   * ```
+   *
+   * # Syntax
+   *
+   * - `<li *ng-for="#item of items; #i = index">...</li>`
+   * - `<li template="ng-for #item of items; #i = index">...</li>`
+   * - `<template ng-for #item [ng-for-of]="items" #i="index"><li>...</li></template>`
+   */
+  class NgFor {
+
+     static bulkRemove(tuples: RecordViewTuple[], viewContainer: ViewContainerRef): RecordViewTuple[];
+
+     static bulkInsert(tuples: RecordViewTuple[], viewContainer: ViewContainerRef, templateRef: TemplateRef): RecordViewTuple[];
+
+     viewContainer: ViewContainerRef;
+
+     templateRef: TemplateRef;
+
+     iterableDiffers: IterableDiffers;
+
+     cdr: ChangeDetectorRef;
+
+     ngForOf: any;
+
+     doCheck(): void;
+  }
+
+  class RecordViewTuple {
+
+     view: ViewRef;
+
+     record: any;
+  }
+
+
+  /**
+   * Removes or recreates a portion of the DOM tree based on an {expression}.
+   *
+   * If the expression assigned to `ng-if` evaluates to a false value then the element
+   * is removed from the DOM, otherwise a clone of the element is reinserted into the DOM.
+   *
+   * # Example:
+   *
+   * ```
+   * <div *ng-if="errorCount > 0" class="error">
+   *   <!-- Error message displayed when the errorCount property on the current context is greater
+   * than 0. -->
+   *   {{errorCount}} errors detected
+   * </div>
+   * ```
+   *
+   * # Syntax
+   *
+   * - `<div *ng-if="condition">...</div>`
+   * - `<div template="ng-if condition">...</div>`
+   * - `<template [ng-if]="condition"><div>...</div></template>`
+   */
+  class NgIf {
+
+     ngIf: any;
+  }
+
+
+  /**
+   * The `NgNonBindable` directive tells Angular not to compile or bind the contents of the current
+   * DOM element. This is useful if the element contains what appears to be Angular directives and
+   * bindings but which should be ignored by Angular. This could be the case if you have a site that
+   * displays snippets of code, for instance.
+   *
+   * Example:
+   *
+   * ```
+   * <div>Normal: {{1 + 2}}</div> // output "Normal: 3"
+   * <div ng-non-bindable>Ignored: {{1 + 2}}</div> // output "Ignored: {{1 + 2}}"
+   * ```
+   */
+  class NgNonBindable {
+  }
+
+
+  /**
+   * Adds or removes styles based on an {expression}.
+   *
+   * When the expression assigned to `ng-style` evaluates to an object, the corresponding element
+   * styles are updated. Style names to update are taken from the object keys and values - from the
+   * corresponding object values.
+   *
+   * # Example:
+   *
+   * ```
+   * <div [ng-style]="{'text-align': alignExp}"></div>
+   * ```
+   *
+   * In the above example the `text-align` style will be updated based on the `alignExp` value
+   * changes.
+   *
+   * # Syntax
+   *
+   * - `<div [ng-style]="{'text-align': alignExp}"></div>`
+   * - `<div [ng-style]="styleExp"></div>`
+   */
+  class NgStyle {
+
+     rawStyle: any;
+
+     doCheck(): void;
+  }
+
+  class SwitchView {
+
+     create(): void;
+
+     destroy(): void;
+  }
+
+
+  /**
+   * The `NgSwitch` directive is used to conditionally swap DOM structure on your template based on a
+   * scope expression.
+   * Elements within `NgSwitch` but without `NgSwitchWhen` or `NgSwitchDefault` directives will be
+   * preserved at the location as specified in the template.
+   *
+   * `NgSwitch` simply chooses nested elements and makes them visible based on which element matches
+   * the value obtained from the evaluated expression. In other words, you define a container element
+   * (where you place the directive), place an expression on the **`[ng-switch]="..."` attribute**),
+   * define any inner elements inside of the directive and place a `[ng-switch-when]` attribute per
+   * element.
+   * The when attribute is used to inform NgSwitch which element to display when the expression is
+   * evaluated. If a matching expression is not found via a when attribute then an element with the
+   * default attribute is displayed.
+   *
+   * # Example:
+   *
+   * ```
+   * <ANY [ng-switch]="expression">
+   *   <template [ng-switch-when]="whenExpression1">...</template>
+   *   <template [ng-switch-when]="whenExpression1">...</template>
+   *   <template ng-switch-default>...</template>
+   * </ANY>
+   * ```
+   */
+  class NgSwitch {
+
+     ngSwitch: any;
+  }
+
+
+  /**
+   * Defines a case statement as an expression.
+   *
+   * If multiple `NgSwitchWhen` match the `NgSwitch` value, all of them are displayed.
+   *
+   * Example:
+   *
+   * ```
+   * // match against a context variable
+   * <template [ng-switch-when]="contextVariable">...</template>
+   *
+   * // match against a constant string
+   * <template ng-switch-when="stringValue">...</template>
+   * ```
+   */
+  class NgSwitchWhen {
+
+     ngSwitchWhen: any;
+  }
+
+
+  /**
+   * Defines a default case statement.
+   *
+   * Default case statements are displayed when no `NgSwitchWhen` match the `ng-switch` value.
+   *
+   * Example:
+   *
+   * ```
+   * <template ng-switch-default>...</template>
+   * ```
+   */
+  class NgSwitchDefault {
+  }
+
+
+  /**
+   * Omitting from external API doc as this is really an abstract internal concept.
+   */
+  class AbstractControl {
+
+     validator: Function;
+
+     value: any;
+
+     status: string;
+
+     valid: boolean;
+
+     errors: StringMap<string, any>;
+
+     pristine: boolean;
+
+     dirty: boolean;
+
+     touched: boolean;
+
+     untouched: boolean;
+
+     valueChanges: Observable;
+
+     markAsTouched(): void;
+
+     markAsDirty({onlySelf}?: {onlySelf?: boolean}): void;
+
+     setParent(parent: ControlGroup | ControlArray): void;
+
+     updateValidity({onlySelf}?: {onlySelf?: boolean}): void;
+
+     updateValueAndValidity({onlySelf, emitEvent}?: {onlySelf?: boolean, emitEvent?: boolean}): void;
+
+     find(path: Array<string | number>| string): AbstractControl;
+
+     getError(errorCode: string, path?: string[]): any;
+
+     hasError(errorCode: string, path?: string[]): boolean;
+  }
+
+
+  /**
+   * Defines a part of a form that cannot be divided into other controls.
+   *
+   * `Control` is one of the three fundamental building blocks used to define forms in Angular, along
+   * with
+   * {@link ControlGroup} and {@link ControlArray}.
+   */
+  class Control extends AbstractControl {
+
+     updateValue(value: any, {onlySelf, emitEvent, emitModelToViewChange}?:
+                  {onlySelf?: boolean, emitEvent?: boolean, emitModelToViewChange?: boolean}): void;
+
+     registerOnChange(fn: Function): void;
+  }
+
+
+  /**
+   * Defines a part of a form, of fixed length, that can contain other controls.
+   *
+   * A ControlGroup aggregates the values and errors of each {@link Control} in the group. Thus, if
+   * one of the controls
+   * in a group is invalid, the entire group is invalid. Similarly, if a control changes its value,
+   * the entire group
+   * changes as well.
+   *
+   * `ControlGroup` is one of the three fundamental building blocks used to define forms in Angular,
+   * along with
+   * {@link Control} and {@link ControlArray}. {@link ControlArray} can also contain other controls,
+   * but is of variable
+   * length.
+   */
+  class ControlGroup extends AbstractControl {
+
+     controls: StringMap<string, AbstractControl>;
+
+     addControl(name: string, c: AbstractControl): void;
+
+     removeControl(name: string): void;
+
+     include(controlName: string): void;
+
+     exclude(controlName: string): void;
+
+     contains(controlName: string): boolean;
+  }
+
+
+  /**
+   * Defines a part of a form, of variable length, that can contain other controls.
+   *
+   * A `ControlArray` aggregates the values and errors of each {@link Control} in the group. Thus, if
+   * one of the controls
+   * in a group is invalid, the entire group is invalid. Similarly, if a control changes its value,
+   * the entire group
+   * changes as well.
+   *
+   * `ControlArray` is one of the three fundamental building blocks used to define forms in Angular,
+   * along with {@link Control} and {@link ControlGroup}. {@link ControlGroup} can also contain
+   * other controls, but is of fixed length.
+   */
+  class ControlArray extends AbstractControl {
+
+     controls: AbstractControl[];
+
+     at(index: number): AbstractControl;
+
+     push(control: AbstractControl): void;
+
+     insert(index: number, control: AbstractControl): void;
+
+     removeAt(index: number): void;
+
+     length: number;
+  }
+
+  class AbstractControlDirective {
+
+     control: AbstractControl;
+
+     value: any;
+
+     valid: boolean;
+
+     errors: StringMap<string, any>;
+
+     pristine: boolean;
+
+     dirty: boolean;
+
+     touched: boolean;
+
+     untouched: boolean;
+  }
+
+
+  /**
+   * An interface that {@link NgFormModel} and {@link NgForm} implement.
+   *
+   * Only used by the forms module.
+   */
+  interface Form {
+
+     addControl(dir: NgControl): void;
+
+     removeControl(dir: NgControl): void;
+
+     getControl(dir: NgControl): Control;
+
+     addControlGroup(dir: NgControlGroup): void;
+
+     removeControlGroup(dir: NgControlGroup): void;
+
+     getControlGroup(dir: NgControlGroup): ControlGroup;
+
+     updateModel(dir: NgControl, value: any): void;
+  }
+
+
+  /**
+   * A directive that contains a group of [NgControl].
+   *
+   * Only used by the forms module.
+   */
+  class ControlContainer extends AbstractControlDirective {
+
+     name: string;
+
+     formDirective: Form;
+
+     path: string[];
+  }
+
+
+  /**
+   * Creates and binds a control with a specified name to a DOM element.
+   *
+   * This directive can only be used as a child of {@link NgForm} or {@link NgFormModel}.
+   *
+   * # Example
+   *
+   * In this example, we create the login and password controls.
+   * We can work with each control separately: check its validity, get its value, listen to its
+   *  changes.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *              <form #f="form" (submit)='onLogIn(f.value)'>
+   *                Login <input type='text' ng-control='login' #l="form">
+   *                <div *ng-if="!l.valid">Login is invalid</div>
+   *
+   *                Password <input type='password' ng-control='password'>
+   *
+   *                <button type='submit'>Log in!</button>
+   *              </form>
+   *      `})
+   * class LoginComp {
+   *  onLogIn(value) {
+   *    // value === {login: 'some login', password: 'some password'}
+   *  }
+   * }
+   *  ```
+   *
+   * We can also use ng-model to bind a domain model to the form.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *              <form (submit)='onLogIn()'>
+   *                Login <input type='text' ng-control='login' [(ng-model)]="credentials.login">
+   *                Password <input type='password' ng-control='password'
+   *  [(ng-model)]="credentials.password">
+   *                <button type='submit'>Log in!</button>
+   *              </form>
+   *      `})
+   * class LoginComp {
+   *  credentials: {login:string, password:string};
+   *
+   *  onLogIn() {
+   *    // this.credentials.login === "some login"
+   *    // this.credentials.password === "some password"
+   *  }
+   * }
+   *  ```
+   */
+  class NgControlName extends NgControl {
+
+     update: any;
+
+     model: any;
+
+     viewModel: any;
+
+     ngValidators: QueryList<NgValidator>;
+
+     onChanges(c: StringMap<string, any>): void;
+
+     onDestroy(): void;
+
+     viewToModelUpdate(newValue: any): void;
+
+     path: string[];
+
+     formDirective: any;
+
+     control: Control;
+
+     validator: Function;
+  }
+
+
+  /**
+   * Binds an existing control to a DOM element.
+   *
+   * # Example
+   *
+   * In this example, we bind the control to an input element. When the value of the input element
+   * changes, the value of
+   * the control will reflect that change. Likewise, if the value of the control changes, the input
+   * element reflects that
+   * change.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: "<input type='text' [ng-form-control]='loginControl'>"
+   *      })
+   * class LoginComp {
+   *  loginControl:Control;
+   *
+   *  constructor() {
+   *    this.loginControl = new Control('');
+   *  }
+   * }
+   *
+   *  ```
+   *
+   * We can also use ng-model to bind a domain model to the form.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: "<input type='text' [ng-form-control]='loginControl' [(ng-model)]='login'>"
+   *      })
+   * class LoginComp {
+   *  loginControl:Control;
+   *  login:string;
+   *
+   *  constructor() {
+   *    this.loginControl = new Control('');
+   *  }
+   * }
+   *  ```
+   */
+  class NgFormControl extends NgControl {
+
+     form: Control;
+
+     update: any;
+
+     model: any;
+
+     viewModel: any;
+
+     ngValidators: QueryList<NgValidator>;
+
+     onChanges(c: StringMap<string, any>): void;
+
+     path: string[];
+
+     control: Control;
+
+     validator: Function;
+
+     viewToModelUpdate(newValue: any): void;
+  }
+
+
+  /**
+   * Binds a domain model to the form.
+   *
+   * # Example
+   *  ```
+   * @Component({selector: "search-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *               <input type='text' [(ng-model)]="searchQuery">
+   *      `})
+   * class SearchComp {
+   *  searchQuery: string;
+   * }
+   *  ```
+   */
+  class NgModel extends NgControl {
+
+     update: any;
+
+     model: any;
+
+     viewModel: any;
+
+     ngValidators: QueryList<NgValidator>;
+
+     onChanges(c: StringMap<string, any>): void;
+
+     control: Control;
+
+     path: string[];
+
+     validator: Function;
+
+     viewToModelUpdate(newValue: any): void;
+  }
+
+
+  /**
+   * An abstract class that all control directive extend.
+   *
+   * It binds a {@link Control} object to a DOM element.
+   */
+  class NgControl extends AbstractControlDirective {
+
+     name: string;
+
+     valueAccessor: ControlValueAccessor;
+
+     validator: Function;
+
+     path: string[];
+
+     viewToModelUpdate(newValue: any): void;
+  }
+
+
+  /**
+   * Creates and binds a control group to a DOM element.
+   *
+   * This directive can only be used as a child of {@link NgForm} or {@link NgFormModel}.
+   *
+   * # Example
+   *
+   * In this example, we create the credentials and personal control groups.
+   * We can work with each group separately: check its validity, get its value, listen to its changes.
+   *
+   *  ```
+   * @Component({selector: "signup-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *              <form #f="form" (submit)='onSignUp(f.value)'>
+   *                <div ng-control-group='credentials' #credentials="form">
+   *                  Login <input type='text' ng-control='login'>
+   *                  Password <input type='password' ng-control='password'>
+   *                </div>
+   *                <div *ng-if="!credentials.valid">Credentials are invalid</div>
+   *
+   *                <div ng-control-group='personal'>
+   *                  Name <input type='text' ng-control='name'>
+   *                </div>
+   *                <button type='submit'>Sign Up!</button>
+   *              </form>
+   *      `})
+   * class SignupComp {
+   *  onSignUp(value) {
+   *    // value === {personal: {name: 'some name'},
+   *    //  credentials: {login: 'some login', password: 'some password'}}
+   *  }
+   * }
+   *
+   *  ```
+   */
+  class NgControlGroup extends ControlContainer {
+
+     onInit(): void;
+
+     onDestroy(): void;
+
+     control: ControlGroup;
+
+     path: string[];
+
+     formDirective: Form;
+  }
+
+
+  /**
+   * Binds an existing control group to a DOM element.
+   *
+   * # Example
+   *
+   * In this example, we bind the control group to the form element, and we bind the login and
+   * password controls to the
+   * login and password elements.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: "<form [ng-form-model]='loginForm'>" +
+   *              "Login <input type='text' ng-control='login'>" +
+   *              "Password <input type='password' ng-control='password'>" +
+   *              "<button (click)="onLogin()">Login</button>" +
+   *              "</form>"
+   *      })
+   * class LoginComp {
+   *  loginForm:ControlGroup;
+   *
+   *  constructor() {
+   *    this.loginForm = new ControlGroup({
+   *      login: new Control(""),
+   *      password: new Control("")
+   *    });
+   *  }
+   *
+   *  onLogin() {
+   *    // this.loginForm.value
+   *  }
+   * }
+   *
+   *  ```
+   *
+   * We can also use ng-model to bind a domain model to the form.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: "<form [ng-form-model]='loginForm'>" +
+   *              "Login <input type='text' ng-control='login' [(ng-model)]='login'>" +
+   *              "Password <input type='password' ng-control='password' [(ng-model)]='password'>" +
+   *              "<button (click)="onLogin()">Login</button>" +
+   *              "</form>"
+   *      })
+   * class LoginComp {
+   *  credentials:{login:string, password:string}
+   *  loginForm:ControlGroup;
+   *
+   *  constructor() {
+   *    this.loginForm = new ControlGroup({
+   *      login: new Control(""),
+   *      password: new Control("")
+   *    });
+   *  }
+   *
+   *  onLogin() {
+   *    // this.credentials.login === 'some login'
+   *    // this.credentials.password === 'some password'
+   *  }
+   * }
+   *  ```
+   */
+  class NgFormModel extends ControlContainer implements Form {
+
+     form: ControlGroup;
+
+     directives: NgControl[];
+
+     ngSubmit: any;
+
+     onChanges(_: any): void;
+
+     formDirective: Form;
+
+     control: ControlGroup;
+
+     path: string[];
+
+     addControl(dir: NgControl): void;
+
+     getControl(dir: NgControl): Control;
+
+     removeControl(dir: NgControl): void;
+
+     addControlGroup(dir: NgControlGroup): void;
+
+     removeControlGroup(dir: NgControlGroup): void;
+
+     getControlGroup(dir: NgControlGroup): ControlGroup;
+
+     updateModel(dir: NgControl, value: any): void;
+
+     onSubmit(): boolean;
+  }
+
+
+  /**
+   * Creates and binds a form object to a DOM element.
+   *
+   * # Example
+   *
+   *  ```
+   * @Component({selector: "signup-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *              <form #f="form" (submit)='onSignUp(f.value)'>
+   *                <div ng-control-group='credentials' #credentials="form">
+   *                  Login <input type='text' ng-control='login'>
+   *                  Password <input type='password' ng-control='password'>
+   *                </div>
+   *                <div *ng-if="!credentials.valid">Credentials are invalid</div>
+   *
+   *                <div ng-control-group='personal'>
+   *                  Name <input type='text' ng-control='name'>
+   *                </div>
+   *                <button type='submit'>Sign Up!</button>
+   *              </form>
+   *      `})
+   * class SignupComp {
+   *  onSignUp(value) {
+   *    // value === {personal: {name: 'some name'},
+   *    //  credentials: {login: 'some login', password: 'some password'}}
+   *  }
+   * }
+   *
+   *  ```
+   */
+  class NgForm extends ControlContainer implements Form {
+
+     form: ControlGroup;
+
+     ngSubmit: any;
+
+     formDirective: Form;
+
+     control: ControlGroup;
+
+     path: string[];
+
+     controls: StringMap<string, AbstractControl>;
+
+     addControl(dir: NgControl): void;
+
+     getControl(dir: NgControl): Control;
+
+     removeControl(dir: NgControl): void;
+
+     addControlGroup(dir: NgControlGroup): void;
+
+     removeControlGroup(dir: NgControlGroup): void;
+
+     getControlGroup(dir: NgControlGroup): ControlGroup;
+
+     updateModel(dir: NgControl, value: any): void;
+
+     onSubmit(): boolean;
+  }
+
+
+  /**
+   * A bridge between a control and a native element.
+   *
+   * Please see {@link DefaultValueAccessor} for more information.
+   */
+  interface ControlValueAccessor {
+
+     writeValue(obj: any): void;
+
+     registerOnChange(fn: any): void;
+
+     registerOnTouched(fn: any): void;
+  }
+
+
+  /**
+   * The default accessor for writing a value and listening to changes that is used by the
+   * {@link NgModel}, {@link NgFormControl}, and {@link NgControlName} directives.
+   *
+   *  # Example
+   *  ```
+   *  <input type="text" [(ng-model)]="searchQuery">
+   *  ```
+   */
+  class DefaultValueAccessor implements ControlValueAccessor {
+
+     cd: NgControl;
+
+     onChange: any;
+
+     onTouched: any;
+
+     renderer: Renderer;
+
+     elementRef: ElementRef;
+
+     writeValue(value: any): void;
+
+     ngClassUntouched: boolean;
+
+     ngClassTouched: boolean;
+
+     ngClassPristine: boolean;
+
+     ngClassDirty: boolean;
+
+     ngClassValid: boolean;
+
+     ngClassInvalid: boolean;
+
+     registerOnChange(fn: (_: any) => void): void;
+
+     registerOnTouched(fn: () => void): void;
+  }
+
+
+  /**
+   * The accessor for writing a value and listening to changes on a checkbox input element.
+   *
+   *  # Example
+   *  ```
+   *  <input type="checkbox" [ng-control]="rememberLogin">
+   *  ```
+   */
+  class CheckboxControlValueAccessor implements ControlValueAccessor {
+
+     cd: NgControl;
+
+     onChange: any;
+
+     onTouched: any;
+
+     renderer: Renderer;
+
+     elementRef: ElementRef;
+
+     writeValue(value: any): void;
+
+     ngClassUntouched: boolean;
+
+     ngClassTouched: boolean;
+
+     ngClassPristine: boolean;
+
+     ngClassDirty: boolean;
+
+     ngClassValid: boolean;
+
+     ngClassInvalid: boolean;
+
+     registerOnChange(fn: (_: any) => {}): void;
+
+     registerOnTouched(fn: () => {}): void;
+  }
+
+
+  /**
+   * Marks <option> as dynamic, so Angular can be notified when options change.
+   *
+   * #Example:
+   *
+   * ```
+   * <select ng-control="city">
+   *   <option *ng-for="#c of cities" [value]="c"></option>
+   * </select>
+   * ```
+   */
+  class NgSelectOption {
+  }
+
+
+  /**
+   * The accessor for writing a value and listening to changes on a select element.
+   */
+  class SelectControlValueAccessor implements ControlValueAccessor {
+
+     cd: NgControl;
+
+     value: string;
+
+     onChange: any;
+
+     onTouched: any;
+
+     renderer: Renderer;
+
+     elementRef: ElementRef;
+
+     writeValue(value: any): void;
+
+     ngClassUntouched: boolean;
+
+     ngClassTouched: boolean;
+
+     ngClassPristine: boolean;
+
+     ngClassDirty: boolean;
+
+     ngClassValid: boolean;
+
+     ngClassInvalid: boolean;
+
+     registerOnChange(fn: () => any): void;
+
+     registerOnTouched(fn: () => any): void;
+  }
+
+
+  /**
+   * A list of all the form directives used as part of a `@View` annotation.
+   *
+   *  This is a shorthand for importing them each individually.
+   */
+  const FORM_DIRECTIVES : Type[] ;
+
+
+  /**
+   * Provides a set of validators used by form controls.
+   *
+   * # Example
+   *
+   * ```
+   * var loginControl = new Control("", Validators.required)
+   * ```
+   */
+  class Validators {
+
+     static required(c:Control): StringMap<string, boolean>;
+
+     static nullValidator(c: any): StringMap<string, boolean>;
+
+     static compose(validators: Function[]): Function;
+
+     static group(c:ControlGroup): StringMap<string, boolean>;
+
+     static array(c:ControlArray): StringMap<string, boolean>;
+  }
+
+  class NgValidator {
+
+     validator: Function;
+  }
+
+  class NgRequiredValidator extends NgValidator {
+
+     validator: Function;
+  }
+
+
+  /**
+   * Creates a form object from a user-specified configuration.
+   *
+   * # Example
+   *
+   * ```
+   * import {Component, View, bootstrap} from 'angular2/angular2';
+   * import {FormBuilder, Validators, FORM_DIRECTIVES, ControlGroup} from 'angular2/forms';
+   *
+   * @Component({
+   *   selector: 'login-comp',
+   *   viewBindings: [
+   *     FormBuilder
+   *   ]
+   * })
+   * @View({
+   *   template: `
+   *     <form [control-group]="loginForm">
+   *       Login <input control="login">
+   *
+   *       <div control-group="passwordRetry">
+   *         Password <input type="password" control="password">
+   *         Confirm password <input type="password" control="passwordConfirmation">
+   *       </div>
+   *     </form>
+   *   `,
+   *   directives: [
+   *     FORM_DIRECTIVES
+   *   ]
+   * })
+   * class LoginComp {
+   *   loginForm: ControlGroup;
+   *
+   *   constructor(builder: FormBuilder) {
+   *     this.loginForm = builder.group({
+   *       login: ["", Validators.required],
+   *
+   *       passwordRetry: builder.group({
+   *         password: ["", Validators.required],
+   *         passwordConfirmation: ["", Validators.required]
+   *       })
+   *     });
+   *   }
+   * }
+   *
+   * bootstrap(LoginComp)
+   * ```
+   *
+   * This example creates a {@link ControlGroup} that consists of a `login` {@link Control}, and a
+   * nested
+   * {@link ControlGroup} that defines a `password` and a `passwordConfirmation` {@link Control}:
+   *
+   * ```
+   *  var loginForm = builder.group({
+   *    login: ["", Validators.required],
+   *
+   *    passwordRetry: builder.group({
+   *      password: ["", Validators.required],
+   *      passwordConfirmation: ["", Validators.required]
+   *    })
+   *  });
+   *
+   *  ```
+   */
+  class FormBuilder {
+
+     group(controlsConfig: StringMap<string, any>, extra?: StringMap<string, any>): ControlGroup;
+
+     control(value: Object, validator?: Function): Control;
+
+     array(controlsConfig: any[], validator?: Function): ControlArray;
+  }
+
+  const FORM_BINDINGS : Type[] ;
+
+  class RenderDirectiveMetadata {
+
+     static DIRECTIVE_TYPE: any;
+
+     static COMPONENT_TYPE: any;
+
+     static create({id, selector, compileChildren, events, host, properties, readAttributes, type,
+                 callOnDestroy, callOnChanges, callDoCheck, callOnInit, callAfterContentInit,
+                 callAfterContentChecked, callAfterViewInit, callAfterViewChecked, changeDetection,
+                 exportAs}: {
+    id?: string,
+    selector?: string,
+    compileChildren?: boolean,
+    events?: string[],
+    host?: Map<string, string>,
+    properties?: string[],
+    readAttributes?: string[],
+    type?: number,
+    callOnDestroy?: boolean,
+    callOnChanges?: boolean,
+    callDoCheck?: boolean,
+    callOnInit?: boolean,
+    callAfterContentInit?: boolean,
+    callAfterContentChecked?: boolean,
+    callAfterViewInit?: boolean,
+    callAfterViewChecked?: boolean,
+    changeDetection?: ChangeDetectionStrategy,
+    exportAs?: string
+  }): RenderDirectiveMetadata;
+
+     id: any;
+
+     selector: string;
+
+     compileChildren: boolean;
+
+     events: string[];
+
+     properties: string[];
+
+     readAttributes: string[];
+
+     type: number;
+
+     callOnDestroy: boolean;
+
+     callOnChanges: boolean;
+
+     callDoCheck: boolean;
+
+     callOnInit: boolean;
+
+     callAfterContentInit: boolean;
+
+     callAfterContentChecked: boolean;
+
+     callAfterViewInit: boolean;
+
+     callAfterViewChecked: boolean;
+
+     changeDetection: ChangeDetectionStrategy;
+
+     exportAs: string;
+
+     hostListeners: Map<string, string>;
+
+     hostProperties: Map<string, string>;
+
+     hostAttributes: Map<string, string>;
+  }
+
+  class DomRenderer extends Renderer {
+
+     createRootHostView(hostProtoViewRef: RenderProtoViewRef, fragmentCount: number, hostElementSelector: string): RenderViewWithFragments;
+
+     createView(protoViewRef: RenderProtoViewRef, fragmentCount: number): RenderViewWithFragments;
+
+     destroyView(viewRef: RenderViewRef): void;
+
+     getNativeElementSync(location: RenderElementRef): any;
+
+     getRootNodes(fragment: RenderFragmentRef): Node[];
+
+     attachFragmentAfterFragment(previousFragmentRef: RenderFragmentRef, fragmentRef: RenderFragmentRef): void;
+
+     attachFragmentAfterElement(elementRef: RenderElementRef, fragmentRef: RenderFragmentRef): void;
+
+     detachFragment(fragmentRef: RenderFragmentRef): void;
+
+     hydrateView(viewRef: RenderViewRef): void;
+
+     dehydrateView(viewRef: RenderViewRef): void;
+
+     setElementProperty(location: RenderElementRef, propertyName: string, propertyValue: any): void;
+
+     setElementAttribute(location: RenderElementRef, attributeName: string, attributeValue: string): void;
+
+     setElementClass(location: RenderElementRef, className: string, isAdd: boolean): void;
+
+     setElementStyle(location: RenderElementRef, styleName: string, styleValue: string): void;
+
+     invokeElementMethod(location: RenderElementRef, methodName: string, args: any[]): void;
+
+     setText(viewRef: RenderViewRef, textNodeIndex: number, text: string): void;
+
+     setEventDispatcher(viewRef: RenderViewRef, dispatcher: any): void;
+  }
+
+
+  /**
+   * A dispatcher for all events happening in a view.
+   */
+  interface RenderEventDispatcher {
+
+
+    /**
+     * Called when an event was triggered for a on-* attribute on an element.
+     * @param {Map<string, any>} locals Locals to be used to evaluate the
+     *   event expressions
+     * @return {boolean} False if `preventDefault` should be called on the DOM event.
+     */
+     dispatchRenderEvent(elementIndex: number, eventName: string, locals: Map<string, any>): boolean;
+  }
+
+  class Renderer {
+
+
+    /**
+     * Creates a root host view that includes the given element.
+     * Note that the fragmentCount needs to be passed in so that we can create a result
+     * synchronously even when dealing with webworkers!
+     *
+     * @param {RenderProtoViewRef} hostProtoViewRef a RenderProtoViewRef of type
+     * ProtoViewDto.HOST_VIEW_TYPE
+     * @param {any} hostElementSelector css selector for the host element (will be queried against the
+     * main document)
+     * @return {RenderViewWithFragments} the created view including fragments
+     */
+     createRootHostView(hostProtoViewRef: RenderProtoViewRef, fragmentCount: number, hostElementSelector: string): RenderViewWithFragments;
+
+
+    /**
+     * Creates a regular view out of the given ProtoView.
+     * Note that the fragmentCount needs to be passed in so that we can create a result
+     * synchronously even when dealing with webworkers!
+     */
+     createView(protoViewRef: RenderProtoViewRef, fragmentCount: number): RenderViewWithFragments;
+
+
+    /**
+     * Destroys the given view after it has been dehydrated and detached
+     */
+     destroyView(viewRef: RenderViewRef): void;
+
+
+    /**
+     * Attaches a fragment after another fragment.
+     */
+     attachFragmentAfterFragment(previousFragmentRef: RenderFragmentRef, fragmentRef: RenderFragmentRef): void;
+
+
+    /**
+     * Attaches a fragment after an element.
+     */
+     attachFragmentAfterElement(elementRef: RenderElementRef, fragmentRef: RenderFragmentRef): void;
+
+
+    /**
+     * Detaches a fragment.
+     */
+     detachFragment(fragmentRef: RenderFragmentRef): void;
+
+
+    /**
+     * Hydrates a view after it has been attached. Hydration/dehydration is used for reusing views
+     * inside of the view pool.
+     */
+     hydrateView(viewRef: RenderViewRef): void;
+
+
+    /**
+     * Dehydrates a view after it has been attached. Hydration/dehydration is used for reusing views
+     * inside of the view pool.
+     */
+     dehydrateView(viewRef: RenderViewRef): void;
+
+
+    /**
+     * Returns the native element at the given location.
+     * Attention: In a WebWorker scenario, this should always return null!
+     */
+     getNativeElementSync(location: RenderElementRef): any;
+
+
+    /**
+     * Sets a property on an element.
+     */
+     setElementProperty(location: RenderElementRef, propertyName: string, propertyValue: any): void;
+
+
+    /**
+     * Sets an attribute on an element.
+     */
+     setElementAttribute(location: RenderElementRef, attributeName: string, attributeValue: string): void;
+
+
+    /**
+     * Sets a class on an element.
+     */
+     setElementClass(location: RenderElementRef, className: string, isAdd: boolean): void;
+
+
+    /**
+     * Sets a style on an element.
+     */
+     setElementStyle(location: RenderElementRef, styleName: string, styleValue: string): void;
+
+
+    /**
+     * Calls a method on an element.
+     */
+     invokeElementMethod(location: RenderElementRef, methodName: string, args: any[]): void;
+
+
+    /**
+     * Sets the value of a text node.
+     */
+     setText(viewRef: RenderViewRef, textNodeIndex: number, text: string): void;
+
+
+    /**
+     * Sets the dispatcher for all events of the given view
+     */
+     setEventDispatcher(viewRef: RenderViewRef, dispatcher: RenderEventDispatcher): void;
+  }
+
+
+  /**
+   * Abstract reference to the element which can be marshaled across web-worker boundary.
+   *
+   * This interface is used by the Renderer API.
+   */
+  interface RenderElementRef {
+
+
+    /**
+     * Reference to the `RenderViewRef` where the `RenderElementRef` is inside of.
+     */
+     renderView: RenderViewRef;
+
+
+    /**
+     * Index of the element inside the `RenderViewRef`.
+     *
+     * This is used internally by the Angular framework to locate elements.
+     */
+     renderBoundElementIndex: number;
+  }
+
+  class RenderViewRef {
+  }
+
+  class RenderProtoViewRef {
+  }
+
+  class RenderFragmentRef {
+  }
+
+  class RenderViewWithFragments {
+
+     viewRef: RenderViewRef;
+
+     fragmentRefs: RenderFragmentRef[];
+  }
+
+  class ViewDefinition {
+
+     componentId: string;
+
+     templateAbsUrl: string;
+
+     template: string;
+
+     directives: RenderDirectiveMetadata[];
+
+     styleAbsUrls: string[];
+
+     styles: string[];
+
+     encapsulation: ViewEncapsulation;
+  }
+
+  const DOCUMENT : OpaqueToken ;
+
+
+  /**
+   * A unique id (string) for an angular application.
+   */
+  const APP_ID : OpaqueToken ;
+
+
+  /**
+   * Defines when a compiled template should be stored as a string
+   * rather than keeping its Nodes to preserve memory.
+   */
+  const MAX_IN_MEMORY_ELEMENTS_PER_TEMPLATE : OpaqueToken ;
+
+
+  /**
+   * Create trace scope.
+   *
+   * Scopes must be strictly nested and are analogous to stack frames, but
+   * do not have to follow the stack frames. Instead it is recommended that they follow logical
+   * nesting. You may want to use
+   * [Event
+   * Signatures](http://google.github.io/tracing-framework/instrumenting-code.html#custom-events)
+   * as they are defined in WTF.
+   *
+   * Used to mark scope entry. The return value is used to leave the scope.
+   *
+   *     var myScope = wtfCreateScope('MyClass#myMethod(ascii someVal)');
+   *
+   *     someMethod() {
+   *        var s = myScope('Foo'); // 'Foo' gets stored in tracing UI
+   *        // DO SOME WORK HERE
+   *        return wtfLeave(s, 123); // Return value 123
+   *     }
+   *
+   * Note, adding try-finally block around the work to ensure that `wtfLeave` gets called can
+   * negatively impact the performance of your application. For this reason we recommend that
+   * you don't add them to ensure that `wtfLeave` gets called. In production `wtfLeave` is a noop and
+   * so try-finally block has no value. When debugging perf issues, skipping `wtfLeave`, do to
+   * exception, will produce incorrect trace, but presence of exception signifies logic error which
+   * needs to be fixed before the app should be profiled. Add try-finally only when you expect that
+   * an exception is expected during normal execution while profiling.
+   */
+  var wtfCreateScope : WtfScopeFn ;
+
+
+  /**
+   * Used to mark end of Scope.
+   *
+   * - `scope` to end.
+   * - `returnValue` (optional) to be passed to the WTF.
+   *
+   * Returns the `returnValue for easy chaining.
+   */
+  var wtfLeave : <T>(scope: any, returnValue?: T) => T ;
+
+
+  /**
+   * Used to mark Async start. Async are similar to scope but they don't have to be strictly nested.
+   * The return value is used in the call to [endAsync]. Async ranges only work if WTF has been
+   * enabled.
+   *
+   *     someMethod() {
+   *        var s = wtfStartTimeRange('HTTP:GET', 'some.url');
+   *        var future = new Future.delay(5).then((_) {
+   *          wtfEndTimeRange(s);
+   *        });
+   *     }
+   */
+  var wtfStartTimeRange : (rangeType: string, action: string) => any ;
+
+
+  /**
+   * Ends a async time range operation.
+   * [range] is the return value from [wtfStartTimeRange] Async ranges only work if WTF has been
+   * enabled.
+   */
+  var wtfEndTimeRange : (range: any) => void ;
+
+  interface WtfScopeFn {
+
+     (arg0?: any, arg1?: any): any;
+
+  }
+
+
+  /**
+   * Bootstrapping a Webworker Application
+   *
+   * You instantiate the application side by calling bootstrapWebworker from your webworker index
+   * script.
+   * You can call bootstrapWebworker() exactly as you would call bootstrap() in a regular Angular
+   * application
+   * See the bootstrap() docs for more details.
+   */
+  function bootstrapWebWorker(appComponentType: Type, componentInjectableBindings?: Array<Type | Binding | any[]>) : Promise<ApplicationRef> ;
+
+
+  /**
+   * Message Bus is a low level API used to communicate between the UI and the background.
+   * Communication is based on a channel abstraction. Messages published in a
+   * given channel to one MessageBusSink are received on the same channel
+   * by the corresponding MessageBusSource.
+   */
+  class MessageBus implements MessageBusSource,  MessageBusSink {
+
+
+    /**
+     * Returns an {@link EventEmitter} that emits every time a messsage
+     * is received on the given channel.
+     */
+     from(channel: string): EventEmitter;
+
+
+    /**
+     * Returns an {@link EventEmitter} for the given channel
+     * To publish methods to that channel just call next (or add in dart) on the returned emitter
+     */
+     to(channel: string): EventEmitter;
+  }
+
+  interface MessageBusSource {
+
+
+    /**
+     * Returns an {@link EventEmitter} that emits every time a messsage
+     * is received on the given channel.
+     */
+     from(channel: string): EventEmitter;
+  }
+
+  interface MessageBusSink {
+
+
+    /**
+     * Returns an {@link EventEmitter} for the given channel
+     * To publish methods to that channel just call next (or add in dart) on the returned emitter
+     */
+     to(channel: string): EventEmitter;
+  }
+
+  class ClientMessageBrokerFactory {
+
+     createMessageBroker(channel: string): ClientMessageBroker;
+  }
+
+  class ClientMessageBroker {
+
+     channel: any;
+
+     runOnService(args: UiArguments, returnType: Type): Promise<any>;
+  }
+
+  class FnArg {
+
+     value: any;
+
+     type: Type;
+  }
+
+  class UiArguments {
+
+     method: string;
+
+     args: FnArg[];
+  }
+
+  class ServiceMessageBrokerFactory {
+
+     createMessageBroker(channel: string): ServiceMessageBroker;
+  }
+
+
+  /**
+   * Helper class for UIComponents that allows components to register methods.
+   * If a registered method message is received from the broker on the worker,
+   * the UIMessageBroker desererializes its arguments and calls the registered method.
+   * If that method returns a promise, the UIMessageBroker returns the result to the worker.
+   */
+  class ServiceMessageBroker {
+
+     channel: any;
+
+     registerMethod(methodName: string, signature: Type[], method: Function, returnType?: Type): void;
+  }
+
+  class ReceivedMessage {
+
+     method: string;
+
+     args: any[];
+
+     id: string;
+
+     type: string;
+  }
+
+  const PRIMITIVE : Type ;
+
+  class Serializer {
+
+     serialize(obj: any, type: Type): Object;
+
+     deserialize(map: any, type: Type, data?: any): any;
+
+     mapToObject(map: Map<string, any>, type?: Type): Object;
+
+     objectToMap(obj: StringMap<string, any>, type?: Type, data?: any): Map<string, any>;
+
+     allocateRenderViews(fragmentCount: number): void;
+  }
+
+  var ChangeDetectorRef: InjectableReference;
+
+  var ApplicationRef: InjectableReference;
+
+  var Compiler: InjectableReference;
+
+  var AppViewManager: InjectableReference;
+
+  var ViewRef: InjectableReference;
+
+  var ProtoViewRef: InjectableReference;
+
+  var ViewContainerRef: InjectableReference;
+
+  var ComponentRef: InjectableReference;
+
+}
+
+declare module "angular2/web_worker/worker" {
+  export = ngWorker;
+}
+
+
+
+declare module ngUi {
+  class WebWorkerApplication {
+
+     createClientMessageBroker(channel: string): ClientMessageBroker;
+
+     createServiceMessageBroker(channel: string): ServiceMessageBroker;
+  }
+
+
+  /**
+   * Bootstrapping a WebWorker
+   *
+   * You instantiate a WebWorker application by calling bootstrap with the URI of your worker's index
+   * script
+   * Note: The WebWorker script must call bootstrapWebworker once it is set up to complete the
+   * bootstrapping process
+   */
+  function bootstrap(uri: string) : WebWorkerInstance ;
+
+  function spawnWebWorker(uri: string) : WebWorkerInstance ;
+
+
+  /**
+   * Wrapper class that exposes the {@link WebWorkerApplication}
+   * Isolate instance and underyling {@link MessageBus} for lower level message passing.
+   */
+  class WebWorkerInstance {
+
+     app: WebWorkerApplication;
+
+     worker: Worker;
+
+     bus: MessageBus;
+  }
+
+
+  /**
+   * Use Rx.Observable but provides an adapter to make it work as specified here:
+   * https://github.com/jhusain/observable-spec
+   *
+   * Once a reference implementation of the spec is available, switch to it.
+   */
+  class EventEmitter extends Observable {
+
+     observer(generator: any): Rx.IDisposable;
+
+     toRx(): Rx.Observable<any>;
+
+     next(value: any): void;
+
+     throw(error: any): void;
+
+     return(value?: any): void;
+  }
+
+  class Observable {
+
+     observer(generator: any): Object;
+  }
+
+
+  /**
+   * Message Bus is a low level API used to communicate between the UI and the background.
+   * Communication is based on a channel abstraction. Messages published in a
+   * given channel to one MessageBusSink are received on the same channel
+   * by the corresponding MessageBusSource.
+   */
+  class MessageBus implements MessageBusSource,  MessageBusSink {
+
+
+    /**
+     * Returns an {@link EventEmitter} that emits every time a messsage
+     * is received on the given channel.
+     */
+     from(channel: string): EventEmitter;
+
+
+    /**
+     * Returns an {@link EventEmitter} for the given channel
+     * To publish methods to that channel just call next (or add in dart) on the returned emitter
+     */
+     to(channel: string): EventEmitter;
+  }
+
+  interface MessageBusSource {
+
+
+    /**
+     * Returns an {@link EventEmitter} that emits every time a messsage
+     * is received on the given channel.
+     */
+     from(channel: string): EventEmitter;
+  }
+
+  interface MessageBusSink {
+
+
+    /**
+     * Returns an {@link EventEmitter} for the given channel
+     * To publish methods to that channel just call next (or add in dart) on the returned emitter
+     */
+     to(channel: string): EventEmitter;
+  }
+
+
+  /**
+   * Runtime representation of a type.
+   *
+   * In JavaScript a Type is a constructor function.
+   */
+  interface Type extends Function {
+
+     new(...args: any[]): any;
+
+  }
+
+  class ClientMessageBrokerFactory {
+
+     createMessageBroker(channel: string): ClientMessageBroker;
+  }
+
+  class ClientMessageBroker {
+
+     channel: any;
+
+     runOnService(args: UiArguments, returnType: Type): Promise<any>;
+  }
+
+  class FnArg {
+
+     value: any;
+
+     type: Type;
+  }
+
+  class UiArguments {
+
+     method: string;
+
+     args: FnArg[];
+  }
+
+  class ServiceMessageBrokerFactory {
+
+     createMessageBroker(channel: string): ServiceMessageBroker;
+  }
+
+
+  /**
+   * Helper class for UIComponents that allows components to register methods.
+   * If a registered method message is received from the broker on the worker,
+   * the UIMessageBroker desererializes its arguments and calls the registered method.
+   * If that method returns a promise, the UIMessageBroker returns the result to the worker.
+   */
+  class ServiceMessageBroker {
+
+     channel: any;
+
+     registerMethod(methodName: string, signature: Type[], method: Function, returnType?: Type): void;
+  }
+
+  class ReceivedMessage {
+
+     method: string;
+
+     args: any[];
+
+     id: string;
+
+     type: string;
+  }
+
+  const PRIMITIVE : Type ;
+
+  class Serializer {
+
+     serialize(obj: any, type: Type): Object;
+
+     deserialize(map: any, type: Type, data?: any): any;
+
+     mapToObject(map: Map<string, any>, type?: Type): Object;
+
+     objectToMap(obj: StringMap<string, any>, type?: Type, data?: any): Map<string, any>;
+
+     allocateRenderViews(fragmentCount: number): void;
+  }
+
+}
+
+declare module "angular2/web_worker/ui" {
+  export = ngUi;
+}
+
+
diff --git a/angular2/angular2-tests.ts b/angular2/angular2-tests.ts
index 1cd77cdf47..70deab5d27 100644
--- a/angular2/angular2-tests.ts
+++ b/angular2/angular2-tests.ts
@@ -16,7 +16,7 @@ class Cmp {
 Cmp.annotations = [
   Component({
     selector: 'cmp',
-    injectables: [Service, bind(Service2).toValue(null)]
+    bindings: [Service, bind(Service2).toValue(null)]
   }),
   View({
     template: '{{greeting}} world!',
@@ -27,9 +27,9 @@ Cmp.annotations = [
     properties: [
       'text: tooltip'
     ],
-    hostListeners: {
-      'onmouseenter': 'onMouseEnter()',
-      'onmouseleave': 'onMouseLeave()'
+    host: {
+      '(onmouseenter)': 'onMouseEnter()',
+      '(onmouseleave)': 'onMouseLeave()'
     }
   })
 ];
diff --git a/angular2/angular2-tests.ts.tscparams b/angular2/angular2-tests.ts.tscparams
index cfedaf1984..3f0863ac67 100644
--- a/angular2/angular2-tests.ts.tscparams
+++ b/angular2/angular2-tests.ts.tscparams
@@ -1 +1 @@
---experimentalDecorators --target ES5
\ No newline at end of file
+--experimentalDecorators --noImplicitAny --target ES5
diff --git a/angular2/angular2.d.ts b/angular2/angular2.d.ts
index 0c7b8609ef..733c9e8eff 100644
--- a/angular2/angular2.d.ts
+++ b/angular2/angular2.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Angular v2.0.0-alpha.36
+// Type definitions for Angular v2.0.0-alpha.37
 // Project: http://angular.io/
 // Definitions by: angular team <https://github.com/angular/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -13,14 +13,26 @@
 // If you don't have them installed you can install them using TSD
 // https://github.com/DefinitelyTyped/tsd
 
+///<reference path="../es6-promise/es6-promise.d.ts"/>
+///<reference path="../rx/rx.d.ts"/>
+// angular2/web_worker/worker depends transitively on these libraries.
+// If you don't have them installed you can install them using TSD
+// https://github.com/DefinitelyTyped/tsd
+
+///<reference path="../es6-promise/es6-promise.d.ts"/>
+///<reference path="../rx/rx.d.ts"/>
+// angular2/web_worker/ui depends transitively on these libraries.
+// If you don't have them installed you can install them using TSD
+// https://github.com/DefinitelyTyped/tsd
+
 ///<reference path="../es6-promise/es6-promise.d.ts"/>
 ///<reference path="../rx/rx.d.ts"/>
 
 
-interface List<T> extends Array<T> {}
 interface Map<K,V> {}
 interface StringMap<K,V> extends Map<K,V> {}
 
+
 declare module ng {
   // See https://github.com/Microsoft/TypeScript/issues/1168
   class BaseException /* extends Error */ {
@@ -31,6 +43,27 @@ declare module ng {
   interface InjectableReference {}
 }
 
+declare module ngWorker {
+  // See https://github.com/Microsoft/TypeScript/issues/1168
+  class BaseException /* extends Error */ {
+    message: string;
+    stack: string;
+    toString(): string;
+  }
+  interface InjectableReference {}
+}
+
+declare module ngUi {
+  // See https://github.com/Microsoft/TypeScript/issues/1168
+  class BaseException /* extends Error */ {
+    message: string;
+    stack: string;
+    toString(): string;
+  }
+  interface InjectableReference {}
+}
+
+
 
 
 
@@ -39,25 +72,154 @@ declare module ng {
  */
 declare module ng {
 
+  /**
+   * Bootstrapping for Angular applications.
+   *
+   * You instantiate an Angular application by explicitly specifying a component to use as the root
+   * component for your
+   * application via the `bootstrap()` method.
+   *
+   * ## Simple Example
+   *
+   * Assuming this `index.html`:
+   *
+   * ```html
+   * <html>
+   *   <!-- load Angular script tags here. -->
+   *   <body>
+   *     <my-app>loading...</my-app>
+   *   </body>
+   * </html>
+   * ```
+   *
+   * An application is bootstrapped inside an existing browser DOM, typically `index.html`. Unlike
+   * Angular 1, Angular 2
+   * does not compile/process bindings in `index.html`. This is mainly for security reasons, as well
+   * as architectural
+   * changes in Angular 2. This means that `index.html` can safely be processed using server-side
+   * technologies such as
+   * bindings. Bindings can thus use double-curly `{{ syntax }}` without collision from Angular 2
+   * component double-curly
+   * `{{ syntax }}`.
+   *
+   * We can use this script code:
+   *
+   * ```
+   * @Component({
+   *    selector: 'my-app'
+   * })
+   * @View({
+   *    template: 'Hello {{ name }}!'
+   * })
+   * class MyApp {
+   *   name:string;
+   *
+   *   constructor() {
+   *     this.name = 'World';
+   *   }
+   * }
+   *
+   * main() {
+   *   return bootstrap(MyApp);
+   * }
+   * ```
+   *
+   * When the app developer invokes `bootstrap()` with the root component `MyApp` as its argument,
+   * Angular performs the
+   * following tasks:
+   *
+   *  1. It uses the component's `selector` property to locate the DOM element which needs to be
+   * upgraded into
+   *     the angular component.
+   *  2. It creates a new child injector (from the platform injector). Optionally, you can also
+   * override the injector configuration for an app by
+   * invoking `bootstrap` with the `componentInjectableBindings` argument.
+   *  3. It creates a new `Zone` and connects it to the angular application's change detection domain
+   * instance.
+   *  4. It creates a shadow DOM on the selected component's host element and loads the template into
+   * it.
+   *  5. It instantiates the specified component.
+   *  6. Finally, Angular performs change detection to apply the initial data bindings for the
+   * application.
+   *
+   *
+   * ## Instantiating Multiple Applications on a Single Page
+   *
+   * There are two ways to do this.
+   *
+   *
+   * ### Isolated Applications
+   *
+   * Angular creates a new application each time that the `bootstrap()` method is invoked. When
+   * multiple applications
+   * are created for a page, Angular treats each application as independent within an isolated change
+   * detection and
+   * `Zone` domain. If you need to share data between applications, use the strategy described in the
+   * next
+   * section, "Applications That Share Change Detection."
+   *
+   *
+   * ### Applications That Share Change Detection
+   *
+   * If you need to bootstrap multiple applications that share common data, the applications must
+   * share a common
+   * change detection and zone. To do that, create a meta-component that lists the application
+   * components in its template.
+   * By only invoking the `bootstrap()` method once, with the meta-component as its argument, you
+   * ensure that only a
+   * single change detection zone is created and therefore data can be shared across the applications.
+   *
+   *
+   * ## Platform Injector
+   *
+   * When working within a browser window, there are many singleton resources: cookies, title,
+   * location, and others.
+   * Angular services that represent these resources must likewise be shared across all Angular
+   * applications that
+   * occupy the same browser window.  For this reason, Angular creates exactly one global platform
+   * injector which stores
+   * all shared services, and each angular application injector has the platform injector as its
+   * parent.
+   *
+   * Each application has its own private injector as well. When there are multiple applications on a
+   * page, Angular treats
+   * each application injector's services as private to that application.
+   *
+   *
+   * # API
+   * - `appComponentType`: The root component which should act as the application. This is a reference
+   * to a `Type`
+   *   which is annotated with `@Component(...)`.
+   * - `componentInjectableBindings`: An additional set of bindings that can be added to the app
+   * injector
+   * to override default injection behavior.
+   * - `errorReporter`: `function(exception:any, stackTrace:string)` a default error reporter for
+   * unhandled exceptions.
+   *
+   * Returns a `Promise` of {@link ApplicationRef}.
+   */
+  function bootstrap(appComponentType: /*Type*/ any, componentInjectableBindings?: Array<Type | Binding | any[]>) : Promise<ApplicationRef> ;
+
+
   /**
    * Declare reusable UI building blocks for an application.
-   * 
+   *
    * Each Angular component requires a single `@Component` and at least one `@View` annotation. The
    * `@Component`
    * annotation specifies when a component is instantiated, and which properties and hostListeners it
    * binds to.
-   * 
+   *
    * When a component is instantiated, Angular
    * - creates a shadow DOM for the component.
    * - loads the selected template into the shadow DOM.
    * - creates all the injectable objects configured with `bindings` and `viewBindings`.
-   * 
+   *
    * All template expressions and statements are then evaluated against the component instance.
-   * 
+   *
    * For details on the `@View` annotation, see {@link ViewMetadata}.
-   * 
+   *
    * ## Example
-   * 
+   *
    * ```
    * @Component({
    *   selector: 'greet'
@@ -67,7 +229,7 @@ declare module ng {
    * })
    * class Greet {
    *   name: string;
-   * 
+   *
    *   constructor() {
    *     this.name = 'World';
    *   }
@@ -75,47 +237,45 @@ declare module ng {
    * ```
    */
   class ComponentMetadata extends DirectiveMetadata {
-    
+
 
     /**
      * Defines the used change detection strategy.
-     * 
+     *
      * When a component is instantiated, Angular creates a change detector, which is responsible for
-     * propagating
-     * the component's bindings.
-     * 
+     * propagating the component's bindings.
+     *
      * The `changeDetection` property defines, whether the change detection will be checked every time
-     * or only when the component
-     * tells it to do so.
+     * or only when the component tells it to do so.
      */
-     changeDetection: string;
-    
+     changeDetection: ChangeDetectionStrategy;
+
 
     /**
      * Defines the set of injectable objects that are visible to its view dom children.
-     * 
+     *
      * ## Simple Example
-     * 
+     *
      * Here is an example of a class that can be injected:
-     * 
+     *
      * ```
      * class Greeter {
      *    greet(name:string) {
      *      return 'Hello ' + name + '!';
      *    }
      * }
-     * 
+     *
      * @Directive({
      *   selector: 'needs-greeter'
      * })
      * class NeedsGreeter {
      *   greeter:Greeter;
-     * 
+     *
      *   constructor(greeter:Greeter) {
      *     this.greeter = greeter;
      *   }
      * }
-     * 
+     *
      * @Component({
      *   selector: 'greet',
      *   viewBindings: [
@@ -128,30 +288,30 @@ declare module ng {
      * })
      * class HelloWorld {
      * }
-     * 
+     *
      * ```
      */
-     viewBindings: List<any>;
+     viewBindings: any[];
   }
-  
+
 
   /**
    * Directives allow you to attach behavior to elements in the DOM.
-   * 
+   *
    * {@link DirectiveMetadata}s with an embedded view are called {@link ComponentMetadata}s.
-   * 
+   *
    * A directive consists of a single directive annotation and a controller class. When the
    * directive's `selector` matches
    * elements in the DOM, the following steps occur:
-   * 
+   *
    * 1. For each directive, the `ElementInjector` attempts to resolve the directive's constructor
    * arguments.
    * 2. Angular instantiates directives for each matched element using `ElementInjector` in a
    * depth-first order,
    *    as declared in the HTML.
-   * 
+   *
    * ## Understanding How Injection Works
-   * 
+   *
    * There are three stages of injection resolution.
    * - *Pre-existing Injectors*:
    *   - The terminal {@link Injector} cannot resolve dependencies. It either throws an error or, if
@@ -165,24 +325,24 @@ declare module ng {
    * - *Element Injectors*: Each component instance has a Shadow DOM. Within the Shadow DOM each
    * element has an `ElementInjector`
    *     which follow the same parent-child hierarchy as the DOM elements themselves.
-   * 
+   *
    * When a template is instantiated, it also must instantiate the corresponding directives in a
    * depth-first order. The
    * current `ElementInjector` resolves the constructor dependencies for each directive.
-   * 
+   *
    * Angular then resolves dependencies as follows, according to the order in which they appear in the
    * {@link ViewMetadata}:
-   * 
+   *
    * 1. Dependencies on the current element
    * 2. Dependencies on element injectors and their parents until it encounters a Shadow DOM boundary
    * 3. Dependencies on component injectors and their parents until it encounters the root component
    * 4. Dependencies on pre-existing injectors
-   * 
-   * 
+   *
+   *
    * The `ElementInjector` can inject other directives, element-specific special objects, or it can
    * delegate to the parent
    * injector.
-   * 
+   *
    * To inject other directives, declare the constructor parameter as:
    * - `directive:DirectiveType`: a directive on the current element only
    * - `@Host() directive:DirectiveType`: any directive that matches the type between the current
@@ -192,21 +352,21 @@ declare module ng {
    * directives.
    * - `@QueryDescendants(DirectiveType) query:QueryList<DirectiveType>`: A live collection of any
    * child directives.
-   * 
+   *
    * To inject element-specific special objects, declare the constructor parameter as:
    * - `element: ElementRef` to obtain a reference to logical element in the view.
    * - `viewContainer: ViewContainerRef` to control child template instantiation, for
    * {@link DirectiveMetadata} directives only
    * - `bindingPropagation: BindingPropagation` to control change detection in a more granular way.
-   * 
+   *
    * ## Example
-   * 
+   *
    * The following example demonstrates how dependency injection resolves constructor arguments in
    * practice.
-   * 
-   * 
+   *
+   *
    * Assume this HTML template:
-   * 
+   *
    * ```
    * <div dependency="1">
    *   <div dependency="2">
@@ -219,14 +379,14 @@ declare module ng {
    *   </div>
    * </div>
    * ```
-   * 
+   *
    * With the following `dependency` decorator and `SomeService` injectable class.
-   * 
+   *
    * ```
    * @Injectable()
    * class SomeService {
    * }
-   * 
+   *
    * @Directive({
    *   selector: '[dependency]',
    *   properties: [
@@ -237,15 +397,15 @@ declare module ng {
    *   id:string;
    * }
    * ```
-   * 
+   *
    * Let's step through the different ways in which `MyDirective` could be declared...
-   * 
-   * 
+   *
+   *
    * ### No injection
-   * 
+   *
    * Here the constructor is declared with no arguments, therefore nothing is injected into
    * `MyDirective`.
-   * 
+   *
    * ```
    * @Directive({ selector: '[my-directive]' })
    * class MyDirective {
@@ -253,15 +413,15 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * This directive would be instantiated with no dependencies.
-   * 
-   * 
+   *
+   *
    * ### Component-level injection
-   * 
+   *
    * Directives can inject any injectable instance from the closest component injector or any of its
    * parents.
-   * 
+   *
    * Here, the constructor declares a parameter, `someService`, and injects the `SomeService` type
    * from the parent
    * component's injector.
@@ -272,14 +432,14 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * This directive would be instantiated with a dependency on `SomeService`.
-   * 
-   * 
+   *
+   *
    * ### Injecting a directive from the current element
-   * 
+   *
    * Directives can inject other directives declared on the current element.
-   * 
+   *
    * ```
    * @Directive({ selector: '[my-directive]' })
    * class MyDirective {
@@ -290,9 +450,9 @@ declare module ng {
    * ```
    * This directive would be instantiated with `Dependency` declared at the same element, in this case
    * `dependency="3"`.
-   * 
+   *
    * ### Injecting a directive from any ancestor elements
-   * 
+   *
    * Directives can inject other directives declared on any ancestor element (in the current Shadow
    * DOM), i.e. on the current element, the
    * parent element, or its parents.
@@ -304,23 +464,23 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * `@Host` checks the current element, the parent, as well as its parents recursively. If
    * `dependency="2"` didn't
    * exist on the direct parent, this injection would
    * have returned
    * `dependency="1"`.
-   * 
-   * 
+   *
+   *
    * ### Injecting a live collection of direct child directives
-   * 
-   * 
+   *
+   *
    * A directive can also query for other child directives. Since parent directives are instantiated
    * before child directives, a directive can't simply inject the list of child directives. Instead,
    * the directive injects a {@link QueryList}, which updates its contents as children are added,
    * removed, or moved by a directive that uses a {@link ViewContainerRef} such as a `ng-for`, an
    * `ng-if`, or an `ng-switch`.
-   * 
+   *
    * ```
    * @Directive({ selector: '[my-directive]' })
    * class MyDirective {
@@ -328,15 +488,15 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * This directive would be instantiated with a {@link QueryList} which contains `Dependency` 4 and
    * 6. Here, `Dependency` 5 would not be included, because it is not a direct child.
-   * 
+   *
    * ### Injecting a live collection of descendant directives
-   * 
+   *
    * By passing the descendant flag to `@Query` above, we can include the children of the child
    * elements.
-   * 
+   *
    * ```
    * @Directive({ selector: '[my-directive]' })
    * class MyDirective {
@@ -344,18 +504,18 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * This directive would be instantiated with a Query which would contain `Dependency` 4, 5 and 6.
-   * 
+   *
    * ### Optional injection
-   * 
+   *
    * The normal behavior of directives is to return an error when a specified dependency cannot be
    * resolved. If you
    * would like to inject `null` on unresolved dependency instead, you can annotate that dependency
    * with `@Optional()`.
    * This explicitly permits the author of a template to treat some of the surrounding directives as
    * optional.
-   * 
+   *
    * ```
    * @Directive({ selector: '[my-directive]' })
    * class MyDirective {
@@ -363,15 +523,15 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * This directive would be instantiated with a `Dependency` directive found on the current element.
    * If none can be
    * found, the injector supplies `null` instead of throwing an error.
-   * 
+   *
    * ## Example
-   * 
+   *
    * Here we use a decorator directive to simply define basic tool-tip behavior.
-   * 
+   *
    * ```
    * @Directive({
    *   selector: '[tooltip]',
@@ -387,16 +547,16 @@ declare module ng {
    *   text:string;
    *   overlay:Overlay; // NOT YET IMPLEMENTED
    *   overlayManager:OverlayManager; // NOT YET IMPLEMENTED
-   * 
+   *
    *   constructor(overlayManager:OverlayManager) {
    *     this.overlay = overlay;
    *   }
-   * 
+   *
    *   onMouseEnter() {
    *     // exact signature to be determined
    *     this.overlay = this.overlayManager.open(text, ...);
    *   }
-   * 
+   *
    *   onMouseLeave() {
    *     this.overlay.close();
    *     this.overlay = null;
@@ -406,39 +566,39 @@ declare module ng {
    * In our HTML template, we can then add this behavior to a `<div>` or any other element with the
    * `tooltip` selector,
    * like so:
-   * 
+   *
    * ```
    * <div tooltip="some text here"></div>
    * ```
-   * 
+   *
    * Directives can also control the instantiation, destruction, and positioning of inline template
    * elements:
-   * 
+   *
    * A directive uses a {@link ViewContainerRef} to instantiate, insert, move, and destroy views at
    * runtime.
    * The {@link ViewContainerRef} is created as a result of `<template>` element, and represents a
    * location in the current view
    * where these actions are performed.
-   * 
+   *
    * Views are always created as children of the current {@link ViewMetadata}, and as siblings of the
    * `<template>` element. Thus a
    * directive in a child view cannot inject the directive that created it.
-   * 
+   *
    * Since directives that create views via ViewContainers are common in Angular, and using the full
    * `<template>` element syntax is wordy, Angular
    * also supports a shorthand notation: `<li *foo="bar">` and `<li template="foo: bar">` are
    * equivalent.
-   * 
+   *
    * Thus,
-   * 
+   *
    * ```
    * <ul>
    *   <li *foo="bar" title="text"></li>
    * </ul>
    * ```
-   * 
+   *
    * Expands in use to:
-   * 
+   *
    * ```
    * <ul>
    *   <template [foo]="bar">
@@ -446,18 +606,18 @@ declare module ng {
    *   </template>
    * </ul>
    * ```
-   * 
+   *
    * Notice that although the shorthand places `*foo="bar"` within the `<li>` element, the binding for
    * the directive
    * controller is correctly instantiated on the `<template>` element rather than the `<li>` element.
-   * 
-   * 
+   *
+   *
    * ## Example
-   * 
+   *
    * Let's suppose we want to implement the `unless` behavior, to conditionally include a template.
-   * 
+   *
    * Here is a simple directive that triggers on an `unless` selector:
-   * 
+   *
    * ```
    * @Directive({
    *   selector: '[unless]',
@@ -467,13 +627,13 @@ declare module ng {
    *   viewContainer: ViewContainerRef;
    *   templateRef: TemplateRef;
    *   prevCondition: boolean;
-   * 
+   *
    *   constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef) {
    *     this.viewContainer = viewContainer;
    *     this.templateRef = templateRef;
    *     this.prevCondition = null;
    *   }
-   * 
+   *
    *   set unless(newCondition) {
    *     if (newCondition && (isBlank(this.prevCondition) || !this.prevCondition)) {
    *       this.prevCondition = true;
@@ -485,17 +645,17 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * We can then use this `unless` selector in a template:
    * ```
    * <ul>
    *   <li *unless="expr"></li>
    * </ul>
    * ```
-   * 
+   *
    * Once the directive instantiates the child view, the shorthand notation for the template expands
    * and the result is:
-   * 
+   *
    * ```
    * <ul>
    *   <template [unless]="exp">
@@ -504,66 +664,66 @@ declare module ng {
    *   <li></li>
    * </ul>
    * ```
-   * 
+   *
    * Note also that although the `<li></li>` template still exists inside the `<template></template>`,
    * the instantiated
    * view occurs on the second `<li></li>` which is a sibling to the `<template>` element.
    */
   class DirectiveMetadata extends InjectableMetadata {
-    
+
 
     /**
      * The CSS selector that triggers the instantiation of a directive.
-     * 
+     *
      * Angular only allows directives to trigger on CSS selectors that do not cross element
      * boundaries.
-     * 
+     *
      * `selector` may be declared as one of the following:
-     * 
+     *
      * - `element-name`: select by element name.
      * - `.class`: select by class name.
      * - `[attribute]`: select by attribute name.
      * - `[attribute=value]`: select by attribute name and value.
      * - `:not(sub_selector)`: select only if the element does not match the `sub_selector`.
      * - `selector1, selector2`: select if either `selector1` or `selector2` matches.
-     * 
-     * 
+     *
+     *
      * ## Example
-     * 
+     *
      * Suppose we have a directive with an `input[type=text]` selector.
-     * 
+     *
      * And the following HTML:
-     * 
+     *
      * ```html
      * <form>
      *   <input type="text">
      *   <input type="radio">
      * <form>
      * ```
-     * 
+     *
      * The directive would only be instantiated on the `<input type="text">` element.
      */
      selector: string;
-    
+
 
     /**
      * Enumerates the set of properties that accept data binding for a directive.
-     * 
+     *
      * The `properties` property defines a set of `directiveProperty` to `bindingProperty`
      * configuration:
-     * 
+     *
      * - `directiveProperty` specifies the component property where the value is written.
      * - `bindingProperty` specifies the DOM property where the value is read from.
-     * 
+     *
      * You can include a {@link PipeMetadata} when specifying a `bindingProperty` to allow for data
      * transformation and structural change detection of the value. These pipes will be evaluated in
      * the context of this component.
-     * 
+     *
      * ## Syntax
-     * 
+     *
      * There is no need to specify both `directiveProperty` and `bindingProperty` when they both have
      * the same value.
-     * 
+     *
      * ```
      * @Directive({
      *   properties: [
@@ -574,13 +734,13 @@ declare module ng {
      *   ]
      * }
      * ```
-     * 
-     * 
+     *
+     *
      * ## Basic Property Binding
-     * 
+     *
      * We can easily build a simple `Tooltip` directive that exposes a `tooltip` property, which can
      * be used in templates with standard Angular syntax. For example:
-     * 
+     *
      * ```
      * @Directive({
      *   selector: '[tooltip]',
@@ -594,97 +754,97 @@ declare module ng {
      *   }
      * }
      * ```
-     * 
+     *
      * We can then bind to the `tooltip' property as either an expression (`someExpression`) or as a
      * string literal, as shown in the HTML template below:
-     * 
+     *
      * ```html
      * <div [tooltip]="someExpression">...</div>
      * <div tooltip="Some Text">...</div>
      * ```
-     * 
+     *
      * Whenever the `someExpression` expression changes, the `properties` declaration instructs
      * Angular to update the `Tooltip`'s `text` property.
-     * 
+     *
      * ### Bindings With Pipes
-     * 
+     *
      * You can use pipes in bindings, as follows:
-     * 
+     *
      * ```html
      * <div [class-set]="someExpression | somePipe">
      * ```
      */
-     properties: List<string>;
-    
+     properties: string[];
+
 
     /**
      * Enumerates the set of emitted events.
-     * 
+     *
      * ## Syntax
-     * 
+     *
      * ```
      * @Component({
      *   events: ['statusChange']
      * })
      * class TaskComponent {
      *   statusChange: EventEmitter;
-     * 
+     *
      *   constructor() {
      *     this.statusChange = new EventEmitter();
      *   }
-     * 
+     *
      *   onComplete() {
      *     this.statusChange.next('completed');
      *   }
      * }
      * ```
-     * 
+     *
      * Use `propertyName: eventName` when the event emitter property name is different from the name
      * of the emitted event:
-     * 
+     *
      * ```
      * @Component({
      *   events: ['status: statusChange']
      * })
      * class TaskComponent {
      *   status: EventEmitter;
-     * 
+     *
      *   constructor() {
      *     this.status = new EventEmitter();
      *   }
-     * 
+     *
      *   onComplete() {
      *     this.status.next('completed');
      *   }
      * }
      * ```
      */
-     events: List<string>;
-    
+     events: string[];
+
 
     /**
      * Specifiy the events, actions, properties and attributes related to the host element.
-     * 
+     *
      * ## Events
-     * 
+     *
      * Specifies which DOM hostListeners a directive listens to via a set of `(event)` to `method`
      * key-value pairs:
-     * 
+     *
      * - `event1`: the DOM event that the directive listens to.
      * - `statement`: the statement to execute when the event occurs.
      * If the evalutation of the statement returns `false`, then `preventDefault`is applied on the DOM
      * event.
-     * 
+     *
      * To listen to global events, a target must be added to the event name.
      * The target can be `window`, `document` or `body`.
-     * 
+     *
      * When writing a directive event binding, you can also refer to the following local variables:
      * - `$event`: Current event object which triggered the event.
      * - `$target`: The source of the event. This will be either a DOM element or an Angular
      * directive. (will be implemented in later release)
-     * 
+     *
      * ## Syntax
-     * 
+     *
      * ```
      * @Directive({
      *   host: {
@@ -694,13 +854,13 @@ declare module ng {
      *   }
      * }
      * ```
-     * 
+     *
      * ## Basic Event Binding:
-     * 
+     *
      * Suppose you want to write a directive that reacts to `change` events in the DOM and on
      * `resize` events in window.
      * You would define the event binding as follows:
-     * 
+     *
      * ```
      * @Directive({
      *   selector: 'input',
@@ -718,13 +878,13 @@ declare module ng {
      *   }
      * }
      * ```
-     * 
+     *
      * ## Properties
-     * 
+     *
      * Specifies which DOM properties a directives updates.
-     * 
+     *
      * ## Syntax
-     * 
+     *
      * ```
      * @Directive({
      *   selector: 'input',
@@ -736,17 +896,17 @@ declare module ng {
      *   value:string;
      * }
      * ```
-     * 
+     *
      * In this example the prop property of the host element is updated with the expression value
      * every time it changes.
-     * 
+     *
      * ## Attributes
-     * 
+     *
      * Specifies static attributes that should be propagated to a host element. Attributes specified
      * in `hostAttributes` are propagated only if a given attribute is not present on a host element.
-     * 
+     *
      * ## Syntax
-     * 
+     *
      * ```
      * @Directive({
      *   selector: '[my-button]',
@@ -757,68 +917,42 @@ declare module ng {
      * class MyButton {
      * }
      * ```
-     * 
+     *
      * In this example using `my-button` directive (ex.: `<div my-button></div>`) on a host element
      * (here: `<div>` ) will ensure that this element will get the "button" role.
-     * 
-     * ## Actions
-     * 
-     * Specifies which DOM methods a directive can invoke.
-     * 
-     * ## Syntax
-     * 
-     * ```
-     * @Directive({
-     *   selector: 'input',
-     *   host: {
-     *     '@emitFocus': 'focus()'
-     *   }
-     * })
-     * class InputDirective {
-     *   constructor() {
-     *     this.emitFocus = new EventEmitter();
-     *   }
-     * 
-     *   focus() {
-     *     this.emitFocus.next();
-     *   }
-     * }
-     * ```
-     * 
-     * In this example calling focus on InputDirective will result in calling focus on the input.
      */
      host: StringMap<string, string>;
-    
+
 
     /**
      * Specifies which lifecycle should be notified to the directive.
-     * 
+     *
      * See {@link LifecycleEvent} for details.
      */
-     lifecycle: List<LifecycleEvent>;
-    
+     lifecycle: LifecycleEvent[];
+
 
     /**
      * If set to false the compiler does not compile the children of this directive.
      */
      compileChildren: boolean;
-    
+
 
     /**
      * Defines the set of injectable objects that are visible to a Directive and its light dom
      * children.
-     * 
+     *
      * ## Simple Example
-     * 
+     *
      * Here is an example of a class that can be injected:
-     * 
+     *
      * ```
      * class Greeter {
      *    greet(name:string) {
      *      return 'Hello ' + name + '!';
      *    }
      * }
-     * 
+     *
      * @Directive({
      *   selector: 'greet',
      *   bindings: [
@@ -827,21 +961,21 @@ declare module ng {
      * })
      * class HelloWorld {
      *   greeter:Greeter;
-     * 
+     *
      *   constructor(greeter:Greeter) {
      *     this.greeter = greeter;
      *   }
      * }
      * ```
      */
-     bindings: List<any>;
-    
+     bindings: any[];
+
 
     /**
      * Defines the name that can be used in the template to assign this directive to a variable.
-     * 
+     *
      * ## Simple Example
-     * 
+     *
      * ```
      * @Directive({
      *   selector: 'child-dir',
@@ -849,7 +983,7 @@ declare module ng {
      * })
      * class ChildDir {
      * }
-     * 
+     *
      * @Component({
      *   selector: 'main',
      * })
@@ -859,18 +993,18 @@ declare module ng {
      * })
      * class MainComponent {
      * }
-     * 
+     *
      * ```
      */
      exportAs: string;
   }
-  
+
 
   /**
    * Declare reusable pipe function.
-   * 
+   *
    * ## Example
-   * 
+   *
    * ```
    * @Pipe({
    *   name: 'lowercase'
@@ -881,30 +1015,56 @@ declare module ng {
    * ```
    */
   class PipeMetadata extends InjectableMetadata {
-    
+
      name: string;
   }
-  
+
 
   /**
    * Lifecycle events are guaranteed to be called in the following order:
-   * - `onChange` (optional if any bindings have changed),
-   * - `onInit` (optional after the first check only),
-   * - `onCheck`,
-   * - `onAllChangesDone`
+   * - `OnChanges` (if any bindings have changed),
+   * - `OnInit` (after the first check only),
+   * - `DoCheck`,
+   * - `AfterContentChecked`
+   * - `AfterContentChecked`
+   * - `OnDestroy` (at the very end before destruction)
    */
   enum LifecycleEvent {
-    
+
+
+    /**
+     * Notify a directive when it has been checked the first time.
+     *
+     * This method is called right after the directive's bindings have been checked,
+     * and before any of its children's bindings have been checked.
+     *
+     * It is invoked only once.
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.OnInit]
+     * })
+     * class ClassSet {
+     *   onInit() {
+     *   }
+     * }
+     *  ```
+     */
+     OnInit,
+
 
     /**
      * Notify a directive whenever a {@link ViewMetadata} that contains it is destroyed.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```
      * @Directive({
      *   ...,
-     *   lifecycle: [LifecycleEvent.onDestroy]
+     *   lifecycle: [LifecycleEvent.OnDestroy]
      * })
      * class ClassSet {
      *   onDestroy() {
@@ -913,19 +1073,19 @@ declare module ng {
      * }
      * ```
      */
-     onDestroy,
-    
+     OnDestroy,
+
 
     /**
      * Notify a directive when any of its bindings have changed.
-     * 
+     *
      * This method is called right after the directive's bindings have been checked,
      * and before any of its children's bindings have been checked.
-     * 
+     *
      * It is invoked only if at least one of the directive's bindings has changed.
-     * 
+     *
      * ## Example:
-     * 
+     *
      * ```
      * @Directive({
      *   selector: '[class-set]',
@@ -933,12 +1093,12 @@ declare module ng {
      *     'propA',
      *     'propB'
      *   ],
-     *   lifecycle: [LifecycleEvent.onChange]
+     *   lifecycle: [LifecycleEvent.OnChanges]
      * })
      * class ClassSet {
      *   propA;
      *   propB;
-     *   onChange(changes:{[idx: string, PropertyUpdate]}) {
+     *   onChanges(changes:{[idx: string, PropertyUpdate]}) {
      *     // This will get called after any of the properties have been updated.
      *     if (changes['propA']) {
      *       // if propA was updated
@@ -950,94 +1110,139 @@ declare module ng {
      * }
      *  ```
      */
-     onChange,
-    
+     OnChanges,
+
 
     /**
      * Notify a directive when it has been checked.
-     * 
+     *
      * This method is called right after the directive's bindings have been checked,
      * and before any of its children's bindings have been checked.
-     * 
+     *
      * It is invoked every time even when none of the directive's bindings has changed.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```
      * @Directive({
      *   selector: '[class-set]',
-     *   lifecycle: [LifecycleEvent.onCheck]
+     *   lifecycle: [LifecycleEvent.DoCheck]
      * })
      * class ClassSet {
-     *   onCheck() {
+     *   doCheck() {
      *   }
      * }
      *  ```
      */
-     onCheck,
-    
+     DoCheck,
+
 
     /**
-     * Notify a directive when it has been checked the first itme.
-     * 
-     * This method is called right after the directive's bindings have been checked,
-     * and before any of its children's bindings have been checked.
-     * 
-     * It is invoked only once.
-     * 
+     * Notify a directive when the bindings of all its content children have been checked the first
+     * time (whether they
+     * have changed or not).
+     *
      * ## Example
-     * 
+     *
      * ```
      * @Directive({
      *   selector: '[class-set]',
-     *   lifecycle: [LifecycleEvent.onInit]
+     *   lifecycle: [LifecycleEvent.AfterContentInit]
      * })
      * class ClassSet {
-     *   onInit() {
+     *
+     *   afterContentInit() {
      *   }
+     *
      * }
      *  ```
      */
-     onInit,
-    
+     AfterContentInit,
+
 
     /**
-     * Notify a directive when the bindings of all its children have been checked (whether they have
-     * changed or not).
-     * 
+     * Notify a directive when the bindings of all its content children have been checked (whether
+     * they
+     * have changed or not).
+     *
      * ## Example
-     * 
+     *
      * ```
      * @Directive({
      *   selector: '[class-set]',
-     *   lifecycle: [LifecycleEvent.onAllChangesDone]
+     *   lifecycle: [LifecycleEvent.AfterContentChecked]
      * })
      * class ClassSet {
-     * 
-     *   onAllChangesDone() {
+     *
+     *   afterContentChecked() {
      *   }
-     * 
+     *
      * }
      *  ```
      */
-     onAllChangesDone
+     AfterContentChecked,
+
+
+    /**
+     * Notify a directive when the bindings of all its view children have been checked the first time
+     * (whether they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterViewInit]
+     * })
+     * class ClassSet {
+     *
+     *   afterViewInit() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterViewInit,
+
+
+    /**
+     * Notify a directive when the bindings of all its view children have been checked (whether they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterViewChecked]
+     * })
+     * class ClassSet {
+     *
+     *   afterViewChecked() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterViewChecked
   }
-  
+
 
   /**
    * Declares the available HTML templates for an application.
-   * 
+   *
    * Each angular component requires a single `@Component` and at least one `@View` annotation. The
    * `@View` annotation specifies the HTML template to use, and lists the directives that are active
    * within the template.
-   * 
+   *
    * When a component is instantiated, the template is loaded into the component's shadow root, and
    * the expressions and statements in the template are evaluated against the component.
-   * 
+   *
    * For details on the `@Component` annotation, see {@link ComponentMetadata}.
-   * 
+   *
    * ## Example
-   * 
+   *
    * ```
    * @Component({
    *   selector: 'greet'
@@ -1048,7 +1253,7 @@ declare module ng {
    * })
    * class Greet {
    *   name: string;
-   * 
+   *
    *   constructor() {
    *     this.name = 'World';
    *   }
@@ -1056,43 +1261,43 @@ declare module ng {
    * ```
    */
   class ViewMetadata {
-    
+
 
     /**
      * Specifies a template URL for an angular component.
-     * 
+     *
      * NOTE: either `templateUrl` or `template` should be used, but not both.
      */
      templateUrl: string;
-    
+
 
     /**
      * Specifies an inline template for an angular component.
-     * 
+     *
      * NOTE: either `templateUrl` or `template` should be used, but not both.
      */
      template: string;
-    
+
 
     /**
      * Specifies stylesheet URLs for an angular component.
      */
-     styleUrls: List<string>;
-    
+     styleUrls: string[];
+
 
     /**
      * Specifies an inline stylesheet for an angular component.
      */
-     styles: List<string>;
-    
+     styles: string[];
+
 
     /**
      * Specifies a list of directives that can be used within a template.
-     * 
+     *
      * Directives must be listed explicitly to provide proper component encapsulation.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```javascript
      * @Component({
      *     selector: 'my-component'
@@ -1108,83 +1313,83 @@ declare module ng {
      * }
      * ```
      */
-     directives: List<Type | any | List<any>>;
-    
-     pipes: List<Type | any | List<any>>;
-    
+     directives: Array<Type | any | any[]>;
+
+     pipes: Array<Type | any | any[]>;
+
 
     /**
      * Specify how the template and the styles should be encapsulated.
-     * The default is {@link ViewEncapsulation#EMULATED `ViewEncapsulation.EMULATED`} if the view
+     * The default is {@link ViewEncapsulation#Emulated `ViewEncapsulation.Emulated`} if the view
      * has styles,
-     * otherwise {@link ViewEncapsulation#NONE `ViewEncapsulation.NONE`}.
+     * otherwise {@link ViewEncapsulation#None `ViewEncapsulation.None`}.
      */
      encapsulation: ViewEncapsulation;
   }
-  
+
 
   /**
    * How the template and styles of a view should be encapsulated.
    */
   enum ViewEncapsulation {
-    
+
 
     /**
      * Emulate scoping of styles by preprocessing the style rules
      * and adding additional attributes to elements. This is the default.
      */
-     EMULATED,
-    
+     Emulated,
+
 
     /**
      * Uses the native mechanism of the renderer. For the DOM this means creating a ShadowRoot.
      */
-     NATIVE,
-    
+     Native,
+
 
     /**
      * Don't scope the template nor the styles.
      */
-     NONE
+     None
   }
-  
+
 
   /**
    * Specifies that a {@link QueryList} should be injected.
-   * 
+   *
    * See {@link QueryList} for usage and example.
    */
   class QueryMetadata extends DependencyMetadata {
-    
+
      descendants: boolean;
-    
+
      isViewQuery: any;
-    
+
      selector: any;
-    
+
      isVarBindingQuery: boolean;
-    
-     varBindings: List<string>;
-    
+
+     varBindings: string[];
+
      toString(): string;
   }
-  
+
 
   /**
    * Specifies that a constant attribute value should be injected.
-   * 
+   *
    * The directive can inject constant string literals of host element attributes.
-   * 
+   *
    * ## Example
-   * 
+   *
    * Suppose we have an `<input>` element and want to know its `type`.
-   * 
+   *
    * ```html
    * <input type="text">
    * ```
-   * 
+   *
    * A decorator can inject string literal `text` like so:
-   * 
+   *
    * ```javascript
    * @Directive({
    *   selector: `input'
@@ -1197,29 +1402,29 @@ declare module ng {
    * ```
    */
   class AttributeMetadata extends DependencyMetadata {
-    
+
      attributeName: string;
-    
+
      token: any;
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * {@link AttributeMetadata} factory function.
    */
   var Attribute : AttributeFactory ;
-  
+
 
   /**
    * {@link AttributeMetadata} factory for creating annotations, decorators or DSL.
-   * 
+   *
    * ## Example as TypeScript Decorator
-   * 
+   *
    * ```
    * import {Attribute, Component, View} from "angular2/angular2";
-   * 
+   *
    * @Component({...})
    * @View({...})
    * class MyComponent {
@@ -1228,9 +1433,9 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * ## Example as ES5 DSL
-   * 
+   *
    * ```
    * var MyComponent = ng
    *   .Component({...})
@@ -1241,14 +1446,14 @@ declare module ng {
    *     }]
    *   })
    * ```
-   * 
+   *
    * ## Example as ES5 annotation
-   * 
+   *
    * ```
    * var MyComponent = function(title) {
    *   ...
    * };
-   * 
+   *
    * MyComponent.annotations = [
    *   new ng.Component({...}),
    *   new ng.View({...})
@@ -1259,28 +1464,28 @@ declare module ng {
    * ```
    */
   interface AttributeFactory {
-    
+
      new(name: string): AttributeMetadata;
-  
-    
+
+
      (name: string): TypeDecorator;
-  
+
   }
-  
+
 
   /**
    * {@link ComponentMetadata} factory function.
    */
   var Component : ComponentFactory ;
-  
+
 
   /**
    * Interface for the {@link ComponentMetadata} decorator function.
-   * 
+   *
    * See {@link ComponentFactory}.
    */
   interface ComponentDecorator extends TypeDecorator {
-    
+
 
     /**
      * Chain {@link ViewMetadata} annotation.
@@ -1288,23 +1493,23 @@ declare module ng {
      View(obj: {
     templateUrl?: string,
     template?: string,
-    directives?: List<Type | any | List<any>>,
-    pipes?: List<Type | any | List<any>>,
+    directives?: Array<Type | any | any[]>,
+    pipes?: Array<Type | any | any[]>,
     renderer?: string,
-    styles?: List<string>,
-    styleUrls?: List<string>,
+    styles?: string[],
+    styleUrls?: string[],
   }): ViewDecorator;
   }
-  
+
 
   /**
    * {@link ComponentAnnotation} factory for creating annotations, decorators or DSL.
-   * 
+   *
    * ## Example as TypeScript Decorator
-   * 
+   *
    * ```
    * import {Component, View} from "angular2/angular2";
-   * 
+   *
    * @Component({...})
    * @View({...})
    * class MyComponent {
@@ -1313,9 +1518,9 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * ## Example as ES5 DSL
-   * 
+   *
    * ```
    * var MyComponent = ng
    *   .Component({...})
@@ -1326,14 +1531,14 @@ declare module ng {
    *     }
    *   })
    * ```
-   * 
+   *
    * ## Example as ES5 annotation
-   * 
+   *
    * ```
    * var MyComponent = function() {
    *   ...
    * };
-   * 
+   *
    * MyComponent.annotations = [
    *   new ng.Component({...}),
    *   new ng.View({...})
@@ -1341,60 +1546,60 @@ declare module ng {
    * ```
    */
   interface ComponentFactory {
-    
+
      new(obj: {
     selector?: string,
-    properties?: List<string>,
-    events?: List<string>,
+    properties?: string[],
+    events?: string[],
     host?: StringMap<string, string>,
-    lifecycle?: List<LifecycleEvent>,
-    bindings?: List<any>,
+    lifecycle?: LifecycleEvent[],
+    bindings?: any[],
     exportAs?: string,
     compileChildren?: boolean,
-    viewBindings?: List<any>,
-    changeDetection?: string,
+    viewBindings?: any[],
+    changeDetection?: ChangeDetectionStrategy,
   }): ComponentMetadata;
-  
-    
+
+
      (obj: {
     selector?: string,
-    properties?: List<string>,
-    events?: List<string>,
+    properties?: string[],
+    events?: string[],
     host?: StringMap<string, string>,
-    lifecycle?: List<LifecycleEvent>,
-    bindings?: List<any>,
+    lifecycle?: LifecycleEvent[],
+    bindings?: any[],
     exportAs?: string,
     compileChildren?: boolean,
-    viewBindings?: List<any>,
-    changeDetection?: string,
+    viewBindings?: any[],
+    changeDetection?: ChangeDetectionStrategy,
   }): ComponentDecorator;
-  
+
   }
-  
+
 
   /**
    * {@link DirectiveMetadata} factory function.
    */
   var Directive : DirectiveFactory ;
-  
+
 
   /**
    * Interface for the {@link DirectiveMetadata} decorator function.
-   * 
+   *
    * See {@link DirectiveFactory}.
    */
   interface DirectiveDecorator extends TypeDecorator {
   }
-  
+
 
   /**
    * {@link DirectiveMetadata} factory for creating annotations, decorators or DSL.
-   * 
+   *
    * ## Example as TypeScript Decorator
-   * 
+   *
    * ```
    * import {Directive} from "angular2/angular2";
-   * 
+   *
    * @Directive({...})
    * class MyDirective {
    *   constructor() {
@@ -1402,9 +1607,9 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * ## Example as ES5 DSL
-   * 
+   *
    * ```
    * var MyDirective = ng
    *   .Directive({...})
@@ -1414,50 +1619,50 @@ declare module ng {
    *     }
    *   })
    * ```
-   * 
+   *
    * ## Example as ES5 annotation
-   * 
+   *
    * ```
    * var MyDirective = function() {
    *   ...
    * };
-   * 
+   *
    * MyDirective.annotations = [
    *   new ng.Directive({...})
    * ]
    * ```
    */
   interface DirectiveFactory {
-    
+
      new(obj: {
-    selector?: string, properties?: List<string>, events?: List<string>,
-        host?: StringMap<string, string>, lifecycle?: List<LifecycleEvent>, bindings?: List<any>,
-        exportAs?: string, compileChildren?: boolean;
+    selector?: string, properties?: string[], events?: string[], host?: StringMap<string, string>,
+        lifecycle?: LifecycleEvent[], bindings?: any[], exportAs?: string,
+        compileChildren?: boolean;
   }): DirectiveMetadata;
-  
-    
+
+
      (obj: {
-    selector?: string, properties?: List<string>, events?: List<string>,
-        host?: StringMap<string, string>, lifecycle?: List<LifecycleEvent>, bindings?: List<any>,
-        exportAs?: string, compileChildren?: boolean;
+    selector?: string, properties?: string[], events?: string[], host?: StringMap<string, string>,
+        lifecycle?: LifecycleEvent[], bindings?: any[], exportAs?: string,
+        compileChildren?: boolean;
   }): DirectiveDecorator;
-  
+
   }
-  
+
 
   /**
    * {@link ViewMetadata} factory function.
    */
   var View : ViewFactory ;
-  
+
 
   /**
    * Interface for the {@link ViewMetadata} decorator function.
-   * 
+   *
    * See {@link ViewFactory}.
    */
   interface ViewDecorator extends TypeDecorator {
-    
+
 
     /**
      * Chain {@link ViewMetadata} annotation.
@@ -1465,23 +1670,23 @@ declare module ng {
      View(obj: {
     templateUrl?: string,
     template?: string,
-    directives?: List<Type | any | List<any>>,
-    pipes?: List<Type | any | List<any>>,
+    directives?: Array<Type | any | any[]>,
+    pipes?: Array<Type | any | any[]>,
     renderer?: string,
-    styles?: List<string>,
-    styleUrls?: List<string>,
+    styles?: string[],
+    styleUrls?: string[],
   }): ViewDecorator;
   }
-  
+
 
   /**
    * {@link ViewAnnotation} factory for creating annotations, decorators or DSL.
-   * 
+   *
    * ## Example as TypeScript Decorator
-   * 
+   *
    * ```
    * import {Component, View} from "angular2/angular2";
-   * 
+   *
    * @Component({...})
    * @View({...})
    * class MyComponent {
@@ -1490,9 +1695,9 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * ## Example as ES5 DSL
-   * 
+   *
    * ```
    * var MyComponent = ng
    *   .Component({...})
@@ -1503,14 +1708,14 @@ declare module ng {
    *     }
    *   })
    * ```
-   * 
+   *
    * ## Example as ES5 annotation
-   * 
+   *
    * ```
    * var MyComponent = function() {
    *   ...
    * };
-   * 
+   *
    * MyComponent.annotations = [
    *   new ng.Component({...}),
    *   new ng.View({...})
@@ -1518,43 +1723,43 @@ declare module ng {
    * ```
    */
   interface ViewFactory {
-    
+
      new(obj: {
     templateUrl?: string,
     template?: string,
-    directives?: List<Type | any | List<any>>,
+    directives?: Array<Type | any | any[]>,
     encapsulation?: ViewEncapsulation,
-    styles?: List<string>,
-    styleUrls?: List<string>,
+    styles?: string[],
+    styleUrls?: string[],
   }): ViewMetadata;
-  
-    
+
+
      (obj: {
     templateUrl?: string,
     template?: string,
-    directives?: List<Type | any | List<any>>,
+    directives?: Array<Type | any | any[]>,
     encapsulation?: ViewEncapsulation,
-    styles?: List<string>,
-    styleUrls?: List<string>,
+    styles?: string[],
+    styleUrls?: string[],
   }): ViewDecorator;
-  
+
   }
-  
+
 
   /**
    * {@link QueryMetadata} factory function.
    */
   var Query : QueryFactory ;
-  
+
 
   /**
    * {@link QueryMetadata} factory for creating annotations, decorators or DSL.
-   * 
+   *
    * ## Example as TypeScript Decorator
-   * 
+   *
    * ```
    * import {Query, QueryList, Component, View} from "angular2/angular2";
-   * 
+   *
    * @Component({...})
    * @View({...})
    * class MyComponent {
@@ -1563,9 +1768,9 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * ## Example as ES5 DSL
-   * 
+   *
    * ```
    * var MyComponent = ng
    *   .Component({...})
@@ -1576,14 +1781,14 @@ declare module ng {
    *     }]
    *   })
    * ```
-   * 
+   *
    * ## Example as ES5 annotation
-   * 
+   *
    * ```
    * var MyComponent = function(queryList) {
    *   ...
    * };
-   * 
+   *
    * MyComponent.annotations = [
    *   new ng.Component({...}),
    *   new ng.View({...})
@@ -1594,153 +1799,186 @@ declare module ng {
    * ```
    */
   interface QueryFactory {
-    
+
      new(selector: Type | string, {descendants}?: {descendants?: boolean}): QueryMetadata;
-  
-    
+
+
      (selector: Type | string, {descendants}?: {descendants?: boolean}): ParameterDecorator;
-  
+
   }
-  
+
 
   /**
    * {@link di/ViewQueryMetadata} factory function.
    */
   var ViewQuery : QueryFactory ;
-  
+
 
   /**
    * {@link PipeMetadata} factory function.
    */
   var Pipe : PipeFactory ;
-  
+
 
   /**
    * {@link PipeMetadata} factory for creating decorators.
-   * 
+   *
    * ## Example as TypeScript Decorator
-   * 
+   *
    * ```
    * import {Pipe} from "angular2/angular2";
-   * 
+   *
    * @Pipe({...})
    * class MyPipe {
    *   constructor() {
    *     ...
    *   }
-   * 
+   *
    *   transform(v, args) {}
    * }
    * ```
    */
   interface PipeFactory {
-    
+
      new(obj: {
     name: string,
   }): any;
-  
-    
+
+
      (obj: {name: string}): any;
-  
+
   }
-  
+
 
   /**
    * Defines lifecycle method
-   * {@link annotations/LifeCycleEvent#onAllChangesDone `LifeCycleEvent.onAllChangesDone`}
-   * called when the bindings of all its children have been changed.
+   * {@link metadata/LifeCycleEvent#AfterContentInit `LifeCycleEvent.afterContentInit`}
+   * called when the bindings of all its content children have been checked the first time.
    */
-  interface OnAllChangesDone {
-    
-     onAllChangesDone(): void;
+  interface AfterContentInit {
+
+     afterContentInit(): void;
   }
-  
+
 
   /**
-   * Defines lifecycle method {@link annotations/LifeCycleEvent#onChange `LifeCycleEvent.onChange`}
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterContentChecked `LifeCycleEvent.afterContentChecked`}
+   * called when the bindings of all its content children have been checked.
+   */
+  interface AfterContentChecked {
+
+     afterContentChecked(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterViewInit `LifeCycleEvent.afterViewInit`}
+   * called when the bindings of all its view children have been checked the first time.
+   */
+  interface AfterViewInit {
+
+     afterViewInit(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterViewChecked `LifeCycleEvent.afterViewChecked`}
+   * called when the bindings of all its view children have been checked.
+   */
+  interface AfterViewChecked {
+
+     afterViewChecked(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#OnChanges `LifeCycleEvent.OnChanges`}
    * called after all of component's bound properties are updated.
    */
-  interface OnChange {
-    
-     onChange(changes: StringMap<string, any>): void;
+  interface OnChanges {
+
+     onChanges(changes: StringMap<string, any>): void;
   }
-  
+
 
   /**
-   * Defines lifecycle method {@link annotations/LifeCycleEvent#onDestroy `LifeCycleEvent.onDestroy`}
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#OnDestroy `LifeCycleEvent.OnDestroy`}
    * called when a directive is being destroyed.
    */
   interface OnDestroy {
-    
+
      onDestroy(): void;
   }
-  
+
 
   /**
-   * Defines lifecycle method {@link annotations/LifeCycleEvent#onInit `LifeCycleEvent.onInit`}
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#OnInit `LifeCycleEvent.OnInit`}
    * called when a directive is being checked the first time.
    */
   interface OnInit {
-    
+
      onInit(): void;
   }
-  
+
 
   /**
-   * Defines lifecycle method {@link annotations/LifeCycleEvent#onCheck `LifeCycleEvent.onCheck`}
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#DoCheck `LifeCycleEvent.DoCheck`}
    * called when a directive is being checked.
    */
-  interface OnCheck {
-    
-     onCheck(): void;
+  interface DoCheck {
+
+     doCheck(): boolean;
   }
-  
+
 
   /**
    * Provides a way for expressing ES6 classes with parameter annotations in ES5.
-   * 
+   *
    * ## Basic Example
-   * 
+   *
    * ```
    * var Greeter = ng.Class({
    *   constructor: function(name) {
    *     this.name = name;
    *   },
-   * 
+   *
    *   greet: function() {
    *     alert('Hello ' + this.name + '!');
    *   }
    * });
    * ```
-   * 
+   *
    * is equivalent to ES6:
-   * 
+   *
    * ```
    * class Greeter {
    *   constructor(name) {
    *     this.name = name;
    *   }
-   * 
+   *
    *   greet() {
    *     alert('Hello ' + this.name + '!');
    *   }
    * }
    * ```
-   * 
+   *
    * or equivalent to ES5:
-   * 
+   *
    * ```
    * var Greeter = function (name) {
    *   this.name = name;
    * }
-   * 
+   *
    * Greeter.prototype.greet = function () {
    *   alert('Hello ' + this.name + '!');
    * }
    * ```
-   * 
+   *
    * ## Example with parameter annotations
-   * 
+   *
    * ```
    * var MyService = neg.Class({
    *   constructor: [String, [new Query(), QueryList], function(name, queryList) {
@@ -1748,9 +1986,9 @@ declare module ng {
    *   }];
    * });
    * ```
-   * 
+   *
    * is equivalent to ES6:
-   * 
+   *
    * ```
    * class MyService {
    *   constructor(name: string, @Query() queryList: QueryList) {
@@ -1758,16 +1996,16 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * ## Example with inheritance
-   * 
+   *
    * ```
    * var Shape = ng.Class({
    *   constructor: (color) {
    *     this.color = color;
    *   }
    * });
-   * 
+   *
    * var Square = ng.Class({
    *   extends: Shape,
    *   constructor: function(color, size) {
@@ -1778,49 +2016,49 @@ declare module ng {
    * ```
    */
   function Class(clsDef: ClassDefinition) : Type ;
-  
+
 
   /**
    * Declares the interface to be used with {@link Class}.
    */
   interface ClassDefinition {
-    
+
 
     /**
      * Optional argument for specifying the superclass.
      */
      extends?: Type;
-    
+
 
     /**
      * Required constructor function for a class.
-     * 
+     *
      * The function may be optionally wrapped in an `Array`, in which case additional parameter
      * annotations may be specified.
      * The number of arguments and the number of parameter annotations must match.
-     * 
+     *
      * See {@link Class} for example of usage.
      */
-     constructor: (Function | Array<any>);
+     constructor: (Function | any[]);
   }
-  
+
 
   /**
    * An interface implemented by all Angular type decorators, which allows them to be used as ES7
    * decorators as well as
    * Angular DSL syntax.
-   * 
+   *
    * DSL syntax:
-   * 
+   *
    * ```
    * var MyClass = ng
    *   .Component({...})
    *   .View({...})
    *   .Class({...});
    * ```
-   * 
+   *
    * ES7 syntax:
-   * 
+   *
    * ```
    * @ng.Component({...})
    * @ng.View({...})
@@ -1828,187 +2066,195 @@ declare module ng {
    * ```
    */
   interface TypeDecorator {
-    
+
 
     /**
      * Invoke as ES7 decorator.
      */
      <T extends Type>(type: T): T;
-  
-    
+
+
 
     /**
      * Storage for the accumulated annotations so far used by the DSL syntax.
-     * 
+     *
      * Used by {@link Class} to annotate the generated class.
      */
-     annotations: Array<any>;
-    
+     annotations: any[];
+
 
     /**
      * Generate a class from the definition and annotate it with {@link TypeDecorator#annotations}.
      */
      Class(obj: ClassDefinition): Type;
   }
-  
 
-  /**
-   * CHECK_ONCE means that after calling detectChanges the mode of the change detector
-   * will become CHECKED.
-   */
-  const CHECK_ONCE : string ;
-  
+  enum ChangeDetectionStrategy {
 
-  /**
-   * CHECK_ALWAYS means that after calling detectChanges the mode of the change detector
-   * will remain CHECK_ALWAYS.
-   */
-  const CHECK_ALWAYS : string ;
-  
 
-  /**
-   * DETACHED means that the change detector sub tree is not a part of the main tree and
-   * should be skipped.
-   */
-  const DETACHED : string ;
-  
+    /**
+     * `CheckedOnce` means that after calling detectChanges the mode of the change detector
+     * will become `Checked`.
+     */
+     CheckOnce,
 
-  /**
-   * CHECKED means that the change detector should be skipped until its mode changes to
-   * CHECK_ONCE or CHECK_ALWAYS.
-   */
-  const CHECKED : string ;
-  
 
-  /**
-   * ON_PUSH means that the change detector's mode will be set to CHECK_ONCE during hydration.
-   */
-  const ON_PUSH : string ;
-  
+    /**
+     * `Checked` means that the change detector should be skipped until its mode changes to
+     * `CheckOnce`.
+     */
+     Checked,
+
+
+    /**
+     * `CheckAlways` means that after calling detectChanges the mode of the change detector
+     * will remain `CheckAlways`.
+     */
+     CheckAlways,
+
+
+    /**
+     * `Detached` means that the change detector sub tree is not a part of the main tree and
+     * should be skipped.
+     */
+     Detached,
+
+
+    /**
+     * `OnPush` means that the change detector's mode will be set to `CheckOnce` during hydration.
+     */
+     OnPush,
+
+
+    /**
+     * `Default` means that the change detector's mode will be set to `CheckAlways` during hydration.
+     */
+     Default,
+
+
+    /**
+     * This is an experimental feature. Works only in Dart.
+     */
+     OnPushObserve
+  }
 
-  /**
-   * DEFAULT means that the change detector's mode will be set to CHECK_ALWAYS during hydration.
-   */
-  const DEFAULT : string ;
-  
 
   /**
    * An error thrown if application changes model breaking the top-down data flow.
-   * 
+   *
    * Angular expects that the data flows from top (root) component to child (leaf) components.
    * This is known as directed acyclic graph. This allows Angular to only execute change detection
    * once and prevents loops in change detection data flow.
-   * 
+   *
    * This exception is only thrown in dev mode.
    */
   class ExpressionChangedAfterItHasBeenCheckedException extends BaseException {
   }
-  
+
 
   /**
    * Thrown when an expression evaluation raises an exception.
-   * 
+   *
    * This error wraps the original exception, this is done to attach expression location information.
    */
   class ChangeDetectionError extends BaseException {
-    
+
 
     /**
      * Location of the expression.
      */
      location: string;
   }
-  
+
   interface ChangeDetector {
-    
+
      parent: ChangeDetector;
-    
-     mode: string;
-    
+
+     mode: ChangeDetectionStrategy;
+
      ref: ChangeDetectorRef;
-    
+
      addChild(cd: ChangeDetector): void;
-    
+
      addShadowDomChild(cd: ChangeDetector): void;
-    
+
      removeChild(cd: ChangeDetector): void;
-    
+
      removeShadowDomChild(cd: ChangeDetector): void;
-    
+
      remove(): void;
-    
+
      hydrate(context: any, locals: Locals, directives: any, pipes: any): void;
-    
+
      dehydrate(): void;
-    
+
      markPathToRootAsCheckOnce(): void;
-    
+
      handleEvent(eventName: string, elIndex: number, locals: Locals): void;
-    
+
      detectChanges(): void;
-    
+
      checkNoChanges(): void;
   }
-  
+
   class Locals {
-    
+
      parent: Locals;
-    
+
      current: Map<any, any>;
-    
+
      contains(name: string): boolean;
-    
+
      get(name: string): any;
-    
+
      set(name: string, value: any): void;
-    
+
      clearValues(): void;
   }
-  
+
 
   /**
    * Controls change detection.
-   * 
+   *
    * {@link ChangeDetectorRef} allows requesting checks for detectors that rely on observables. It
    * also allows detaching and attaching change detector subtrees.
    */
   interface ChangeDetectorRef {
-    
+
 
     /**
-     * Request to check all ON_PUSH ancestors.
+     * Request to check all OnPush ancestors.
      */
-     requestCheck(): void;
-    
+     markForCheck(): void;
+
 
     /**
      * Detaches the change detector from the change detector tree.
-     * 
+     *
      * The detached change detector will not be checked until it is reattached.
      */
      detach(): void;
-    
+
 
     /**
      * Reattach the change detector to the change detector tree.
-     * 
+     *
      * This also requests a check of this change detector. This reattached change detector will be
-     * checked during the
-     * next change detection run.
+     * checked during the next change detection run.
      */
      reattach(): void;
   }
-  
+
 
   /**
    * Indicates that the result of a {@link PipeMetadata} transformation has changed even though the
    * reference
    * has not changed.
-   * 
+   *
    * The wrapped value will be unwrapped by change detection, and the unwrapped value will be stored.
-   * 
+   *
    * Example:
-   * 
+   *
    * ```
    * if (this._latestValue === this._latestReturnedValue) {
    *    return this._latestReturnedValue;
@@ -2019,18 +2265,18 @@ declare module ng {
    * ```
    */
   class WrappedValue {
-    
+
      static wrap(value: any): WrappedValue;
-    
+
      wrapped: any;
   }
-  
+
 
   /**
    * An interface which all pipes must implement.
-   * 
+   *
    * #Example
-   * 
+   *
    * ```
    * class DoublePipe implements PipeTransform {
    *  transform(value, args = []) {
@@ -2040,24 +2286,24 @@ declare module ng {
    * ```
    */
   interface PipeTransform {
-    
-     transform(value: any, args: List<any>): any;
+
+     transform(value: any, args: any[]): any;
   }
-  
+
 
   /**
    * An interface that stateful pipes should implement.
-   * 
+   *
    * #Example
-   * 
+   *
    * ```
    * class StatefulPipe implements PipeTransform, PipeOnDestroy {
    *  connection;
-   * 
+   *
    *  onDestroy() {
    *    this.connection.release();
    *  }
-   * 
+   *
    *  transform(value, args = []) {
    *    this.connection = createConnection();
    *    // ...
@@ -2067,30 +2313,30 @@ declare module ng {
    * ```
    */
   interface PipeOnDestroy {
-    
+
      onDestroy(): void;
   }
-  
+
 
   /**
    * A repository of different iterable diffing strategies used by NgFor, NgClass, and others.
    */
   class IterableDiffers {
-    
+
      static create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers;
-    
+
 
     /**
      * Takes an array of {@link IterableDifferFactory} and returns a binding used to extend the
      * inherited {@link IterableDiffers} instance with the provided factories and return a new
      * {@link IterableDiffers} instance.
-     * 
+     *
      * The following example shows how to extend an existing list of factories,
      * which will only be applied to the injector for this component and its children.
      * This step is all that's required to make a new {@link IterableDiffer} available.
-     * 
+     *
      * # Example
-     * 
+     *
      * ```
      * @Component({
      *   viewBindings: [
@@ -2100,50 +2346,50 @@ declare module ng {
      * ```
      */
      static extend(factories: IterableDifferFactory[]): Binding;
-    
+
      factories: IterableDifferFactory[];
-    
+
      find(iterable: Object): IterableDifferFactory;
   }
-  
+
   interface IterableDiffer {
-    
+
      diff(object: Object): any;
-    
+
      onDestroy(): void;
   }
-  
+
 
   /**
    * Provides a factory for {@link IterableDiffer}.
    */
   interface IterableDifferFactory {
-    
+
      supports(objects: Object): boolean;
-    
+
      create(cdRef: ChangeDetectorRef): IterableDiffer;
   }
-  
+
 
   /**
    * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.
    */
   class KeyValueDiffers {
-    
+
      static create(factories: KeyValueDifferFactory[], parent?: KeyValueDiffers): KeyValueDiffers;
-    
+
 
     /**
      * Takes an array of {@link KeyValueDifferFactory} and returns a binding used to extend the
      * inherited {@link KeyValueDiffers} instance with the provided factories and return a new
      * {@link KeyValueDiffers} instance.
-     * 
+     *
      * The following example shows how to extend an existing list of factories,
      * which will only be applied to the injector for this component and its children.
      * This step is all that's required to make a new {@link KeyValueDiffer} available.
-     * 
+     *
      * # Example
-     * 
+     *
      * ```
      * @Component({
      *   viewBindings: [
@@ -2153,254 +2399,125 @@ declare module ng {
      * ```
      */
      static extend(factories: KeyValueDifferFactory[]): Binding;
-    
+
      factories: KeyValueDifferFactory[];
-    
+
      find(kv: Object): KeyValueDifferFactory;
   }
-  
+
   interface KeyValueDiffer {
-    
+
      diff(object: Object): void;
-    
+
      onDestroy(): void;
   }
-  
+
 
   /**
    * Provides a factory for {@link KeyValueDiffer}.
    */
   interface KeyValueDifferFactory {
-    
+
      supports(objects: Object): boolean;
-    
+
      create(cdRef: ChangeDetectorRef): KeyValueDiffer;
   }
-  
+
 
   /**
    * An opaque token representing the application root type in the {@link Injector}.
-   * 
+   *
    * ```
    * @Component(...)
    * @View(...)
    * class MyApp {
    *   ...
    * }
-   * 
+   *
    * bootstrap(MyApp).then((appRef:ApplicationRef) {
    *   expect(appRef.injector.get(appComponentTypeToken)).toEqual(MyApp);
    * });
-   * 
+   *
    * ```
    */
   const APP_COMPONENT : OpaqueToken ;
-  
 
-  /**
-   * Bootstrapping for Angular applications.
-   * 
-   * You instantiate an Angular application by explicitly specifying a component to use as the root
-   * component for your
-   * application via the `bootstrap()` method.
-   * 
-   * ## Simple Example
-   * 
-   * Assuming this `index.html`:
-   * 
-   * ```html
-   * <html>
-   *   <!-- load Angular script tags here. -->
-   *   <body>
-   *     <my-app>loading...</my-app>
-   *   </body>
-   * </html>
-   * ```
-   * 
-   * An application is bootstrapped inside an existing browser DOM, typically `index.html`. Unlike
-   * Angular 1, Angular 2
-   * does not compile/process bindings in `index.html`. This is mainly for security reasons, as well
-   * as architectural
-   * changes in Angular 2. This means that `index.html` can safely be processed using server-side
-   * technologies such as
-   * bindings. Bindings can thus use double-curly `{{ syntax }}` without collision from Angular 2
-   * component double-curly
-   * `{{ syntax }}`.
-   * 
-   * We can use this script code:
-   * 
-   * ```
-   * @Component({
-   *    selector: 'my-app'
-   * })
-   * @View({
-   *    template: 'Hello {{ name }}!'
-   * })
-   * class MyApp {
-   *   name:string;
-   * 
-   *   constructor() {
-   *     this.name = 'World';
-   *   }
-   * }
-   * 
-   * main() {
-   *   return bootstrap(MyApp);
-   * }
-   * ```
-   * 
-   * When the app developer invokes `bootstrap()` with the root component `MyApp` as its argument,
-   * Angular performs the
-   * following tasks:
-   * 
-   *  1. It uses the component's `selector` property to locate the DOM element which needs to be
-   * upgraded into
-   *     the angular component.
-   *  2. It creates a new child injector (from the platform injector). Optionally, you can also
-   * override the injector configuration for an app by
-   * invoking `bootstrap` with the `componentInjectableBindings` argument.
-   *  3. It creates a new `Zone` and connects it to the angular application's change detection domain
-   * instance.
-   *  4. It creates a shadow DOM on the selected component's host element and loads the template into
-   * it.
-   *  5. It instantiates the specified component.
-   *  6. Finally, Angular performs change detection to apply the initial data bindings for the
-   * application.
-   * 
-   * 
-   * ## Instantiating Multiple Applications on a Single Page
-   * 
-   * There are two ways to do this.
-   * 
-   * 
-   * ### Isolated Applications
-   * 
-   * Angular creates a new application each time that the `bootstrap()` method is invoked. When
-   * multiple applications
-   * are created for a page, Angular treats each application as independent within an isolated change
-   * detection and
-   * `Zone` domain. If you need to share data between applications, use the strategy described in the
-   * next
-   * section, "Applications That Share Change Detection."
-   * 
-   * 
-   * ### Applications That Share Change Detection
-   * 
-   * If you need to bootstrap multiple applications that share common data, the applications must
-   * share a common
-   * change detection and zone. To do that, create a meta-component that lists the application
-   * components in its template.
-   * By only invoking the `bootstrap()` method once, with the meta-component as its argument, you
-   * ensure that only a
-   * single change detection zone is created and therefore data can be shared across the applications.
-   * 
-   * 
-   * ## Platform Injector
-   * 
-   * When working within a browser window, there are many singleton resources: cookies, title,
-   * location, and others.
-   * Angular services that represent these resources must likewise be shared across all Angular
-   * applications that
-   * occupy the same browser window.  For this reason, Angular creates exactly one global platform
-   * injector which stores
-   * all shared services, and each angular application injector has the platform injector as its
-   * parent.
-   * 
-   * Each application has its own private injector as well. When there are multiple applications on a
-   * page, Angular treats
-   * each application injector's services as private to that application.
-   * 
-   * 
-   * # API
-   * - `appComponentType`: The root component which should act as the application. This is a reference
-   * to a `Type`
-   *   which is annotated with `@Component(...)`.
-   * - `componentInjectableBindings`: An additional set of bindings that can be added to the app
-   * injector
-   * to override default injection behavior.
-   * - `errorReporter`: `function(exception:any, stackTrace:string)` a default error reporter for
-   * unhandled exceptions.
-   * 
-   * Returns a `Promise` of {@link ApplicationRef}.
-   */
-  function bootstrap(appComponentType: /*Type*/ any, componentInjectableBindings?: List<Type | Binding | List<any>>) : Promise<ApplicationRef> ;
-  
 
   /**
    * Runtime representation of a type.
-   * 
+   *
    * In JavaScript a Type is a constructor function.
    */
   interface Type extends Function {
-    
-     new(args: any): any;
-  
+
+     new(...args: any[]): any;
+
   }
-  
+
 
   /**
    * Represents a Angular's representation of an Application.
-   * 
+   *
    * `ApplicationRef` represents a running application instance. Use it to retrieve the host
    * component, injector,
    * or dispose of an application.
    */
   interface ApplicationRef {
-    
+
 
     /**
      * Returns the current {@link ComponentMetadata} type.
      */
      hostComponentType: Type;
-    
+
 
     /**
      * Returns the current {@link ComponentMetadata} instance.
      */
      hostComponent: any;
-    
+
 
     /**
      * Dispose (un-load) the application.
      */
      dispose(): void;
-    
+
 
     /**
      * Returns the root application {@link Injector}.
      */
      injector: Injector;
   }
-  
+
 
   /**
    * Specifies app root url for the application.
-   * 
+   *
    * Used by the {@link Compiler} when resolving HTML and CSS template URLs.
-   * 
+   *
    * This interface can be overridden by the application developer to create custom behavior.
-   * 
+   *
    * See {@link Compiler}
    */
   class AppRootUrl {
-    
+
 
     /**
      * Returns the base URL of the currently running application.
      */
      value: any;
   }
-  
+
 
   /**
    * Used by the {@link Compiler} when resolving HTML and CSS template URLs.
-   * 
+   *
    * This interface can be overridden by the application developer to create custom behavior.
-   * 
+   *
    * See {@link Compiler}
    */
   class UrlResolver {
-    
+
 
     /**
      * Resolves the `url` given the `baseUrl`:
@@ -2409,24 +2526,24 @@ declare module ng {
      * `baseUrl` and `url`,
      * - if `url` is absolute (it has a scheme: 'http://', 'https://' or start with '/'), the `url` is
      * returned as is (ignoring the `baseUrl`)
-     * 
+     *
      * @param {string} baseUrl
      * @param {string} url
      * @returns {string} the resolved URL
      */
      resolve(baseUrl: string, url: string): string;
   }
-  
+
 
   /**
    * Resolve a `Type` from a {@link ComponentMetadata} into a URL.
-   * 
+   *
    * This interface can be overridden by the application developer to create custom behavior.
-   * 
+   *
    * See {@link Compiler}
    */
   class ComponentUrlMapper {
-    
+
 
     /**
      * Returns the base URL to the component source file.
@@ -2436,39 +2553,39 @@ declare module ng {
      */
      getUrl(component: Type): string;
   }
-  
+
 
   /**
    * Resolve a `Type` for {@link DirectiveMetadata}.
-   * 
+   *
    * This interface can be overridden by the application developer to create custom behavior.
-   * 
+   *
    * See {@link Compiler}
    */
   class DirectiveResolver {
-    
+
 
     /**
      * Return {@link DirectiveMetadata} for a given `Type`.
      */
      resolve(type: Type): DirectiveMetadata;
   }
-  
+
 
   /**
    * ## URL Resolution
-   * 
+   *
    * ```
    * var appRootUrl: AppRootUrl = ...;
    * var componentUrlMapper: ComponentUrlMapper = ...;
    * var urlResolver: UrlResolver = ...;
-   * 
+   *
    * var componentType: Type = ...;
    * var componentAnnotation: ComponentAnnotation = ...;
    * var viewAnnotation: ViewAnnotation = ...;
-   * 
+   *
    * // Resolving a URL
-   * 
+   *
    * var url = viewAnnotation.templateUrl;
    * var componentUrl = componentUrlMapper.getUrl(componentType);
    * var componentResolvedUrl = urlResolver.resolve(appRootUrl.value, componentUrl);
@@ -2476,10 +2593,10 @@ declare module ng {
    * ```
    */
   interface Compiler {
-    
+
      compileInHost(componentTypeOrBinding: Type | Binding): Promise<ProtoViewRef>;
   }
-  
+
 
   /**
    * Entry point for creating, moving views in the view hierarchy and destroying views.
@@ -2487,58 +2604,58 @@ declare module ng {
    * in AppViewManagerUtils and the Renderer, so unit tests get simpler.
    */
   interface AppViewManager {
-    
+
 
     /**
      * Returns a {@link ViewContainerRef} at the {@link ElementRef} location.
      */
      getViewContainer(location: ElementRef): ViewContainerRef;
-    
+
 
     /**
      * Return the first child element of the host element view.
      */
      getHostElement(hostViewRef: HostViewRef): ElementRef;
-    
+
 
     /**
      * Returns an ElementRef for the element with the given variable name
      * in the current view.
-     * 
+     *
      * - `hostLocation`: {@link ElementRef} of any element in the View which defines the scope of
      *   search.
      * - `variableName`: Name of the variable to locate.
      * - Returns {@link ElementRef} of the found element or null. (Throws if not found.)
      */
      getNamedElementInComponentView(hostLocation: ElementRef, variableName: string): ElementRef;
-    
+
 
     /**
      * Returns the component instance for a given element.
-     * 
+     *
      * The component is the execution context as seen by an expression at that {@link ElementRef}
      * location.
      */
      getComponent(hostLocation: ElementRef): any;
-    
+
 
     /**
      * Load component view into existing element.
-     * 
+     *
      * Use this if a host element is already in the DOM and it is necessary to upgrade
      * the element into Angular component by attaching a view but reusing the existing element.
-     * 
+     *
      * - `hostProtoViewRef`: {@link ProtoViewRef} Proto view to use in creating a view for this
      *   component.
      * - `overrideSelector`: (optional) selector to use in locating the existing element to load
      *   the view into. If not specified use the selector in the component definition of the
      *   `hostProtoView`.
      * - injector: {@link Injector} to use as parent injector for the view.
-     * 
+     *
      * See {@link AppViewManager#destroyRootHostView}.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```
      * @ng.Component({
      *   selector: 'child-component'
@@ -2547,9 +2664,9 @@ declare module ng {
      *   template: 'Child'
      * })
      * class ChildComponent {
-     * 
+     *
      * }
-     * 
+     *
      * @ng.Component({
      *   selector: 'my-app'
      * })
@@ -2560,103 +2677,103 @@ declare module ng {
      * })
      * class MyApp {
      *   viewRef: ng.ViewRef;
-     * 
+     *
      *   constructor(public appViewManager: ng.AppViewManager, compiler: ng.Compiler) {
      *     compiler.compileInHost(ChildComponent).then((protoView: ng.ProtoViewRef) => {
      *       this.viewRef = appViewManager.createRootHostView(protoView, 'some-component', null);
      *     })
      *   }
-     * 
+     *
      *   onDestroy() {
      *     this.appViewManager.destroyRootHostView(this.viewRef);
      *     this.viewRef = null;
      *   }
      * }
-     * 
+     *
      * ng.bootstrap(MyApp);
      * ```
      */
      createRootHostView(hostProtoViewRef: ProtoViewRef, overrideSelector: string, injector: Injector): HostViewRef;
-    
+
 
     /**
      * Remove the View created with {@link AppViewManager#createRootHostView}.
      */
      destroyRootHostView(hostViewRef: HostViewRef): void;
-    
+
 
     /**
      * See {@link AppViewManager#destroyViewInContainer}.
      */
      createEmbeddedViewInContainer(viewContainerLocation: ElementRef, atIndex: number, templateRef: TemplateRef): ViewRef;
-    
+
 
     /**
      * See {@link AppViewManager#destroyViewInContainer}.
      */
      createHostViewInContainer(viewContainerLocation: ElementRef, atIndex: number, protoViewRef: ProtoViewRef, imperativelyCreatedInjector: ResolvedBinding[]): HostViewRef;
-    
+
 
     /**
      * See {@link AppViewManager#createViewInContainer}.
      */
      destroyViewInContainer(viewContainerLocation: ElementRef, atIndex: number): void;
-    
+
 
     /**
      * See {@link AppViewManager#detachViewInContainer}.
      */
      attachViewInContainer(viewContainerLocation: ElementRef, atIndex: number, viewRef: ViewRef): ViewRef;
-    
+
 
     /**
      * See {@link AppViewManager#attachViewInContainer}.
      */
      detachViewInContainer(viewContainerLocation: ElementRef, atIndex: number): ViewRef;
   }
-  
+
 
   /**
    * An iterable and observable live list of components in the DOM.
-   * 
+   *
    * A QueryList contains a live list of child directives in the DOM of a directive.
    * The directives are kept in depth-first pre-order traversal of the DOM.
-   * 
+   *
    * The `QueryList` is iterable, therefore it can be used in both javascript code with `for..of` loop
    * as well as in template with `*ng-for="of"` directive.
-   * 
+   *
    * QueryList is updated as part of the change-detection cycle of a directive. Since change detection
    * happens after construction of a directive, QueryList will always be empty when observed in the
    * constructor.
-   * 
-   * 
+   *
+   *
    * NOTE: In the future this class will implement an `Observable` interface. For now it uses a plain
    * list of observable callbacks.
-   * 
+   *
    * # Example:
-   * 
+   *
    * Assume that `<tabs>` component would like to get a list its children which are `<pane>`
    * components as shown in this example:
-   * 
+   *
    * ```html
    * <tabs>
    *   <pane title="Overview">...</pane>
    *   <pane *ng-for="#o of objects" [title]="o.title">{{o.text}}</pane>
    * </tabs>
    * ```
-   * 
+   *
    * In the above example the list of `<tabs>` elements needs to get a list of `<pane>` elements so
    * that it could render tabs with the correct titles and in the correct order.
-   * 
+   *
    * A possible solution would be for a `<pane>` to inject `<tabs>` component and then register itself
    * with `<tabs>` component's on `hydrate` and deregister on `dehydrate` event. While a reasonable
    * approach, this would only work partialy since `*ng-for` could rearrange the list of `<pane>`
    * components which would not be reported to `<tabs>` component and thus the list of `<pane>`
    * components would be out of sync with respect to the list of `<pane>` elements.
-   * 
+   *
    * A preferred solution is to inject a `QueryList` which is a live list of directives in the
    * component`s light DOM.
-   * 
+   *
    * ```javascript
    * @Component({
    *   selector: 'tabs'
@@ -2671,12 +2788,12 @@ declare module ng {
    * })
    * class Tabs {
    *   panes: QueryList<Pane>
-   * 
+   *
    *   constructor(@Query(Pane) panes:QueryList<Pane>) {
    *     this.panes = panes;
    *   }
    * }
-   * 
+   *
    * @Component({
    *   selector: 'pane',
    *   properties: ['title']
@@ -2688,50 +2805,50 @@ declare module ng {
    * ```
    */
   class QueryList<T> {
-    
-     reset(newList: List<T>): void;
-    
+
+     reset(newList: T[]): void;
+
      add(obj: T): void;
-    
+
      fireCallbacks(): void;
-    
+
      onChange(callback: () => void): void;
-    
+
      removeCallback(callback: () => void): void;
-    
+
      toString(): string;
-    
+
      length: number;
-    
+
      first: T;
-    
+
      last: T;
-    
+
      map<U>(fn: (item: T) => U): U[];
   }
-  
+
 
   /**
    * Service for dynamically loading a Component into an arbitrary position in the internal Angular
    * application tree.
    */
   class DynamicComponentLoader {
-    
+
 
     /**
      * Loads a root component that is placed at the first element that matches the component's
      * selector.
-     * 
+     *
      * - `typeOrBinding` `Type` \ {@link Binding} - representing the component to load.
      * - `overrideSelector` (optional) selector to load the component at (or use
      *   `@Component.selector`) The selector can be anywhere (i.e. outside the current component.)
      * - `injector` {@link Injector} - optional injector to use for the component.
-     * 
+     *
      * The loaded component receives injection normally as a hosted view.
-     * 
-     * 
+     *
+     *
      * ## Example
-     * 
+     *
      * ```
      * @ng.Component({
      *   selector: 'child-component'
@@ -2741,9 +2858,9 @@ declare module ng {
      * })
      * class ChildComponent {
      * }
-     * 
-     * 
-     * 
+     *
+     *
+     *
      * @ng.Component({
      *   selector: 'my-app'
      * })
@@ -2757,12 +2874,12 @@ declare module ng {
      *     dynamicComponentLoader.loadAsRoot(ChildComponent, '#child', injector);
      *   }
      * }
-     * 
+     *
      * ng.bootstrap(MyApp);
      * ```
-     * 
+     *
      * Resulting DOM:
-     * 
+     *
      * ```
      * <my-app>
      *   Parent (
@@ -2774,16 +2891,16 @@ declare module ng {
      * ```
      */
      loadAsRoot(typeOrBinding: Type | Binding, overrideSelector: string, injector: Injector): Promise<ComponentRef>;
-    
+
 
     /**
      * Loads a component into the component view of the provided ElementRef next to the element
      * with the given name.
-     * 
+     *
      * The loaded component receives injection normally as a hosted view.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```
      * @ng.Component({
      *   selector: 'child-component'
@@ -2793,8 +2910,8 @@ declare module ng {
      * })
      * class ChildComponent {
      * }
-     * 
-     * 
+     *
+     *
      * @ng.Component({
      *   selector: 'my-app'
      * })
@@ -2808,12 +2925,12 @@ declare module ng {
      *     dynamicComponentLoader.loadIntoLocation(ChildComponent, elementRef, 'child');
      *   }
      * }
-     * 
+     *
      * ng.bootstrap(MyApp);
      * ```
-     * 
+     *
      * Resulting DOM:
-     * 
+     *
      * ```
      * <my-app>
      *    Parent (
@@ -2824,16 +2941,16 @@ declare module ng {
      * ```
      */
      loadIntoLocation(typeOrBinding: Type | Binding, hostLocation: ElementRef, anchorName: string, bindings?: ResolvedBinding[]): Promise<ComponentRef>;
-    
+
 
     /**
      * Loads a component next to the provided ElementRef.
-     * 
+     *
      * The loaded component receives injection normally as a hosted view.
-     * 
-     * 
+     *
+     *
      * ## Example
-     * 
+     *
      * ```
      * @ng.Component({
      *   selector: 'child-component'
@@ -2843,8 +2960,8 @@ declare module ng {
      * })
      * class ChildComponent {
      * }
-     * 
-     * 
+     *
+     *
      * @ng.Component({
      *   selector: 'my-app'
      * })
@@ -2856,12 +2973,12 @@ declare module ng {
      *     dynamicComponentLoader.loadIntoLocation(ChildComponent, elementRef, 'child');
      *   }
      * }
-     * 
+     *
      * ng.bootstrap(MyApp);
      * ```
-     * 
+     *
      * Resulting DOM:
-     * 
+     *
      * ```
      * <my-app>Parent</my-app>
      * <child-component>Child</child-component>
@@ -2869,46 +2986,46 @@ declare module ng {
      */
      loadNextToLocation(typeOrBinding: Type | Binding, location: ElementRef, bindings?: ResolvedBinding[]): Promise<ComponentRef>;
   }
-  
+
 
   /**
    * Provides access to explicitly trigger change detection in an application.
-   * 
+   *
    * By default, `Zone` triggers change detection in Angular on each virtual machine (VM) turn. When
    * testing, or in some
    * limited application use cases, a developer can also trigger change detection with the
    * `lifecycle.tick()` method.
-   * 
+   *
    * Each Angular application has a single `LifeCycle` instance.
-   * 
+   *
    * # Example
-   * 
+   *
    * This is a contrived example, since the bootstrap automatically runs inside of the `Zone`, which
    * invokes
    * `lifecycle.tick()` on your behalf.
-   * 
+   *
    * ```javascript
    * bootstrap(MyApp).then((ref:ComponentRef) => {
    *   var lifeCycle = ref.injector.get(LifeCycle);
    *   var myApp = ref.instance;
-   * 
+   *
    *   ref.doSomething();
    *   lifecycle.tick();
    * });
    * ```
    */
   class LifeCycle {
-    
+
 
     /**
      * @private
      */
      registerWith(zone: NgZone, changeDetector?: ChangeDetector): void;
-    
+
 
     /**
      * Invoke this method to explicitly process change detection and its side-effects.
-     * 
+     *
      *  In development mode, `tick()` also performs a second change detection cycle to ensure that no
      * further
      *  changes are detected. If additional changes are picked up during this second cycle, bindings
@@ -2922,105 +3039,105 @@ declare module ng {
      */
      tick(): void;
   }
-  
+
 
   /**
    * Reference to the element.
-   * 
+   *
    * Represents an opaque reference to the underlying element. The element is a DOM ELement in
    * a Browser, but may represent other types on other rendering platforms. In the browser the
    * `ElementRef` can be sent to the web-worker. Web Workers can not have references to the
    * DOM Elements.
    */
   class ElementRef implements RenderElementRef {
-    
+
 
     /**
      * Reference to the {@link ViewRef} where the `ElementRef` is inside of.
      */
      parentView: ViewRef;
-    
+
 
     /**
      * Index of the element inside the {@link ViewRef}.
-     * 
+     *
      * This is used internally by the Angular framework to locate elements.
      */
      boundElementIndex: number;
-    
+
 
     /**
      * Index of the element inside the `RenderViewRef`.
-     * 
+     *
      * This is used internally by the Angular framework to locate elements.
      */
      renderBoundElementIndex: number;
-    
+
      renderView: RenderViewRef;
-    
+
 
     /**
      * Returns the native Element implementation.
-     * 
+     *
      * In the browser this represents the DOM Element.
-     * 
+     *
      * The `nativeElement` can be used as an escape hatch when direct DOM manipulation is needed. Use
      * this with caution, as it creates tight coupling between your application and the Browser, which
      * will not work in WebWorkers.
-     * 
+     *
      * NOTE: This method will return null in the webworker scenario!
      */
      nativeElement: any;
   }
-  
+
 
   /**
    * Reference to a template within a component.
-   * 
+   *
    * Represents an opaque reference to the underlying template that can
    * be instantiated using the {@link ViewContainerRef}.
    */
   class TemplateRef {
-    
+
 
     /**
      * The location of the template
      */
      elementRef: ElementRef;
-    
+
      protoViewRef: ProtoViewRef;
-    
+
 
     /**
      * Whether this template has a local variable with the given name
      */
      hasLocal(name: string): boolean;
   }
-  
+
 
   /**
    * A reference to an Angular View.
-   * 
+   *
    * A View is a fundamental building block of Application UI. A View is the smallest set of
    * elements which are created and destroyed together. A View can change properties on the elements
    * within the view, but it can not change the structure of those elements.
-   * 
+   *
    * To change structure of the elements, the Views can contain zero or more {@link ViewContainerRef}s
    * which allow the views to be nested.
-   * 
+   *
    * ## Example
-   * 
+   *
    * Given this template
-   * 
+   *
    * ```
    * Count: {{items.length}}
    * <ul>
    *   <li *ng-for="var item of items">{{item}}</li>
    * </ul>
    * ```
-   * 
+   *
    * The above example we have two {@link ProtoViewRef}s:
-   * 
+   *
    * Outter {@link ProtoViewRef}:
    * ```
    * Count: {{items.length}}
@@ -3028,16 +3145,16 @@ declare module ng {
    *   <template ng-for var-item [ng-for-of]="items"></template>
    * </ul>
    * ```
-   * 
+   *
    * Inner {@link ProtoViewRef}:
    * ```
    *   <li>{{item}}</li>
    * ```
-   * 
+   *
    * Notice that the original template is broken down into two separate {@link ProtoViewRef}s.
-   * 
+   *
    * The outter/inner {@link ProtoViewRef}s are then assembled into views like so:
-   * 
+   *
    * ```
    * <!-- ViewRef: outer-0 -->
    * Count: 2
@@ -3050,55 +3167,55 @@ declare module ng {
    * ```
    */
   interface ViewRef extends HostViewRef {
-    
+
 
     /**
      * Return `RenderViewRef`
      */
      render: RenderViewRef;
-    
+
 
     /**
      * Return `RenderFragmentRef`
      */
      renderFragment: RenderFragmentRef;
-    
+
 
     /**
      * Set local variable in a view.
-     * 
+     *
      * - `contextName` - Name of the local variable in a view.
      * - `value` - Value for the local variable in a view.
      */
      setLocal(contextName: string, value: any): void;
   }
-  
+
   interface HostViewRef {
   }
-  
+
 
   /**
    * A reference to an Angular ProtoView.
-   * 
+   *
    * A ProtoView is a reference to a template for easy creation of views.
    * (See {@link AppViewManager#createViewInContainer `AppViewManager#createViewInContainer`} and
    * {@link AppViewManager#createRootHostView `AppViewManager#createRootHostView`}).
-   * 
+   *
    * A `ProtoView` is a factory for creating `View`s.
-   * 
+   *
    * ## Example
-   * 
+   *
    * Given this template
-   * 
+   *
    * ```
    * Count: {{items.length}}
    * <ul>
    *   <li *ng-for="var item of items">{{item}}</li>
    * </ul>
    * ```
-   * 
+   *
    * The above example we have two {@link ProtoViewRef}s:
-   * 
+   *
    * Outter {@link ProtoViewRef}:
    * ```
    * Count: {{items.length}}
@@ -3106,53 +3223,53 @@ declare module ng {
    *   <template ng-for var-item [ng-for-of]="items"></template>
    * </ul>
    * ```
-   * 
+   *
    * Inner {@link ProtoViewRef}:
    * ```
    *   <li>{{item}}</li>
    * ```
-   * 
+   *
    * Notice that the original template is broken down into two separate {@link ProtoViewRef}s.
    */
   interface ProtoViewRef {
   }
-  
+
 
   /**
    * A location where {@link ViewRef}s can be attached.
-   * 
+   *
    * A `ViewContainerRef` represents a location in a {@link ViewRef} where other child
    * {@link ViewRef}s can be inserted. Adding and removing views is the only way of structurally
    * changing the rendered DOM of the application.
    */
   interface ViewContainerRef {
-    
+
      viewManager: AppViewManager;
-    
+
      element: ElementRef;
-    
+
 
     /**
      * Remove all {@link ViewRef}s at current location.
      */
      clear(): void;
-    
+
 
     /**
      * Return a {@link ViewRef} at specific index.
      */
      get(index: number): ViewRef;
-    
+
 
     /**
      * Returns number of {@link ViewRef}s currently attached at this location.
      */
      length: number;
-    
+
 
     /**
      * Create and insert a {@link ViewRef} into the view-container.
-     * 
+     *
      * - `protoViewRef` (optional) {@link ProtoViewRef} - The `ProtoView` to use for creating
      *   `View` to be inserted at this location. If `ViewContainer` is created at a location
      *   of inline template, then `protoViewRef` is the `ProtoView` of the template.
@@ -3161,38 +3278,38 @@ declare module ng {
      *   {@link ElementRef} location. (Or current context if unspecified.)
      * - `bindings` (optional) Array of {@link ResolvedBinding} - Used for configuring
      *   `ElementInjector`.
-     * 
+     *
      * Returns newly created {@link ViewRef}.
      */
      createEmbeddedView(templateRef: TemplateRef, atIndex?: number): ViewRef;
-    
+
      createHostView(protoViewRef?: ProtoViewRef, atIndex?: number, dynamicallyCreatedBindings?: ResolvedBinding[]): HostViewRef;
-    
+
 
     /**
      * Insert a {@link ViewRef} at specefic index.
-     * 
+     *
      * The index is location at which the {@link ViewRef} should be attached. If omitted it is
      * inserted at the end.
-     * 
+     *
      * Returns the inserted {@link ViewRef}.
      */
      insert(viewRef: ViewRef, atIndex?: number): ViewRef;
-    
+
 
     /**
      * Return the index of already inserted {@link ViewRef}.
      */
      indexOf(viewRef: ViewRef): number;
-    
+
 
     /**
      * Remove a {@link ViewRef} at specific index.
-     * 
+     *
      * If the index is omitted last {@link ViewRef} is removed.
      */
      remove(atIndex?: number): void;
-    
+
 
     /**
      * The method can be used together with insert to implement a view move, i.e.
@@ -3200,77 +3317,77 @@ declare module ng {
      */
      detach(atIndex?: number): ViewRef;
   }
-  
+
 
   /**
    * Angular's reference to a component instance.
-   * 
+   *
    * `ComponentRef` represents a component instance lifecycle and meta information.
    */
   interface ComponentRef {
-    
+
 
     /**
      * Location of the component host element.
      */
      location: ElementRef;
-    
+
 
     /**
      * Instance of component.
      */
      instance: any;
-    
+
 
     /**
      * Returns the host {@link ViewRef}.
      */
      hostView: HostViewRef;
-    
+
 
     /**
      * Dispose of the component instance.
      */
      dispose(): void;
   }
-  
+
 
   /**
    * A wrapper around zones that lets you schedule tasks after it has executed a task.
-   * 
+   *
    * The wrapper maintains an "inner" and an "mount" `Zone`. The application code will executes
    * in the "inner" zone unless `runOutsideAngular` is explicitely called.
-   * 
+   *
    * A typical application will create a singleton `NgZone`. The outer `Zone` is a fork of the root
    * `Zone`. The default `onTurnDone` runs the Angular change detection.
    */
   class NgZone {
-    
+
 
     /**
      * Sets the zone hook that is called just before Angular event turn starts.
      * It is called once per browser event.
      */
      overrideOnTurnStart(onTurnStartFn: Function): void;
-    
+
 
     /**
      * Sets the zone hook that is called immediately after Angular processes
      * all pending microtasks.
      */
      overrideOnTurnDone(onTurnDoneFn: Function): void;
-    
+
 
     /**
      * Sets the zone hook that is called immediately after the last turn in
      * an event completes. At this point Angular will no longer attempt to
      * sync the UI. Any changes to the data model will not be reflected in the
      * DOM. `onEventDoneFn` is executed outside Angular zone.
-     * 
+     *
      * This hook is useful for validating application state (e.g. in a test).
      */
      overrideOnEventDone(onEventDoneFn: Function, opt_waitForAsync: boolean): void;
-    
+
 
     /**
      * Sets the zone hook that is called when an error is uncaught in the
@@ -3278,17 +3395,17 @@ declare module ng {
      * the stack trace.
      */
      overrideOnErrorHandler(errorHandlingFn: Function): void;
-    
+
 
     /**
      * Runs `fn` in the inner zone and returns whatever it returns.
-     * 
+     *
      * In a typical app where the inner zone is the Angular zone, this allows one to make use of the
      * Angular's auto digest mechanism.
-     * 
+     *
      * ```
      * var zone: NgZone = [ref to the application zone];
-     * 
+     *
      * zone.run(() => {
      *   // the change detection will run after this function and the microtasks it enqueues have
      * executed.
@@ -3296,17 +3413,17 @@ declare module ng {
      * ```
      */
      run(fn: () => any): any;
-    
+
 
     /**
      * Runs `fn` in the outer zone and returns whatever it returns.
-     * 
+     *
      * In a typical app where the inner zone is the Angular zone, this allows one to escape Angular's
      * auto-digest mechanism.
-     * 
+     *
      * ```
      * var zone: NgZone = [ref to the application zone];
-     * 
+     *
      * zone.runOutsideAngular(() => {
      *   element.onClick(() => {
      *     // Clicking on the element would not trigger the change detection
@@ -3316,36 +3433,36 @@ declare module ng {
      */
      runOutsideAngular(fn: () => any): any;
   }
-  
+
   class Observable {
-    
+
      observer(generator: any): Object;
   }
-  
+
 
   /**
    * Use Rx.Observable but provides an adapter to make it work as specified here:
    * https://github.com/jhusain/observable-spec
-   * 
+   *
    * Once a reference implementation of the spec is available, switch to it.
    */
   class EventEmitter extends Observable {
-    
+
      observer(generator: any): Rx.IDisposable;
-    
+
      toRx(): Rx.Observable<any>;
-    
+
      next(value: any): void;
-    
+
      throw(error: any): void;
-    
+
      return(value?: any): void;
   }
-  
+
 
   /**
    * A parameter metadata that specifies a dependency.
-   * 
+   *
    * ```
    * class AComponent {
    *   constructor(@Inject(MyService) aService:MyService) {}
@@ -3353,17 +3470,17 @@ declare module ng {
    * ```
    */
   class InjectMetadata {
-    
+
      token: any;
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * A parameter metadata that marks a dependency as optional. {@link Injector} provides `null` if
    * the dependency is not found.
-   * 
+   *
    * ```
    * class AComponent {
    *   constructor(@Optional() aService:MyService) {
@@ -3373,66 +3490,66 @@ declare module ng {
    * ```
    */
   class OptionalMetadata {
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * A marker metadata that marks a class as available to `Injector` for creation. Used by tooling
    * for generating constructor stubs.
-   * 
+   *
    * ```
    * class NeedsService {
    *   constructor(svc:UsefulService) {}
    * }
-   * 
+   *
    * @Injectable
    * class UsefulService {}
    * ```
    */
   class InjectableMetadata {
   }
-  
+
 
   /**
    * Specifies that an injector should retrieve a dependency from itself.
-   * 
+   *
    * ## Example
-   * 
+   *
    * ```
    * class Dependency {
    * }
-   * 
+   *
    * class NeedsDependency {
    *   constructor(public @Self() dependency:Dependency) {}
    * }
-   * 
+   *
    * var inj = Injector.resolveAndCreate([Dependency, NeedsDependency]);
    * var nd = inj.get(NeedsDependency);
    * expect(nd.dependency).toBeAnInstanceOf(Dependency);
    * ```
    */
   class SelfMetadata {
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * Specifies that an injector should retrieve a dependency from any injector until reaching the
    * closest host.
-   * 
+   *
    * ## Example
-   * 
+   *
    * ```
    * class Dependency {
    * }
-   * 
+   *
    * class NeedsDependency {
    *   constructor(public @Host() dependency:Dependency) {}
    * }
-   * 
+   *
    * var parent = Injector.resolveAndCreate([
    *   bind(Dependency).toClass(HostDependency)
    * ]);
@@ -3443,27 +3560,27 @@ declare module ng {
    * ```
    */
   class HostMetadata {
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * Specifies that the dependency resolution should start from the parent injector.
-   * 
+   *
    * ## Example
-   * 
-   * 
+   *
+   *
    * ```
    * class Service {}
-   * 
+   *
    * class ParentService implements Service {
    * }
-   * 
+   *
    * class ChildService implements Service {
    *   constructor(public @SkipSelf() parentService:Service) {}
    * }
-   * 
+   *
    * var parent = Injector.resolveAndCreate([
    *   bind(Service).toClass(ParentService)
    * ]);
@@ -3476,115 +3593,115 @@ declare module ng {
    * ```
    */
   class SkipSelfMetadata {
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * `DependencyMetadata is used by the framework to extend DI.
-   * 
+   *
    * Only metadata implementing `DependencyMetadata` are added to the list of dependency
    * properties.
-   * 
+   *
    * For example:
-   * 
+   *
    * ```
    * class Exclude extends DependencyMetadata {}
    * class NotDependencyProperty {}
-   * 
+   *
    * class AComponent {
    *   constructor(@Exclude @NotDependencyProperty aService:AService) {}
    * }
    * ```
-   * 
+   *
    * will create the following dependency:
-   * 
+   *
    * ```
    * new Dependency(Key.get(AService), [new Exclude()])
    * ```
-   * 
+   *
    * The framework can use `new Exclude()` to handle the `aService` dependency
    * in a specific way.
    */
   class DependencyMetadata {
-    
+
      token: any;
   }
-  
+
 
   /**
    * Allows to refer to references which are not yet defined.
-   * 
+   *
    * This situation arises when the key which we need te refer to for the purposes of DI is declared,
    * but not yet defined.
-   * 
+   *
    * ## Example:
-   * 
+   *
    * ```
    * class Door {
    *   // Incorrect way to refer to a reference which is defined later.
    *   // This fails because `Lock` is undefined at this point.
    *   constructor(lock:Lock) { }
-   * 
+   *
    *   // Correct way to refer to a reference which is defined later.
    *   // The reference needs to be captured in a closure.
    *   constructor(@Inject(forwardRef(() => Lock)) lock:Lock) { }
    * }
-   * 
+   *
    * // Only at this point the lock is defined.
    * class Lock {
    * }
    * ```
    */
   function forwardRef(forwardRefFn: ForwardRefFn) : Type ;
-  
+
 
   /**
    * Lazily retrieve the reference value.
-   * 
+   *
    * See: {@link forwardRef}
    */
   function resolveForwardRef(type: any) : any ;
-  
+
   interface ForwardRefFn {
-    
+
      (): any;
-  
+
   }
-  
+
 
   /**
    * A dependency injection container used for resolving dependencies.
-   * 
+   *
    * An `Injector` is a replacement for a `new` operator, which can automatically resolve the
    * constructor dependencies.
    * In typical use, application code asks for the dependencies in the constructor and they are
    * resolved by the `Injector`.
-   * 
+   *
    * ## Example:
-   * 
+   *
    * Suppose that we want to inject an `Engine` into class `Car`, we would define it like this:
-   * 
+   *
    * ```javascript
    * class Engine {
    * }
-   * 
+   *
    * class Car {
    *   constructor(@Inject(Engine) engine) {
    *   }
    * }
-   * 
+   *
    * ```
-   * 
+   *
    * Next we need to write the code that creates and instantiates the `Injector`. We then ask for the
    * `root` object, `Car`, so that the `Injector` can recursively build all of that object's
    * dependencies.
-   * 
+   *
    * ```javascript
    * main() {
    *   var injector = Injector.resolveAndCreate([Car, Engine]);
-   * 
+   *
    *   // Get a reference to the `root` object, which will recursively instantiate the tree.
    *   var car = injector.get(Car);
    * }
@@ -3593,226 +3710,226 @@ declare module ng {
    * resolve all of the object's dependencies automatically.
    */
   class Injector {
-    
+
 
     /**
      * Turns a list of binding definitions into an internal resolved list of resolved bindings.
-     * 
+     *
      * A resolution is a process of flattening multiple nested lists and converting individual
      * bindings into a list of {@link ResolvedBinding}s. The resolution can be cached by `resolve`
      * for the {@link Injector} for performance-sensitive code.
-     * 
+     *
      * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
      * recursive list of more bindings.
-     * 
+     *
      * The returned list is sparse, indexed by `id` for the {@link Key}. It is generally not useful to
      * application code
      * other than for passing it to {@link Injector} functions that require resolved binding lists,
      * such as
      * `fromResolvedBindings` and `createChildFromResolved`.
      */
-     static resolve(bindings: List<Type | Binding | List<any>>): List<ResolvedBinding>;
-    
+     static resolve(bindings: Array<Type | Binding | any[]>): ResolvedBinding[];
+
 
     /**
      * Resolves bindings and creates an injector based on those bindings. This function is slower than
      * the corresponding `fromResolvedBindings` because it needs to resolve bindings first. See
      * `resolve`
      * for the {@link Injector}.
-     * 
+     *
      * Prefer `fromResolvedBindings` in performance-critical code that creates lots of injectors.
-     * 
+     *
      * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
      * recursive list of more
      * bindings.
      * @param `depProvider`
      */
-     static resolveAndCreate(bindings: List<Type | Binding | List<any>>, depProvider?: DependencyProvider): Injector;
-    
+     static resolveAndCreate(bindings: Array<Type | Binding | any[]>, depProvider?: DependencyProvider): Injector;
+
 
     /**
      * Creates an injector from previously resolved bindings. This bypasses resolution and flattening.
      * This API is the recommended way to construct injectors in performance-sensitive parts.
-     * 
+     *
      * @param `bindings` A sparse list of {@link ResolvedBinding}s. See `resolve` for the
      * {@link Injector}.
      * @param `depProvider`
      */
-     static fromResolvedBindings(bindings: List<ResolvedBinding>, depProvider?: DependencyProvider): Injector;
-    
+     static fromResolvedBindings(bindings: ResolvedBinding[], depProvider?: DependencyProvider): Injector;
+
 
     /**
      * Returns debug information about the injector.
-     * 
+     *
      * This information is included into exceptions thrown by the injector.
      */
      debugContext(): any;
-    
+
 
     /**
      * Retrieves an instance from the injector.
-     * 
+     *
      * @param `token`: usually the `Type` of an object. (Same as the token used while setting up a
      * binding).
      * @returns an instance represented by the token. Throws if not found.
      */
      get(token: any): any;
-    
+
 
     /**
      * Retrieves an instance from the injector.
-     * 
+     *
      * @param `token`: usually a `Type`. (Same as the token used while setting up a binding).
      * @returns an instance represented by the token. Returns `null` if not found.
      */
      getOptional(token: any): any;
-    
+
 
     /**
      * Retrieves an instance from the injector.
-     * 
+     *
      * @param `index`: index of an instance.
      * @returns an instance represented by the index. Throws if not found.
      */
      getAt(index: number): any;
-    
+
 
     /**
      * Direct parent of this injector.
      */
      parent: Injector;
-    
+
 
     /**
      * Internal. Do not use.
-     * 
+     *
      * We return `any` not to export the InjectorStrategy type.
      */
      internalStrategy: any;
-    
+
 
     /**
      * Creates a child injector and loads a new set of bindings into it.
-     * 
+     *
      * A resolution is a process of flattening multiple nested lists and converting individual
      * bindings into a list of {@link ResolvedBinding}s. The resolution can be cached by `resolve`
      * for the {@link Injector} for performance-sensitive code.
-     * 
+     *
      * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
      * recursive list of more bindings.
      * @param `depProvider`
      */
-     resolveAndCreateChild(bindings: List<Type | Binding | List<any>>, depProvider?: DependencyProvider): Injector;
-    
+     resolveAndCreateChild(bindings: Array<Type | Binding | any[]>, depProvider?: DependencyProvider): Injector;
+
 
     /**
      * Creates a child injector and loads a new set of {@link ResolvedBinding}s into it.
-     * 
+     *
      * @param `bindings`: A sparse list of {@link ResolvedBinding}s.
      * See `resolve` for the {@link Injector}.
      * @param `depProvider`
      * @returns a new child {@link Injector}.
      */
-     createChildFromResolved(bindings: List<ResolvedBinding>, depProvider?: DependencyProvider): Injector;
-    
+     createChildFromResolved(bindings: ResolvedBinding[], depProvider?: DependencyProvider): Injector;
+
 
     /**
      * Resolves a binding and instantiates an object in the context of the injector.
-     * 
+     *
      * @param `binding`: either a type or a binding.
      * @returns an object created using binding.
      */
      resolveAndInstantiate(binding: Type | Binding): any;
-    
+
 
     /**
      * Instantiates an object using a resolved bindin in the context of the injector.
-     * 
+     *
      * @param `binding`: a resolved binding
      * @returns an object created using binding.
      */
      instantiateResolved(binding: ResolvedBinding): any;
-    
+
      displayName: string;
-    
+
      toString(): string;
   }
-  
+
   class ProtoInjector {
-    
+
      numberOfBindings: number;
-    
+
      getBindingAtIndex(index: number): any;
   }
-  
+
   class BindingWithVisibility {
-    
+
      binding: ResolvedBinding;
-    
+
      visibility: Visibility;
-    
+
      getKeyId(): number;
   }
-  
+
 
   /**
    * Used to provide dependencies that cannot be easily expressed as bindings.
    */
   interface DependencyProvider {
-    
+
      getDependency(injector: Injector, binding: ResolvedBinding, dependency: Dependency): any;
   }
-  
+
   enum Visibility {
-    
+
      Public,
-    
+
      Private,
-    
+
      PublicAndPrivate
   }
-  
+
   const UNDEFINED : Object ;
-  
+
 
   /**
    * Describes how_ the {@link Injector} should instantiate a given token.
-   * 
+   *
    * See {@link bind}.
-   * 
+   *
    * ## Example
-   * 
+   *
    * ```javascript
    * var injector = Injector.resolveAndCreate([
    *   new Binding(String, { toValue: 'Hello' })
    * ]);
-   * 
+   *
    * expect(injector.get(String)).toEqual('Hello');
    * ```
    */
   class Binding {
-    
+
 
     /**
      * Token used when retrieving this binding. Usually the `Type`.
      */
      token: any;
-    
+
 
     /**
      * Binds an interface to an implementation / subclass.
-     * 
+     *
      * ## Example
-     * 
+     *
      * Becuse `toAlias` and `toClass` are often confused, the example contains both use cases for easy
      * comparison.
-     * 
+     *
      * ```javascript
-     * 
+     *
      * class Vehicle {}
-     * 
+     *
      * class Car extends Vehicle {}
-     * 
+     *
      * var injectorClass = Injector.resolveAndCreate([
      *   Car,
      *   new Binding(Vehicle, { toClass: Car })
@@ -3821,50 +3938,50 @@ declare module ng {
      *   Car,
      *   new Binding(Vehicle, { toAlias: Car })
      * ]);
-     * 
+     *
      * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
      * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
-     * 
+     *
      * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
      * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
      * ```
      */
      toClass: Type;
-    
+
 
     /**
      * Binds a key to a value.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```javascript
      * var injector = Injector.resolveAndCreate([
      *   new Binding(String, { toValue: 'Hello' })
      * ]);
-     * 
+     *
      * expect(injector.get(String)).toEqual('Hello');
      * ```
      */
      toValue: any;
-    
+
 
     /**
      * Binds a key to the alias for an existing key.
-     * 
+     *
      * An alias means that {@link Injector} returns the same instance as if the alias token was used.
      * This is in contrast to `toClass` where a separate instance of `toClass` is returned.
-     * 
+     *
      * ## Example
-     * 
+     *
      * Becuse `toAlias` and `toClass` are often confused the example contains both use cases for easy
      * comparison.
-     * 
+     *
      * ```javascript
-     * 
+     *
      * class Vehicle {}
-     * 
+     *
      * class Car extends Vehicle {}
-     * 
+     *
      * var injectorAlias = Injector.resolveAndCreate([
      *   Car,
      *   new Binding(Vehicle, { toAlias: Car })
@@ -3873,88 +3990,88 @@ declare module ng {
      *   Car,
      *   new Binding(Vehicle, { toClass: Car })
      * ]);
-     * 
+     *
      * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
      * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
-     * 
+     *
      * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
      * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
      * ```
      */
      toAlias: any;
-    
+
 
     /**
      * Binds a key to a function which computes the value.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```javascript
      * var injector = Injector.resolveAndCreate([
      *   new Binding(Number, { toFactory: () => { return 1+2; }}),
      *   new Binding(String, { toFactory: (value) => { return "Value: " + value; },
      *                         dependencies: [Number] })
      * ]);
-     * 
+     *
      * expect(injector.get(Number)).toEqual(3);
      * expect(injector.get(String)).toEqual('Value: 3');
      * ```
      */
      toFactory: Function;
-    
+
 
     /**
      * Used in conjunction with `toFactory` and specifies a set of dependencies
      * (as `token`s) which should be injected into the factory function.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```javascript
      * var injector = Injector.resolveAndCreate([
      *   new Binding(Number, { toFactory: () => { return 1+2; }}),
      *   new Binding(String, { toFactory: (value) => { return "Value: " + value; },
      *                         dependencies: [Number] })
      * ]);
-     * 
+     *
      * expect(injector.get(Number)).toEqual(3);
      * expect(injector.get(String)).toEqual('Value: 3');
      * ```
      */
-     dependencies: List<any>;
-    
+     dependencies: any[];
+
 
     /**
      * Converts the {@link Binding} into {@link ResolvedBinding}.
-     * 
+     *
      * {@link Injector} internally only uses {@link ResolvedBinding}, {@link Binding} contains
      * convenience binding syntax.
      */
      resolve(): ResolvedBinding;
   }
-  
+
 
   /**
    * Helper class for the {@link bind} function.
    */
   class BindingBuilder {
-    
+
      token: any;
-    
+
 
     /**
      * Binds an interface to an implementation / subclass.
-     * 
+     *
      * ## Example
-     * 
+     *
      * Because `toAlias` and `toClass` are often confused, the example contains both use cases for
      * easy comparison.
-     * 
+     *
      * ```javascript
-     * 
+     *
      * class Vehicle {}
-     * 
+     *
      * class Car extends Vehicle {}
-     * 
+     *
      * var injectorClass = Injector.resolveAndCreate([
      *   Car,
      *   bind(Vehicle).toClass(Car)
@@ -3963,50 +4080,50 @@ declare module ng {
      *   Car,
      *   bind(Vehicle).toAlias(Car)
      * ]);
-     * 
+     *
      * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
      * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
-     * 
+     *
      * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
      * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
      * ```
      */
      toClass(type: Type): Binding;
-    
+
 
     /**
      * Binds a key to a value.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```javascript
      * var injector = Injector.resolveAndCreate([
      *   bind(String).toValue('Hello')
      * ]);
-     * 
+     *
      * expect(injector.get(String)).toEqual('Hello');
      * ```
      */
      toValue(value: any): Binding;
-    
+
 
     /**
      * Binds a key to the alias for an existing key.
-     * 
+     *
      * An alias means that we will return the same instance as if the alias token was used. (This is
      * in contrast to `toClass` where a separate instance of `toClass` will be returned.)
-     * 
+     *
      * ## Example
-     * 
+     *
      * Becuse `toAlias` and `toClass` are often confused, the example contains both use cases for easy
      * comparison.
-     * 
+     *
      * ```javascript
-     * 
+     *
      * class Vehicle {}
-     * 
+     *
      * class Car extends Vehicle {}
-     * 
+     *
      * var injectorAlias = Injector.resolveAndCreate([
      *   Car,
      *   bind(Vehicle).toAlias(Car)
@@ -4015,151 +4132,151 @@ declare module ng {
      *   Car,
      *   bind(Vehicle).toClass(Car)
      * ]);
-     * 
+     *
      * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
      * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
-     * 
+     *
      * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
      * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
      * ```
      */
      toAlias(aliasToken: /*Type*/ any): Binding;
-    
+
 
     /**
      * Binds a key to a function which computes the value.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```javascript
      * var injector = Injector.resolveAndCreate([
      *   bind(Number).toFactory(() => { return 1+2; }),
      *   bind(String).toFactory((v) => { return "Value: " + v; }, [Number])
      * ]);
-     * 
+     *
      * expect(injector.get(Number)).toEqual(3);
      * expect(injector.get(String)).toEqual('Value: 3');
      * ```
      */
-     toFactory(factoryFunction: Function, dependencies?: List<any>): Binding;
+     toFactory(factoryFunction: Function, dependencies?: any[]): Binding;
   }
-  
+
 
   /**
    * An internal resolved representation of a {@link Binding} used by the {@link Injector}.
-   * 
+   *
    * A {@link Binding} is resolved when it has a factory function. Binding to a class, alias, or
    * value, are just convenience methods, as {@link Injector} only operates on calling factory
    * functions.
    */
   class ResolvedBinding {
-    
+
 
     /**
      * A key, usually a `Type`.
      */
      key: Key;
-    
+
 
     /**
      * Factory function which can return an instance of an object represented by a key.
      */
      factory: Function;
-    
+
 
     /**
      * Arguments (dependencies) to the `factory` function.
      */
-     dependencies: List<Dependency>;
+     dependencies: Dependency[];
   }
-  
+
 
   /**
    * @private
    */
   class Dependency {
-    
+
      static fromKey(key: Key): Dependency;
-    
+
      key: Key;
-    
+
      optional: boolean;
-    
+
      lowerBoundVisibility: any;
-    
+
      upperBoundVisibility: any;
-    
-     properties: List<any>;
+
+     properties: any[];
   }
-  
+
 
   /**
    * Provides an API for imperatively constructing {@link Binding}s.
-   * 
+   *
    * This is only relevant for JavaScript. See {@link BindingBuilder}.
-   * 
+   *
    * ## Example
-   * 
+   *
    * ```javascript
    * bind(MyInterface).toClass(MyClass)
-   * 
+   *
    * ```
    */
   function bind(token: any) : BindingBuilder ;
-  
+
 
   /**
    * A unique object used for retrieving items from the {@link Injector}.
-   * 
+   *
    * Keys have:
    * - a system-wide unique `id`.
    * - a `token`, usually the `Type` of the instance.
-   * 
+   *
    * Keys are used internally by the {@link Injector} because their system-wide unique `id`s allow the
    * injector to index in arrays rather than looking up items in maps.
    */
   class Key {
-    
+
 
     /**
      * Retrieves a `Key` for a token.
      */
      static get(token: Object): Key;
-    
+
 
     /**
      * @returns the number of keys registered in the system.
      */
      static numberOfKeys: number;
-    
+
      token: Object;
-    
+
      id: number;
-    
+
      displayName: string;
   }
-  
+
 
   /**
    * @private
    */
   class KeyRegistry {
-    
+
      get(token: Object): Key;
-    
+
      numberOfKeys: number;
   }
-  
+
 
   /**
    * Type literals is a Dart-only feature. This is here only so we can x-compile
    * to multiple languages.
    */
   class TypeLiteral {
-    
+
      type: any;
   }
-  
+
 
   /**
    * Thrown when trying to retrieve a dependency by `Key` from {@link Injector}, but the
@@ -4167,36 +4284,36 @@ declare module ng {
    */
   class NoBindingError extends AbstractBindingError {
   }
-  
+
 
   /**
    * Base class for all errors arising from misconfigured bindings.
    */
   class AbstractBindingError extends BaseException {
-    
+
      name: string;
-    
+
      message: string;
-    
-     keys: List<Key>;
-    
-     injectors: List<Injector>;
-    
+
+     keys: Key[];
+
+     injectors: Injector[];
+
      constructResolvingMessage: Function;
-    
+
      addKey(injector: Injector, key: Key): void;
-    
+
      context: any;
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * Thrown when dependencies form a cycle.
-   * 
+   *
    * ## Example:
-   * 
+   *
    * ```javascript
    * class A {
    *   constructor(b:B) {}
@@ -4205,195 +4322,195 @@ declare module ng {
    *   constructor(a:A) {}
    * }
    * ```
-   * 
+   *
    * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.
    */
   class CyclicDependencyError extends AbstractBindingError {
   }
-  
+
 
   /**
    * Thrown when a constructing type returns with an Error.
-   * 
+   *
    * The `InstantiationError` class contains the original error plus the dependency graph which caused
    * this object to be instantiated.
    */
   class InstantiationError extends AbstractBindingError {
-    
+
      causeKey: Key;
   }
-  
+
 
   /**
    * Thrown when an object other then {@link Binding} (or `Type`) is passed to {@link Injector}
    * creation.
    */
   class InvalidBindingError extends BaseException {
-    
+
      message: string;
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * Thrown when the class has no annotation information.
-   * 
+   *
    * Lack of annotation information prevents the {@link Injector} from determining which dependencies
    * need to be injected into the constructor.
    */
   class NoAnnotationError extends BaseException {
-    
+
      name: string;
-    
+
      message: string;
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * Thrown when getting an object by index.
    */
   class OutOfBoundsError extends BaseException {
-    
+
      message: string;
-    
+
      toString(): string;
   }
-  
+
   class OpaqueToken {
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * Factory for creating {@link InjectMetadata}.
    */
   interface InjectFactory {
-    
+
      new(token: any): InjectMetadata;
-  
-    
+
+
      (token: any): any;
-  
+
   }
-  
+
 
   /**
    * Factory for creating {@link OptionalMetadata}.
    */
   interface OptionalFactory {
-    
+
      new(): OptionalMetadata;
-  
-    
+
+
      (): any;
-  
+
   }
-  
+
 
   /**
    * Factory for creating {@link InjectableMetadata}.
    */
   interface InjectableFactory {
-    
+
      new(): InjectableMetadata;
-  
-    
+
+
      (): any;
-  
+
   }
-  
+
 
   /**
    * Factory for creating {@link SelfMetadata}.
    */
   interface SelfFactory {
-    
+
      new(): SelfMetadata;
-  
-    
+
+
      (): any;
-  
+
   }
-  
+
 
   /**
    * Factory for creating {@link HostMetadata}.
    */
   interface HostFactory {
-    
+
      new(): HostMetadata;
-  
-    
+
+
      (): any;
-  
+
   }
-  
+
 
   /**
    * Factory for creating {@link SkipSelfMetadata}.
    */
   interface SkipSelfFactory {
-    
+
      new(): SkipSelfMetadata;
-  
-    
+
+
      (): any;
-  
+
   }
-  
+
 
   /**
    * Factory for creating {@link InjectMetadata}.
    */
   var Inject : InjectFactory ;
-  
+
 
   /**
    * Factory for creating {@link OptionalMetadata}.
    */
   var Optional : OptionalFactory ;
-  
+
 
   /**
    * Factory for creating {@link InjectableMetadata}.
    */
   var Injectable : InjectableFactory ;
-  
+
 
   /**
    * Factory for creating {@link SelfMetadata}.
    */
   var Self : SelfFactory ;
-  
+
 
   /**
    * Factory for creating {@link HostMetadata}.
    */
   var Host : HostFactory ;
-  
+
 
   /**
    * Factory for creating {@link SkipSelfMetadata}.
    */
   var SkipSelf : SkipSelfFactory ;
-  
+
 
   /**
    * A collection of the Angular core directives that are likely to be used in each and every Angular
    * application.
-   * 
+   *
    * This collection can be used to quickly enumerate all the built-in directives in the `@View`
    * annotation. For example,
    * instead of writing:
-   * 
+   *
    * ```
    * import {NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault} from 'angular2/angular2';
    * import {OtherDirective} from 'myDirectives';
-   * 
+   *
    * @Component({
    *  selector: 'my-component'
    * })
@@ -4406,11 +4523,11 @@ declare module ng {
    * }
    * ```
    * one could import all the core directives at once:
-   * 
+   *
    * ```
    * import {CORE_DIRECTIVES} from 'angular2/angular2';
    * import {OtherDirective} from 'myDirectives';
-   * 
+   *
    * @Component({
    *  selector: 'my-component'
    * })
@@ -4423,12 +4540,12 @@ declare module ng {
    * }
    * ```
    */
-  const CORE_DIRECTIVES : List<Type> ;
-  
+  const CORE_DIRECTIVES : Type[] ;
+
 
   /**
    * Adds and removes CSS classes based on an {expression} value.
-   * 
+   *
    * The result of expression is used to add and remove CSS classes using the following logic,
    * based on expression's value type:
    * - {string} - all the CSS classes (space - separated) are added
@@ -4437,9 +4554,9 @@ declare module ng {
    * are interpreted as {boolean} expression. If a given expression
    * evaluates to {true} a corresponding CSS class is added - otherwise
    * it is removed.
-   * 
+   *
    * # Example:
-   * 
+   *
    * ```
    * <div class="message" [ng-class]="{error: errorCount > 0}">
    *     Please check errors.
@@ -4447,33 +4564,33 @@ declare module ng {
    * ```
    */
   class NgClass {
-    
+
      initialClasses: any;
-    
+
      rawClass: any;
-    
-     onCheck(): void;
-    
+
+     doCheck(): void;
+
      onDestroy(): void;
   }
-  
+
 
   /**
    * The `NgFor` directive instantiates a template once per item from an iterable. The context for
    * each instantiated template inherits from the outer context with the given loop variable set
    * to the current item from the iterable.
-   * 
+   *
    * It is possible to alias the `index` to a local variable that will be set to the current loop
    * iteration in the template context.
-   * 
+   *
    * When the contents of the iterator changes, `NgFor` makes the corresponding changes to the DOM:
-   * 
+   *
    * * When an item is added, a new instance of the template is added to the DOM.
    * * When an item is removed, its template instance is removed from the DOM.
    * * When items are reordered, their respective templates are reordered in the DOM.
-   * 
+   *
    * # Example
-   * 
+   *
    * ```
    * <ul>
    *   <li *ng-for="#error of errors; #i = index">
@@ -4481,48 +4598,48 @@ declare module ng {
    *   </li>
    * </ul>
    * ```
-   * 
+   *
    * # Syntax
-   * 
+   *
    * - `<li *ng-for="#item of items; #i = index">...</li>`
    * - `<li template="ng-for #item of items; #i = index">...</li>`
    * - `<template ng-for #item [ng-for-of]="items" #i="index"><li>...</li></template>`
    */
   class NgFor {
-    
-     static bulkRemove(tuples: List<RecordViewTuple>, viewContainer: ViewContainerRef): List<RecordViewTuple>;
-    
-     static bulkInsert(tuples: List<RecordViewTuple>, viewContainer: ViewContainerRef, templateRef: TemplateRef): List<RecordViewTuple>;
-    
+
+     static bulkRemove(tuples: RecordViewTuple[], viewContainer: ViewContainerRef): RecordViewTuple[];
+
+     static bulkInsert(tuples: RecordViewTuple[], viewContainer: ViewContainerRef, templateRef: TemplateRef): RecordViewTuple[];
+
      viewContainer: ViewContainerRef;
-    
+
      templateRef: TemplateRef;
-    
+
      iterableDiffers: IterableDiffers;
-    
+
      cdr: ChangeDetectorRef;
-    
+
      ngForOf: any;
-    
-     onCheck(): void;
+
+     doCheck(): void;
   }
-  
+
   class RecordViewTuple {
-    
+
      view: ViewRef;
-    
+
      record: any;
   }
-  
+
 
   /**
    * Removes or recreates a portion of the DOM tree based on an {expression}.
-   * 
+   *
    * If the expression assigned to `ng-if` evaluates to a false value then the element
    * is removed from the DOM, otherwise a clone of the element is reinserted into the DOM.
-   * 
+   *
    * # Example:
-   * 
+   *
    * ```
    * <div *ng-if="errorCount > 0" class="error">
    *   <!-- Error message displayed when the errorCount property on the current context is greater
@@ -4530,27 +4647,27 @@ declare module ng {
    *   {{errorCount}} errors detected
    * </div>
    * ```
-   * 
+   *
    * # Syntax
-   * 
+   *
    * - `<div *ng-if="condition">...</div>`
    * - `<div template="ng-if condition">...</div>`
    * - `<template [ng-if]="condition"><div>...</div></template>`
    */
   class NgIf {
-    
+
      ngIf: any;
   }
-  
+
 
   /**
    * The `NgNonBindable` directive tells Angular not to compile or bind the contents of the current
    * DOM element. This is useful if the element contains what appears to be Angular directives and
    * bindings but which should be ignored by Angular. This could be the case if you have a site that
    * displays snippets of code, for instance.
-   * 
+   *
    * Example:
-   * 
+   *
    * ```
    * <div>Normal: {{1 + 2}}</div> // output "Normal: 3"
    * <div ng-non-bindable>Ignored: {{1 + 2}}</div> // output "Ignored: {{1 + 2}}"
@@ -4558,50 +4675,50 @@ declare module ng {
    */
   class NgNonBindable {
   }
-  
+
 
   /**
    * Adds or removes styles based on an {expression}.
-   * 
+   *
    * When the expression assigned to `ng-style` evaluates to an object, the corresponding element
    * styles are updated. Style names to update are taken from the object keys and values - from the
    * corresponding object values.
-   * 
+   *
    * # Example:
-   * 
+   *
    * ```
    * <div [ng-style]="{'text-align': alignExp}"></div>
    * ```
-   * 
+   *
    * In the above example the `text-align` style will be updated based on the `alignExp` value
    * changes.
-   * 
+   *
    * # Syntax
-   * 
+   *
    * - `<div [ng-style]="{'text-align': alignExp}"></div>`
    * - `<div [ng-style]="styleExp"></div>`
    */
   class NgStyle {
-    
+
      rawStyle: any;
-    
-     onCheck(): void;
+
+     doCheck(): void;
   }
-  
+
   class SwitchView {
-    
+
      create(): void;
-    
+
      destroy(): void;
   }
-  
+
 
   /**
    * The `NgSwitch` directive is used to conditionally swap DOM structure on your template based on a
    * scope expression.
    * Elements within `NgSwitch` but without `NgSwitchWhen` or `NgSwitchDefault` directives will be
    * preserved at the location as specified in the template.
-   * 
+   *
    * `NgSwitch` simply chooses nested elements and makes them visible based on which element matches
    * the value obtained from the evaluated expression. In other words, you define a container element
    * (where you place the directive), place an expression on the **`[ng-switch]="..."` attribute**),
@@ -4610,9 +4727,9 @@ declare module ng {
    * The when attribute is used to inform NgSwitch which element to display when the expression is
    * evaluated. If a matching expression is not found via a when attribute then an element with the
    * default attribute is displayed.
-   * 
+   *
    * # Example:
-   * 
+   *
    * ```
    * <ANY [ng-switch]="expression">
    *   <template [ng-switch-when]="whenExpression1">...</template>
@@ -4622,115 +4739,115 @@ declare module ng {
    * ```
    */
   class NgSwitch {
-    
+
      ngSwitch: any;
   }
-  
+
 
   /**
    * Defines a case statement as an expression.
-   * 
+   *
    * If multiple `NgSwitchWhen` match the `NgSwitch` value, all of them are displayed.
-   * 
+   *
    * Example:
-   * 
+   *
    * ```
    * // match against a context variable
    * <template [ng-switch-when]="contextVariable">...</template>
-   * 
+   *
    * // match against a constant string
    * <template ng-switch-when="stringValue">...</template>
    * ```
    */
   class NgSwitchWhen {
-    
+
      ngSwitchWhen: any;
   }
-  
+
 
   /**
    * Defines a default case statement.
-   * 
+   *
    * Default case statements are displayed when no `NgSwitchWhen` match the `ng-switch` value.
-   * 
+   *
    * Example:
-   * 
+   *
    * ```
    * <template ng-switch-default>...</template>
    * ```
    */
   class NgSwitchDefault {
   }
-  
+
 
   /**
    * Omitting from external API doc as this is really an abstract internal concept.
    */
   class AbstractControl {
-    
+
      validator: Function;
-    
+
      value: any;
-    
+
      status: string;
-    
+
      valid: boolean;
-    
+
      errors: StringMap<string, any>;
-    
+
      pristine: boolean;
-    
+
      dirty: boolean;
-    
+
      touched: boolean;
-    
+
      untouched: boolean;
-    
+
      valueChanges: Observable;
-    
+
      markAsTouched(): void;
-    
+
      markAsDirty({onlySelf}?: {onlySelf?: boolean}): void;
-    
+
      setParent(parent: ControlGroup | ControlArray): void;
-    
+
      updateValidity({onlySelf}?: {onlySelf?: boolean}): void;
-    
+
      updateValueAndValidity({onlySelf, emitEvent}?: {onlySelf?: boolean, emitEvent?: boolean}): void;
-    
-     find(path: List<string | number>| string): AbstractControl;
-    
-     getError(errorCode: string, path?: List<string>): any;
-    
-     hasError(errorCode: string, path?: List<string>): boolean;
+
+     find(path: Array<string | number>| string): AbstractControl;
+
+     getError(errorCode: string, path?: string[]): any;
+
+     hasError(errorCode: string, path?: string[]): boolean;
   }
-  
+
 
   /**
    * Defines a part of a form that cannot be divided into other controls.
-   * 
+   *
    * `Control` is one of the three fundamental building blocks used to define forms in Angular, along
    * with
    * {@link ControlGroup} and {@link ControlArray}.
    */
   class Control extends AbstractControl {
-    
+
      updateValue(value: any, {onlySelf, emitEvent, emitModelToViewChange}?:
                   {onlySelf?: boolean, emitEvent?: boolean, emitModelToViewChange?: boolean}): void;
-    
+
      registerOnChange(fn: Function): void;
   }
-  
+
 
   /**
    * Defines a part of a form, of fixed length, that can contain other controls.
-   * 
+   *
    * A ControlGroup aggregates the values and errors of each {@link Control} in the group. Thus, if
    * one of the controls
    * in a group is invalid, the entire group is invalid. Similarly, if a control changes its value,
    * the entire group
    * changes as well.
-   * 
+   *
    * `ControlGroup` is one of the three fundamental building blocks used to define forms in Angular,
    * along with
    * {@link Control} and {@link ControlArray}. {@link ControlArray} can also contain other controls,
@@ -4738,118 +4855,118 @@ declare module ng {
    * length.
    */
   class ControlGroup extends AbstractControl {
-    
+
      controls: StringMap<string, AbstractControl>;
-    
+
      addControl(name: string, c: AbstractControl): void;
-    
+
      removeControl(name: string): void;
-    
+
      include(controlName: string): void;
-    
+
      exclude(controlName: string): void;
-    
+
      contains(controlName: string): boolean;
   }
-  
+
 
   /**
    * Defines a part of a form, of variable length, that can contain other controls.
-   * 
+   *
    * A `ControlArray` aggregates the values and errors of each {@link Control} in the group. Thus, if
    * one of the controls
    * in a group is invalid, the entire group is invalid. Similarly, if a control changes its value,
    * the entire group
    * changes as well.
-   * 
+   *
    * `ControlArray` is one of the three fundamental building blocks used to define forms in Angular,
    * along with {@link Control} and {@link ControlGroup}. {@link ControlGroup} can also contain
    * other controls, but is of fixed length.
    */
   class ControlArray extends AbstractControl {
-    
-     controls: List<AbstractControl>;
-    
+
+     controls: AbstractControl[];
+
      at(index: number): AbstractControl;
-    
+
      push(control: AbstractControl): void;
-    
+
      insert(index: number, control: AbstractControl): void;
-    
+
      removeAt(index: number): void;
-    
+
      length: number;
   }
-  
+
   class AbstractControlDirective {
-    
+
      control: AbstractControl;
-    
+
      value: any;
-    
+
      valid: boolean;
-    
+
      errors: StringMap<string, any>;
-    
+
      pristine: boolean;
-    
+
      dirty: boolean;
-    
+
      touched: boolean;
-    
+
      untouched: boolean;
   }
-  
+
 
   /**
    * An interface that {@link NgFormModel} and {@link NgForm} implement.
-   * 
+   *
    * Only used by the forms module.
    */
   interface Form {
-    
+
      addControl(dir: NgControl): void;
-    
+
      removeControl(dir: NgControl): void;
-    
+
      getControl(dir: NgControl): Control;
-    
+
      addControlGroup(dir: NgControlGroup): void;
-    
+
      removeControlGroup(dir: NgControlGroup): void;
-    
+
      getControlGroup(dir: NgControlGroup): ControlGroup;
-    
+
      updateModel(dir: NgControl, value: any): void;
   }
-  
+
 
   /**
    * A directive that contains a group of [NgControl].
-   * 
+   *
    * Only used by the forms module.
    */
   class ControlContainer extends AbstractControlDirective {
-    
+
      name: string;
-    
+
      formDirective: Form;
-    
-     path: List<string>;
+
+     path: string[];
   }
-  
+
 
   /**
    * Creates and binds a control with a specified name to a DOM element.
-   * 
+   *
    * This directive can only be used as a child of {@link NgForm} or {@link NgFormModel}.
-   * 
+   *
    * # Example
-   * 
+   *
    * In this example, we create the login and password controls.
    * We can work with each control separately: check its validity, get its value, listen to its
    *  changes.
-   * 
+   *
    *  ```
    * @Component({selector: "login-comp"})
    * @View({
@@ -4858,9 +4975,9 @@ declare module ng {
    *              <form #f="form" (submit)='onLogIn(f.value)'>
    *                Login <input type='text' ng-control='login' #l="form">
    *                <div *ng-if="!l.valid">Login is invalid</div>
-   * 
+   *
    *                Password <input type='password' ng-control='password'>
-   * 
+   *
    *                <button type='submit'>Log in!</button>
    *              </form>
    *      `})
@@ -4870,9 +4987,9 @@ declare module ng {
    *  }
    * }
    *  ```
-   * 
+   *
    * We can also use ng-model to bind a domain model to the form.
-   * 
+   *
    *  ```
    * @Component({selector: "login-comp"})
    * @View({
@@ -4887,7 +5004,7 @@ declare module ng {
    *      `})
    * class LoginComp {
    *  credentials: {login:string, password:string};
-   * 
+   *
    *  onLogIn() {
    *    // this.credentials.login === "some login"
    *    // this.credentials.password === "some password"
@@ -4896,42 +5013,42 @@ declare module ng {
    *  ```
    */
   class NgControlName extends NgControl {
-    
+
      update: any;
-    
+
      model: any;
-    
+
      viewModel: any;
-    
+
      ngValidators: QueryList<NgValidator>;
-    
-     onChange(c: StringMap<string, any>): void;
-    
+
+     onChanges(c: StringMap<string, any>): void;
+
      onDestroy(): void;
-    
+
      viewToModelUpdate(newValue: any): void;
-    
-     path: List<string>;
-    
+
+     path: string[];
+
      formDirective: any;
-    
+
      control: Control;
-    
+
      validator: Function;
   }
-  
+
 
   /**
    * Binds an existing control to a DOM element.
-   * 
+   *
    * # Example
-   * 
+   *
    * In this example, we bind the control to an input element. When the value of the input element
    * changes, the value of
    * the control will reflect that change. Likewise, if the value of the control changes, the input
    * element reflects that
    * change.
-   * 
+   *
    *  ```
    * @Component({selector: "login-comp"})
    * @View({
@@ -4940,16 +5057,16 @@ declare module ng {
    *      })
    * class LoginComp {
    *  loginControl:Control;
-   * 
+   *
    *  constructor() {
    *    this.loginControl = new Control('');
    *  }
    * }
-   * 
+   *
    *  ```
-   * 
+   *
    * We can also use ng-model to bind a domain model to the form.
-   * 
+   *
    *  ```
    * @Component({selector: "login-comp"})
    * @View({
@@ -4959,7 +5076,7 @@ declare module ng {
    * class LoginComp {
    *  loginControl:Control;
    *  login:string;
-   * 
+   *
    *  constructor() {
    *    this.loginControl = new Control('');
    *  }
@@ -4967,32 +5084,32 @@ declare module ng {
    *  ```
    */
   class NgFormControl extends NgControl {
-    
+
      form: Control;
-    
+
      update: any;
-    
+
      model: any;
-    
+
      viewModel: any;
-    
+
      ngValidators: QueryList<NgValidator>;
-    
-     onChange(c: StringMap<string, any>): void;
-    
-     path: List<string>;
-    
+
+     onChanges(c: StringMap<string, any>): void;
+
+     path: string[];
+
      control: Control;
-    
+
      validator: Function;
-    
+
      viewToModelUpdate(newValue: any): void;
   }
-  
+
 
   /**
    * Binds a domain model to the form.
-   * 
+   *
    * # Example
    *  ```
    * @Component({selector: "search-comp"})
@@ -5007,56 +5124,56 @@ declare module ng {
    *  ```
    */
   class NgModel extends NgControl {
-    
+
      update: any;
-    
+
      model: any;
-    
+
      viewModel: any;
-    
+
      ngValidators: QueryList<NgValidator>;
-    
-     onChange(c: StringMap<string, any>): void;
-    
+
+     onChanges(c: StringMap<string, any>): void;
+
      control: Control;
-    
-     path: List<string>;
-    
+
+     path: string[];
+
      validator: Function;
-    
+
      viewToModelUpdate(newValue: any): void;
   }
-  
+
 
   /**
    * An abstract class that all control directive extend.
-   * 
+   *
    * It binds a {@link Control} object to a DOM element.
    */
   class NgControl extends AbstractControlDirective {
-    
+
      name: string;
-    
+
      valueAccessor: ControlValueAccessor;
-    
+
      validator: Function;
-    
-     path: List<string>;
-    
+
+     path: string[];
+
      viewToModelUpdate(newValue: any): void;
   }
-  
+
 
   /**
    * Creates and binds a control group to a DOM element.
-   * 
+   *
    * This directive can only be used as a child of {@link NgForm} or {@link NgFormModel}.
-   * 
+   *
    * # Example
-   * 
+   *
    * In this example, we create the credentials and personal control groups.
    * We can work with each group separately: check its validity, get its value, listen to its changes.
-   * 
+   *
    *  ```
    * @Component({selector: "signup-comp"})
    * @View({
@@ -5068,7 +5185,7 @@ declare module ng {
    *                  Password <input type='password' ng-control='password'>
    *                </div>
    *                <div *ng-if="!credentials.valid">Credentials are invalid</div>
-   * 
+   *
    *                <div ng-control-group='personal'>
    *                  Name <input type='text' ng-control='name'>
    *                </div>
@@ -5081,32 +5198,32 @@ declare module ng {
    *    //  credentials: {login: 'some login', password: 'some password'}}
    *  }
    * }
-   * 
+   *
    *  ```
    */
   class NgControlGroup extends ControlContainer {
-    
+
      onInit(): void;
-    
+
      onDestroy(): void;
-    
+
      control: ControlGroup;
-    
-     path: List<string>;
-    
+
+     path: string[];
+
      formDirective: Form;
   }
-  
+
 
   /**
    * Binds an existing control group to a DOM element.
-   * 
+   *
    * # Example
-   * 
+   *
    * In this example, we bind the control group to the form element, and we bind the login and
    * password controls to the
    * login and password elements.
-   * 
+   *
    *  ```
    * @Component({selector: "login-comp"})
    * @View({
@@ -5119,23 +5236,23 @@ declare module ng {
    *      })
    * class LoginComp {
    *  loginForm:ControlGroup;
-   * 
+   *
    *  constructor() {
    *    this.loginForm = new ControlGroup({
    *      login: new Control(""),
    *      password: new Control("")
    *    });
    *  }
-   * 
+   *
    *  onLogin() {
    *    // this.loginForm.value
    *  }
    * }
-   * 
+   *
    *  ```
-   * 
+   *
    * We can also use ng-model to bind a domain model to the form.
-   * 
+   *
    *  ```
    * @Component({selector: "login-comp"})
    * @View({
@@ -5149,14 +5266,14 @@ declare module ng {
    * class LoginComp {
    *  credentials:{login:string, password:string}
    *  loginForm:ControlGroup;
-   * 
+   *
    *  constructor() {
    *    this.loginForm = new ControlGroup({
    *      login: new Control(""),
    *      password: new Control("")
    *    });
    *  }
-   * 
+   *
    *  onLogin() {
    *    // this.credentials.login === 'some login'
    *    // this.credentials.password === 'some password'
@@ -5165,44 +5282,44 @@ declare module ng {
    *  ```
    */
   class NgFormModel extends ControlContainer implements Form {
-    
+
      form: ControlGroup;
-    
-     directives: List<NgControl>;
-    
+
+     directives: NgControl[];
+
      ngSubmit: any;
-    
-     onChange(_: any): void;
-    
+
+     onChanges(_: any): void;
+
      formDirective: Form;
-    
+
      control: ControlGroup;
-    
-     path: List<string>;
-    
+
+     path: string[];
+
      addControl(dir: NgControl): void;
-    
+
      getControl(dir: NgControl): Control;
-    
+
      removeControl(dir: NgControl): void;
-    
+
      addControlGroup(dir: NgControlGroup): void;
-    
+
      removeControlGroup(dir: NgControlGroup): void;
-    
+
      getControlGroup(dir: NgControlGroup): ControlGroup;
-    
+
      updateModel(dir: NgControl, value: any): void;
-    
+
      onSubmit(): boolean;
   }
-  
+
 
   /**
    * Creates and binds a form object to a DOM element.
-   * 
+   *
    * # Example
-   * 
+   *
    *  ```
    * @Component({selector: "signup-comp"})
    * @View({
@@ -5214,7 +5331,7 @@ declare module ng {
    *                  Password <input type='password' ng-control='password'>
    *                </div>
    *                <div *ng-if="!credentials.valid">Credentials are invalid</div>
-   * 
+   *
    *                <div ng-control-group='personal'>
    *                  Name <input type='text' ng-control='name'>
    *                </div>
@@ -5227,142 +5344,142 @@ declare module ng {
    *    //  credentials: {login: 'some login', password: 'some password'}}
    *  }
    * }
-   * 
+   *
    *  ```
    */
   class NgForm extends ControlContainer implements Form {
-    
+
      form: ControlGroup;
-    
+
      ngSubmit: any;
-    
+
      formDirective: Form;
-    
+
      control: ControlGroup;
-    
-     path: List<string>;
-    
+
+     path: string[];
+
      controls: StringMap<string, AbstractControl>;
-    
+
      addControl(dir: NgControl): void;
-    
+
      getControl(dir: NgControl): Control;
-    
+
      removeControl(dir: NgControl): void;
-    
+
      addControlGroup(dir: NgControlGroup): void;
-    
+
      removeControlGroup(dir: NgControlGroup): void;
-    
+
      getControlGroup(dir: NgControlGroup): ControlGroup;
-    
+
      updateModel(dir: NgControl, value: any): void;
-    
+
      onSubmit(): boolean;
   }
-  
+
 
   /**
    * A bridge between a control and a native element.
-   * 
+   *
    * Please see {@link DefaultValueAccessor} for more information.
    */
   interface ControlValueAccessor {
-    
+
      writeValue(obj: any): void;
-    
+
      registerOnChange(fn: any): void;
-    
+
      registerOnTouched(fn: any): void;
   }
-  
+
 
   /**
    * The default accessor for writing a value and listening to changes that is used by the
    * {@link NgModel}, {@link NgFormControl}, and {@link NgControlName} directives.
-   * 
+   *
    *  # Example
    *  ```
    *  <input type="text" [(ng-model)]="searchQuery">
    *  ```
    */
   class DefaultValueAccessor implements ControlValueAccessor {
-    
+
      cd: NgControl;
-    
+
      onChange: any;
-    
+
      onTouched: any;
-    
+
      renderer: Renderer;
-    
+
      elementRef: ElementRef;
-    
+
      writeValue(value: any): void;
-    
+
      ngClassUntouched: boolean;
-    
+
      ngClassTouched: boolean;
-    
+
      ngClassPristine: boolean;
-    
+
      ngClassDirty: boolean;
-    
+
      ngClassValid: boolean;
-    
+
      ngClassInvalid: boolean;
-    
+
      registerOnChange(fn: (_: any) => void): void;
-    
+
      registerOnTouched(fn: () => void): void;
   }
-  
+
 
   /**
    * The accessor for writing a value and listening to changes on a checkbox input element.
-   * 
+   *
    *  # Example
    *  ```
    *  <input type="checkbox" [ng-control]="rememberLogin">
    *  ```
    */
   class CheckboxControlValueAccessor implements ControlValueAccessor {
-    
+
      cd: NgControl;
-    
+
      onChange: any;
-    
+
      onTouched: any;
-    
+
      renderer: Renderer;
-    
+
      elementRef: ElementRef;
-    
+
      writeValue(value: any): void;
-    
+
      ngClassUntouched: boolean;
-    
+
      ngClassTouched: boolean;
-    
+
      ngClassPristine: boolean;
-    
+
      ngClassDirty: boolean;
-    
+
      ngClassValid: boolean;
-    
+
      ngClassInvalid: boolean;
-    
+
      registerOnChange(fn: (_: any) => {}): void;
-    
+
      registerOnTouched(fn: () => {}): void;
   }
-  
+
 
   /**
    * Marks <option> as dynamic, so Angular can be notified when options change.
-   * 
+   *
    * #Example:
-   * 
+   *
    * ```
    * <select ng-control="city">
    *   <option *ng-for="#c of cities" [value]="c"></option>
@@ -5371,95 +5488,95 @@ declare module ng {
    */
   class NgSelectOption {
   }
-  
+
 
   /**
    * The accessor for writing a value and listening to changes on a select element.
    */
   class SelectControlValueAccessor implements ControlValueAccessor {
-    
+
      cd: NgControl;
-    
+
      value: string;
-    
+
      onChange: any;
-    
+
      onTouched: any;
-    
+
      renderer: Renderer;
-    
+
      elementRef: ElementRef;
-    
+
      writeValue(value: any): void;
-    
+
      ngClassUntouched: boolean;
-    
+
      ngClassTouched: boolean;
-    
+
      ngClassPristine: boolean;
-    
+
      ngClassDirty: boolean;
-    
+
      ngClassValid: boolean;
-    
+
      ngClassInvalid: boolean;
-    
+
      registerOnChange(fn: () => any): void;
-    
+
      registerOnTouched(fn: () => any): void;
   }
-  
+
 
   /**
    * A list of all the form directives used as part of a `@View` annotation.
-   * 
+   *
    *  This is a shorthand for importing them each individually.
    */
-  const FORM_DIRECTIVES : List<Type> ;
-  
+  const FORM_DIRECTIVES : Type[] ;
+
 
   /**
    * Provides a set of validators used by form controls.
-   * 
+   *
    * # Example
-   * 
+   *
    * ```
    * var loginControl = new Control("", Validators.required)
    * ```
    */
   class Validators {
-    
+
      static required(c:Control): StringMap<string, boolean>;
-    
+
      static nullValidator(c: any): StringMap<string, boolean>;
-    
-     static compose(validators: List<Function>): Function;
-    
+
+     static compose(validators: Function[]): Function;
+
      static group(c:ControlGroup): StringMap<string, boolean>;
-    
+
      static array(c:ControlArray): StringMap<string, boolean>;
   }
-  
+
   class NgValidator {
-    
+
      validator: Function;
   }
-  
+
   class NgRequiredValidator extends NgValidator {
-    
+
      validator: Function;
   }
-  
+
 
   /**
    * Creates a form object from a user-specified configuration.
-   * 
+   *
    * # Example
-   * 
+   *
    * ```
    * import {Component, View, bootstrap} from 'angular2/angular2';
    * import {FormBuilder, Validators, FORM_DIRECTIVES, ControlGroup} from 'angular2/forms';
-   * 
+   *
    * @Component({
    *   selector: 'login-comp',
    *   viewBindings: [
@@ -5470,7 +5587,7 @@ declare module ng {
    *   template: `
    *     <form [control-group]="loginForm">
    *       Login <input control="login">
-   * 
+   *
    *       <div control-group="passwordRetry">
    *         Password <input type="password" control="password">
    *         Confirm password <input type="password" control="passwordConfirmation">
@@ -5483,11 +5600,11 @@ declare module ng {
    * })
    * class LoginComp {
    *   loginForm: ControlGroup;
-   * 
+   *
    *   constructor(builder: FormBuilder) {
    *     this.loginForm = builder.group({
    *       login: ["", Validators.required],
-   * 
+   *
    *       passwordRetry: builder.group({
    *         password: ["", Validators.required],
    *         passwordConfirmation: ["", Validators.required]
@@ -5495,160 +5612,169 @@ declare module ng {
    *     });
    *   }
    * }
-   * 
+   *
    * bootstrap(LoginComp)
    * ```
-   * 
+   *
    * This example creates a {@link ControlGroup} that consists of a `login` {@link Control}, and a
    * nested
    * {@link ControlGroup} that defines a `password` and a `passwordConfirmation` {@link Control}:
-   * 
+   *
    * ```
    *  var loginForm = builder.group({
    *    login: ["", Validators.required],
-   * 
+   *
    *    passwordRetry: builder.group({
    *      password: ["", Validators.required],
    *      passwordConfirmation: ["", Validators.required]
    *    })
    *  });
-   * 
+   *
    *  ```
    */
   class FormBuilder {
-    
+
      group(controlsConfig: StringMap<string, any>, extra?: StringMap<string, any>): ControlGroup;
-    
+
      control(value: Object, validator?: Function): Control;
-    
-     array(controlsConfig: List<any>, validator?: Function): ControlArray;
+
+     array(controlsConfig: any[], validator?: Function): ControlArray;
   }
-  
-  const FORM_BINDINGS : List<Type> ;
-  
+
+  const FORM_BINDINGS : Type[] ;
+
   class RenderDirectiveMetadata {
-    
+
      static DIRECTIVE_TYPE: any;
-    
+
      static COMPONENT_TYPE: any;
-    
+
      static create({id, selector, compileChildren, events, host, properties, readAttributes, type,
-                 callOnDestroy, callOnChange, callOnCheck, callOnInit, callOnAllChangesDone,
-                 changeDetection, exportAs}: {
+                 callOnDestroy, callOnChanges, callDoCheck, callOnInit, callAfterContentInit,
+                 callAfterContentChecked, callAfterViewInit, callAfterViewChecked, changeDetection,
+                 exportAs}: {
     id?: string,
     selector?: string,
     compileChildren?: boolean,
-    events?: List<string>,
+    events?: string[],
     host?: Map<string, string>,
-    properties?: List<string>,
-    readAttributes?: List<string>,
+    properties?: string[],
+    readAttributes?: string[],
     type?: number,
     callOnDestroy?: boolean,
-    callOnChange?: boolean,
-    callOnCheck?: boolean,
+    callOnChanges?: boolean,
+    callDoCheck?: boolean,
     callOnInit?: boolean,
-    callOnAllChangesDone?: boolean,
-    changeDetection?: string,
+    callAfterContentInit?: boolean,
+    callAfterContentChecked?: boolean,
+    callAfterViewInit?: boolean,
+    callAfterViewChecked?: boolean,
+    changeDetection?: ChangeDetectionStrategy,
     exportAs?: string
   }): RenderDirectiveMetadata;
-    
+
      id: any;
-    
+
      selector: string;
-    
+
      compileChildren: boolean;
-    
-     events: List<string>;
-    
-     properties: List<string>;
-    
-     readAttributes: List<string>;
-    
+
+     events: string[];
+
+     properties: string[];
+
+     readAttributes: string[];
+
      type: number;
-    
+
      callOnDestroy: boolean;
-    
-     callOnChange: boolean;
-    
-     callOnCheck: boolean;
-    
+
+     callOnChanges: boolean;
+
+     callDoCheck: boolean;
+
      callOnInit: boolean;
-    
-     callOnAllChangesDone: boolean;
-    
-     changeDetection: string;
-    
+
+     callAfterContentInit: boolean;
+
+     callAfterContentChecked: boolean;
+
+     callAfterViewInit: boolean;
+
+     callAfterViewChecked: boolean;
+
+     changeDetection: ChangeDetectionStrategy;
+
      exportAs: string;
-    
+
      hostListeners: Map<string, string>;
-    
+
      hostProperties: Map<string, string>;
-    
+
      hostAttributes: Map<string, string>;
-    
-     hostActions: Map<string, string>;
   }
-  
+
   class DomRenderer extends Renderer {
-    
+
      createRootHostView(hostProtoViewRef: RenderProtoViewRef, fragmentCount: number, hostElementSelector: string): RenderViewWithFragments;
-    
+
      createView(protoViewRef: RenderProtoViewRef, fragmentCount: number): RenderViewWithFragments;
-    
+
      destroyView(viewRef: RenderViewRef): void;
-    
+
      getNativeElementSync(location: RenderElementRef): any;
-    
-     getRootNodes(fragment: RenderFragmentRef): List<Node>;
-    
+
+     getRootNodes(fragment: RenderFragmentRef): Node[];
+
      attachFragmentAfterFragment(previousFragmentRef: RenderFragmentRef, fragmentRef: RenderFragmentRef): void;
-    
+
      attachFragmentAfterElement(elementRef: RenderElementRef, fragmentRef: RenderFragmentRef): void;
-    
+
      detachFragment(fragmentRef: RenderFragmentRef): void;
-    
+
      hydrateView(viewRef: RenderViewRef): void;
-    
+
      dehydrateView(viewRef: RenderViewRef): void;
-    
+
      setElementProperty(location: RenderElementRef, propertyName: string, propertyValue: any): void;
-    
+
      setElementAttribute(location: RenderElementRef, attributeName: string, attributeValue: string): void;
-    
+
      setElementClass(location: RenderElementRef, className: string, isAdd: boolean): void;
-    
+
      setElementStyle(location: RenderElementRef, styleName: string, styleValue: string): void;
-    
-     invokeElementMethod(location: RenderElementRef, methodName: string, args: List<any>): void;
-    
+
+     invokeElementMethod(location: RenderElementRef, methodName: string, args: any[]): void;
+
      setText(viewRef: RenderViewRef, textNodeIndex: number, text: string): void;
-    
+
      setEventDispatcher(viewRef: RenderViewRef, dispatcher: any): void;
   }
-  
+
 
   /**
    * A dispatcher for all events happening in a view.
    */
   interface RenderEventDispatcher {
-    
+
 
     /**
      * Called when an event was triggered for a on-* attribute on an element.
      * @param {Map<string, any>} locals Locals to be used to evaluate the
      *   event expressions
+     * @return {boolean} False if `preventDefault` should be called on the DOM event.
      */
-     dispatchRenderEvent(elementIndex: number, eventName: string, locals: Map<string, any>): void;
+     dispatchRenderEvent(elementIndex: number, eventName: string, locals: Map<string, any>): boolean;
   }
-  
+
   class Renderer {
-    
+
 
     /**
      * Creates a root host view that includes the given element.
      * Note that the fragmentCount needs to be passed in so that we can create a result
      * synchronously even when dealing with webworkers!
-     * 
+     *
      * @param {RenderProtoViewRef} hostProtoViewRef a RenderProtoViewRef of type
      * ProtoViewDto.HOST_VIEW_TYPE
      * @param {any} hostElementSelector css selector for the host element (will be queried against the
@@ -5656,7 +5782,7 @@ declare module ng {
      * @return {RenderViewWithFragments} the created view including fragments
      */
      createRootHostView(hostProtoViewRef: RenderProtoViewRef, fragmentCount: number, hostElementSelector: string): RenderViewWithFragments;
-    
+
 
     /**
      * Creates a regular view out of the given ProtoView.
@@ -5664,187 +5790,187 @@ declare module ng {
      * synchronously even when dealing with webworkers!
      */
      createView(protoViewRef: RenderProtoViewRef, fragmentCount: number): RenderViewWithFragments;
-    
+
 
     /**
      * Destroys the given view after it has been dehydrated and detached
      */
      destroyView(viewRef: RenderViewRef): void;
-    
+
 
     /**
      * Attaches a fragment after another fragment.
      */
      attachFragmentAfterFragment(previousFragmentRef: RenderFragmentRef, fragmentRef: RenderFragmentRef): void;
-    
+
 
     /**
      * Attaches a fragment after an element.
      */
      attachFragmentAfterElement(elementRef: RenderElementRef, fragmentRef: RenderFragmentRef): void;
-    
+
 
     /**
      * Detaches a fragment.
      */
      detachFragment(fragmentRef: RenderFragmentRef): void;
-    
+
 
     /**
      * Hydrates a view after it has been attached. Hydration/dehydration is used for reusing views
      * inside of the view pool.
      */
      hydrateView(viewRef: RenderViewRef): void;
-    
+
 
     /**
      * Dehydrates a view after it has been attached. Hydration/dehydration is used for reusing views
      * inside of the view pool.
      */
      dehydrateView(viewRef: RenderViewRef): void;
-    
+
 
     /**
      * Returns the native element at the given location.
      * Attention: In a WebWorker scenario, this should always return null!
      */
      getNativeElementSync(location: RenderElementRef): any;
-    
+
 
     /**
      * Sets a property on an element.
      */
      setElementProperty(location: RenderElementRef, propertyName: string, propertyValue: any): void;
-    
+
 
     /**
      * Sets an attribute on an element.
      */
      setElementAttribute(location: RenderElementRef, attributeName: string, attributeValue: string): void;
-    
+
 
     /**
      * Sets a class on an element.
      */
      setElementClass(location: RenderElementRef, className: string, isAdd: boolean): void;
-    
+
 
     /**
      * Sets a style on an element.
      */
      setElementStyle(location: RenderElementRef, styleName: string, styleValue: string): void;
-    
+
 
     /**
      * Calls a method on an element.
      */
-     invokeElementMethod(location: RenderElementRef, methodName: string, args: List<any>): void;
-    
+     invokeElementMethod(location: RenderElementRef, methodName: string, args: any[]): void;
+
 
     /**
      * Sets the value of a text node.
      */
      setText(viewRef: RenderViewRef, textNodeIndex: number, text: string): void;
-    
+
 
     /**
      * Sets the dispatcher for all events of the given view
      */
      setEventDispatcher(viewRef: RenderViewRef, dispatcher: RenderEventDispatcher): void;
   }
-  
+
 
   /**
    * Abstract reference to the element which can be marshaled across web-worker boundary.
-   * 
+   *
    * This interface is used by the Renderer API.
    */
   interface RenderElementRef {
-    
+
 
     /**
      * Reference to the `RenderViewRef` where the `RenderElementRef` is inside of.
      */
      renderView: RenderViewRef;
-    
+
 
     /**
      * Index of the element inside the `RenderViewRef`.
-     * 
+     *
      * This is used internally by the Angular framework to locate elements.
      */
      renderBoundElementIndex: number;
   }
-  
+
   class RenderViewRef {
   }
-  
+
   class RenderProtoViewRef {
   }
-  
+
   class RenderFragmentRef {
   }
-  
+
   class RenderViewWithFragments {
-    
+
      viewRef: RenderViewRef;
-    
+
      fragmentRefs: RenderFragmentRef[];
   }
-  
+
   class ViewDefinition {
-    
+
      componentId: string;
-    
+
      templateAbsUrl: string;
-    
+
      template: string;
-    
-     directives: List<RenderDirectiveMetadata>;
-    
-     styleAbsUrls: List<string>;
-    
-     styles: List<string>;
-    
+
+     directives: RenderDirectiveMetadata[];
+
+     styleAbsUrls: string[];
+
+     styles: string[];
+
      encapsulation: ViewEncapsulation;
   }
-  
+
   const DOCUMENT : OpaqueToken ;
-  
+
 
   /**
    * A unique id (string) for an angular application.
    */
   const APP_ID : OpaqueToken ;
-  
+
 
   /**
    * Defines when a compiled template should be stored as a string
    * rather than keeping its Nodes to preserve memory.
    */
   const MAX_IN_MEMORY_ELEMENTS_PER_TEMPLATE : OpaqueToken ;
-  
+
 
   /**
    * Create trace scope.
-   * 
+   *
    * Scopes must be strictly nested and are analogous to stack frames, but
    * do not have to follow the stack frames. Instead it is recommended that they follow logical
    * nesting. You may want to use
    * [Event
    * Signatures](http://google.github.io/tracing-framework/instrumenting-code.html#custom-events)
    * as they are defined in WTF.
-   * 
+   *
    * Used to mark scope entry. The return value is used to leave the scope.
-   * 
-   *     final myScope = wtfCreateScope('MyClass#myMethod(ascii someVal)');
-   * 
+   *
+   *     var myScope = wtfCreateScope('MyClass#myMethod(ascii someVal)');
+   *
    *     someMethod() {
    *        var s = myScope('Foo'); // 'Foo' gets stored in tracing UI
    *        // DO SOME WORK HERE
    *        return wtfLeave(s, 123); // Return value 123
    *     }
-   * 
+   *
    * Note, adding try-finally block around the work to ensure that `wtfLeave` gets called can
    * negatively impact the performance of your application. For this reason we recommend that
    * you don't add them to ensure that `wtfLeave` gets called. In production `wtfLeave` is a noop and
@@ -5854,24 +5980,24 @@ declare module ng {
    * an exception is expected during normal execution while profiling.
    */
   var wtfCreateScope : WtfScopeFn ;
-  
+
 
   /**
    * Used to mark end of Scope.
-   * 
+   *
    * - `scope` to end.
    * - `returnValue` (optional) to be passed to the WTF.
-   * 
+   *
    * Returns the `returnValue for easy chaining.
    */
   var wtfLeave : <T>(scope: any, returnValue?: T) => T ;
-  
+
 
   /**
    * Used to mark Async start. Async are similar to scope but they don't have to be strictly nested.
    * The return value is used in the call to [endAsync]. Async ranges only work if WTF has been
    * enabled.
-   * 
+   *
    *     someMethod() {
    *        var s = wtfStartTimeRange('HTTP:GET', 'some.url');
    *        var future = new Future.delay(5).then((_) {
@@ -5880,7 +6006,7 @@ declare module ng {
    *     }
    */
   var wtfStartTimeRange : (rangeType: string, action: string) => any ;
-  
+
 
   /**
    * Ends a async time range operation.
@@ -5888,29 +6014,29 @@ declare module ng {
    * enabled.
    */
   var wtfEndTimeRange : (range: any) => void ;
-  
+
   interface WtfScopeFn {
-    
+
      (arg0?: any, arg1?: any): any;
-  
+
   }
-  
+
   var ChangeDetectorRef: InjectableReference;
-  
+
   var ApplicationRef: InjectableReference;
-  
+
   var Compiler: InjectableReference;
-  
+
   var AppViewManager: InjectableReference;
-  
+
   var ViewRef: InjectableReference;
-  
+
   var ProtoViewRef: InjectableReference;
-  
+
   var ViewContainerRef: InjectableReference;
-  
+
   var ComponentRef: InjectableReference;
-  
+
 }
 
 declare module "angular2/angular2" {
@@ -5918,3 +6044,6171 @@ declare module "angular2/angular2" {
 }
 
 
+
+declare module ngWorker {
+
+  /**
+   * Declare reusable UI building blocks for an application.
+   *
+   * Each Angular component requires a single `@Component` and at least one `@View` annotation. The
+   * `@Component`
+   * annotation specifies when a component is instantiated, and which properties and hostListeners it
+   * binds to.
+   *
+   * When a component is instantiated, Angular
+   * - creates a shadow DOM for the component.
+   * - loads the selected template into the shadow DOM.
+   * - creates all the injectable objects configured with `bindings` and `viewBindings`.
+   *
+   * All template expressions and statements are then evaluated against the component instance.
+   *
+   * For details on the `@View` annotation, see {@link ViewMetadata}.
+   *
+   * ## Example
+   *
+   * ```
+   * @Component({
+   *   selector: 'greet'
+   * })
+   * @View({
+   *   template: 'Hello {{name}}!'
+   * })
+   * class Greet {
+   *   name: string;
+   *
+   *   constructor() {
+   *     this.name = 'World';
+   *   }
+   * }
+   * ```
+   */
+  class ComponentMetadata extends DirectiveMetadata {
+
+
+    /**
+     * Defines the used change detection strategy.
+     *
+     * When a component is instantiated, Angular creates a change detector, which is responsible for
+     * propagating the component's bindings.
+     *
+     * The `changeDetection` property defines, whether the change detection will be checked every time
+     * or only when the component tells it to do so.
+     */
+     changeDetection: ChangeDetectionStrategy;
+
+
+    /**
+     * Defines the set of injectable objects that are visible to its view dom children.
+     *
+     * ## Simple Example
+     *
+     * Here is an example of a class that can be injected:
+     *
+     * ```
+     * class Greeter {
+     *    greet(name:string) {
+     *      return 'Hello ' + name + '!';
+     *    }
+     * }
+     *
+     * @Directive({
+     *   selector: 'needs-greeter'
+     * })
+     * class NeedsGreeter {
+     *   greeter:Greeter;
+     *
+     *   constructor(greeter:Greeter) {
+     *     this.greeter = greeter;
+     *   }
+     * }
+     *
+     * @Component({
+     *   selector: 'greet',
+     *   viewBindings: [
+     *     Greeter
+     *   ]
+     * })
+     * @View({
+     *   template: `<needs-greeter></needs-greeter>`,
+     *   directives: [NeedsGreeter]
+     * })
+     * class HelloWorld {
+     * }
+     *
+     * ```
+     */
+     viewBindings: any[];
+  }
+
+
+  /**
+   * Directives allow you to attach behavior to elements in the DOM.
+   *
+   * {@link DirectiveMetadata}s with an embedded view are called {@link ComponentMetadata}s.
+   *
+   * A directive consists of a single directive annotation and a controller class. When the
+   * directive's `selector` matches
+   * elements in the DOM, the following steps occur:
+   *
+   * 1. For each directive, the `ElementInjector` attempts to resolve the directive's constructor
+   * arguments.
+   * 2. Angular instantiates directives for each matched element using `ElementInjector` in a
+   * depth-first order,
+   *    as declared in the HTML.
+   *
+   * ## Understanding How Injection Works
+   *
+   * There are three stages of injection resolution.
+   * - *Pre-existing Injectors*:
+   *   - The terminal {@link Injector} cannot resolve dependencies. It either throws an error or, if
+   * the dependency was
+   *     specified as `@Optional`, returns `null`.
+   *   - The platform injector resolves browser singleton resources, such as: cookies, title,
+   * location, and others.
+   * - *Component Injectors*: Each component instance has its own {@link Injector}, and they follow
+   * the same parent-child hierarchy
+   *     as the component instances in the DOM.
+   * - *Element Injectors*: Each component instance has a Shadow DOM. Within the Shadow DOM each
+   * element has an `ElementInjector`
+   *     which follow the same parent-child hierarchy as the DOM elements themselves.
+   *
+   * When a template is instantiated, it also must instantiate the corresponding directives in a
+   * depth-first order. The
+   * current `ElementInjector` resolves the constructor dependencies for each directive.
+   *
+   * Angular then resolves dependencies as follows, according to the order in which they appear in the
+   * {@link ViewMetadata}:
+   *
+   * 1. Dependencies on the current element
+   * 2. Dependencies on element injectors and their parents until it encounters a Shadow DOM boundary
+   * 3. Dependencies on component injectors and their parents until it encounters the root component
+   * 4. Dependencies on pre-existing injectors
+   *
+   *
+   * The `ElementInjector` can inject other directives, element-specific special objects, or it can
+   * delegate to the parent
+   * injector.
+   *
+   * To inject other directives, declare the constructor parameter as:
+   * - `directive:DirectiveType`: a directive on the current element only
+   * - `@Host() directive:DirectiveType`: any directive that matches the type between the current
+   * element and the
+   *    Shadow DOM root.
+   * - `@Query(DirectiveType) query:QueryList<DirectiveType>`: A live collection of direct child
+   * directives.
+   * - `@QueryDescendants(DirectiveType) query:QueryList<DirectiveType>`: A live collection of any
+   * child directives.
+   *
+   * To inject element-specific special objects, declare the constructor parameter as:
+   * - `element: ElementRef` to obtain a reference to logical element in the view.
+   * - `viewContainer: ViewContainerRef` to control child template instantiation, for
+   * {@link DirectiveMetadata} directives only
+   * - `bindingPropagation: BindingPropagation` to control change detection in a more granular way.
+   *
+   * ## Example
+   *
+   * The following example demonstrates how dependency injection resolves constructor arguments in
+   * practice.
+   *
+   *
+   * Assume this HTML template:
+   *
+   * ```
+   * <div dependency="1">
+   *   <div dependency="2">
+   *     <div dependency="3" my-directive>
+   *       <div dependency="4">
+   *         <div dependency="5"></div>
+   *       </div>
+   *       <div dependency="6"></div>
+   *     </div>
+   *   </div>
+   * </div>
+   * ```
+   *
+   * With the following `dependency` decorator and `SomeService` injectable class.
+   *
+   * ```
+   * @Injectable()
+   * class SomeService {
+   * }
+   *
+   * @Directive({
+   *   selector: '[dependency]',
+   *   properties: [
+   *     'id: dependency'
+   *   ]
+   * })
+   * class Dependency {
+   *   id:string;
+   * }
+   * ```
+   *
+   * Let's step through the different ways in which `MyDirective` could be declared...
+   *
+   *
+   * ### No injection
+   *
+   * Here the constructor is declared with no arguments, therefore nothing is injected into
+   * `MyDirective`.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor() {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with no dependencies.
+   *
+   *
+   * ### Component-level injection
+   *
+   * Directives can inject any injectable instance from the closest component injector or any of its
+   * parents.
+   *
+   * Here, the constructor declares a parameter, `someService`, and injects the `SomeService` type
+   * from the parent
+   * component's injector.
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(someService: SomeService) {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with a dependency on `SomeService`.
+   *
+   *
+   * ### Injecting a directive from the current element
+   *
+   * Directives can inject other directives declared on the current element.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(dependency: Dependency) {
+   *     expect(dependency.id).toEqual(3);
+   *   }
+   * }
+   * ```
+   * This directive would be instantiated with `Dependency` declared at the same element, in this case
+   * `dependency="3"`.
+   *
+   * ### Injecting a directive from any ancestor elements
+   *
+   * Directives can inject other directives declared on any ancestor element (in the current Shadow
+   * DOM), i.e. on the current element, the
+   * parent element, or its parents.
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(@Host() dependency: Dependency) {
+   *     expect(dependency.id).toEqual(2);
+   *   }
+   * }
+   * ```
+   *
+   * `@Host` checks the current element, the parent, as well as its parents recursively. If
+   * `dependency="2"` didn't
+   * exist on the direct parent, this injection would
+   * have returned
+   * `dependency="1"`.
+   *
+   *
+   * ### Injecting a live collection of direct child directives
+   *
+   *
+   * A directive can also query for other child directives. Since parent directives are instantiated
+   * before child directives, a directive can't simply inject the list of child directives. Instead,
+   * the directive injects a {@link QueryList}, which updates its contents as children are added,
+   * removed, or moved by a directive that uses a {@link ViewContainerRef} such as a `ng-for`, an
+   * `ng-if`, or an `ng-switch`.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(@Query(Dependency) dependencies:QueryList<Dependency>) {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with a {@link QueryList} which contains `Dependency` 4 and
+   * 6. Here, `Dependency` 5 would not be included, because it is not a direct child.
+   *
+   * ### Injecting a live collection of descendant directives
+   *
+   * By passing the descendant flag to `@Query` above, we can include the children of the child
+   * elements.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(@Query(Dependency, {descendants: true}) dependencies:QueryList<Dependency>) {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with a Query which would contain `Dependency` 4, 5 and 6.
+   *
+   * ### Optional injection
+   *
+   * The normal behavior of directives is to return an error when a specified dependency cannot be
+   * resolved. If you
+   * would like to inject `null` on unresolved dependency instead, you can annotate that dependency
+   * with `@Optional()`.
+   * This explicitly permits the author of a template to treat some of the surrounding directives as
+   * optional.
+   *
+   * ```
+   * @Directive({ selector: '[my-directive]' })
+   * class MyDirective {
+   *   constructor(@Optional() dependency:Dependency) {
+   *   }
+   * }
+   * ```
+   *
+   * This directive would be instantiated with a `Dependency` directive found on the current element.
+   * If none can be
+   * found, the injector supplies `null` instead of throwing an error.
+   *
+   * ## Example
+   *
+   * Here we use a decorator directive to simply define basic tool-tip behavior.
+   *
+   * ```
+   * @Directive({
+   *   selector: '[tooltip]',
+   *   properties: [
+   *     'text: tooltip'
+   *   ],
+   *   host: {
+   *     '(mouseenter)': 'onMouseEnter()',
+   *     '(mouseleave)': 'onMouseLeave()'
+   *   }
+   * })
+   * class Tooltip{
+   *   text:string;
+   *   overlay:Overlay; // NOT YET IMPLEMENTED
+   *   overlayManager:OverlayManager; // NOT YET IMPLEMENTED
+   *
+   *   constructor(overlayManager:OverlayManager) {
+   *     this.overlay = overlay;
+   *   }
+   *
+   *   onMouseEnter() {
+   *     // exact signature to be determined
+   *     this.overlay = this.overlayManager.open(text, ...);
+   *   }
+   *
+   *   onMouseLeave() {
+   *     this.overlay.close();
+   *     this.overlay = null;
+   *   }
+   * }
+   * ```
+   * In our HTML template, we can then add this behavior to a `<div>` or any other element with the
+   * `tooltip` selector,
+   * like so:
+   *
+   * ```
+   * <div tooltip="some text here"></div>
+   * ```
+   *
+   * Directives can also control the instantiation, destruction, and positioning of inline template
+   * elements:
+   *
+   * A directive uses a {@link ViewContainerRef} to instantiate, insert, move, and destroy views at
+   * runtime.
+   * The {@link ViewContainerRef} is created as a result of `<template>` element, and represents a
+   * location in the current view
+   * where these actions are performed.
+   *
+   * Views are always created as children of the current {@link ViewMetadata}, and as siblings of the
+   * `<template>` element. Thus a
+   * directive in a child view cannot inject the directive that created it.
+   *
+   * Since directives that create views via ViewContainers are common in Angular, and using the full
+   * `<template>` element syntax is wordy, Angular
+   * also supports a shorthand notation: `<li *foo="bar">` and `<li template="foo: bar">` are
+   * equivalent.
+   *
+   * Thus,
+   *
+   * ```
+   * <ul>
+   *   <li *foo="bar" title="text"></li>
+   * </ul>
+   * ```
+   *
+   * Expands in use to:
+   *
+   * ```
+   * <ul>
+   *   <template [foo]="bar">
+   *     <li title="text"></li>
+   *   </template>
+   * </ul>
+   * ```
+   *
+   * Notice that although the shorthand places `*foo="bar"` within the `<li>` element, the binding for
+   * the directive
+   * controller is correctly instantiated on the `<template>` element rather than the `<li>` element.
+   *
+   *
+   * ## Example
+   *
+   * Let's suppose we want to implement the `unless` behavior, to conditionally include a template.
+   *
+   * Here is a simple directive that triggers on an `unless` selector:
+   *
+   * ```
+   * @Directive({
+   *   selector: '[unless]',
+   *   properties: ['unless']
+   * })
+   * export class Unless {
+   *   viewContainer: ViewContainerRef;
+   *   templateRef: TemplateRef;
+   *   prevCondition: boolean;
+   *
+   *   constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef) {
+   *     this.viewContainer = viewContainer;
+   *     this.templateRef = templateRef;
+   *     this.prevCondition = null;
+   *   }
+   *
+   *   set unless(newCondition) {
+   *     if (newCondition && (isBlank(this.prevCondition) || !this.prevCondition)) {
+   *       this.prevCondition = true;
+   *       this.viewContainer.clear();
+   *     } else if (!newCondition && (isBlank(this.prevCondition) || this.prevCondition)) {
+   *       this.prevCondition = false;
+   *       this.viewContainer.create(this.templateRef);
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * We can then use this `unless` selector in a template:
+   * ```
+   * <ul>
+   *   <li *unless="expr"></li>
+   * </ul>
+   * ```
+   *
+   * Once the directive instantiates the child view, the shorthand notation for the template expands
+   * and the result is:
+   *
+   * ```
+   * <ul>
+   *   <template [unless]="exp">
+   *     <li></li>
+   *   </template>
+   *   <li></li>
+   * </ul>
+   * ```
+   *
+   * Note also that although the `<li></li>` template still exists inside the `<template></template>`,
+   * the instantiated
+   * view occurs on the second `<li></li>` which is a sibling to the `<template>` element.
+   */
+  class DirectiveMetadata extends InjectableMetadata {
+
+
+    /**
+     * The CSS selector that triggers the instantiation of a directive.
+     *
+     * Angular only allows directives to trigger on CSS selectors that do not cross element
+     * boundaries.
+     *
+     * `selector` may be declared as one of the following:
+     *
+     * - `element-name`: select by element name.
+     * - `.class`: select by class name.
+     * - `[attribute]`: select by attribute name.
+     * - `[attribute=value]`: select by attribute name and value.
+     * - `:not(sub_selector)`: select only if the element does not match the `sub_selector`.
+     * - `selector1, selector2`: select if either `selector1` or `selector2` matches.
+     *
+     *
+     * ## Example
+     *
+     * Suppose we have a directive with an `input[type=text]` selector.
+     *
+     * And the following HTML:
+     *
+     * ```html
+     * <form>
+     *   <input type="text">
+     *   <input type="radio">
+     * <form>
+     * ```
+     *
+     * The directive would only be instantiated on the `<input type="text">` element.
+     */
+     selector: string;
+
+
+    /**
+     * Enumerates the set of properties that accept data binding for a directive.
+     *
+     * The `properties` property defines a set of `directiveProperty` to `bindingProperty`
+     * configuration:
+     *
+     * - `directiveProperty` specifies the component property where the value is written.
+     * - `bindingProperty` specifies the DOM property where the value is read from.
+     *
+     * You can include a {@link PipeMetadata} when specifying a `bindingProperty` to allow for data
+     * transformation and structural change detection of the value. These pipes will be evaluated in
+     * the context of this component.
+     *
+     * ## Syntax
+     *
+     * There is no need to specify both `directiveProperty` and `bindingProperty` when they both have
+     * the same value.
+     *
+     * ```
+     * @Directive({
+     *   properties: [
+     *     'propertyName', // shorthand notation for 'propertyName: propertyName'
+     *     'directiveProperty1: bindingProperty1',
+     *     'directiveProperty2: bindingProperty2 | pipe1 | ...',
+     *     ...
+     *   ]
+     * }
+     * ```
+     *
+     *
+     * ## Basic Property Binding
+     *
+     * We can easily build a simple `Tooltip` directive that exposes a `tooltip` property, which can
+     * be used in templates with standard Angular syntax. For example:
+     *
+     * ```
+     * @Directive({
+     *   selector: '[tooltip]',
+     *   properties: [
+     *     'text: tooltip'
+     *   ]
+     * })
+     * class Tooltip {
+     *   set text(value: string) {
+     *     // This will get called every time with the new value when the 'tooltip' property changes
+     *   }
+     * }
+     * ```
+     *
+     * We can then bind to the `tooltip' property as either an expression (`someExpression`) or as a
+     * string literal, as shown in the HTML template below:
+     *
+     * ```html
+     * <div [tooltip]="someExpression">...</div>
+     * <div tooltip="Some Text">...</div>
+     * ```
+     *
+     * Whenever the `someExpression` expression changes, the `properties` declaration instructs
+     * Angular to update the `Tooltip`'s `text` property.
+     *
+     * ### Bindings With Pipes
+     *
+     * You can use pipes in bindings, as follows:
+     *
+     * ```html
+     * <div [class-set]="someExpression | somePipe">
+     * ```
+     */
+     properties: string[];
+
+
+    /**
+     * Enumerates the set of emitted events.
+     *
+     * ## Syntax
+     *
+     * ```
+     * @Component({
+     *   events: ['statusChange']
+     * })
+     * class TaskComponent {
+     *   statusChange: EventEmitter;
+     *
+     *   constructor() {
+     *     this.statusChange = new EventEmitter();
+     *   }
+     *
+     *   onComplete() {
+     *     this.statusChange.next('completed');
+     *   }
+     * }
+     * ```
+     *
+     * Use `propertyName: eventName` when the event emitter property name is different from the name
+     * of the emitted event:
+     *
+     * ```
+     * @Component({
+     *   events: ['status: statusChange']
+     * })
+     * class TaskComponent {
+     *   status: EventEmitter;
+     *
+     *   constructor() {
+     *     this.status = new EventEmitter();
+     *   }
+     *
+     *   onComplete() {
+     *     this.status.next('completed');
+     *   }
+     * }
+     * ```
+     */
+     events: string[];
+
+
+    /**
+     * Specifiy the events, actions, properties and attributes related to the host element.
+     *
+     * ## Events
+     *
+     * Specifies which DOM hostListeners a directive listens to via a set of `(event)` to `method`
+     * key-value pairs:
+     *
+     * - `event1`: the DOM event that the directive listens to.
+     * - `statement`: the statement to execute when the event occurs.
+     * If the evalutation of the statement returns `false`, then `preventDefault`is applied on the DOM
+     * event.
+     *
+     * To listen to global events, a target must be added to the event name.
+     * The target can be `window`, `document` or `body`.
+     *
+     * When writing a directive event binding, you can also refer to the following local variables:
+     * - `$event`: Current event object which triggered the event.
+     * - `$target`: The source of the event. This will be either a DOM element or an Angular
+     * directive. (will be implemented in later release)
+     *
+     * ## Syntax
+     *
+     * ```
+     * @Directive({
+     *   host: {
+     *     '(event1)': 'onMethod1(arguments)',
+     *     '(target:event2)': 'onMethod2(arguments)',
+     *     ...
+     *   }
+     * }
+     * ```
+     *
+     * ## Basic Event Binding:
+     *
+     * Suppose you want to write a directive that reacts to `change` events in the DOM and on
+     * `resize` events in window.
+     * You would define the event binding as follows:
+     *
+     * ```
+     * @Directive({
+     *   selector: 'input',
+     *   host: {
+     *     '(change)': 'onChange($event)',
+     *     '(window:resize)': 'onResize($event)'
+     *   }
+     * })
+     * class InputDirective {
+     *   onChange(event:Event) {
+     *     // invoked when the input element fires the 'change' event
+     *   }
+     *   onResize(event:Event) {
+     *     // invoked when the window fires the 'resize' event
+     *   }
+     * }
+     * ```
+     *
+     * ## Properties
+     *
+     * Specifies which DOM properties a directives updates.
+     *
+     * ## Syntax
+     *
+     * ```
+     * @Directive({
+     *   selector: 'input',
+     *   host: {
+     *     '[prop]': 'expression'
+     *   }
+     * })
+     * class InputDirective {
+     *   value:string;
+     * }
+     * ```
+     *
+     * In this example the prop property of the host element is updated with the expression value
+     * every time it changes.
+     *
+     * ## Attributes
+     *
+     * Specifies static attributes that should be propagated to a host element. Attributes specified
+     * in `hostAttributes` are propagated only if a given attribute is not present on a host element.
+     *
+     * ## Syntax
+     *
+     * ```
+     * @Directive({
+     *   selector: '[my-button]',
+     *   host: {
+     *     'role': 'button'
+     *   }
+     * })
+     * class MyButton {
+     * }
+     * ```
+     *
+     * In this example using `my-button` directive (ex.: `<div my-button></div>`) on a host element
+     * (here: `<div>` ) will ensure that this element will get the "button" role.
+     */
+     host: StringMap<string, string>;
+
+
+    /**
+     * Specifies which lifecycle should be notified to the directive.
+     *
+     * See {@link LifecycleEvent} for details.
+     */
+     lifecycle: LifecycleEvent[];
+
+
+    /**
+     * If set to false the compiler does not compile the children of this directive.
+     */
+     compileChildren: boolean;
+
+
+    /**
+     * Defines the set of injectable objects that are visible to a Directive and its light dom
+     * children.
+     *
+     * ## Simple Example
+     *
+     * Here is an example of a class that can be injected:
+     *
+     * ```
+     * class Greeter {
+     *    greet(name:string) {
+     *      return 'Hello ' + name + '!';
+     *    }
+     * }
+     *
+     * @Directive({
+     *   selector: 'greet',
+     *   bindings: [
+     *     Greeter
+     *   ]
+     * })
+     * class HelloWorld {
+     *   greeter:Greeter;
+     *
+     *   constructor(greeter:Greeter) {
+     *     this.greeter = greeter;
+     *   }
+     * }
+     * ```
+     */
+     bindings: any[];
+
+
+    /**
+     * Defines the name that can be used in the template to assign this directive to a variable.
+     *
+     * ## Simple Example
+     *
+     * ```
+     * @Directive({
+     *   selector: 'child-dir',
+     *   exportAs: 'child'
+     * })
+     * class ChildDir {
+     * }
+     *
+     * @Component({
+     *   selector: 'main',
+     * })
+     * @View({
+     *   template: `<child-dir #c="child"></child-dir>`,
+     *   directives: [ChildDir]
+     * })
+     * class MainComponent {
+     * }
+     *
+     * ```
+     */
+     exportAs: string;
+  }
+
+
+  /**
+   * Declare reusable pipe function.
+   *
+   * ## Example
+   *
+   * ```
+   * @Pipe({
+   *   name: 'lowercase'
+   * })
+   * class Lowercase {
+   *   transform(v, args) { return v.toLowerCase(); }
+   * }
+   * ```
+   */
+  class PipeMetadata extends InjectableMetadata {
+
+     name: string;
+  }
+
+
+  /**
+   * Lifecycle events are guaranteed to be called in the following order:
+   * - `OnChanges` (if any bindings have changed),
+   * - `OnInit` (after the first check only),
+   * - `DoCheck`,
+   * - `AfterContentChecked`
+   * - `AfterContentChecked`
+   * - `OnDestroy` (at the very end before destruction)
+   */
+  enum LifecycleEvent {
+
+
+    /**
+     * Notify a directive when it has been checked the first time.
+     *
+     * This method is called right after the directive's bindings have been checked,
+     * and before any of its children's bindings have been checked.
+     *
+     * It is invoked only once.
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.OnInit]
+     * })
+     * class ClassSet {
+     *   onInit() {
+     *   }
+     * }
+     *  ```
+     */
+     OnInit,
+
+
+    /**
+     * Notify a directive whenever a {@link ViewMetadata} that contains it is destroyed.
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   ...,
+     *   lifecycle: [LifecycleEvent.OnDestroy]
+     * })
+     * class ClassSet {
+     *   onDestroy() {
+     *     // invoked to notify directive of the containing view destruction.
+     *   }
+     * }
+     * ```
+     */
+     OnDestroy,
+
+
+    /**
+     * Notify a directive when any of its bindings have changed.
+     *
+     * This method is called right after the directive's bindings have been checked,
+     * and before any of its children's bindings have been checked.
+     *
+     * It is invoked only if at least one of the directive's bindings has changed.
+     *
+     * ## Example:
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   properties: [
+     *     'propA',
+     *     'propB'
+     *   ],
+     *   lifecycle: [LifecycleEvent.OnChanges]
+     * })
+     * class ClassSet {
+     *   propA;
+     *   propB;
+     *   onChanges(changes:{[idx: string, PropertyUpdate]}) {
+     *     // This will get called after any of the properties have been updated.
+     *     if (changes['propA']) {
+     *       // if propA was updated
+     *     }
+     *     if (changes['propA']) {
+     *       // if propB was updated
+     *     }
+     *   }
+     * }
+     *  ```
+     */
+     OnChanges,
+
+
+    /**
+     * Notify a directive when it has been checked.
+     *
+     * This method is called right after the directive's bindings have been checked,
+     * and before any of its children's bindings have been checked.
+     *
+     * It is invoked every time even when none of the directive's bindings has changed.
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.DoCheck]
+     * })
+     * class ClassSet {
+     *   doCheck() {
+     *   }
+     * }
+     *  ```
+     */
+     DoCheck,
+
+
+    /**
+     * Notify a directive when the bindings of all its content children have been checked the first
+     * time (whether they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterContentInit]
+     * })
+     * class ClassSet {
+     *
+     *   afterContentInit() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterContentInit,
+
+
+    /**
+     * Notify a directive when the bindings of all its content children have been checked (whether
+     * they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterContentChecked]
+     * })
+     * class ClassSet {
+     *
+     *   afterContentChecked() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterContentChecked,
+
+
+    /**
+     * Notify a directive when the bindings of all its view children have been checked the first time
+     * (whether they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterViewInit]
+     * })
+     * class ClassSet {
+     *
+     *   afterViewInit() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterViewInit,
+
+
+    /**
+     * Notify a directive when the bindings of all its view children have been checked (whether they
+     * have changed or not).
+     *
+     * ## Example
+     *
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   lifecycle: [LifecycleEvent.AfterViewChecked]
+     * })
+     * class ClassSet {
+     *
+     *   afterViewChecked() {
+     *   }
+     *
+     * }
+     *  ```
+     */
+     AfterViewChecked
+  }
+
+
+  /**
+   * Declares the available HTML templates for an application.
+   *
+   * Each angular component requires a single `@Component` and at least one `@View` annotation. The
+   * `@View` annotation specifies the HTML template to use, and lists the directives that are active
+   * within the template.
+   *
+   * When a component is instantiated, the template is loaded into the component's shadow root, and
+   * the expressions and statements in the template are evaluated against the component.
+   *
+   * For details on the `@Component` annotation, see {@link ComponentMetadata}.
+   *
+   * ## Example
+   *
+   * ```
+   * @Component({
+   *   selector: 'greet'
+   * })
+   * @View({
+   *   template: 'Hello {{name}}!',
+   *   directives: [GreetUser, Bold]
+   * })
+   * class Greet {
+   *   name: string;
+   *
+   *   constructor() {
+   *     this.name = 'World';
+   *   }
+   * }
+   * ```
+   */
+  class ViewMetadata {
+
+
+    /**
+     * Specifies a template URL for an angular component.
+     *
+     * NOTE: either `templateUrl` or `template` should be used, but not both.
+     */
+     templateUrl: string;
+
+
+    /**
+     * Specifies an inline template for an angular component.
+     *
+     * NOTE: either `templateUrl` or `template` should be used, but not both.
+     */
+     template: string;
+
+
+    /**
+     * Specifies stylesheet URLs for an angular component.
+     */
+     styleUrls: string[];
+
+
+    /**
+     * Specifies an inline stylesheet for an angular component.
+     */
+     styles: string[];
+
+
+    /**
+     * Specifies a list of directives that can be used within a template.
+     *
+     * Directives must be listed explicitly to provide proper component encapsulation.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * @Component({
+     *     selector: 'my-component'
+     *   })
+     * @View({
+     *   directives: [For]
+     *   template: '
+     *   <ul>
+     *     <li *ng-for="#item of items">{{item}}</li>
+     *   </ul>'
+     * })
+     * class MyComponent {
+     * }
+     * ```
+     */
+     directives: Array<Type | any | any[]>;
+
+     pipes: Array<Type | any | any[]>;
+
+
+    /**
+     * Specify how the template and the styles should be encapsulated.
+     * The default is {@link ViewEncapsulation#Emulated `ViewEncapsulation.Emulated`} if the view
+     * has styles,
+     * otherwise {@link ViewEncapsulation#None `ViewEncapsulation.None`}.
+     */
+     encapsulation: ViewEncapsulation;
+  }
+
+
+  /**
+   * How the template and styles of a view should be encapsulated.
+   */
+  enum ViewEncapsulation {
+
+
+    /**
+     * Emulate scoping of styles by preprocessing the style rules
+     * and adding additional attributes to elements. This is the default.
+     */
+     Emulated,
+
+
+    /**
+     * Uses the native mechanism of the renderer. For the DOM this means creating a ShadowRoot.
+     */
+     Native,
+
+
+    /**
+     * Don't scope the template nor the styles.
+     */
+     None
+  }
+
+
+  /**
+   * Specifies that a {@link QueryList} should be injected.
+   *
+   * See {@link QueryList} for usage and example.
+   */
+  class QueryMetadata extends DependencyMetadata {
+
+     descendants: boolean;
+
+     isViewQuery: any;
+
+     selector: any;
+
+     isVarBindingQuery: boolean;
+
+     varBindings: string[];
+
+     toString(): string;
+  }
+
+
+  /**
+   * Specifies that a constant attribute value should be injected.
+   *
+   * The directive can inject constant string literals of host element attributes.
+   *
+   * ## Example
+   *
+   * Suppose we have an `<input>` element and want to know its `type`.
+   *
+   * ```html
+   * <input type="text">
+   * ```
+   *
+   * A decorator can inject string literal `text` like so:
+   *
+   * ```javascript
+   * @Directive({
+   *   selector: `input'
+   * })
+   * class InputDirective {
+   *   constructor(@Attribute('type') type) {
+   *     // type would be `text` in this example
+   *   }
+   * }
+   * ```
+   */
+  class AttributeMetadata extends DependencyMetadata {
+
+     attributeName: string;
+
+     token: any;
+
+     toString(): string;
+  }
+
+
+  /**
+   * {@link AttributeMetadata} factory function.
+   */
+  var Attribute : AttributeFactory ;
+
+
+  /**
+   * {@link AttributeMetadata} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Attribute, Component, View} from "angular2/angular2";
+   *
+   * @Component({...})
+   * @View({...})
+   * class MyComponent {
+   *   constructor(@Attribute('title') title: string) {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyComponent = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({
+   *     constructor: [new ng.Attribute('title'), function(title) {
+   *       ...
+   *     }]
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyComponent = function(title) {
+   *   ...
+   * };
+   *
+   * MyComponent.annotations = [
+   *   new ng.Component({...}),
+   *   new ng.View({...})
+   * ]
+   * MyComponent.parameters = [
+   *   [new ng.Attribute('title')]
+   * ]
+   * ```
+   */
+  interface AttributeFactory {
+
+     new(name: string): AttributeMetadata;
+
+
+     (name: string): TypeDecorator;
+
+  }
+
+
+  /**
+   * {@link ComponentMetadata} factory function.
+   */
+  var Component : ComponentFactory ;
+
+
+  /**
+   * Interface for the {@link ComponentMetadata} decorator function.
+   *
+   * See {@link ComponentFactory}.
+   */
+  interface ComponentDecorator extends TypeDecorator {
+
+
+    /**
+     * Chain {@link ViewMetadata} annotation.
+     */
+     View(obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: Array<Type | any | any[]>,
+    pipes?: Array<Type | any | any[]>,
+    renderer?: string,
+    styles?: string[],
+    styleUrls?: string[],
+  }): ViewDecorator;
+  }
+
+
+  /**
+   * {@link ComponentAnnotation} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Component, View} from "angular2/angular2";
+   *
+   * @Component({...})
+   * @View({...})
+   * class MyComponent {
+   *   constructor() {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyComponent = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({
+   *     constructor: function() {
+   *       ...
+   *     }
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyComponent = function() {
+   *   ...
+   * };
+   *
+   * MyComponent.annotations = [
+   *   new ng.Component({...}),
+   *   new ng.View({...})
+   * ]
+   * ```
+   */
+  interface ComponentFactory {
+
+     new(obj: {
+    selector?: string,
+    properties?: string[],
+    events?: string[],
+    host?: StringMap<string, string>,
+    lifecycle?: LifecycleEvent[],
+    bindings?: any[],
+    exportAs?: string,
+    compileChildren?: boolean,
+    viewBindings?: any[],
+    changeDetection?: ChangeDetectionStrategy,
+  }): ComponentMetadata;
+
+
+     (obj: {
+    selector?: string,
+    properties?: string[],
+    events?: string[],
+    host?: StringMap<string, string>,
+    lifecycle?: LifecycleEvent[],
+    bindings?: any[],
+    exportAs?: string,
+    compileChildren?: boolean,
+    viewBindings?: any[],
+    changeDetection?: ChangeDetectionStrategy,
+  }): ComponentDecorator;
+
+  }
+
+
+  /**
+   * {@link DirectiveMetadata} factory function.
+   */
+  var Directive : DirectiveFactory ;
+
+
+  /**
+   * Interface for the {@link DirectiveMetadata} decorator function.
+   *
+   * See {@link DirectiveFactory}.
+   */
+  interface DirectiveDecorator extends TypeDecorator {
+  }
+
+
+  /**
+   * {@link DirectiveMetadata} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Directive} from "angular2/angular2";
+   *
+   * @Directive({...})
+   * class MyDirective {
+   *   constructor() {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyDirective = ng
+   *   .Directive({...})
+   *   .Class({
+   *     constructor: function() {
+   *       ...
+   *     }
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyDirective = function() {
+   *   ...
+   * };
+   *
+   * MyDirective.annotations = [
+   *   new ng.Directive({...})
+   * ]
+   * ```
+   */
+  interface DirectiveFactory {
+
+     new(obj: {
+    selector?: string, properties?: string[], events?: string[], host?: StringMap<string, string>,
+        lifecycle?: LifecycleEvent[], bindings?: any[], exportAs?: string,
+        compileChildren?: boolean;
+  }): DirectiveMetadata;
+
+
+     (obj: {
+    selector?: string, properties?: string[], events?: string[], host?: StringMap<string, string>,
+        lifecycle?: LifecycleEvent[], bindings?: any[], exportAs?: string,
+        compileChildren?: boolean;
+  }): DirectiveDecorator;
+
+  }
+
+
+  /**
+   * {@link ViewMetadata} factory function.
+   */
+  var View : ViewFactory ;
+
+
+  /**
+   * Interface for the {@link ViewMetadata} decorator function.
+   *
+   * See {@link ViewFactory}.
+   */
+  interface ViewDecorator extends TypeDecorator {
+
+
+    /**
+     * Chain {@link ViewMetadata} annotation.
+     */
+     View(obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: Array<Type | any | any[]>,
+    pipes?: Array<Type | any | any[]>,
+    renderer?: string,
+    styles?: string[],
+    styleUrls?: string[],
+  }): ViewDecorator;
+  }
+
+
+  /**
+   * {@link ViewAnnotation} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Component, View} from "angular2/angular2";
+   *
+   * @Component({...})
+   * @View({...})
+   * class MyComponent {
+   *   constructor() {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyComponent = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({
+   *     constructor: function() {
+   *       ...
+   *     }
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyComponent = function() {
+   *   ...
+   * };
+   *
+   * MyComponent.annotations = [
+   *   new ng.Component({...}),
+   *   new ng.View({...})
+   * ]
+   * ```
+   */
+  interface ViewFactory {
+
+     new(obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: Array<Type | any | any[]>,
+    encapsulation?: ViewEncapsulation,
+    styles?: string[],
+    styleUrls?: string[],
+  }): ViewMetadata;
+
+
+     (obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: Array<Type | any | any[]>,
+    encapsulation?: ViewEncapsulation,
+    styles?: string[],
+    styleUrls?: string[],
+  }): ViewDecorator;
+
+  }
+
+
+  /**
+   * {@link QueryMetadata} factory function.
+   */
+  var Query : QueryFactory ;
+
+
+  /**
+   * {@link QueryMetadata} factory for creating annotations, decorators or DSL.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Query, QueryList, Component, View} from "angular2/angular2";
+   *
+   * @Component({...})
+   * @View({...})
+   * class MyComponent {
+   *   constructor(@Query(SomeType) queryList: QueryList) {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example as ES5 DSL
+   *
+   * ```
+   * var MyComponent = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({
+   *     constructor: [new ng.Query(SomeType), function(queryList) {
+   *       ...
+   *     }]
+   *   })
+   * ```
+   *
+   * ## Example as ES5 annotation
+   *
+   * ```
+   * var MyComponent = function(queryList) {
+   *   ...
+   * };
+   *
+   * MyComponent.annotations = [
+   *   new ng.Component({...}),
+   *   new ng.View({...})
+   * ]
+   * MyComponent.parameters = [
+   *   [new ng.Query(SomeType)]
+   * ]
+   * ```
+   */
+  interface QueryFactory {
+
+     new(selector: Type | string, {descendants}?: {descendants?: boolean}): QueryMetadata;
+
+
+     (selector: Type | string, {descendants}?: {descendants?: boolean}): ParameterDecorator;
+
+  }
+
+
+  /**
+   * {@link di/ViewQueryMetadata} factory function.
+   */
+  var ViewQuery : QueryFactory ;
+
+
+  /**
+   * {@link PipeMetadata} factory function.
+   */
+  var Pipe : PipeFactory ;
+
+
+  /**
+   * {@link PipeMetadata} factory for creating decorators.
+   *
+   * ## Example as TypeScript Decorator
+   *
+   * ```
+   * import {Pipe} from "angular2/angular2";
+   *
+   * @Pipe({...})
+   * class MyPipe {
+   *   constructor() {
+   *     ...
+   *   }
+   *
+   *   transform(v, args) {}
+   * }
+   * ```
+   */
+  interface PipeFactory {
+
+     new(obj: {
+    name: string,
+  }): any;
+
+
+     (obj: {name: string}): any;
+
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterContentInit `LifeCycleEvent.afterContentInit`}
+   * called when the bindings of all its content children have been checked the first time.
+   */
+  interface AfterContentInit {
+
+     afterContentInit(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterContentChecked `LifeCycleEvent.afterContentChecked`}
+   * called when the bindings of all its content children have been checked.
+   */
+  interface AfterContentChecked {
+
+     afterContentChecked(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterViewInit `LifeCycleEvent.afterViewInit`}
+   * called when the bindings of all its view children have been checked the first time.
+   */
+  interface AfterViewInit {
+
+     afterViewInit(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method
+   * {@link metadata/LifeCycleEvent#AfterViewChecked `LifeCycleEvent.afterViewChecked`}
+   * called when the bindings of all its view children have been checked.
+   */
+  interface AfterViewChecked {
+
+     afterViewChecked(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#OnChanges `LifeCycleEvent.OnChanges`}
+   * called after all of component's bound properties are updated.
+   */
+  interface OnChanges {
+
+     onChanges(changes: StringMap<string, any>): void;
+  }
+
+
+  /**
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#OnDestroy `LifeCycleEvent.OnDestroy`}
+   * called when a directive is being destroyed.
+   */
+  interface OnDestroy {
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#OnInit `LifeCycleEvent.OnInit`}
+   * called when a directive is being checked the first time.
+   */
+  interface OnInit {
+
+     onInit(): void;
+  }
+
+
+  /**
+   * Defines lifecycle method {@link metadata/LifeCycleEvent#DoCheck `LifeCycleEvent.DoCheck`}
+   * called when a directive is being checked.
+   */
+  interface DoCheck {
+
+     doCheck(): boolean;
+  }
+
+
+  /**
+   * Provides a way for expressing ES6 classes with parameter annotations in ES5.
+   *
+   * ## Basic Example
+   *
+   * ```
+   * var Greeter = ng.Class({
+   *   constructor: function(name) {
+   *     this.name = name;
+   *   },
+   *
+   *   greet: function() {
+   *     alert('Hello ' + this.name + '!');
+   *   }
+   * });
+   * ```
+   *
+   * is equivalent to ES6:
+   *
+   * ```
+   * class Greeter {
+   *   constructor(name) {
+   *     this.name = name;
+   *   }
+   *
+   *   greet() {
+   *     alert('Hello ' + this.name + '!');
+   *   }
+   * }
+   * ```
+   *
+   * or equivalent to ES5:
+   *
+   * ```
+   * var Greeter = function (name) {
+   *   this.name = name;
+   * }
+   *
+   * Greeter.prototype.greet = function () {
+   *   alert('Hello ' + this.name + '!');
+   * }
+   * ```
+   *
+   * ## Example with parameter annotations
+   *
+   * ```
+   * var MyService = neg.Class({
+   *   constructor: [String, [new Query(), QueryList], function(name, queryList) {
+   *     ...
+   *   }];
+   * });
+   * ```
+   *
+   * is equivalent to ES6:
+   *
+   * ```
+   * class MyService {
+   *   constructor(name: string, @Query() queryList: QueryList) {
+   *     ...
+   *   }
+   * }
+   * ```
+   *
+   * ## Example with inheritance
+   *
+   * ```
+   * var Shape = ng.Class({
+   *   constructor: (color) {
+   *     this.color = color;
+   *   }
+   * });
+   *
+   * var Square = ng.Class({
+   *   extends: Shape,
+   *   constructor: function(color, size) {
+   *     Shape.call(this, color);
+   *     this.size = size;
+   *   }
+   * });
+   * ```
+   */
+  function Class(clsDef: ClassDefinition) : Type ;
+
+
+  /**
+   * Declares the interface to be used with {@link Class}.
+   */
+  interface ClassDefinition {
+
+
+    /**
+     * Optional argument for specifying the superclass.
+     */
+     extends?: Type;
+
+
+    /**
+     * Required constructor function for a class.
+     *
+     * The function may be optionally wrapped in an `Array`, in which case additional parameter
+     * annotations may be specified.
+     * The number of arguments and the number of parameter annotations must match.
+     *
+     * See {@link Class} for example of usage.
+     */
+     constructor: (Function | any[]);
+  }
+
+
+  /**
+   * An interface implemented by all Angular type decorators, which allows them to be used as ES7
+   * decorators as well as
+   * Angular DSL syntax.
+   *
+   * DSL syntax:
+   *
+   * ```
+   * var MyClass = ng
+   *   .Component({...})
+   *   .View({...})
+   *   .Class({...});
+   * ```
+   *
+   * ES7 syntax:
+   *
+   * ```
+   * @ng.Component({...})
+   * @ng.View({...})
+   * class MyClass {...}
+   * ```
+   */
+  interface TypeDecorator {
+
+
+    /**
+     * Invoke as ES7 decorator.
+     */
+     <T extends Type>(type: T): T;
+
+
+
+    /**
+     * Storage for the accumulated annotations so far used by the DSL syntax.
+     *
+     * Used by {@link Class} to annotate the generated class.
+     */
+     annotations: any[];
+
+
+    /**
+     * Generate a class from the definition and annotate it with {@link TypeDecorator#annotations}.
+     */
+     Class(obj: ClassDefinition): Type;
+  }
+
+  enum ChangeDetectionStrategy {
+
+
+    /**
+     * `CheckedOnce` means that after calling detectChanges the mode of the change detector
+     * will become `Checked`.
+     */
+     CheckOnce,
+
+
+    /**
+     * `Checked` means that the change detector should be skipped until its mode changes to
+     * `CheckOnce`.
+     */
+     Checked,
+
+
+    /**
+     * `CheckAlways` means that after calling detectChanges the mode of the change detector
+     * will remain `CheckAlways`.
+     */
+     CheckAlways,
+
+
+    /**
+     * `Detached` means that the change detector sub tree is not a part of the main tree and
+     * should be skipped.
+     */
+     Detached,
+
+
+    /**
+     * `OnPush` means that the change detector's mode will be set to `CheckOnce` during hydration.
+     */
+     OnPush,
+
+
+    /**
+     * `Default` means that the change detector's mode will be set to `CheckAlways` during hydration.
+     */
+     Default,
+
+
+    /**
+     * This is an experimental feature. Works only in Dart.
+     */
+     OnPushObserve
+  }
+
+
+  /**
+   * An error thrown if application changes model breaking the top-down data flow.
+   *
+   * Angular expects that the data flows from top (root) component to child (leaf) components.
+   * This is known as directed acyclic graph. This allows Angular to only execute change detection
+   * once and prevents loops in change detection data flow.
+   *
+   * This exception is only thrown in dev mode.
+   */
+  class ExpressionChangedAfterItHasBeenCheckedException extends BaseException {
+  }
+
+
+  /**
+   * Thrown when an expression evaluation raises an exception.
+   *
+   * This error wraps the original exception, this is done to attach expression location information.
+   */
+  class ChangeDetectionError extends BaseException {
+
+
+    /**
+     * Location of the expression.
+     */
+     location: string;
+  }
+
+  interface ChangeDetector {
+
+     parent: ChangeDetector;
+
+     mode: ChangeDetectionStrategy;
+
+     ref: ChangeDetectorRef;
+
+     addChild(cd: ChangeDetector): void;
+
+     addShadowDomChild(cd: ChangeDetector): void;
+
+     removeChild(cd: ChangeDetector): void;
+
+     removeShadowDomChild(cd: ChangeDetector): void;
+
+     remove(): void;
+
+     hydrate(context: any, locals: Locals, directives: any, pipes: any): void;
+
+     dehydrate(): void;
+
+     markPathToRootAsCheckOnce(): void;
+
+     handleEvent(eventName: string, elIndex: number, locals: Locals): void;
+
+     detectChanges(): void;
+
+     checkNoChanges(): void;
+  }
+
+  class Locals {
+
+     parent: Locals;
+
+     current: Map<any, any>;
+
+     contains(name: string): boolean;
+
+     get(name: string): any;
+
+     set(name: string, value: any): void;
+
+     clearValues(): void;
+  }
+
+
+  /**
+   * Controls change detection.
+   *
+   * {@link ChangeDetectorRef} allows requesting checks for detectors that rely on observables. It
+   * also allows detaching and attaching change detector subtrees.
+   */
+  interface ChangeDetectorRef {
+
+
+    /**
+     * Request to check all OnPush ancestors.
+     */
+     markForCheck(): void;
+
+
+    /**
+     * Detaches the change detector from the change detector tree.
+     *
+     * The detached change detector will not be checked until it is reattached.
+     */
+     detach(): void;
+
+
+    /**
+     * Reattach the change detector to the change detector tree.
+     *
+     * This also requests a check of this change detector. This reattached change detector will be
+     * checked during the next change detection run.
+     */
+     reattach(): void;
+  }
+
+
+  /**
+   * Indicates that the result of a {@link PipeMetadata} transformation has changed even though the
+   * reference
+   * has not changed.
+   *
+   * The wrapped value will be unwrapped by change detection, and the unwrapped value will be stored.
+   *
+   * Example:
+   *
+   * ```
+   * if (this._latestValue === this._latestReturnedValue) {
+   *    return this._latestReturnedValue;
+   *  } else {
+   *    this._latestReturnedValue = this._latestValue;
+   *    return WrappedValue.wrap(this._latestValue); // this will force update
+   *  }
+   * ```
+   */
+  class WrappedValue {
+
+     static wrap(value: any): WrappedValue;
+
+     wrapped: any;
+  }
+
+
+  /**
+   * An interface which all pipes must implement.
+   *
+   * #Example
+   *
+   * ```
+   * class DoublePipe implements PipeTransform {
+   *  transform(value, args = []) {
+   *    return `${value}${value}`;
+   *  }
+   * }
+   * ```
+   */
+  interface PipeTransform {
+
+     transform(value: any, args: any[]): any;
+  }
+
+
+  /**
+   * An interface that stateful pipes should implement.
+   *
+   * #Example
+   *
+   * ```
+   * class StatefulPipe implements PipeTransform, PipeOnDestroy {
+   *  connection;
+   *
+   *  onDestroy() {
+   *    this.connection.release();
+   *  }
+   *
+   *  transform(value, args = []) {
+   *    this.connection = createConnection();
+   *    // ...
+   *    return someValue;
+   *  }
+   * }
+   * ```
+   */
+  interface PipeOnDestroy {
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * A repository of different iterable diffing strategies used by NgFor, NgClass, and others.
+   */
+  class IterableDiffers {
+
+     static create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers;
+
+
+    /**
+     * Takes an array of {@link IterableDifferFactory} and returns a binding used to extend the
+     * inherited {@link IterableDiffers} instance with the provided factories and return a new
+     * {@link IterableDiffers} instance.
+     *
+     * The following example shows how to extend an existing list of factories,
+     * which will only be applied to the injector for this component and its children.
+     * This step is all that's required to make a new {@link IterableDiffer} available.
+     *
+     * # Example
+     *
+     * ```
+     * @Component({
+     *   viewBindings: [
+     *     IterableDiffers.extend([new ImmutableListDiffer()])
+     *   ]
+     * })
+     * ```
+     */
+     static extend(factories: IterableDifferFactory[]): Binding;
+
+     factories: IterableDifferFactory[];
+
+     find(iterable: Object): IterableDifferFactory;
+  }
+
+  interface IterableDiffer {
+
+     diff(object: Object): any;
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * Provides a factory for {@link IterableDiffer}.
+   */
+  interface IterableDifferFactory {
+
+     supports(objects: Object): boolean;
+
+     create(cdRef: ChangeDetectorRef): IterableDiffer;
+  }
+
+
+  /**
+   * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.
+   */
+  class KeyValueDiffers {
+
+     static create(factories: KeyValueDifferFactory[], parent?: KeyValueDiffers): KeyValueDiffers;
+
+
+    /**
+     * Takes an array of {@link KeyValueDifferFactory} and returns a binding used to extend the
+     * inherited {@link KeyValueDiffers} instance with the provided factories and return a new
+     * {@link KeyValueDiffers} instance.
+     *
+     * The following example shows how to extend an existing list of factories,
+     * which will only be applied to the injector for this component and its children.
+     * This step is all that's required to make a new {@link KeyValueDiffer} available.
+     *
+     * # Example
+     *
+     * ```
+     * @Component({
+     *   viewBindings: [
+     *     KeyValueDiffers.extend([new ImmutableMapDiffer()])
+     *   ]
+     * })
+     * ```
+     */
+     static extend(factories: KeyValueDifferFactory[]): Binding;
+
+     factories: KeyValueDifferFactory[];
+
+     find(kv: Object): KeyValueDifferFactory;
+  }
+
+  interface KeyValueDiffer {
+
+     diff(object: Object): void;
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * Provides a factory for {@link KeyValueDiffer}.
+   */
+  interface KeyValueDifferFactory {
+
+     supports(objects: Object): boolean;
+
+     create(cdRef: ChangeDetectorRef): KeyValueDiffer;
+  }
+
+
+  /**
+   * An opaque token representing the application root type in the {@link Injector}.
+   *
+   * ```
+   * @Component(...)
+   * @View(...)
+   * class MyApp {
+   *   ...
+   * }
+   *
+   * bootstrap(MyApp).then((appRef:ApplicationRef) {
+   *   expect(appRef.injector.get(appComponentTypeToken)).toEqual(MyApp);
+   * });
+   *
+   * ```
+   */
+  const APP_COMPONENT : OpaqueToken ;
+
+
+  /**
+   * Runtime representation of a type.
+   *
+   * In JavaScript a Type is a constructor function.
+   */
+  interface Type extends Function {
+
+     new(...args: any[]): any;
+
+  }
+
+
+  /**
+   * Represents a Angular's representation of an Application.
+   *
+   * `ApplicationRef` represents a running application instance. Use it to retrieve the host
+   * component, injector,
+   * or dispose of an application.
+   */
+  interface ApplicationRef {
+
+
+    /**
+     * Returns the current {@link ComponentMetadata} type.
+     */
+     hostComponentType: Type;
+
+
+    /**
+     * Returns the current {@link ComponentMetadata} instance.
+     */
+     hostComponent: any;
+
+
+    /**
+     * Dispose (un-load) the application.
+     */
+     dispose(): void;
+
+
+    /**
+     * Returns the root application {@link Injector}.
+     */
+     injector: Injector;
+  }
+
+
+  /**
+   * Specifies app root url for the application.
+   *
+   * Used by the {@link Compiler} when resolving HTML and CSS template URLs.
+   *
+   * This interface can be overridden by the application developer to create custom behavior.
+   *
+   * See {@link Compiler}
+   */
+  class AppRootUrl {
+
+
+    /**
+     * Returns the base URL of the currently running application.
+     */
+     value: any;
+  }
+
+
+  /**
+   * Used by the {@link Compiler} when resolving HTML and CSS template URLs.
+   *
+   * This interface can be overridden by the application developer to create custom behavior.
+   *
+   * See {@link Compiler}
+   */
+  class UrlResolver {
+
+
+    /**
+     * Resolves the `url` given the `baseUrl`:
+     * - when the `url` is null, the `baseUrl` is returned,
+     * - if `url` is relative ('path/to/here', './path/to/here'), the resolved url is a combination of
+     * `baseUrl` and `url`,
+     * - if `url` is absolute (it has a scheme: 'http://', 'https://' or start with '/'), the `url` is
+     * returned as is (ignoring the `baseUrl`)
+     *
+     * @param {string} baseUrl
+     * @param {string} url
+     * @returns {string} the resolved URL
+     */
+     resolve(baseUrl: string, url: string): string;
+  }
+
+
+  /**
+   * Resolve a `Type` from a {@link ComponentMetadata} into a URL.
+   *
+   * This interface can be overridden by the application developer to create custom behavior.
+   *
+   * See {@link Compiler}
+   */
+  class ComponentUrlMapper {
+
+
+    /**
+     * Returns the base URL to the component source file.
+     * The returned URL could be:
+     * - an absolute URL,
+     * - a path relative to the application
+     */
+     getUrl(component: Type): string;
+  }
+
+
+  /**
+   * Resolve a `Type` for {@link DirectiveMetadata}.
+   *
+   * This interface can be overridden by the application developer to create custom behavior.
+   *
+   * See {@link Compiler}
+   */
+  class DirectiveResolver {
+
+
+    /**
+     * Return {@link DirectiveMetadata} for a given `Type`.
+     */
+     resolve(type: Type): DirectiveMetadata;
+  }
+
+
+  /**
+   * ## URL Resolution
+   *
+   * ```
+   * var appRootUrl: AppRootUrl = ...;
+   * var componentUrlMapper: ComponentUrlMapper = ...;
+   * var urlResolver: UrlResolver = ...;
+   *
+   * var componentType: Type = ...;
+   * var componentAnnotation: ComponentAnnotation = ...;
+   * var viewAnnotation: ViewAnnotation = ...;
+   *
+   * // Resolving a URL
+   *
+   * var url = viewAnnotation.templateUrl;
+   * var componentUrl = componentUrlMapper.getUrl(componentType);
+   * var componentResolvedUrl = urlResolver.resolve(appRootUrl.value, componentUrl);
+   * var templateResolvedUrl = urlResolver.resolve(componetResolvedUrl, url);
+   * ```
+   */
+  interface Compiler {
+
+     compileInHost(componentTypeOrBinding: Type | Binding): Promise<ProtoViewRef>;
+  }
+
+
+  /**
+   * Entry point for creating, moving views in the view hierarchy and destroying views.
+   * This manager contains all recursion and delegates to helper methods
+   * in AppViewManagerUtils and the Renderer, so unit tests get simpler.
+   */
+  interface AppViewManager {
+
+
+    /**
+     * Returns a {@link ViewContainerRef} at the {@link ElementRef} location.
+     */
+     getViewContainer(location: ElementRef): ViewContainerRef;
+
+
+    /**
+     * Return the first child element of the host element view.
+     */
+     getHostElement(hostViewRef: HostViewRef): ElementRef;
+
+
+    /**
+     * Returns an ElementRef for the element with the given variable name
+     * in the current view.
+     *
+     * - `hostLocation`: {@link ElementRef} of any element in the View which defines the scope of
+     *   search.
+     * - `variableName`: Name of the variable to locate.
+     * - Returns {@link ElementRef} of the found element or null. (Throws if not found.)
+     */
+     getNamedElementInComponentView(hostLocation: ElementRef, variableName: string): ElementRef;
+
+
+    /**
+     * Returns the component instance for a given element.
+     *
+     * The component is the execution context as seen by an expression at that {@link ElementRef}
+     * location.
+     */
+     getComponent(hostLocation: ElementRef): any;
+
+
+    /**
+     * Load component view into existing element.
+     *
+     * Use this if a host element is already in the DOM and it is necessary to upgrade
+     * the element into Angular component by attaching a view but reusing the existing element.
+     *
+     * - `hostProtoViewRef`: {@link ProtoViewRef} Proto view to use in creating a view for this
+     *   component.
+     * - `overrideSelector`: (optional) selector to use in locating the existing element to load
+     *   the view into. If not specified use the selector in the component definition of the
+     *   `hostProtoView`.
+     * - injector: {@link Injector} to use as parent injector for the view.
+     *
+     * See {@link AppViewManager#destroyRootHostView}.
+     *
+     * ## Example
+     *
+     * ```
+     * @ng.Component({
+     *   selector: 'child-component'
+     * })
+     * @ng.View({
+     *   template: 'Child'
+     * })
+     * class ChildComponent {
+     *
+     * }
+     *
+     * @ng.Component({
+     *   selector: 'my-app'
+     * })
+     * @ng.View({
+     *   template: `
+     *     Parent (<some-component></some-component>)
+     *   `
+     * })
+     * class MyApp {
+     *   viewRef: ng.ViewRef;
+     *
+     *   constructor(public appViewManager: ng.AppViewManager, compiler: ng.Compiler) {
+     *     compiler.compileInHost(ChildComponent).then((protoView: ng.ProtoViewRef) => {
+     *       this.viewRef = appViewManager.createRootHostView(protoView, 'some-component', null);
+     *     })
+     *   }
+     *
+     *   onDestroy() {
+     *     this.appViewManager.destroyRootHostView(this.viewRef);
+     *     this.viewRef = null;
+     *   }
+     * }
+     *
+     * ng.bootstrap(MyApp);
+     * ```
+     */
+     createRootHostView(hostProtoViewRef: ProtoViewRef, overrideSelector: string, injector: Injector): HostViewRef;
+
+
+    /**
+     * Remove the View created with {@link AppViewManager#createRootHostView}.
+     */
+     destroyRootHostView(hostViewRef: HostViewRef): void;
+
+
+    /**
+     * See {@link AppViewManager#destroyViewInContainer}.
+     */
+     createEmbeddedViewInContainer(viewContainerLocation: ElementRef, atIndex: number, templateRef: TemplateRef): ViewRef;
+
+
+    /**
+     * See {@link AppViewManager#destroyViewInContainer}.
+     */
+     createHostViewInContainer(viewContainerLocation: ElementRef, atIndex: number, protoViewRef: ProtoViewRef, imperativelyCreatedInjector: ResolvedBinding[]): HostViewRef;
+
+
+    /**
+     * See {@link AppViewManager#createViewInContainer}.
+     */
+     destroyViewInContainer(viewContainerLocation: ElementRef, atIndex: number): void;
+
+
+    /**
+     * See {@link AppViewManager#detachViewInContainer}.
+     */
+     attachViewInContainer(viewContainerLocation: ElementRef, atIndex: number, viewRef: ViewRef): ViewRef;
+
+
+    /**
+     * See {@link AppViewManager#attachViewInContainer}.
+     */
+     detachViewInContainer(viewContainerLocation: ElementRef, atIndex: number): ViewRef;
+  }
+
+
+  /**
+   * An iterable and observable live list of components in the DOM.
+   *
+   * A QueryList contains a live list of child directives in the DOM of a directive.
+   * The directives are kept in depth-first pre-order traversal of the DOM.
+   *
+   * The `QueryList` is iterable, therefore it can be used in both javascript code with `for..of` loop
+   * as well as in template with `*ng-for="of"` directive.
+   *
+   * QueryList is updated as part of the change-detection cycle of a directive. Since change detection
+   * happens after construction of a directive, QueryList will always be empty when observed in the
+   * constructor.
+   *
+   *
+   * NOTE: In the future this class will implement an `Observable` interface. For now it uses a plain
+   * list of observable callbacks.
+   *
+   * # Example:
+   *
+   * Assume that `<tabs>` component would like to get a list its children which are `<pane>`
+   * components as shown in this example:
+   *
+   * ```html
+   * <tabs>
+   *   <pane title="Overview">...</pane>
+   *   <pane *ng-for="#o of objects" [title]="o.title">{{o.text}}</pane>
+   * </tabs>
+   * ```
+   *
+   * In the above example the list of `<tabs>` elements needs to get a list of `<pane>` elements so
+   * that it could render tabs with the correct titles and in the correct order.
+   *
+   * A possible solution would be for a `<pane>` to inject `<tabs>` component and then register itself
+   * with `<tabs>` component's on `hydrate` and deregister on `dehydrate` event. While a reasonable
+   * approach, this would only work partialy since `*ng-for` could rearrange the list of `<pane>`
+   * components which would not be reported to `<tabs>` component and thus the list of `<pane>`
+   * components would be out of sync with respect to the list of `<pane>` elements.
+   *
+   * A preferred solution is to inject a `QueryList` which is a live list of directives in the
+   * component`s light DOM.
+   *
+   * ```javascript
+   * @Component({
+   *   selector: 'tabs'
+   * })
+   * @View({
+   *  template: `
+   *    <ul>
+   *      <li *ng-for="#pane of panes">{{pane.title}}</li>
+   *    </ul>
+   *    <content></content>
+   *  `
+   * })
+   * class Tabs {
+   *   panes: QueryList<Pane>
+   *
+   *   constructor(@Query(Pane) panes:QueryList<Pane>) {
+   *     this.panes = panes;
+   *   }
+   * }
+   *
+   * @Component({
+   *   selector: 'pane',
+   *   properties: ['title']
+   * })
+   * @View(...)
+   * class Pane {
+   *   title:string;
+   * }
+   * ```
+   */
+  class QueryList<T> {
+
+     reset(newList: T[]): void;
+
+     add(obj: T): void;
+
+     fireCallbacks(): void;
+
+     onChange(callback: () => void): void;
+
+     removeCallback(callback: () => void): void;
+
+     toString(): string;
+
+     length: number;
+
+     first: T;
+
+     last: T;
+
+     map<U>(fn: (item: T) => U): U[];
+  }
+
+
+  /**
+   * Service for dynamically loading a Component into an arbitrary position in the internal Angular
+   * application tree.
+   */
+  class DynamicComponentLoader {
+
+
+    /**
+     * Loads a root component that is placed at the first element that matches the component's
+     * selector.
+     *
+     * - `typeOrBinding` `Type` \ {@link Binding} - representing the component to load.
+     * - `overrideSelector` (optional) selector to load the component at (or use
+     *   `@Component.selector`) The selector can be anywhere (i.e. outside the current component.)
+     * - `injector` {@link Injector} - optional injector to use for the component.
+     *
+     * The loaded component receives injection normally as a hosted view.
+     *
+     *
+     * ## Example
+     *
+     * ```
+     * @ng.Component({
+     *   selector: 'child-component'
+     * })
+     * @ng.View({
+     *   template: 'Child'
+     * })
+     * class ChildComponent {
+     * }
+     *
+     *
+     *
+     * @ng.Component({
+     *   selector: 'my-app'
+     * })
+     * @ng.View({
+     *   template: `
+     *     Parent (<child id="child"></child>)
+     *   `
+     * })
+     * class MyApp {
+     *   constructor(dynamicComponentLoader: ng.DynamicComponentLoader, injector: ng.Injector) {
+     *     dynamicComponentLoader.loadAsRoot(ChildComponent, '#child', injector);
+     *   }
+     * }
+     *
+     * ng.bootstrap(MyApp);
+     * ```
+     *
+     * Resulting DOM:
+     *
+     * ```
+     * <my-app>
+     *   Parent (
+     *     <child id="child">
+     *        Child
+     *     </child>
+     *   )
+     * </my-app>
+     * ```
+     */
+     loadAsRoot(typeOrBinding: Type | Binding, overrideSelector: string, injector: Injector): Promise<ComponentRef>;
+
+
+    /**
+     * Loads a component into the component view of the provided ElementRef next to the element
+     * with the given name.
+     *
+     * The loaded component receives injection normally as a hosted view.
+     *
+     * ## Example
+     *
+     * ```
+     * @ng.Component({
+     *   selector: 'child-component'
+     * })
+     * @ng.View({
+     *   template: 'Child'
+     * })
+     * class ChildComponent {
+     * }
+     *
+     *
+     * @ng.Component({
+     *   selector: 'my-app'
+     * })
+     * @ng.View({
+     *   template: `
+     *     Parent (<div #child></div>)
+     *   `
+     * })
+     * class MyApp {
+     *   constructor(dynamicComponentLoader: ng.DynamicComponentLoader, elementRef: ng.ElementRef) {
+     *     dynamicComponentLoader.loadIntoLocation(ChildComponent, elementRef, 'child');
+     *   }
+     * }
+     *
+     * ng.bootstrap(MyApp);
+     * ```
+     *
+     * Resulting DOM:
+     *
+     * ```
+     * <my-app>
+     *    Parent (
+     *      <div #child="" class="ng-binding"></div>
+     *      <child-component class="ng-binding">Child</child-component>
+     *    )
+     * </my-app>
+     * ```
+     */
+     loadIntoLocation(typeOrBinding: Type | Binding, hostLocation: ElementRef, anchorName: string, bindings?: ResolvedBinding[]): Promise<ComponentRef>;
+
+
+    /**
+     * Loads a component next to the provided ElementRef.
+     *
+     * The loaded component receives injection normally as a hosted view.
+     *
+     *
+     * ## Example
+     *
+     * ```
+     * @ng.Component({
+     *   selector: 'child-component'
+     * })
+     * @ng.View({
+     *   template: 'Child'
+     * })
+     * class ChildComponent {
+     * }
+     *
+     *
+     * @ng.Component({
+     *   selector: 'my-app'
+     * })
+     * @ng.View({
+     *   template: `Parent`
+     * })
+     * class MyApp {
+     *   constructor(dynamicComponentLoader: ng.DynamicComponentLoader, elementRef: ng.ElementRef) {
+     *     dynamicComponentLoader.loadIntoLocation(ChildComponent, elementRef, 'child');
+     *   }
+     * }
+     *
+     * ng.bootstrap(MyApp);
+     * ```
+     *
+     * Resulting DOM:
+     *
+     * ```
+     * <my-app>Parent</my-app>
+     * <child-component>Child</child-component>
+     * ```
+     */
+     loadNextToLocation(typeOrBinding: Type | Binding, location: ElementRef, bindings?: ResolvedBinding[]): Promise<ComponentRef>;
+  }
+
+
+  /**
+   * Provides access to explicitly trigger change detection in an application.
+   *
+   * By default, `Zone` triggers change detection in Angular on each virtual machine (VM) turn. When
+   * testing, or in some
+   * limited application use cases, a developer can also trigger change detection with the
+   * `lifecycle.tick()` method.
+   *
+   * Each Angular application has a single `LifeCycle` instance.
+   *
+   * # Example
+   *
+   * This is a contrived example, since the bootstrap automatically runs inside of the `Zone`, which
+   * invokes
+   * `lifecycle.tick()` on your behalf.
+   *
+   * ```javascript
+   * bootstrap(MyApp).then((ref:ComponentRef) => {
+   *   var lifeCycle = ref.injector.get(LifeCycle);
+   *   var myApp = ref.instance;
+   *
+   *   ref.doSomething();
+   *   lifecycle.tick();
+   * });
+   * ```
+   */
+  class LifeCycle {
+
+
+    /**
+     * @private
+     */
+     registerWith(zone: NgZone, changeDetector?: ChangeDetector): void;
+
+
+    /**
+     * Invoke this method to explicitly process change detection and its side-effects.
+     *
+     *  In development mode, `tick()` also performs a second change detection cycle to ensure that no
+     * further
+     *  changes are detected. If additional changes are picked up during this second cycle, bindings
+     * in
+     * the app have
+     *  side-effects that cannot be resolved in a single change detection pass. In this case, Angular
+     * throws an error,
+     *  since an Angular application can only have one change detection pass during which all change
+     * detection must
+     *  complete.
+     */
+     tick(): void;
+  }
+
+
+  /**
+   * Reference to the element.
+   *
+   * Represents an opaque reference to the underlying element. The element is a DOM ELement in
+   * a Browser, but may represent other types on other rendering platforms. In the browser the
+   * `ElementRef` can be sent to the web-worker. Web Workers can not have references to the
+   * DOM Elements.
+   */
+  class ElementRef implements RenderElementRef {
+
+
+    /**
+     * Reference to the {@link ViewRef} where the `ElementRef` is inside of.
+     */
+     parentView: ViewRef;
+
+
+    /**
+     * Index of the element inside the {@link ViewRef}.
+     *
+     * This is used internally by the Angular framework to locate elements.
+     */
+     boundElementIndex: number;
+
+
+    /**
+     * Index of the element inside the `RenderViewRef`.
+     *
+     * This is used internally by the Angular framework to locate elements.
+     */
+     renderBoundElementIndex: number;
+
+     renderView: RenderViewRef;
+
+
+    /**
+     * Returns the native Element implementation.
+     *
+     * In the browser this represents the DOM Element.
+     *
+     * The `nativeElement` can be used as an escape hatch when direct DOM manipulation is needed. Use
+     * this with caution, as it creates tight coupling between your application and the Browser, which
+     * will not work in WebWorkers.
+     *
+     * NOTE: This method will return null in the webworker scenario!
+     */
+     nativeElement: any;
+  }
+
+
+  /**
+   * Reference to a template within a component.
+   *
+   * Represents an opaque reference to the underlying template that can
+   * be instantiated using the {@link ViewContainerRef}.
+   */
+  class TemplateRef {
+
+
+    /**
+     * The location of the template
+     */
+     elementRef: ElementRef;
+
+     protoViewRef: ProtoViewRef;
+
+
+    /**
+     * Whether this template has a local variable with the given name
+     */
+     hasLocal(name: string): boolean;
+  }
+
+
+  /**
+   * A reference to an Angular View.
+   *
+   * A View is a fundamental building block of Application UI. A View is the smallest set of
+   * elements which are created and destroyed together. A View can change properties on the elements
+   * within the view, but it can not change the structure of those elements.
+   *
+   * To change structure of the elements, the Views can contain zero or more {@link ViewContainerRef}s
+   * which allow the views to be nested.
+   *
+   * ## Example
+   *
+   * Given this template
+   *
+   * ```
+   * Count: {{items.length}}
+   * <ul>
+   *   <li *ng-for="var item of items">{{item}}</li>
+   * </ul>
+   * ```
+   *
+   * The above example we have two {@link ProtoViewRef}s:
+   *
+   * Outter {@link ProtoViewRef}:
+   * ```
+   * Count: {{items.length}}
+   * <ul>
+   *   <template ng-for var-item [ng-for-of]="items"></template>
+   * </ul>
+   * ```
+   *
+   * Inner {@link ProtoViewRef}:
+   * ```
+   *   <li>{{item}}</li>
+   * ```
+   *
+   * Notice that the original template is broken down into two separate {@link ProtoViewRef}s.
+   *
+   * The outter/inner {@link ProtoViewRef}s are then assembled into views like so:
+   *
+   * ```
+   * <!-- ViewRef: outer-0 -->
+   * Count: 2
+   * <ul>
+   *   <template view-container-ref></template>
+   *   <!-- ViewRef: inner-1 --><li>first</li><!-- /ViewRef: inner-1 -->
+   *   <!-- ViewRef: inner-2 --><li>second</li><!-- /ViewRef: inner-2 -->
+   * </ul>
+   * <!-- /ViewRef: outer-0 -->
+   * ```
+   */
+  interface ViewRef extends HostViewRef {
+
+
+    /**
+     * Return `RenderViewRef`
+     */
+     render: RenderViewRef;
+
+
+    /**
+     * Return `RenderFragmentRef`
+     */
+     renderFragment: RenderFragmentRef;
+
+
+    /**
+     * Set local variable in a view.
+     *
+     * - `contextName` - Name of the local variable in a view.
+     * - `value` - Value for the local variable in a view.
+     */
+     setLocal(contextName: string, value: any): void;
+  }
+
+  interface HostViewRef {
+  }
+
+
+  /**
+   * A reference to an Angular ProtoView.
+   *
+   * A ProtoView is a reference to a template for easy creation of views.
+   * (See {@link AppViewManager#createViewInContainer `AppViewManager#createViewInContainer`} and
+   * {@link AppViewManager#createRootHostView `AppViewManager#createRootHostView`}).
+   *
+   * A `ProtoView` is a factory for creating `View`s.
+   *
+   * ## Example
+   *
+   * Given this template
+   *
+   * ```
+   * Count: {{items.length}}
+   * <ul>
+   *   <li *ng-for="var item of items">{{item}}</li>
+   * </ul>
+   * ```
+   *
+   * The above example we have two {@link ProtoViewRef}s:
+   *
+   * Outter {@link ProtoViewRef}:
+   * ```
+   * Count: {{items.length}}
+   * <ul>
+   *   <template ng-for var-item [ng-for-of]="items"></template>
+   * </ul>
+   * ```
+   *
+   * Inner {@link ProtoViewRef}:
+   * ```
+   *   <li>{{item}}</li>
+   * ```
+   *
+   * Notice that the original template is broken down into two separate {@link ProtoViewRef}s.
+   */
+  interface ProtoViewRef {
+  }
+
+
+  /**
+   * A location where {@link ViewRef}s can be attached.
+   *
+   * A `ViewContainerRef` represents a location in a {@link ViewRef} where other child
+   * {@link ViewRef}s can be inserted. Adding and removing views is the only way of structurally
+   * changing the rendered DOM of the application.
+   */
+  interface ViewContainerRef {
+
+     viewManager: AppViewManager;
+
+     element: ElementRef;
+
+
+    /**
+     * Remove all {@link ViewRef}s at current location.
+     */
+     clear(): void;
+
+
+    /**
+     * Return a {@link ViewRef} at specific index.
+     */
+     get(index: number): ViewRef;
+
+
+    /**
+     * Returns number of {@link ViewRef}s currently attached at this location.
+     */
+     length: number;
+
+
+    /**
+     * Create and insert a {@link ViewRef} into the view-container.
+     *
+     * - `protoViewRef` (optional) {@link ProtoViewRef} - The `ProtoView` to use for creating
+     *   `View` to be inserted at this location. If `ViewContainer` is created at a location
+     *   of inline template, then `protoViewRef` is the `ProtoView` of the template.
+     * - `atIndex` (optional) `number` - location of insertion point. (Or at the end if unspecified.)
+     * - `context` (optional) {@link ElementRef} - Context (for expression evaluation) from the
+     *   {@link ElementRef} location. (Or current context if unspecified.)
+     * - `bindings` (optional) Array of {@link ResolvedBinding} - Used for configuring
+     *   `ElementInjector`.
+     *
+     * Returns newly created {@link ViewRef}.
+     */
+     createEmbeddedView(templateRef: TemplateRef, atIndex?: number): ViewRef;
+
+     createHostView(protoViewRef?: ProtoViewRef, atIndex?: number, dynamicallyCreatedBindings?: ResolvedBinding[]): HostViewRef;
+
+
+    /**
+     * Insert a {@link ViewRef} at specefic index.
+     *
+     * The index is location at which the {@link ViewRef} should be attached. If omitted it is
+     * inserted at the end.
+     *
+     * Returns the inserted {@link ViewRef}.
+     */
+     insert(viewRef: ViewRef, atIndex?: number): ViewRef;
+
+
+    /**
+     * Return the index of already inserted {@link ViewRef}.
+     */
+     indexOf(viewRef: ViewRef): number;
+
+
+    /**
+     * Remove a {@link ViewRef} at specific index.
+     *
+     * If the index is omitted last {@link ViewRef} is removed.
+     */
+     remove(atIndex?: number): void;
+
+
+    /**
+     * The method can be used together with insert to implement a view move, i.e.
+     * moving the dom nodes while the directives in the view stay intact.
+     */
+     detach(atIndex?: number): ViewRef;
+  }
+
+
+  /**
+   * Angular's reference to a component instance.
+   *
+   * `ComponentRef` represents a component instance lifecycle and meta information.
+   */
+  interface ComponentRef {
+
+
+    /**
+     * Location of the component host element.
+     */
+     location: ElementRef;
+
+
+    /**
+     * Instance of component.
+     */
+     instance: any;
+
+
+    /**
+     * Returns the host {@link ViewRef}.
+     */
+     hostView: HostViewRef;
+
+
+    /**
+     * Dispose of the component instance.
+     */
+     dispose(): void;
+  }
+
+
+  /**
+   * A wrapper around zones that lets you schedule tasks after it has executed a task.
+   *
+   * The wrapper maintains an "inner" and an "mount" `Zone`. The application code will executes
+   * in the "inner" zone unless `runOutsideAngular` is explicitely called.
+   *
+   * A typical application will create a singleton `NgZone`. The outer `Zone` is a fork of the root
+   * `Zone`. The default `onTurnDone` runs the Angular change detection.
+   */
+  class NgZone {
+
+
+    /**
+     * Sets the zone hook that is called just before Angular event turn starts.
+     * It is called once per browser event.
+     */
+     overrideOnTurnStart(onTurnStartFn: Function): void;
+
+
+    /**
+     * Sets the zone hook that is called immediately after Angular processes
+     * all pending microtasks.
+     */
+     overrideOnTurnDone(onTurnDoneFn: Function): void;
+
+
+    /**
+     * Sets the zone hook that is called immediately after the last turn in
+     * an event completes. At this point Angular will no longer attempt to
+     * sync the UI. Any changes to the data model will not be reflected in the
+     * DOM. `onEventDoneFn` is executed outside Angular zone.
+     *
+     * This hook is useful for validating application state (e.g. in a test).
+     */
+     overrideOnEventDone(onEventDoneFn: Function, opt_waitForAsync: boolean): void;
+
+
+    /**
+     * Sets the zone hook that is called when an error is uncaught in the
+     * Angular zone. The first argument is the error. The second argument is
+     * the stack trace.
+     */
+     overrideOnErrorHandler(errorHandlingFn: Function): void;
+
+
+    /**
+     * Runs `fn` in the inner zone and returns whatever it returns.
+     *
+     * In a typical app where the inner zone is the Angular zone, this allows one to make use of the
+     * Angular's auto digest mechanism.
+     *
+     * ```
+     * var zone: NgZone = [ref to the application zone];
+     *
+     * zone.run(() => {
+     *   // the change detection will run after this function and the microtasks it enqueues have
+     * executed.
+     * });
+     * ```
+     */
+     run(fn: () => any): any;
+
+
+    /**
+     * Runs `fn` in the outer zone and returns whatever it returns.
+     *
+     * In a typical app where the inner zone is the Angular zone, this allows one to escape Angular's
+     * auto-digest mechanism.
+     *
+     * ```
+     * var zone: NgZone = [ref to the application zone];
+     *
+     * zone.runOutsideAngular(() => {
+     *   element.onClick(() => {
+     *     // Clicking on the element would not trigger the change detection
+     *   });
+     * });
+     * ```
+     */
+     runOutsideAngular(fn: () => any): any;
+  }
+
+  class Observable {
+
+     observer(generator: any): Object;
+  }
+
+
+  /**
+   * Use Rx.Observable but provides an adapter to make it work as specified here:
+   * https://github.com/jhusain/observable-spec
+   *
+   * Once a reference implementation of the spec is available, switch to it.
+   */
+  class EventEmitter extends Observable {
+
+     observer(generator: any): Rx.IDisposable;
+
+     toRx(): Rx.Observable<any>;
+
+     next(value: any): void;
+
+     throw(error: any): void;
+
+     return(value?: any): void;
+  }
+
+
+  /**
+   * A parameter metadata that specifies a dependency.
+   *
+   * ```
+   * class AComponent {
+   *   constructor(@Inject(MyService) aService:MyService) {}
+   * }
+   * ```
+   */
+  class InjectMetadata {
+
+     token: any;
+
+     toString(): string;
+  }
+
+
+  /**
+   * A parameter metadata that marks a dependency as optional. {@link Injector} provides `null` if
+   * the dependency is not found.
+   *
+   * ```
+   * class AComponent {
+   *   constructor(@Optional() aService:MyService) {
+   *     this.aService = aService;
+   *   }
+   * }
+   * ```
+   */
+  class OptionalMetadata {
+
+     toString(): string;
+  }
+
+
+  /**
+   * A marker metadata that marks a class as available to `Injector` for creation. Used by tooling
+   * for generating constructor stubs.
+   *
+   * ```
+   * class NeedsService {
+   *   constructor(svc:UsefulService) {}
+   * }
+   *
+   * @Injectable
+   * class UsefulService {}
+   * ```
+   */
+  class InjectableMetadata {
+  }
+
+
+  /**
+   * Specifies that an injector should retrieve a dependency from itself.
+   *
+   * ## Example
+   *
+   * ```
+   * class Dependency {
+   * }
+   *
+   * class NeedsDependency {
+   *   constructor(public @Self() dependency:Dependency) {}
+   * }
+   *
+   * var inj = Injector.resolveAndCreate([Dependency, NeedsDependency]);
+   * var nd = inj.get(NeedsDependency);
+   * expect(nd.dependency).toBeAnInstanceOf(Dependency);
+   * ```
+   */
+  class SelfMetadata {
+
+     toString(): string;
+  }
+
+
+  /**
+   * Specifies that an injector should retrieve a dependency from any injector until reaching the
+   * closest host.
+   *
+   * ## Example
+   *
+   * ```
+   * class Dependency {
+   * }
+   *
+   * class NeedsDependency {
+   *   constructor(public @Host() dependency:Dependency) {}
+   * }
+   *
+   * var parent = Injector.resolveAndCreate([
+   *   bind(Dependency).toClass(HostDependency)
+   * ]);
+   * var child = parent.resolveAndCreateChild([]);
+   * var grandChild = child.resolveAndCreateChild([NeedsDependency, Depedency]);
+   * var nd = grandChild.get(NeedsDependency);
+   * expect(nd.dependency).toBeAnInstanceOf(HostDependency);
+   * ```
+   */
+  class HostMetadata {
+
+     toString(): string;
+  }
+
+
+  /**
+   * Specifies that the dependency resolution should start from the parent injector.
+   *
+   * ## Example
+   *
+   *
+   * ```
+   * class Service {}
+   *
+   * class ParentService implements Service {
+   * }
+   *
+   * class ChildService implements Service {
+   *   constructor(public @SkipSelf() parentService:Service) {}
+   * }
+   *
+   * var parent = Injector.resolveAndCreate([
+   *   bind(Service).toClass(ParentService)
+   * ]);
+   * var child = parent.resolveAndCreateChild([
+   *   bind(Service).toClass(ChildSerice)
+   * ]);
+   * var s = child.get(Service);
+   * expect(s).toBeAnInstanceOf(ChildService);
+   * expect(s.parentService).toBeAnInstanceOf(ParentService);
+   * ```
+   */
+  class SkipSelfMetadata {
+
+     toString(): string;
+  }
+
+
+  /**
+   * `DependencyMetadata is used by the framework to extend DI.
+   *
+   * Only metadata implementing `DependencyMetadata` are added to the list of dependency
+   * properties.
+   *
+   * For example:
+   *
+   * ```
+   * class Exclude extends DependencyMetadata {}
+   * class NotDependencyProperty {}
+   *
+   * class AComponent {
+   *   constructor(@Exclude @NotDependencyProperty aService:AService) {}
+   * }
+   * ```
+   *
+   * will create the following dependency:
+   *
+   * ```
+   * new Dependency(Key.get(AService), [new Exclude()])
+   * ```
+   *
+   * The framework can use `new Exclude()` to handle the `aService` dependency
+   * in a specific way.
+   */
+  class DependencyMetadata {
+
+     token: any;
+  }
+
+
+  /**
+   * Allows to refer to references which are not yet defined.
+   *
+   * This situation arises when the key which we need te refer to for the purposes of DI is declared,
+   * but not yet defined.
+   *
+   * ## Example:
+   *
+   * ```
+   * class Door {
+   *   // Incorrect way to refer to a reference which is defined later.
+   *   // This fails because `Lock` is undefined at this point.
+   *   constructor(lock:Lock) { }
+   *
+   *   // Correct way to refer to a reference which is defined later.
+   *   // The reference needs to be captured in a closure.
+   *   constructor(@Inject(forwardRef(() => Lock)) lock:Lock) { }
+   * }
+   *
+   * // Only at this point the lock is defined.
+   * class Lock {
+   * }
+   * ```
+   */
+  function forwardRef(forwardRefFn: ForwardRefFn) : Type ;
+
+
+  /**
+   * Lazily retrieve the reference value.
+   *
+   * See: {@link forwardRef}
+   */
+  function resolveForwardRef(type: any) : any ;
+
+  interface ForwardRefFn {
+
+     (): any;
+
+  }
+
+
+  /**
+   * A dependency injection container used for resolving dependencies.
+   *
+   * An `Injector` is a replacement for a `new` operator, which can automatically resolve the
+   * constructor dependencies.
+   * In typical use, application code asks for the dependencies in the constructor and they are
+   * resolved by the `Injector`.
+   *
+   * ## Example:
+   *
+   * Suppose that we want to inject an `Engine` into class `Car`, we would define it like this:
+   *
+   * ```javascript
+   * class Engine {
+   * }
+   *
+   * class Car {
+   *   constructor(@Inject(Engine) engine) {
+   *   }
+   * }
+   *
+   * ```
+   *
+   * Next we need to write the code that creates and instantiates the `Injector`. We then ask for the
+   * `root` object, `Car`, so that the `Injector` can recursively build all of that object's
+   * dependencies.
+   *
+   * ```javascript
+   * main() {
+   *   var injector = Injector.resolveAndCreate([Car, Engine]);
+   *
+   *   // Get a reference to the `root` object, which will recursively instantiate the tree.
+   *   var car = injector.get(Car);
+   * }
+   * ```
+   * Notice that we don't use the `new` operator because we explicitly want to have the `Injector`
+   * resolve all of the object's dependencies automatically.
+   */
+  class Injector {
+
+
+    /**
+     * Turns a list of binding definitions into an internal resolved list of resolved bindings.
+     *
+     * A resolution is a process of flattening multiple nested lists and converting individual
+     * bindings into a list of {@link ResolvedBinding}s. The resolution can be cached by `resolve`
+     * for the {@link Injector} for performance-sensitive code.
+     *
+     * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
+     * recursive list of more bindings.
+     *
+     * The returned list is sparse, indexed by `id` for the {@link Key}. It is generally not useful to
+     * application code
+     * other than for passing it to {@link Injector} functions that require resolved binding lists,
+     * such as
+     * `fromResolvedBindings` and `createChildFromResolved`.
+     */
+     static resolve(bindings: Array<Type | Binding | any[]>): ResolvedBinding[];
+
+
+    /**
+     * Resolves bindings and creates an injector based on those bindings. This function is slower than
+     * the corresponding `fromResolvedBindings` because it needs to resolve bindings first. See
+     * `resolve`
+     * for the {@link Injector}.
+     *
+     * Prefer `fromResolvedBindings` in performance-critical code that creates lots of injectors.
+     *
+     * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
+     * recursive list of more
+     * bindings.
+     * @param `depProvider`
+     */
+     static resolveAndCreate(bindings: Array<Type | Binding | any[]>, depProvider?: DependencyProvider): Injector;
+
+
+    /**
+     * Creates an injector from previously resolved bindings. This bypasses resolution and flattening.
+     * This API is the recommended way to construct injectors in performance-sensitive parts.
+     *
+     * @param `bindings` A sparse list of {@link ResolvedBinding}s. See `resolve` for the
+     * {@link Injector}.
+     * @param `depProvider`
+     */
+     static fromResolvedBindings(bindings: ResolvedBinding[], depProvider?: DependencyProvider): Injector;
+
+
+    /**
+     * Returns debug information about the injector.
+     *
+     * This information is included into exceptions thrown by the injector.
+     */
+     debugContext(): any;
+
+
+    /**
+     * Retrieves an instance from the injector.
+     *
+     * @param `token`: usually the `Type` of an object. (Same as the token used while setting up a
+     * binding).
+     * @returns an instance represented by the token. Throws if not found.
+     */
+     get(token: any): any;
+
+
+    /**
+     * Retrieves an instance from the injector.
+     *
+     * @param `token`: usually a `Type`. (Same as the token used while setting up a binding).
+     * @returns an instance represented by the token. Returns `null` if not found.
+     */
+     getOptional(token: any): any;
+
+
+    /**
+     * Retrieves an instance from the injector.
+     *
+     * @param `index`: index of an instance.
+     * @returns an instance represented by the index. Throws if not found.
+     */
+     getAt(index: number): any;
+
+
+    /**
+     * Direct parent of this injector.
+     */
+     parent: Injector;
+
+
+    /**
+     * Internal. Do not use.
+     *
+     * We return `any` not to export the InjectorStrategy type.
+     */
+     internalStrategy: any;
+
+
+    /**
+     * Creates a child injector and loads a new set of bindings into it.
+     *
+     * A resolution is a process of flattening multiple nested lists and converting individual
+     * bindings into a list of {@link ResolvedBinding}s. The resolution can be cached by `resolve`
+     * for the {@link Injector} for performance-sensitive code.
+     *
+     * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
+     * recursive list of more bindings.
+     * @param `depProvider`
+     */
+     resolveAndCreateChild(bindings: Array<Type | Binding | any[]>, depProvider?: DependencyProvider): Injector;
+
+
+    /**
+     * Creates a child injector and loads a new set of {@link ResolvedBinding}s into it.
+     *
+     * @param `bindings`: A sparse list of {@link ResolvedBinding}s.
+     * See `resolve` for the {@link Injector}.
+     * @param `depProvider`
+     * @returns a new child {@link Injector}.
+     */
+     createChildFromResolved(bindings: ResolvedBinding[], depProvider?: DependencyProvider): Injector;
+
+
+    /**
+     * Resolves a binding and instantiates an object in the context of the injector.
+     *
+     * @param `binding`: either a type or a binding.
+     * @returns an object created using binding.
+     */
+     resolveAndInstantiate(binding: Type | Binding): any;
+
+
+    /**
+     * Instantiates an object using a resolved bindin in the context of the injector.
+     *
+     * @param `binding`: a resolved binding
+     * @returns an object created using binding.
+     */
+     instantiateResolved(binding: ResolvedBinding): any;
+
+     displayName: string;
+
+     toString(): string;
+  }
+
+  class ProtoInjector {
+
+     numberOfBindings: number;
+
+     getBindingAtIndex(index: number): any;
+  }
+
+  class BindingWithVisibility {
+
+     binding: ResolvedBinding;
+
+     visibility: Visibility;
+
+     getKeyId(): number;
+  }
+
+
+  /**
+   * Used to provide dependencies that cannot be easily expressed as bindings.
+   */
+  interface DependencyProvider {
+
+     getDependency(injector: Injector, binding: ResolvedBinding, dependency: Dependency): any;
+  }
+
+  enum Visibility {
+
+     Public,
+
+     Private,
+
+     PublicAndPrivate
+  }
+
+  const UNDEFINED : Object ;
+
+
+  /**
+   * Describes how_ the {@link Injector} should instantiate a given token.
+   *
+   * See {@link bind}.
+   *
+   * ## Example
+   *
+   * ```javascript
+   * var injector = Injector.resolveAndCreate([
+   *   new Binding(String, { toValue: 'Hello' })
+   * ]);
+   *
+   * expect(injector.get(String)).toEqual('Hello');
+   * ```
+   */
+  class Binding {
+
+
+    /**
+     * Token used when retrieving this binding. Usually the `Type`.
+     */
+     token: any;
+
+
+    /**
+     * Binds an interface to an implementation / subclass.
+     *
+     * ## Example
+     *
+     * Becuse `toAlias` and `toClass` are often confused, the example contains both use cases for easy
+     * comparison.
+     *
+     * ```javascript
+     *
+     * class Vehicle {}
+     *
+     * class Car extends Vehicle {}
+     *
+     * var injectorClass = Injector.resolveAndCreate([
+     *   Car,
+     *   new Binding(Vehicle, { toClass: Car })
+     * ]);
+     * var injectorAlias = Injector.resolveAndCreate([
+     *   Car,
+     *   new Binding(Vehicle, { toAlias: Car })
+     * ]);
+     *
+     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+     *
+     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+     * ```
+     */
+     toClass: Type;
+
+
+    /**
+     * Binds a key to a value.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   new Binding(String, { toValue: 'Hello' })
+     * ]);
+     *
+     * expect(injector.get(String)).toEqual('Hello');
+     * ```
+     */
+     toValue: any;
+
+
+    /**
+     * Binds a key to the alias for an existing key.
+     *
+     * An alias means that {@link Injector} returns the same instance as if the alias token was used.
+     * This is in contrast to `toClass` where a separate instance of `toClass` is returned.
+     *
+     * ## Example
+     *
+     * Becuse `toAlias` and `toClass` are often confused the example contains both use cases for easy
+     * comparison.
+     *
+     * ```javascript
+     *
+     * class Vehicle {}
+     *
+     * class Car extends Vehicle {}
+     *
+     * var injectorAlias = Injector.resolveAndCreate([
+     *   Car,
+     *   new Binding(Vehicle, { toAlias: Car })
+     * ]);
+     * var injectorClass = Injector.resolveAndCreate([
+     *   Car,
+     *   new Binding(Vehicle, { toClass: Car })
+     * ]);
+     *
+     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+     *
+     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+     * ```
+     */
+     toAlias: any;
+
+
+    /**
+     * Binds a key to a function which computes the value.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   new Binding(Number, { toFactory: () => { return 1+2; }}),
+     *   new Binding(String, { toFactory: (value) => { return "Value: " + value; },
+     *                         dependencies: [Number] })
+     * ]);
+     *
+     * expect(injector.get(Number)).toEqual(3);
+     * expect(injector.get(String)).toEqual('Value: 3');
+     * ```
+     */
+     toFactory: Function;
+
+
+    /**
+     * Used in conjunction with `toFactory` and specifies a set of dependencies
+     * (as `token`s) which should be injected into the factory function.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   new Binding(Number, { toFactory: () => { return 1+2; }}),
+     *   new Binding(String, { toFactory: (value) => { return "Value: " + value; },
+     *                         dependencies: [Number] })
+     * ]);
+     *
+     * expect(injector.get(Number)).toEqual(3);
+     * expect(injector.get(String)).toEqual('Value: 3');
+     * ```
+     */
+     dependencies: any[];
+
+
+    /**
+     * Converts the {@link Binding} into {@link ResolvedBinding}.
+     *
+     * {@link Injector} internally only uses {@link ResolvedBinding}, {@link Binding} contains
+     * convenience binding syntax.
+     */
+     resolve(): ResolvedBinding;
+  }
+
+
+  /**
+   * Helper class for the {@link bind} function.
+   */
+  class BindingBuilder {
+
+     token: any;
+
+
+    /**
+     * Binds an interface to an implementation / subclass.
+     *
+     * ## Example
+     *
+     * Because `toAlias` and `toClass` are often confused, the example contains both use cases for
+     * easy comparison.
+     *
+     * ```javascript
+     *
+     * class Vehicle {}
+     *
+     * class Car extends Vehicle {}
+     *
+     * var injectorClass = Injector.resolveAndCreate([
+     *   Car,
+     *   bind(Vehicle).toClass(Car)
+     * ]);
+     * var injectorAlias = Injector.resolveAndCreate([
+     *   Car,
+     *   bind(Vehicle).toAlias(Car)
+     * ]);
+     *
+     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+     *
+     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+     * ```
+     */
+     toClass(type: Type): Binding;
+
+
+    /**
+     * Binds a key to a value.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   bind(String).toValue('Hello')
+     * ]);
+     *
+     * expect(injector.get(String)).toEqual('Hello');
+     * ```
+     */
+     toValue(value: any): Binding;
+
+
+    /**
+     * Binds a key to the alias for an existing key.
+     *
+     * An alias means that we will return the same instance as if the alias token was used. (This is
+     * in contrast to `toClass` where a separate instance of `toClass` will be returned.)
+     *
+     * ## Example
+     *
+     * Becuse `toAlias` and `toClass` are often confused, the example contains both use cases for easy
+     * comparison.
+     *
+     * ```javascript
+     *
+     * class Vehicle {}
+     *
+     * class Car extends Vehicle {}
+     *
+     * var injectorAlias = Injector.resolveAndCreate([
+     *   Car,
+     *   bind(Vehicle).toAlias(Car)
+     * ]);
+     * var injectorClass = Injector.resolveAndCreate([
+     *   Car,
+     *   bind(Vehicle).toClass(Car)
+     * ]);
+     *
+     * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+     * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+     *
+     * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+     * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+     * ```
+     */
+     toAlias(aliasToken: /*Type*/ any): Binding;
+
+
+    /**
+     * Binds a key to a function which computes the value.
+     *
+     * ## Example
+     *
+     * ```javascript
+     * var injector = Injector.resolveAndCreate([
+     *   bind(Number).toFactory(() => { return 1+2; }),
+     *   bind(String).toFactory((v) => { return "Value: " + v; }, [Number])
+     * ]);
+     *
+     * expect(injector.get(Number)).toEqual(3);
+     * expect(injector.get(String)).toEqual('Value: 3');
+     * ```
+     */
+     toFactory(factoryFunction: Function, dependencies?: any[]): Binding;
+  }
+
+
+  /**
+   * An internal resolved representation of a {@link Binding} used by the {@link Injector}.
+   *
+   * A {@link Binding} is resolved when it has a factory function. Binding to a class, alias, or
+   * value, are just convenience methods, as {@link Injector} only operates on calling factory
+   * functions.
+   */
+  class ResolvedBinding {
+
+
+    /**
+     * A key, usually a `Type`.
+     */
+     key: Key;
+
+
+    /**
+     * Factory function which can return an instance of an object represented by a key.
+     */
+     factory: Function;
+
+
+    /**
+     * Arguments (dependencies) to the `factory` function.
+     */
+     dependencies: Dependency[];
+  }
+
+
+  /**
+   * @private
+   */
+  class Dependency {
+
+     static fromKey(key: Key): Dependency;
+
+     key: Key;
+
+     optional: boolean;
+
+     lowerBoundVisibility: any;
+
+     upperBoundVisibility: any;
+
+     properties: any[];
+  }
+
+
+  /**
+   * Provides an API for imperatively constructing {@link Binding}s.
+   *
+   * This is only relevant for JavaScript. See {@link BindingBuilder}.
+   *
+   * ## Example
+   *
+   * ```javascript
+   * bind(MyInterface).toClass(MyClass)
+   *
+   * ```
+   */
+  function bind(token: any) : BindingBuilder ;
+
+
+  /**
+   * A unique object used for retrieving items from the {@link Injector}.
+   *
+   * Keys have:
+   * - a system-wide unique `id`.
+   * - a `token`, usually the `Type` of the instance.
+   *
+   * Keys are used internally by the {@link Injector} because their system-wide unique `id`s allow the
+   * injector to index in arrays rather than looking up items in maps.
+   */
+  class Key {
+
+
+    /**
+     * Retrieves a `Key` for a token.
+     */
+     static get(token: Object): Key;
+
+
+    /**
+     * @returns the number of keys registered in the system.
+     */
+     static numberOfKeys: number;
+
+     token: Object;
+
+     id: number;
+
+     displayName: string;
+  }
+
+
+  /**
+   * @private
+   */
+  class KeyRegistry {
+
+     get(token: Object): Key;
+
+     numberOfKeys: number;
+  }
+
+
+  /**
+   * Type literals is a Dart-only feature. This is here only so we can x-compile
+   * to multiple languages.
+   */
+  class TypeLiteral {
+
+     type: any;
+  }
+
+
+  /**
+   * Thrown when trying to retrieve a dependency by `Key` from {@link Injector}, but the
+   * {@link Injector} does not have a {@link Binding} for {@link Key}.
+   */
+  class NoBindingError extends AbstractBindingError {
+  }
+
+
+  /**
+   * Base class for all errors arising from misconfigured bindings.
+   */
+  class AbstractBindingError extends BaseException {
+
+     name: string;
+
+     message: string;
+
+     keys: Key[];
+
+     injectors: Injector[];
+
+     constructResolvingMessage: Function;
+
+     addKey(injector: Injector, key: Key): void;
+
+     context: any;
+
+     toString(): string;
+  }
+
+
+  /**
+   * Thrown when dependencies form a cycle.
+   *
+   * ## Example:
+   *
+   * ```javascript
+   * class A {
+   *   constructor(b:B) {}
+   * }
+   * class B {
+   *   constructor(a:A) {}
+   * }
+   * ```
+   *
+   * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.
+   */
+  class CyclicDependencyError extends AbstractBindingError {
+  }
+
+
+  /**
+   * Thrown when a constructing type returns with an Error.
+   *
+   * The `InstantiationError` class contains the original error plus the dependency graph which caused
+   * this object to be instantiated.
+   */
+  class InstantiationError extends AbstractBindingError {
+
+     causeKey: Key;
+  }
+
+
+  /**
+   * Thrown when an object other then {@link Binding} (or `Type`) is passed to {@link Injector}
+   * creation.
+   */
+  class InvalidBindingError extends BaseException {
+
+     message: string;
+
+     toString(): string;
+  }
+
+
+  /**
+   * Thrown when the class has no annotation information.
+   *
+   * Lack of annotation information prevents the {@link Injector} from determining which dependencies
+   * need to be injected into the constructor.
+   */
+  class NoAnnotationError extends BaseException {
+
+     name: string;
+
+     message: string;
+
+     toString(): string;
+  }
+
+
+  /**
+   * Thrown when getting an object by index.
+   */
+  class OutOfBoundsError extends BaseException {
+
+     message: string;
+
+     toString(): string;
+  }
+
+  class OpaqueToken {
+
+     toString(): string;
+  }
+
+
+  /**
+   * Factory for creating {@link InjectMetadata}.
+   */
+  interface InjectFactory {
+
+     new(token: any): InjectMetadata;
+
+
+     (token: any): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link OptionalMetadata}.
+   */
+  interface OptionalFactory {
+
+     new(): OptionalMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link InjectableMetadata}.
+   */
+  interface InjectableFactory {
+
+     new(): InjectableMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link SelfMetadata}.
+   */
+  interface SelfFactory {
+
+     new(): SelfMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link HostMetadata}.
+   */
+  interface HostFactory {
+
+     new(): HostMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link SkipSelfMetadata}.
+   */
+  interface SkipSelfFactory {
+
+     new(): SkipSelfMetadata;
+
+
+     (): any;
+
+  }
+
+
+  /**
+   * Factory for creating {@link InjectMetadata}.
+   */
+  var Inject : InjectFactory ;
+
+
+  /**
+   * Factory for creating {@link OptionalMetadata}.
+   */
+  var Optional : OptionalFactory ;
+
+
+  /**
+   * Factory for creating {@link InjectableMetadata}.
+   */
+  var Injectable : InjectableFactory ;
+
+
+  /**
+   * Factory for creating {@link SelfMetadata}.
+   */
+  var Self : SelfFactory ;
+
+
+  /**
+   * Factory for creating {@link HostMetadata}.
+   */
+  var Host : HostFactory ;
+
+
+  /**
+   * Factory for creating {@link SkipSelfMetadata}.
+   */
+  var SkipSelf : SkipSelfFactory ;
+
+
+  /**
+   * A collection of the Angular core directives that are likely to be used in each and every Angular
+   * application.
+   *
+   * This collection can be used to quickly enumerate all the built-in directives in the `@View`
+   * annotation. For example,
+   * instead of writing:
+   *
+   * ```
+   * import {NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault} from 'angular2/angular2';
+   * import {OtherDirective} from 'myDirectives';
+   *
+   * @Component({
+   *  selector: 'my-component'
+   * })
+   * @View({
+   *   templateUrl: 'myComponent.html',
+   *   directives: [NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault, OtherDirective]
+   * })
+   * export class MyComponent {
+   *   ...
+   * }
+   * ```
+   * one could import all the core directives at once:
+   *
+   * ```
+   * import {CORE_DIRECTIVES} from 'angular2/angular2';
+   * import {OtherDirective} from 'myDirectives';
+   *
+   * @Component({
+   *  selector: 'my-component'
+   * })
+   * @View({
+   *   templateUrl: 'myComponent.html',
+   *   directives: [CORE_DIRECTIVES, OtherDirective]
+   * })
+   * export class MyComponent {
+   *   ...
+   * }
+   * ```
+   */
+  const CORE_DIRECTIVES : Type[] ;
+
+
+  /**
+   * Adds and removes CSS classes based on an {expression} value.
+   *
+   * The result of expression is used to add and remove CSS classes using the following logic,
+   * based on expression's value type:
+   * - {string} - all the CSS classes (space - separated) are added
+   * - {Array} - all the CSS classes (Array elements) are added
+   * - {Object} - each key corresponds to a CSS class name while values
+   * are interpreted as {boolean} expression. If a given expression
+   * evaluates to {true} a corresponding CSS class is added - otherwise
+   * it is removed.
+   *
+   * # Example:
+   *
+   * ```
+   * <div class="message" [ng-class]="{error: errorCount > 0}">
+   *     Please check errors.
+   * </div>
+   * ```
+   */
+  class NgClass {
+
+     initialClasses: any;
+
+     rawClass: any;
+
+     doCheck(): void;
+
+     onDestroy(): void;
+  }
+
+
+  /**
+   * The `NgFor` directive instantiates a template once per item from an iterable. The context for
+   * each instantiated template inherits from the outer context with the given loop variable set
+   * to the current item from the iterable.
+   *
+   * It is possible to alias the `index` to a local variable that will be set to the current loop
+   * iteration in the template context.
+   *
+   * When the contents of the iterator changes, `NgFor` makes the corresponding changes to the DOM:
+   *
+   * * When an item is added, a new instance of the template is added to the DOM.
+   * * When an item is removed, its template instance is removed from the DOM.
+   * * When items are reordered, their respective templates are reordered in the DOM.
+   *
+   * # Example
+   *
+   * ```
+   * <ul>
+   *   <li *ng-for="#error of errors; #i = index">
+   *     Error {{i}} of {{errors.length}}: {{error.message}}
+   *   </li>
+   * </ul>
+   * ```
+   *
+   * # Syntax
+   *
+   * - `<li *ng-for="#item of items; #i = index">...</li>`
+   * - `<li template="ng-for #item of items; #i = index">...</li>`
+   * - `<template ng-for #item [ng-for-of]="items" #i="index"><li>...</li></template>`
+   */
+  class NgFor {
+
+     static bulkRemove(tuples: RecordViewTuple[], viewContainer: ViewContainerRef): RecordViewTuple[];
+
+     static bulkInsert(tuples: RecordViewTuple[], viewContainer: ViewContainerRef, templateRef: TemplateRef): RecordViewTuple[];
+
+     viewContainer: ViewContainerRef;
+
+     templateRef: TemplateRef;
+
+     iterableDiffers: IterableDiffers;
+
+     cdr: ChangeDetectorRef;
+
+     ngForOf: any;
+
+     doCheck(): void;
+  }
+
+  class RecordViewTuple {
+
+     view: ViewRef;
+
+     record: any;
+  }
+
+
+  /**
+   * Removes or recreates a portion of the DOM tree based on an {expression}.
+   *
+   * If the expression assigned to `ng-if` evaluates to a false value then the element
+   * is removed from the DOM, otherwise a clone of the element is reinserted into the DOM.
+   *
+   * # Example:
+   *
+   * ```
+   * <div *ng-if="errorCount > 0" class="error">
+   *   <!-- Error message displayed when the errorCount property on the current context is greater
+   * than 0. -->
+   *   {{errorCount}} errors detected
+   * </div>
+   * ```
+   *
+   * # Syntax
+   *
+   * - `<div *ng-if="condition">...</div>`
+   * - `<div template="ng-if condition">...</div>`
+   * - `<template [ng-if]="condition"><div>...</div></template>`
+   */
+  class NgIf {
+
+     ngIf: any;
+  }
+
+
+  /**
+   * The `NgNonBindable` directive tells Angular not to compile or bind the contents of the current
+   * DOM element. This is useful if the element contains what appears to be Angular directives and
+   * bindings but which should be ignored by Angular. This could be the case if you have a site that
+   * displays snippets of code, for instance.
+   *
+   * Example:
+   *
+   * ```
+   * <div>Normal: {{1 + 2}}</div> // output "Normal: 3"
+   * <div ng-non-bindable>Ignored: {{1 + 2}}</div> // output "Ignored: {{1 + 2}}"
+   * ```
+   */
+  class NgNonBindable {
+  }
+
+
+  /**
+   * Adds or removes styles based on an {expression}.
+   *
+   * When the expression assigned to `ng-style` evaluates to an object, the corresponding element
+   * styles are updated. Style names to update are taken from the object keys and values - from the
+   * corresponding object values.
+   *
+   * # Example:
+   *
+   * ```
+   * <div [ng-style]="{'text-align': alignExp}"></div>
+   * ```
+   *
+   * In the above example the `text-align` style will be updated based on the `alignExp` value
+   * changes.
+   *
+   * # Syntax
+   *
+   * - `<div [ng-style]="{'text-align': alignExp}"></div>`
+   * - `<div [ng-style]="styleExp"></div>`
+   */
+  class NgStyle {
+
+     rawStyle: any;
+
+     doCheck(): void;
+  }
+
+  class SwitchView {
+
+     create(): void;
+
+     destroy(): void;
+  }
+
+
+  /**
+   * The `NgSwitch` directive is used to conditionally swap DOM structure on your template based on a
+   * scope expression.
+   * Elements within `NgSwitch` but without `NgSwitchWhen` or `NgSwitchDefault` directives will be
+   * preserved at the location as specified in the template.
+   *
+   * `NgSwitch` simply chooses nested elements and makes them visible based on which element matches
+   * the value obtained from the evaluated expression. In other words, you define a container element
+   * (where you place the directive), place an expression on the **`[ng-switch]="..."` attribute**),
+   * define any inner elements inside of the directive and place a `[ng-switch-when]` attribute per
+   * element.
+   * The when attribute is used to inform NgSwitch which element to display when the expression is
+   * evaluated. If a matching expression is not found via a when attribute then an element with the
+   * default attribute is displayed.
+   *
+   * # Example:
+   *
+   * ```
+   * <ANY [ng-switch]="expression">
+   *   <template [ng-switch-when]="whenExpression1">...</template>
+   *   <template [ng-switch-when]="whenExpression1">...</template>
+   *   <template ng-switch-default>...</template>
+   * </ANY>
+   * ```
+   */
+  class NgSwitch {
+
+     ngSwitch: any;
+  }
+
+
+  /**
+   * Defines a case statement as an expression.
+   *
+   * If multiple `NgSwitchWhen` match the `NgSwitch` value, all of them are displayed.
+   *
+   * Example:
+   *
+   * ```
+   * // match against a context variable
+   * <template [ng-switch-when]="contextVariable">...</template>
+   *
+   * // match against a constant string
+   * <template ng-switch-when="stringValue">...</template>
+   * ```
+   */
+  class NgSwitchWhen {
+
+     ngSwitchWhen: any;
+  }
+
+
+  /**
+   * Defines a default case statement.
+   *
+   * Default case statements are displayed when no `NgSwitchWhen` match the `ng-switch` value.
+   *
+   * Example:
+   *
+   * ```
+   * <template ng-switch-default>...</template>
+   * ```
+   */
+  class NgSwitchDefault {
+  }
+
+
+  /**
+   * Omitting from external API doc as this is really an abstract internal concept.
+   */
+  class AbstractControl {
+
+     validator: Function;
+
+     value: any;
+
+     status: string;
+
+     valid: boolean;
+
+     errors: StringMap<string, any>;
+
+     pristine: boolean;
+
+     dirty: boolean;
+
+     touched: boolean;
+
+     untouched: boolean;
+
+     valueChanges: Observable;
+
+     markAsTouched(): void;
+
+     markAsDirty({onlySelf}?: {onlySelf?: boolean}): void;
+
+     setParent(parent: ControlGroup | ControlArray): void;
+
+     updateValidity({onlySelf}?: {onlySelf?: boolean}): void;
+
+     updateValueAndValidity({onlySelf, emitEvent}?: {onlySelf?: boolean, emitEvent?: boolean}): void;
+
+     find(path: Array<string | number>| string): AbstractControl;
+
+     getError(errorCode: string, path?: string[]): any;
+
+     hasError(errorCode: string, path?: string[]): boolean;
+  }
+
+
+  /**
+   * Defines a part of a form that cannot be divided into other controls.
+   *
+   * `Control` is one of the three fundamental building blocks used to define forms in Angular, along
+   * with
+   * {@link ControlGroup} and {@link ControlArray}.
+   */
+  class Control extends AbstractControl {
+
+     updateValue(value: any, {onlySelf, emitEvent, emitModelToViewChange}?:
+                  {onlySelf?: boolean, emitEvent?: boolean, emitModelToViewChange?: boolean}): void;
+
+     registerOnChange(fn: Function): void;
+  }
+
+
+  /**
+   * Defines a part of a form, of fixed length, that can contain other controls.
+   *
+   * A ControlGroup aggregates the values and errors of each {@link Control} in the group. Thus, if
+   * one of the controls
+   * in a group is invalid, the entire group is invalid. Similarly, if a control changes its value,
+   * the entire group
+   * changes as well.
+   *
+   * `ControlGroup` is one of the three fundamental building blocks used to define forms in Angular,
+   * along with
+   * {@link Control} and {@link ControlArray}. {@link ControlArray} can also contain other controls,
+   * but is of variable
+   * length.
+   */
+  class ControlGroup extends AbstractControl {
+
+     controls: StringMap<string, AbstractControl>;
+
+     addControl(name: string, c: AbstractControl): void;
+
+     removeControl(name: string): void;
+
+     include(controlName: string): void;
+
+     exclude(controlName: string): void;
+
+     contains(controlName: string): boolean;
+  }
+
+
+  /**
+   * Defines a part of a form, of variable length, that can contain other controls.
+   *
+   * A `ControlArray` aggregates the values and errors of each {@link Control} in the group. Thus, if
+   * one of the controls
+   * in a group is invalid, the entire group is invalid. Similarly, if a control changes its value,
+   * the entire group
+   * changes as well.
+   *
+   * `ControlArray` is one of the three fundamental building blocks used to define forms in Angular,
+   * along with {@link Control} and {@link ControlGroup}. {@link ControlGroup} can also contain
+   * other controls, but is of fixed length.
+   */
+  class ControlArray extends AbstractControl {
+
+     controls: AbstractControl[];
+
+     at(index: number): AbstractControl;
+
+     push(control: AbstractControl): void;
+
+     insert(index: number, control: AbstractControl): void;
+
+     removeAt(index: number): void;
+
+     length: number;
+  }
+
+  class AbstractControlDirective {
+
+     control: AbstractControl;
+
+     value: any;
+
+     valid: boolean;
+
+     errors: StringMap<string, any>;
+
+     pristine: boolean;
+
+     dirty: boolean;
+
+     touched: boolean;
+
+     untouched: boolean;
+  }
+
+
+  /**
+   * An interface that {@link NgFormModel} and {@link NgForm} implement.
+   *
+   * Only used by the forms module.
+   */
+  interface Form {
+
+     addControl(dir: NgControl): void;
+
+     removeControl(dir: NgControl): void;
+
+     getControl(dir: NgControl): Control;
+
+     addControlGroup(dir: NgControlGroup): void;
+
+     removeControlGroup(dir: NgControlGroup): void;
+
+     getControlGroup(dir: NgControlGroup): ControlGroup;
+
+     updateModel(dir: NgControl, value: any): void;
+  }
+
+
+  /**
+   * A directive that contains a group of [NgControl].
+   *
+   * Only used by the forms module.
+   */
+  class ControlContainer extends AbstractControlDirective {
+
+     name: string;
+
+     formDirective: Form;
+
+     path: string[];
+  }
+
+
+  /**
+   * Creates and binds a control with a specified name to a DOM element.
+   *
+   * This directive can only be used as a child of {@link NgForm} or {@link NgFormModel}.
+   *
+   * # Example
+   *
+   * In this example, we create the login and password controls.
+   * We can work with each control separately: check its validity, get its value, listen to its
+   *  changes.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *              <form #f="form" (submit)='onLogIn(f.value)'>
+   *                Login <input type='text' ng-control='login' #l="form">
+   *                <div *ng-if="!l.valid">Login is invalid</div>
+   *
+   *                Password <input type='password' ng-control='password'>
+   *
+   *                <button type='submit'>Log in!</button>
+   *              </form>
+   *      `})
+   * class LoginComp {
+   *  onLogIn(value) {
+   *    // value === {login: 'some login', password: 'some password'}
+   *  }
+   * }
+   *  ```
+   *
+   * We can also use ng-model to bind a domain model to the form.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *              <form (submit)='onLogIn()'>
+   *                Login <input type='text' ng-control='login' [(ng-model)]="credentials.login">
+   *                Password <input type='password' ng-control='password'
+   *  [(ng-model)]="credentials.password">
+   *                <button type='submit'>Log in!</button>
+   *              </form>
+   *      `})
+   * class LoginComp {
+   *  credentials: {login:string, password:string};
+   *
+   *  onLogIn() {
+   *    // this.credentials.login === "some login"
+   *    // this.credentials.password === "some password"
+   *  }
+   * }
+   *  ```
+   */
+  class NgControlName extends NgControl {
+
+     update: any;
+
+     model: any;
+
+     viewModel: any;
+
+     ngValidators: QueryList<NgValidator>;
+
+     onChanges(c: StringMap<string, any>): void;
+
+     onDestroy(): void;
+
+     viewToModelUpdate(newValue: any): void;
+
+     path: string[];
+
+     formDirective: any;
+
+     control: Control;
+
+     validator: Function;
+  }
+
+
+  /**
+   * Binds an existing control to a DOM element.
+   *
+   * # Example
+   *
+   * In this example, we bind the control to an input element. When the value of the input element
+   * changes, the value of
+   * the control will reflect that change. Likewise, if the value of the control changes, the input
+   * element reflects that
+   * change.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: "<input type='text' [ng-form-control]='loginControl'>"
+   *      })
+   * class LoginComp {
+   *  loginControl:Control;
+   *
+   *  constructor() {
+   *    this.loginControl = new Control('');
+   *  }
+   * }
+   *
+   *  ```
+   *
+   * We can also use ng-model to bind a domain model to the form.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: "<input type='text' [ng-form-control]='loginControl' [(ng-model)]='login'>"
+   *      })
+   * class LoginComp {
+   *  loginControl:Control;
+   *  login:string;
+   *
+   *  constructor() {
+   *    this.loginControl = new Control('');
+   *  }
+   * }
+   *  ```
+   */
+  class NgFormControl extends NgControl {
+
+     form: Control;
+
+     update: any;
+
+     model: any;
+
+     viewModel: any;
+
+     ngValidators: QueryList<NgValidator>;
+
+     onChanges(c: StringMap<string, any>): void;
+
+     path: string[];
+
+     control: Control;
+
+     validator: Function;
+
+     viewToModelUpdate(newValue: any): void;
+  }
+
+
+  /**
+   * Binds a domain model to the form.
+   *
+   * # Example
+   *  ```
+   * @Component({selector: "search-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *               <input type='text' [(ng-model)]="searchQuery">
+   *      `})
+   * class SearchComp {
+   *  searchQuery: string;
+   * }
+   *  ```
+   */
+  class NgModel extends NgControl {
+
+     update: any;
+
+     model: any;
+
+     viewModel: any;
+
+     ngValidators: QueryList<NgValidator>;
+
+     onChanges(c: StringMap<string, any>): void;
+
+     control: Control;
+
+     path: string[];
+
+     validator: Function;
+
+     viewToModelUpdate(newValue: any): void;
+  }
+
+
+  /**
+   * An abstract class that all control directive extend.
+   *
+   * It binds a {@link Control} object to a DOM element.
+   */
+  class NgControl extends AbstractControlDirective {
+
+     name: string;
+
+     valueAccessor: ControlValueAccessor;
+
+     validator: Function;
+
+     path: string[];
+
+     viewToModelUpdate(newValue: any): void;
+  }
+
+
+  /**
+   * Creates and binds a control group to a DOM element.
+   *
+   * This directive can only be used as a child of {@link NgForm} or {@link NgFormModel}.
+   *
+   * # Example
+   *
+   * In this example, we create the credentials and personal control groups.
+   * We can work with each group separately: check its validity, get its value, listen to its changes.
+   *
+   *  ```
+   * @Component({selector: "signup-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *              <form #f="form" (submit)='onSignUp(f.value)'>
+   *                <div ng-control-group='credentials' #credentials="form">
+   *                  Login <input type='text' ng-control='login'>
+   *                  Password <input type='password' ng-control='password'>
+   *                </div>
+   *                <div *ng-if="!credentials.valid">Credentials are invalid</div>
+   *
+   *                <div ng-control-group='personal'>
+   *                  Name <input type='text' ng-control='name'>
+   *                </div>
+   *                <button type='submit'>Sign Up!</button>
+   *              </form>
+   *      `})
+   * class SignupComp {
+   *  onSignUp(value) {
+   *    // value === {personal: {name: 'some name'},
+   *    //  credentials: {login: 'some login', password: 'some password'}}
+   *  }
+   * }
+   *
+   *  ```
+   */
+  class NgControlGroup extends ControlContainer {
+
+     onInit(): void;
+
+     onDestroy(): void;
+
+     control: ControlGroup;
+
+     path: string[];
+
+     formDirective: Form;
+  }
+
+
+  /**
+   * Binds an existing control group to a DOM element.
+   *
+   * # Example
+   *
+   * In this example, we bind the control group to the form element, and we bind the login and
+   * password controls to the
+   * login and password elements.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: "<form [ng-form-model]='loginForm'>" +
+   *              "Login <input type='text' ng-control='login'>" +
+   *              "Password <input type='password' ng-control='password'>" +
+   *              "<button (click)="onLogin()">Login</button>" +
+   *              "</form>"
+   *      })
+   * class LoginComp {
+   *  loginForm:ControlGroup;
+   *
+   *  constructor() {
+   *    this.loginForm = new ControlGroup({
+   *      login: new Control(""),
+   *      password: new Control("")
+   *    });
+   *  }
+   *
+   *  onLogin() {
+   *    // this.loginForm.value
+   *  }
+   * }
+   *
+   *  ```
+   *
+   * We can also use ng-model to bind a domain model to the form.
+   *
+   *  ```
+   * @Component({selector: "login-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: "<form [ng-form-model]='loginForm'>" +
+   *              "Login <input type='text' ng-control='login' [(ng-model)]='login'>" +
+   *              "Password <input type='password' ng-control='password' [(ng-model)]='password'>" +
+   *              "<button (click)="onLogin()">Login</button>" +
+   *              "</form>"
+   *      })
+   * class LoginComp {
+   *  credentials:{login:string, password:string}
+   *  loginForm:ControlGroup;
+   *
+   *  constructor() {
+   *    this.loginForm = new ControlGroup({
+   *      login: new Control(""),
+   *      password: new Control("")
+   *    });
+   *  }
+   *
+   *  onLogin() {
+   *    // this.credentials.login === 'some login'
+   *    // this.credentials.password === 'some password'
+   *  }
+   * }
+   *  ```
+   */
+  class NgFormModel extends ControlContainer implements Form {
+
+     form: ControlGroup;
+
+     directives: NgControl[];
+
+     ngSubmit: any;
+
+     onChanges(_: any): void;
+
+     formDirective: Form;
+
+     control: ControlGroup;
+
+     path: string[];
+
+     addControl(dir: NgControl): void;
+
+     getControl(dir: NgControl): Control;
+
+     removeControl(dir: NgControl): void;
+
+     addControlGroup(dir: NgControlGroup): void;
+
+     removeControlGroup(dir: NgControlGroup): void;
+
+     getControlGroup(dir: NgControlGroup): ControlGroup;
+
+     updateModel(dir: NgControl, value: any): void;
+
+     onSubmit(): boolean;
+  }
+
+
+  /**
+   * Creates and binds a form object to a DOM element.
+   *
+   * # Example
+   *
+   *  ```
+   * @Component({selector: "signup-comp"})
+   * @View({
+   *      directives: [FORM_DIRECTIVES],
+   *      template: `
+   *              <form #f="form" (submit)='onSignUp(f.value)'>
+   *                <div ng-control-group='credentials' #credentials="form">
+   *                  Login <input type='text' ng-control='login'>
+   *                  Password <input type='password' ng-control='password'>
+   *                </div>
+   *                <div *ng-if="!credentials.valid">Credentials are invalid</div>
+   *
+   *                <div ng-control-group='personal'>
+   *                  Name <input type='text' ng-control='name'>
+   *                </div>
+   *                <button type='submit'>Sign Up!</button>
+   *              </form>
+   *      `})
+   * class SignupComp {
+   *  onSignUp(value) {
+   *    // value === {personal: {name: 'some name'},
+   *    //  credentials: {login: 'some login', password: 'some password'}}
+   *  }
+   * }
+   *
+   *  ```
+   */
+  class NgForm extends ControlContainer implements Form {
+
+     form: ControlGroup;
+
+     ngSubmit: any;
+
+     formDirective: Form;
+
+     control: ControlGroup;
+
+     path: string[];
+
+     controls: StringMap<string, AbstractControl>;
+
+     addControl(dir: NgControl): void;
+
+     getControl(dir: NgControl): Control;
+
+     removeControl(dir: NgControl): void;
+
+     addControlGroup(dir: NgControlGroup): void;
+
+     removeControlGroup(dir: NgControlGroup): void;
+
+     getControlGroup(dir: NgControlGroup): ControlGroup;
+
+     updateModel(dir: NgControl, value: any): void;
+
+     onSubmit(): boolean;
+  }
+
+
+  /**
+   * A bridge between a control and a native element.
+   *
+   * Please see {@link DefaultValueAccessor} for more information.
+   */
+  interface ControlValueAccessor {
+
+     writeValue(obj: any): void;
+
+     registerOnChange(fn: any): void;
+
+     registerOnTouched(fn: any): void;
+  }
+
+
+  /**
+   * The default accessor for writing a value and listening to changes that is used by the
+   * {@link NgModel}, {@link NgFormControl}, and {@link NgControlName} directives.
+   *
+   *  # Example
+   *  ```
+   *  <input type="text" [(ng-model)]="searchQuery">
+   *  ```
+   */
+  class DefaultValueAccessor implements ControlValueAccessor {
+
+     cd: NgControl;
+
+     onChange: any;
+
+     onTouched: any;
+
+     renderer: Renderer;
+
+     elementRef: ElementRef;
+
+     writeValue(value: any): void;
+
+     ngClassUntouched: boolean;
+
+     ngClassTouched: boolean;
+
+     ngClassPristine: boolean;
+
+     ngClassDirty: boolean;
+
+     ngClassValid: boolean;
+
+     ngClassInvalid: boolean;
+
+     registerOnChange(fn: (_: any) => void): void;
+
+     registerOnTouched(fn: () => void): void;
+  }
+
+
+  /**
+   * The accessor for writing a value and listening to changes on a checkbox input element.
+   *
+   *  # Example
+   *  ```
+   *  <input type="checkbox" [ng-control]="rememberLogin">
+   *  ```
+   */
+  class CheckboxControlValueAccessor implements ControlValueAccessor {
+
+     cd: NgControl;
+
+     onChange: any;
+
+     onTouched: any;
+
+     renderer: Renderer;
+
+     elementRef: ElementRef;
+
+     writeValue(value: any): void;
+
+     ngClassUntouched: boolean;
+
+     ngClassTouched: boolean;
+
+     ngClassPristine: boolean;
+
+     ngClassDirty: boolean;
+
+     ngClassValid: boolean;
+
+     ngClassInvalid: boolean;
+
+     registerOnChange(fn: (_: any) => {}): void;
+
+     registerOnTouched(fn: () => {}): void;
+  }
+
+
+  /**
+   * Marks <option> as dynamic, so Angular can be notified when options change.
+   *
+   * #Example:
+   *
+   * ```
+   * <select ng-control="city">
+   *   <option *ng-for="#c of cities" [value]="c"></option>
+   * </select>
+   * ```
+   */
+  class NgSelectOption {
+  }
+
+
+  /**
+   * The accessor for writing a value and listening to changes on a select element.
+   */
+  class SelectControlValueAccessor implements ControlValueAccessor {
+
+     cd: NgControl;
+
+     value: string;
+
+     onChange: any;
+
+     onTouched: any;
+
+     renderer: Renderer;
+
+     elementRef: ElementRef;
+
+     writeValue(value: any): void;
+
+     ngClassUntouched: boolean;
+
+     ngClassTouched: boolean;
+
+     ngClassPristine: boolean;
+
+     ngClassDirty: boolean;
+
+     ngClassValid: boolean;
+
+     ngClassInvalid: boolean;
+
+     registerOnChange(fn: () => any): void;
+
+     registerOnTouched(fn: () => any): void;
+  }
+
+
+  /**
+   * A list of all the form directives used as part of a `@View` annotation.
+   *
+   *  This is a shorthand for importing them each individually.
+   */
+  const FORM_DIRECTIVES : Type[] ;
+
+
+  /**
+   * Provides a set of validators used by form controls.
+   *
+   * # Example
+   *
+   * ```
+   * var loginControl = new Control("", Validators.required)
+   * ```
+   */
+  class Validators {
+
+     static required(c:Control): StringMap<string, boolean>;
+
+     static nullValidator(c: any): StringMap<string, boolean>;
+
+     static compose(validators: Function[]): Function;
+
+     static group(c:ControlGroup): StringMap<string, boolean>;
+
+     static array(c:ControlArray): StringMap<string, boolean>;
+  }
+
+  class NgValidator {
+
+     validator: Function;
+  }
+
+  class NgRequiredValidator extends NgValidator {
+
+     validator: Function;
+  }
+
+
+  /**
+   * Creates a form object from a user-specified configuration.
+   *
+   * # Example
+   *
+   * ```
+   * import {Component, View, bootstrap} from 'angular2/angular2';
+   * import {FormBuilder, Validators, FORM_DIRECTIVES, ControlGroup} from 'angular2/forms';
+   *
+   * @Component({
+   *   selector: 'login-comp',
+   *   viewBindings: [
+   *     FormBuilder
+   *   ]
+   * })
+   * @View({
+   *   template: `
+   *     <form [control-group]="loginForm">
+   *       Login <input control="login">
+   *
+   *       <div control-group="passwordRetry">
+   *         Password <input type="password" control="password">
+   *         Confirm password <input type="password" control="passwordConfirmation">
+   *       </div>
+   *     </form>
+   *   `,
+   *   directives: [
+   *     FORM_DIRECTIVES
+   *   ]
+   * })
+   * class LoginComp {
+   *   loginForm: ControlGroup;
+   *
+   *   constructor(builder: FormBuilder) {
+   *     this.loginForm = builder.group({
+   *       login: ["", Validators.required],
+   *
+   *       passwordRetry: builder.group({
+   *         password: ["", Validators.required],
+   *         passwordConfirmation: ["", Validators.required]
+   *       })
+   *     });
+   *   }
+   * }
+   *
+   * bootstrap(LoginComp)
+   * ```
+   *
+   * This example creates a {@link ControlGroup} that consists of a `login` {@link Control}, and a
+   * nested
+   * {@link ControlGroup} that defines a `password` and a `passwordConfirmation` {@link Control}:
+   *
+   * ```
+   *  var loginForm = builder.group({
+   *    login: ["", Validators.required],
+   *
+   *    passwordRetry: builder.group({
+   *      password: ["", Validators.required],
+   *      passwordConfirmation: ["", Validators.required]
+   *    })
+   *  });
+   *
+   *  ```
+   */
+  class FormBuilder {
+
+     group(controlsConfig: StringMap<string, any>, extra?: StringMap<string, any>): ControlGroup;
+
+     control(value: Object, validator?: Function): Control;
+
+     array(controlsConfig: any[], validator?: Function): ControlArray;
+  }
+
+  const FORM_BINDINGS : Type[] ;
+
+  class RenderDirectiveMetadata {
+
+     static DIRECTIVE_TYPE: any;
+
+     static COMPONENT_TYPE: any;
+
+     static create({id, selector, compileChildren, events, host, properties, readAttributes, type,
+                 callOnDestroy, callOnChanges, callDoCheck, callOnInit, callAfterContentInit,
+                 callAfterContentChecked, callAfterViewInit, callAfterViewChecked, changeDetection,
+                 exportAs}: {
+    id?: string,
+    selector?: string,
+    compileChildren?: boolean,
+    events?: string[],
+    host?: Map<string, string>,
+    properties?: string[],
+    readAttributes?: string[],
+    type?: number,
+    callOnDestroy?: boolean,
+    callOnChanges?: boolean,
+    callDoCheck?: boolean,
+    callOnInit?: boolean,
+    callAfterContentInit?: boolean,
+    callAfterContentChecked?: boolean,
+    callAfterViewInit?: boolean,
+    callAfterViewChecked?: boolean,
+    changeDetection?: ChangeDetectionStrategy,
+    exportAs?: string
+  }): RenderDirectiveMetadata;
+
+     id: any;
+
+     selector: string;
+
+     compileChildren: boolean;
+
+     events: string[];
+
+     properties: string[];
+
+     readAttributes: string[];
+
+     type: number;
+
+     callOnDestroy: boolean;
+
+     callOnChanges: boolean;
+
+     callDoCheck: boolean;
+
+     callOnInit: boolean;
+
+     callAfterContentInit: boolean;
+
+     callAfterContentChecked: boolean;
+
+     callAfterViewInit: boolean;
+
+     callAfterViewChecked: boolean;
+
+     changeDetection: ChangeDetectionStrategy;
+
+     exportAs: string;
+
+     hostListeners: Map<string, string>;
+
+     hostProperties: Map<string, string>;
+
+     hostAttributes: Map<string, string>;
+  }
+
+  class DomRenderer extends Renderer {
+
+     createRootHostView(hostProtoViewRef: RenderProtoViewRef, fragmentCount: number, hostElementSelector: string): RenderViewWithFragments;
+
+     createView(protoViewRef: RenderProtoViewRef, fragmentCount: number): RenderViewWithFragments;
+
+     destroyView(viewRef: RenderViewRef): void;
+
+     getNativeElementSync(location: RenderElementRef): any;
+
+     getRootNodes(fragment: RenderFragmentRef): Node[];
+
+     attachFragmentAfterFragment(previousFragmentRef: RenderFragmentRef, fragmentRef: RenderFragmentRef): void;
+
+     attachFragmentAfterElement(elementRef: RenderElementRef, fragmentRef: RenderFragmentRef): void;
+
+     detachFragment(fragmentRef: RenderFragmentRef): void;
+
+     hydrateView(viewRef: RenderViewRef): void;
+
+     dehydrateView(viewRef: RenderViewRef): void;
+
+     setElementProperty(location: RenderElementRef, propertyName: string, propertyValue: any): void;
+
+     setElementAttribute(location: RenderElementRef, attributeName: string, attributeValue: string): void;
+
+     setElementClass(location: RenderElementRef, className: string, isAdd: boolean): void;
+
+     setElementStyle(location: RenderElementRef, styleName: string, styleValue: string): void;
+
+     invokeElementMethod(location: RenderElementRef, methodName: string, args: any[]): void;
+
+     setText(viewRef: RenderViewRef, textNodeIndex: number, text: string): void;
+
+     setEventDispatcher(viewRef: RenderViewRef, dispatcher: any): void;
+  }
+
+
+  /**
+   * A dispatcher for all events happening in a view.
+   */
+  interface RenderEventDispatcher {
+
+
+    /**
+     * Called when an event was triggered for a on-* attribute on an element.
+     * @param {Map<string, any>} locals Locals to be used to evaluate the
+     *   event expressions
+     * @return {boolean} False if `preventDefault` should be called on the DOM event.
+     */
+     dispatchRenderEvent(elementIndex: number, eventName: string, locals: Map<string, any>): boolean;
+  }
+
+  class Renderer {
+
+
+    /**
+     * Creates a root host view that includes the given element.
+     * Note that the fragmentCount needs to be passed in so that we can create a result
+     * synchronously even when dealing with webworkers!
+     *
+     * @param {RenderProtoViewRef} hostProtoViewRef a RenderProtoViewRef of type
+     * ProtoViewDto.HOST_VIEW_TYPE
+     * @param {any} hostElementSelector css selector for the host element (will be queried against the
+     * main document)
+     * @return {RenderViewWithFragments} the created view including fragments
+     */
+     createRootHostView(hostProtoViewRef: RenderProtoViewRef, fragmentCount: number, hostElementSelector: string): RenderViewWithFragments;
+
+
+    /**
+     * Creates a regular view out of the given ProtoView.
+     * Note that the fragmentCount needs to be passed in so that we can create a result
+     * synchronously even when dealing with webworkers!
+     */
+     createView(protoViewRef: RenderProtoViewRef, fragmentCount: number): RenderViewWithFragments;
+
+
+    /**
+     * Destroys the given view after it has been dehydrated and detached
+     */
+     destroyView(viewRef: RenderViewRef): void;
+
+
+    /**
+     * Attaches a fragment after another fragment.
+     */
+     attachFragmentAfterFragment(previousFragmentRef: RenderFragmentRef, fragmentRef: RenderFragmentRef): void;
+
+
+    /**
+     * Attaches a fragment after an element.
+     */
+     attachFragmentAfterElement(elementRef: RenderElementRef, fragmentRef: RenderFragmentRef): void;
+
+
+    /**
+     * Detaches a fragment.
+     */
+     detachFragment(fragmentRef: RenderFragmentRef): void;
+
+
+    /**
+     * Hydrates a view after it has been attached. Hydration/dehydration is used for reusing views
+     * inside of the view pool.
+     */
+     hydrateView(viewRef: RenderViewRef): void;
+
+
+    /**
+     * Dehydrates a view after it has been attached. Hydration/dehydration is used for reusing views
+     * inside of the view pool.
+     */
+     dehydrateView(viewRef: RenderViewRef): void;
+
+
+    /**
+     * Returns the native element at the given location.
+     * Attention: In a WebWorker scenario, this should always return null!
+     */
+     getNativeElementSync(location: RenderElementRef): any;
+
+
+    /**
+     * Sets a property on an element.
+     */
+     setElementProperty(location: RenderElementRef, propertyName: string, propertyValue: any): void;
+
+
+    /**
+     * Sets an attribute on an element.
+     */
+     setElementAttribute(location: RenderElementRef, attributeName: string, attributeValue: string): void;
+
+
+    /**
+     * Sets a class on an element.
+     */
+     setElementClass(location: RenderElementRef, className: string, isAdd: boolean): void;
+
+
+    /**
+     * Sets a style on an element.
+     */
+     setElementStyle(location: RenderElementRef, styleName: string, styleValue: string): void;
+
+
+    /**
+     * Calls a method on an element.
+     */
+     invokeElementMethod(location: RenderElementRef, methodName: string, args: any[]): void;
+
+
+    /**
+     * Sets the value of a text node.
+     */
+     setText(viewRef: RenderViewRef, textNodeIndex: number, text: string): void;
+
+
+    /**
+     * Sets the dispatcher for all events of the given view
+     */
+     setEventDispatcher(viewRef: RenderViewRef, dispatcher: RenderEventDispatcher): void;
+  }
+
+
+  /**
+   * Abstract reference to the element which can be marshaled across web-worker boundary.
+   *
+   * This interface is used by the Renderer API.
+   */
+  interface RenderElementRef {
+
+
+    /**
+     * Reference to the `RenderViewRef` where the `RenderElementRef` is inside of.
+     */
+     renderView: RenderViewRef;
+
+
+    /**
+     * Index of the element inside the `RenderViewRef`.
+     *
+     * This is used internally by the Angular framework to locate elements.
+     */
+     renderBoundElementIndex: number;
+  }
+
+  class RenderViewRef {
+  }
+
+  class RenderProtoViewRef {
+  }
+
+  class RenderFragmentRef {
+  }
+
+  class RenderViewWithFragments {
+
+     viewRef: RenderViewRef;
+
+     fragmentRefs: RenderFragmentRef[];
+  }
+
+  class ViewDefinition {
+
+     componentId: string;
+
+     templateAbsUrl: string;
+
+     template: string;
+
+     directives: RenderDirectiveMetadata[];
+
+     styleAbsUrls: string[];
+
+     styles: string[];
+
+     encapsulation: ViewEncapsulation;
+  }
+
+  const DOCUMENT : OpaqueToken ;
+
+
+  /**
+   * A unique id (string) for an angular application.
+   */
+  const APP_ID : OpaqueToken ;
+
+
+  /**
+   * Defines when a compiled template should be stored as a string
+   * rather than keeping its Nodes to preserve memory.
+   */
+  const MAX_IN_MEMORY_ELEMENTS_PER_TEMPLATE : OpaqueToken ;
+
+
+  /**
+   * Create trace scope.
+   *
+   * Scopes must be strictly nested and are analogous to stack frames, but
+   * do not have to follow the stack frames. Instead it is recommended that they follow logical
+   * nesting. You may want to use
+   * [Event
+   * Signatures](http://google.github.io/tracing-framework/instrumenting-code.html#custom-events)
+   * as they are defined in WTF.
+   *
+   * Used to mark scope entry. The return value is used to leave the scope.
+   *
+   *     var myScope = wtfCreateScope('MyClass#myMethod(ascii someVal)');
+   *
+   *     someMethod() {
+   *        var s = myScope('Foo'); // 'Foo' gets stored in tracing UI
+   *        // DO SOME WORK HERE
+   *        return wtfLeave(s, 123); // Return value 123
+   *     }
+   *
+   * Note, adding try-finally block around the work to ensure that `wtfLeave` gets called can
+   * negatively impact the performance of your application. For this reason we recommend that
+   * you don't add them to ensure that `wtfLeave` gets called. In production `wtfLeave` is a noop and
+   * so try-finally block has no value. When debugging perf issues, skipping `wtfLeave`, do to
+   * exception, will produce incorrect trace, but presence of exception signifies logic error which
+   * needs to be fixed before the app should be profiled. Add try-finally only when you expect that
+   * an exception is expected during normal execution while profiling.
+   */
+  var wtfCreateScope : WtfScopeFn ;
+
+
+  /**
+   * Used to mark end of Scope.
+   *
+   * - `scope` to end.
+   * - `returnValue` (optional) to be passed to the WTF.
+   *
+   * Returns the `returnValue for easy chaining.
+   */
+  var wtfLeave : <T>(scope: any, returnValue?: T) => T ;
+
+
+  /**
+   * Used to mark Async start. Async are similar to scope but they don't have to be strictly nested.
+   * The return value is used in the call to [endAsync]. Async ranges only work if WTF has been
+   * enabled.
+   *
+   *     someMethod() {
+   *        var s = wtfStartTimeRange('HTTP:GET', 'some.url');
+   *        var future = new Future.delay(5).then((_) {
+   *          wtfEndTimeRange(s);
+   *        });
+   *     }
+   */
+  var wtfStartTimeRange : (rangeType: string, action: string) => any ;
+
+
+  /**
+   * Ends a async time range operation.
+   * [range] is the return value from [wtfStartTimeRange] Async ranges only work if WTF has been
+   * enabled.
+   */
+  var wtfEndTimeRange : (range: any) => void ;
+
+  interface WtfScopeFn {
+
+     (arg0?: any, arg1?: any): any;
+
+  }
+
+
+  /**
+   * Bootstrapping a Webworker Application
+   *
+   * You instantiate the application side by calling bootstrapWebworker from your webworker index
+   * script.
+   * You can call bootstrapWebworker() exactly as you would call bootstrap() in a regular Angular
+   * application
+   * See the bootstrap() docs for more details.
+   */
+  function bootstrapWebWorker(appComponentType: Type, componentInjectableBindings?: Array<Type | Binding | any[]>) : Promise<ApplicationRef> ;
+
+
+  /**
+   * Message Bus is a low level API used to communicate between the UI and the background.
+   * Communication is based on a channel abstraction. Messages published in a
+   * given channel to one MessageBusSink are received on the same channel
+   * by the corresponding MessageBusSource.
+   */
+  class MessageBus implements MessageBusSource,  MessageBusSink {
+
+
+    /**
+     * Returns an {@link EventEmitter} that emits every time a messsage
+     * is received on the given channel.
+     */
+     from(channel: string): EventEmitter;
+
+
+    /**
+     * Returns an {@link EventEmitter} for the given channel
+     * To publish methods to that channel just call next (or add in dart) on the returned emitter
+     */
+     to(channel: string): EventEmitter;
+  }
+
+  interface MessageBusSource {
+
+
+    /**
+     * Returns an {@link EventEmitter} that emits every time a messsage
+     * is received on the given channel.
+     */
+     from(channel: string): EventEmitter;
+  }
+
+  interface MessageBusSink {
+
+
+    /**
+     * Returns an {@link EventEmitter} for the given channel
+     * To publish methods to that channel just call next (or add in dart) on the returned emitter
+     */
+     to(channel: string): EventEmitter;
+  }
+
+  class ClientMessageBrokerFactory {
+
+     createMessageBroker(channel: string): ClientMessageBroker;
+  }
+
+  class ClientMessageBroker {
+
+     channel: any;
+
+     runOnService(args: UiArguments, returnType: Type): Promise<any>;
+  }
+
+  class FnArg {
+
+     value: any;
+
+     type: Type;
+  }
+
+  class UiArguments {
+
+     method: string;
+
+     args: FnArg[];
+  }
+
+  class ServiceMessageBrokerFactory {
+
+     createMessageBroker(channel: string): ServiceMessageBroker;
+  }
+
+
+  /**
+   * Helper class for UIComponents that allows components to register methods.
+   * If a registered method message is received from the broker on the worker,
+   * the UIMessageBroker desererializes its arguments and calls the registered method.
+   * If that method returns a promise, the UIMessageBroker returns the result to the worker.
+   */
+  class ServiceMessageBroker {
+
+     channel: any;
+
+     registerMethod(methodName: string, signature: Type[], method: Function, returnType?: Type): void;
+  }
+
+  class ReceivedMessage {
+
+     method: string;
+
+     args: any[];
+
+     id: string;
+
+     type: string;
+  }
+
+  const PRIMITIVE : Type ;
+
+  class Serializer {
+
+     serialize(obj: any, type: Type): Object;
+
+     deserialize(map: any, type: Type, data?: any): any;
+
+     mapToObject(map: Map<string, any>, type?: Type): Object;
+
+     objectToMap(obj: StringMap<string, any>, type?: Type, data?: any): Map<string, any>;
+
+     allocateRenderViews(fragmentCount: number): void;
+  }
+
+  var ChangeDetectorRef: InjectableReference;
+
+  var ApplicationRef: InjectableReference;
+
+  var Compiler: InjectableReference;
+
+  var AppViewManager: InjectableReference;
+
+  var ViewRef: InjectableReference;
+
+  var ProtoViewRef: InjectableReference;
+
+  var ViewContainerRef: InjectableReference;
+
+  var ComponentRef: InjectableReference;
+
+}
+
+declare module "angular2/web_worker/worker" {
+  export = ngWorker;
+}
+
+
+
+declare module ngUi {
+  class WebWorkerApplication {
+
+     createClientMessageBroker(channel: string): ClientMessageBroker;
+
+     createServiceMessageBroker(channel: string): ServiceMessageBroker;
+  }
+
+
+  /**
+   * Bootstrapping a WebWorker
+   *
+   * You instantiate a WebWorker application by calling bootstrap with the URI of your worker's index
+   * script
+   * Note: The WebWorker script must call bootstrapWebworker once it is set up to complete the
+   * bootstrapping process
+   */
+  function bootstrap(uri: string) : WebWorkerInstance ;
+
+  function spawnWebWorker(uri: string) : WebWorkerInstance ;
+
+
+  /**
+   * Wrapper class that exposes the {@link WebWorkerApplication}
+   * Isolate instance and underyling {@link MessageBus} for lower level message passing.
+   */
+  class WebWorkerInstance {
+
+     app: WebWorkerApplication;
+
+     worker: Worker;
+
+     bus: MessageBus;
+  }
+
+
+  /**
+   * Use Rx.Observable but provides an adapter to make it work as specified here:
+   * https://github.com/jhusain/observable-spec
+   *
+   * Once a reference implementation of the spec is available, switch to it.
+   */
+  class EventEmitter extends Observable {
+
+     observer(generator: any): Rx.IDisposable;
+
+     toRx(): Rx.Observable<any>;
+
+     next(value: any): void;
+
+     throw(error: any): void;
+
+     return(value?: any): void;
+  }
+
+  class Observable {
+
+     observer(generator: any): Object;
+  }
+
+
+  /**
+   * Message Bus is a low level API used to communicate between the UI and the background.
+   * Communication is based on a channel abstraction. Messages published in a
+   * given channel to one MessageBusSink are received on the same channel
+   * by the corresponding MessageBusSource.
+   */
+  class MessageBus implements MessageBusSource,  MessageBusSink {
+
+
+    /**
+     * Returns an {@link EventEmitter} that emits every time a messsage
+     * is received on the given channel.
+     */
+     from(channel: string): EventEmitter;
+
+
+    /**
+     * Returns an {@link EventEmitter} for the given channel
+     * To publish methods to that channel just call next (or add in dart) on the returned emitter
+     */
+     to(channel: string): EventEmitter;
+  }
+
+  interface MessageBusSource {
+
+
+    /**
+     * Returns an {@link EventEmitter} that emits every time a messsage
+     * is received on the given channel.
+     */
+     from(channel: string): EventEmitter;
+  }
+
+  interface MessageBusSink {
+
+
+    /**
+     * Returns an {@link EventEmitter} for the given channel
+     * To publish methods to that channel just call next (or add in dart) on the returned emitter
+     */
+     to(channel: string): EventEmitter;
+  }
+
+
+  /**
+   * Runtime representation of a type.
+   *
+   * In JavaScript a Type is a constructor function.
+   */
+  interface Type extends Function {
+
+     new(...args: any[]): any;
+
+  }
+
+  class ClientMessageBrokerFactory {
+
+     createMessageBroker(channel: string): ClientMessageBroker;
+  }
+
+  class ClientMessageBroker {
+
+     channel: any;
+
+     runOnService(args: UiArguments, returnType: Type): Promise<any>;
+  }
+
+  class FnArg {
+
+     value: any;
+
+     type: Type;
+  }
+
+  class UiArguments {
+
+     method: string;
+
+     args: FnArg[];
+  }
+
+  class ServiceMessageBrokerFactory {
+
+     createMessageBroker(channel: string): ServiceMessageBroker;
+  }
+
+
+  /**
+   * Helper class for UIComponents that allows components to register methods.
+   * If a registered method message is received from the broker on the worker,
+   * the UIMessageBroker desererializes its arguments and calls the registered method.
+   * If that method returns a promise, the UIMessageBroker returns the result to the worker.
+   */
+  class ServiceMessageBroker {
+
+     channel: any;
+
+     registerMethod(methodName: string, signature: Type[], method: Function, returnType?: Type): void;
+  }
+
+  class ReceivedMessage {
+
+     method: string;
+
+     args: any[];
+
+     id: string;
+
+     type: string;
+  }
+
+  const PRIMITIVE : Type ;
+
+  class Serializer {
+
+     serialize(obj: any, type: Type): Object;
+
+     deserialize(map: any, type: Type, data?: any): any;
+
+     mapToObject(map: Map<string, any>, type?: Type): Object;
+
+     objectToMap(obj: StringMap<string, any>, type?: Type, data?: any): Map<string, any>;
+
+     allocateRenderViews(fragmentCount: number): void;
+  }
+
+}
+
+declare module "angular2/web_worker/ui" {
+  export = ngUi;
+}
+
+
diff --git a/angular2/http-2.0.0-alpha.37.d.ts b/angular2/http-2.0.0-alpha.37.d.ts
new file mode 100644
index 0000000000..b1f284954c
--- /dev/null
+++ b/angular2/http-2.0.0-alpha.37.d.ts
@@ -0,0 +1,1007 @@
+// Type definitions for Angular v2.0.0-alpha.37
+// Project: http://angular.io/
+// Definitions by: angular team <https://github.com/angular/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// ***********************************************************
+// This file is generated by the Angular build process.
+// Please do not create manual edits or send pull requests
+// modifying this file.
+// ***********************************************************
+
+// angular2/http depends transitively on these libraries.
+// If you don't have them installed you can install them using TSD
+// https://github.com/DefinitelyTyped/tsd
+
+///<reference path="./angular2.d.ts"/>
+
+
+
+
+/**
+ * @module
+ * @description
+ * The http module provides services to perform http requests. To get started, see the {@link Http}
+ * class.
+ */
+declare module ngHttp {
+
+  /**
+   * Mock Connection to represent a {@link Connection} for tests.
+   */
+  class MockConnection implements Connection {
+
+
+    /**
+     * Describes the state of the connection, based on `XMLHttpRequest.readyState`, but with
+     * additional states. For example, state 5 indicates an aborted connection.
+     */
+     readyState: ReadyStates;
+
+
+    /**
+     * {@link Request} instance used to create the connection.
+     */
+     request: Request;
+
+
+    /**
+     * {@link EventEmitter} of {@link Response}. Can be subscribed to in order to be notified when a
+     * response is available.
+     */
+     response: ng.EventEmitter;
+
+
+    /**
+     * Changes the `readyState` of the connection to a custom state of 5 (cancelled).
+     */
+     dispose(): void;
+
+
+    /**
+     * Sends a mock response to the connection. This response is the value that is emitted to the
+     * {@link EventEmitter} returned by {@link Http}.
+     *
+     * #Example
+     *
+     * ```
+     * var connection;
+     * backend.connections.subscribe(c => connection = c);
+     * http.request('data.json').subscribe(res => console.log(res.text()));
+     * connection.mockRespond(new Response('fake response')); //logs 'fake response'
+     * ```
+     */
+     mockRespond(res: Response): void;
+
+
+    /**
+     * Not yet implemented!
+     *
+     * Sends the provided {@link Response} to the `downloadObserver` of the `Request`
+     * associated with this connection.
+     */
+     mockDownload(res: Response): void;
+
+
+    /**
+     * Emits the provided error object as an error to the {@link Response} {@link EventEmitter}
+     * returned
+     * from {@link Http}.
+     */
+     mockError(err?: Error): void;
+  }
+
+
+  /**
+   * A mock backend for testing the {@link Http} service.
+   *
+   * This class can be injected in tests, and should be used to override bindings
+   * to other backends, such as {@link XHRBackend}.
+   *
+   * #Example
+   *
+   * ```
+   * import {MockBackend, DefaultOptions, Http} from 'angular2/http';
+   * it('should get some data', inject([AsyncTestCompleter], (async) => {
+   *   var connection;
+   *   var injector = Injector.resolveAndCreate([
+   *     MockBackend,
+   *     bind(Http).toFactory((backend, defaultOptions) => {
+   *       return new Http(backend, defaultOptions)
+   *     }, [MockBackend, DefaultOptions])]);
+   *   var http = injector.get(Http);
+   *   var backend = injector.get(MockBackend);
+   *   //Assign any newly-created connection to local variable
+   *   backend.connections.subscribe(c => connection = c);
+   *   http.request('data.json').subscribe((res) => {
+   *     expect(res.text()).toBe('awesome');
+   *     async.done();
+   *   });
+   *   connection.mockRespond(new Response('awesome'));
+   * }));
+   * ```
+   *
+   * This method only exists in the mock implementation, not in real Backends.
+   */
+  class MockBackend implements ConnectionBackend {
+
+
+    /**
+     * {@link EventEmitter}
+     * of {@link MockConnection} instances that have been created by this backend. Can be subscribed
+     * to in order to respond to connections.
+     *
+     * #Example
+     *
+     * ```
+     * import {MockBackend, Http, BaseRequestOptions} from 'angular2/http';
+     * import {Injector} from 'angular2/di';
+     *
+     * it('should get a response', () => {
+     *   var connection; //this will be set when a new connection is emitted from the backend.
+     *   var text; //this will be set from mock response
+     *   var injector = Injector.resolveAndCreate([
+     *     MockBackend,
+     *     bind(Http).toFactory(backend, options) {
+     *       return new Http(backend, options);
+     *     }, [MockBackend, BaseRequestOptions]]);
+     *   var backend = injector.get(MockBackend);
+     *   var http = injector.get(Http);
+     *   backend.connections.subscribe(c => connection = c);
+     *   http.request('something.json').subscribe(res => {
+     *     text = res.text();
+     *   });
+     *   connection.mockRespond(new Response({body: 'Something'}));
+     *   expect(text).toBe('Something');
+     * });
+     * ```
+     *
+     * This property only exists in the mock implementation, not in real Backends.
+     */
+     connections: ng.EventEmitter;
+
+
+    /**
+     * An array representation of `connections`. This array will be updated with each connection that
+     * is created by this backend.
+     *
+     * This property only exists in the mock implementation, not in real Backends.
+     */
+     connectionsArray: MockConnection[];
+
+
+    /**
+     * {@link EventEmitter} of {@link MockConnection} instances that haven't yet been resolved (i.e.
+     * with a `readyState`
+     * less than 4). Used internally to verify that no connections are pending via the
+     * `verifyNoPendingRequests` method.
+     *
+     * This property only exists in the mock implementation, not in real Backends.
+     */
+     pendingConnections: ng.EventEmitter;
+
+
+    /**
+     * Checks all connections, and raises an exception if any connection has not received a response.
+     *
+     * This method only exists in the mock implementation, not in real Backends.
+     */
+     verifyNoPendingRequests(): void;
+
+
+    /**
+     * Can be used in conjunction with `verifyNoPendingRequests` to resolve any not-yet-resolve
+     * connections, if it's expected that there are connections that have not yet received a response.
+     *
+     * This method only exists in the mock implementation, not in real Backends.
+     */
+     resolveAllConnections(): void;
+
+
+    /**
+     * Creates a new {@link MockConnection}. This is equivalent to calling `new
+     * MockConnection()`, except that it also will emit the new `Connection` to the `connections`
+     * emitter of this `MockBackend` instance. This method will usually only be used by tests
+     * against the framework itself, not by end-users.
+     */
+     createConnection(req: Request): Connection;
+  }
+
+
+  /**
+   * Creates `Request` instances from provided values.
+   *
+   * The Request's interface is inspired by the Request constructor defined in the [Fetch
+   * Spec](https://fetch.spec.whatwg.org/#request-class),
+   * but is considered a static value whose body can be accessed many times. There are other
+   * differences in the implementation, but this is the most significant.
+   */
+  class Request {
+
+
+    /**
+     * Http method with which to perform the request.
+     *
+     * Defaults to GET.
+     */
+     method: RequestMethods;
+
+     mode: RequestModesOpts;
+
+     credentials: RequestCredentialsOpts;
+
+
+    /**
+     * Headers object based on the `Headers` class in the [Fetch
+     * Spec](https://fetch.spec.whatwg.org/#headers-class). {@link Headers} class reference.
+     */
+     headers: Headers;
+
+
+    /**
+     * Url of the remote resource
+     */
+     url: string;
+
+     cache: RequestCacheOpts;
+
+
+    /**
+     * Returns the request's body as string, assuming that body exists. If body is undefined, return
+     * empty
+     * string.
+     */
+     text(): String;
+  }
+
+
+  /**
+   * Creates `Response` instances from provided values.
+   *
+   * Though this object isn't
+   * usually instantiated by end-users, it is the primary object interacted with when it comes time to
+   * add data to a view.
+   *
+   * #Example
+   *
+   * ```
+   * http.request('my-friends.txt').subscribe(response => this.friends = response.text());
+   * ```
+   *
+   * The Response's interface is inspired by the Response constructor defined in the [Fetch
+   * Spec](https://fetch.spec.whatwg.org/#response-class), but is considered a static value whose body
+   * can be accessed many times. There are other differences in the implementation, but this is the
+   * most significant.
+   */
+  class Response {
+
+
+    /**
+     * One of "basic", "cors", "default", "error, or "opaque".
+     *
+     * Defaults to "default".
+     */
+     type: ResponseTypes;
+
+
+    /**
+     * True if the response's status is within 200-299
+     */
+     ok: boolean;
+
+
+    /**
+     * URL of response.
+     *
+     * Defaults to empty string.
+     */
+     url: string;
+
+
+    /**
+     * Status code returned by server.
+     *
+     * Defaults to 200.
+     */
+     status: number;
+
+
+    /**
+     * Text representing the corresponding reason phrase to the `status`, as defined in [ietf rfc 2616
+     * section 6.1.1](https://tools.ietf.org/html/rfc2616#section-6.1.1)
+     *
+     * Defaults to "OK"
+     */
+     statusText: string;
+
+
+    /**
+     * Non-standard property
+     *
+     * Denotes how many of the response body's bytes have been loaded, for example if the response is
+     * the result of a progress event.
+     */
+     bytesLoaded: number;
+
+
+    /**
+     * Non-standard property
+     *
+     * Denotes how many bytes are expected in the final response body.
+     */
+     totalBytes: number;
+
+
+    /**
+     * Headers object based on the `Headers` class in the [Fetch
+     * Spec](https://fetch.spec.whatwg.org/#headers-class).
+     */
+     headers: Headers;
+
+
+    /**
+     * Not yet implemented
+     */
+     blob(): any;
+
+
+    /**
+     * Attempts to return body as parsed `JSON` object, or raises an exception.
+     */
+     json(): Object;
+
+
+    /**
+     * Returns the body as a string, presuming `toString()` can be called on the response body.
+     */
+     text(): string;
+
+
+    /**
+     * Not yet implemented
+     */
+     arrayBuffer(): any;
+  }
+
+
+  /**
+   * Interface for options to construct a Request, based on
+   * [RequestInit](https://fetch.spec.whatwg.org/#requestinit) from the Fetch spec.
+   */
+  interface RequestOptionsArgs {
+
+     url?: string;
+
+     method?: RequestMethods;
+
+     search?: string | URLSearchParams;
+
+     headers?: Headers;
+
+     body?: string;
+
+     mode?: RequestModesOpts;
+
+     credentials?: RequestCredentialsOpts;
+
+     cache?: RequestCacheOpts;
+  }
+
+
+  /**
+   * Interface for options to construct a Response, based on
+   * [ResponseInit](https://fetch.spec.whatwg.org/#responseinit) from the Fetch spec.
+   */
+  interface ResponseOptionsArgs {
+
+     body?: string | Object | FormData;
+
+     status?: number;
+
+     statusText?: string;
+
+     headers?: Headers;
+
+     type?: ResponseTypes;
+
+     url?: string;
+  }
+
+
+  /**
+   * Abstract class from which real connections are derived.
+   */
+  class Connection {
+
+     readyState: ReadyStates;
+
+     request: Request;
+
+     response: ng.EventEmitter;
+
+     dispose(): void;
+  }
+
+
+  /**
+   * Abstract class from which real backends are derived.
+   *
+   * The primary purpose of a `ConnectionBackend` is to create new connections to fulfill a given
+   * {@link Request}.
+   */
+  class ConnectionBackend {
+
+     createConnection(request: any): Connection;
+  }
+
+  class BrowserXhr {
+
+     build(): any;
+  }
+
+
+  /**
+   * Injectable version of {@link RequestOptions}, with overridable default values.
+   *
+   * #Example
+   *
+   * ```
+   * import {Http, BaseRequestOptions, Request} from 'angular2/http';
+   * ...
+   * class MyComponent {
+   *   constructor(baseRequestOptions:BaseRequestOptions, http:Http) {
+   *     var options = baseRequestOptions.merge({body: 'foobar', url: 'https://foo'});
+   *     var request = new Request(options);
+   *     http.request(request).subscribe(res => this.bars = res.json());
+   *   }
+   * }
+   *
+   * ```
+   */
+  class BaseRequestOptions extends RequestOptions {
+  }
+
+
+  /**
+   * Creates a request options object similar to the `RequestInit` description
+   * in the [Fetch
+   * Spec](https://fetch.spec.whatwg.org/#requestinit) to be optionally provided when instantiating a
+   * {@link Request}.
+   *
+   * All values are null by default.
+   */
+  class RequestOptions {
+
+
+    /**
+     * Http method with which to execute the request.
+     *
+     * Defaults to "GET".
+     */
+     method: RequestMethods;
+
+
+    /**
+     * Headers object based on the `Headers` class in the [Fetch
+     * Spec](https://fetch.spec.whatwg.org/#headers-class).
+     */
+     headers: Headers;
+
+
+    /**
+     * Body to be used when creating the request.
+     */
+     body: string;
+
+     mode: RequestModesOpts;
+
+     credentials: RequestCredentialsOpts;
+
+     cache: RequestCacheOpts;
+
+     url: string;
+
+     search: URLSearchParams;
+
+
+    /**
+     * Creates a copy of the `RequestOptions` instance, using the optional input as values to override
+     * existing values.
+     */
+     merge(options?: RequestOptionsArgs): RequestOptions;
+  }
+
+
+  /**
+   * Injectable version of {@link ResponseOptions}, with overridable default values.
+   */
+  class BaseResponseOptions extends ResponseOptions {
+
+     body: string | Object | ArrayBuffer | JSON | FormData | Blob;
+
+     status: number;
+
+     headers: Headers;
+
+     statusText: string;
+
+     type: ResponseTypes;
+
+     url: string;
+  }
+
+
+  /**
+   * Creates a response options object similar to the
+   * [ResponseInit](https://fetch.spec.whatwg.org/#responseinit) description
+   * in the Fetch
+   * Spec to be optionally provided when instantiating a
+   * {@link Response}.
+   *
+   * All values are null by default.
+   */
+  class ResponseOptions {
+
+     body: string | Object;
+
+     status: number;
+
+     headers: Headers;
+
+     statusText: string;
+
+     type: ResponseTypes;
+
+     url: string;
+
+     merge(options?: ResponseOptionsArgs): ResponseOptions;
+  }
+
+
+  /**
+   * Creates {@link XHRConnection} instances.
+   *
+   * This class would typically not be used by end users, but could be
+   * overridden if a different backend implementation should be used,
+   * such as in a node backend.
+   *
+   * #Example
+   *
+   * ```
+   * import {Http, MyNodeBackend, HTTP_BINDINGS, BaseRequestOptions} from 'angular2/http';
+   * @Component({
+   *   viewBindings: [
+   *     HTTP_BINDINGS,
+   *     bind(Http).toFactory((backend, options) => {
+   *       return new Http(backend, options);
+   *     }, [MyNodeBackend, BaseRequestOptions])]
+   * })
+   * class MyComponent {
+   *   constructor(http:Http) {
+   *     http('people.json').subscribe(res => this.people = res.json());
+   *   }
+   * }
+   * ```
+   */
+  class XHRBackend implements ConnectionBackend {
+
+     createConnection(request: Request): XHRConnection;
+  }
+
+
+  /**
+   * Creates connections using `XMLHttpRequest`. Given a fully-qualified
+   * request, an `XHRConnection` will immediately create an `XMLHttpRequest` object and send the
+   * request.
+   *
+   * This class would typically not be created or interacted with directly inside applications, though
+   * the {@link MockConnection} may be interacted with in tests.
+   */
+  class XHRConnection implements Connection {
+
+     request: Request;
+
+
+    /**
+     * Response {@link EventEmitter} which emits a single {@link Response} value on load event of
+     * `XMLHttpRequest`.
+     */
+     response: ng.EventEmitter;
+
+     readyState: ReadyStates;
+
+
+    /**
+     * Calls abort on the underlying XMLHttpRequest.
+     */
+     dispose(): void;
+  }
+
+  class JSONPBackend implements ConnectionBackend {
+
+     createConnection(request: Request): JSONPConnection;
+  }
+
+  class JSONPConnection implements Connection {
+
+     readyState: ReadyStates;
+
+     request: Request;
+
+     response: ng.EventEmitter;
+
+     baseResponseOptions: ResponseOptions;
+
+     finished(data?: any): void;
+
+     dispose(): void;
+  }
+
+
+  /**
+   * Performs http requests using `XMLHttpRequest` as the default backend.
+   *
+   * `Http` is available as an injectable class, with methods to perform http requests. Calling
+   * `request` returns an {@link EventEmitter} which will emit a single {@link Response} when a
+   * response is received.
+   *
+   *
+   * ## Breaking Change
+   *
+   * Previously, methods of `Http` would return an RxJS Observable directly. For now,
+   * the `toRx()` method of {@link EventEmitter} needs to be called in order to get the RxJS
+   * Subject. `EventEmitter` does not provide combinators like `map`, and has different semantics for
+   * subscribing/observing. This is temporary; the result of all `Http` method calls will be either an
+   * Observable
+   * or Dart Stream when [issue #2794](https://github.com/angular/angular/issues/2794) is resolved.
+   *
+   * #Example
+   *
+   * ```
+   * import {Http, HTTP_BINDINGS} from 'angular2/http';
+   * @Component({selector: 'http-app', viewBindings: [HTTP_BINDINGS]})
+   * @View({templateUrl: 'people.html'})
+   * class PeopleComponent {
+   *   constructor(http: Http) {
+   *     http.get('people.json')
+   *       //Get the RxJS Subject
+   *       .toRx()
+   *       // Call map on the response observable to get the parsed people object
+   *       .map(res => res.json())
+   *       // Subscribe to the observable to get the parsed people object and attach it to the
+   *       // component
+   *       .subscribe(people => this.people = people);
+   *   }
+   * }
+   * ```
+   *
+   * To use the {@link EventEmitter} returned by `Http`, simply pass a generator (See "interface
+   * Generator" in the Async Generator spec: https://github.com/jhusain/asyncgenerator) to the
+   * `observer` method of the returned emitter, with optional methods of `next`, `throw`, and `return`.
+   *
+   * #Example
+   *
+   * ```
+   * http.get('people.json').observer({next: (value) => this.people = people});
+   * ```
+   *
+   * The default construct used to perform requests, `XMLHttpRequest`, is abstracted as a "Backend" (
+   * {@link XHRBackend} in this case), which could be mocked with dependency injection by replacing
+   * the {@link XHRBackend} binding, as in the following example:
+   *
+   * #Example
+   *
+   * ```
+   * import {MockBackend, BaseRequestOptions, Http} from 'angular2/http';
+   * var injector = Injector.resolveAndCreate([
+   *   BaseRequestOptions,
+   *   MockBackend,
+   *   bind(Http).toFactory(
+   *       function(backend, defaultOptions) {
+   *         return new Http(backend, defaultOptions);
+   *       },
+   *       [MockBackend, BaseRequestOptions])
+   * ]);
+   * var http = injector.get(Http);
+   * http.get('request-from-mock-backend.json').toRx().subscribe((res:Response) => doSomething(res));
+   * ```
+   */
+  class Http {
+
+
+    /**
+     * Performs any type of http request. First argument is required, and can either be a url or
+     * a {@link Request} instance. If the first argument is a url, an optional {@link RequestOptions}
+     * object can be provided as the 2nd argument. The options object will be merged with the values
+     * of {@link BaseRequestOptions} before performing the request.
+     */
+     request(url: string | Request, options?: RequestOptionsArgs): ng.EventEmitter;
+
+
+    /**
+     * Performs a request with `get` http method.
+     */
+     get(url: string, options?: RequestOptionsArgs): ng.EventEmitter;
+
+
+    /**
+     * Performs a request with `post` http method.
+     */
+     post(url: string, body: string, options?: RequestOptionsArgs): ng.EventEmitter;
+
+
+    /**
+     * Performs a request with `put` http method.
+     */
+     put(url: string, body: string, options?: RequestOptionsArgs): ng.EventEmitter;
+
+
+    /**
+     * Performs a request with `delete` http method.
+     */
+     delete(url: string, options?: RequestOptionsArgs): ng.EventEmitter;
+
+
+    /**
+     * Performs a request with `patch` http method.
+     */
+     patch(url: string, body: string, options?: RequestOptionsArgs): ng.EventEmitter;
+
+
+    /**
+     * Performs a request with `head` http method.
+     */
+     head(url: string, options?: RequestOptionsArgs): ng.EventEmitter;
+  }
+
+  class Jsonp extends Http {
+
+
+    /**
+     * Performs any type of http request. First argument is required, and can either be a url or
+     * a {@link Request} instance. If the first argument is a url, an optional {@link RequestOptions}
+     * object can be provided as the 2nd argument. The options object will be merged with the values
+     * of {@link BaseRequestOptions} before performing the request.
+     */
+     request(url: string | Request, options?: RequestOptionsArgs): ng.EventEmitter;
+  }
+
+
+  /**
+   * Polyfill for [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers/Headers), as
+   * specified in the [Fetch Spec](https://fetch.spec.whatwg.org/#headers-class). The only known
+   * difference from the spec is the lack of an `entries` method.
+   */
+  class Headers {
+
+
+    /**
+     * Appends a header to existing list of header values for a given header name.
+     */
+     append(name: string, value: string): void;
+
+
+    /**
+     * Deletes all header values for the given name.
+     */
+     delete(name: string): void;
+
+     forEach(fn: Function): void;
+
+
+    /**
+     * Returns first header that matches given name.
+     */
+     get(header: string): string;
+
+
+    /**
+     * Check for existence of header by given name.
+     */
+     has(header: string): boolean;
+
+
+    /**
+     * Provides names of set headers
+     */
+     keys(): string[];
+
+
+    /**
+     * Sets or overrides header value for given name.
+     */
+     set(header: string, value: string | string[]): void;
+
+
+    /**
+     * Returns values of all headers.
+     */
+     values(): string[][];
+
+
+    /**
+     * Returns list of header values for a given name.
+     */
+     getAll(header: string): string[];
+
+
+    /**
+     * This method is not implemented.
+     */
+     entries(): void;
+  }
+
+
+  /**
+   * Acceptable response types to be associated with a {@link Response}, based on
+   * [ResponseType](https://fetch.spec.whatwg.org/#responsetype) from the Fetch spec.
+   */
+  enum ResponseTypes {
+
+     Basic,
+
+     Cors,
+
+     Default,
+
+     Error,
+
+     Opaque
+  }
+
+
+  /**
+   * All possible states in which a connection can be, based on
+   * [States](http://www.w3.org/TR/XMLHttpRequest/#states) from the `XMLHttpRequest` spec, but with an
+   * additional "CANCELLED" state.
+   */
+  enum ReadyStates {
+
+     Unsent,
+
+     Open,
+
+     HeadersReceived,
+
+     Loading,
+
+     Done,
+
+     Cancelled
+  }
+
+
+  /**
+   * Supported http methods.
+   */
+  enum RequestMethods {
+
+     Get,
+
+     Post,
+
+     Put,
+
+     Delete,
+
+     Options,
+
+     Head,
+
+     Patch
+  }
+
+
+  /**
+   * Acceptable credentials option to be associated with a {@link Request}, based on
+   * [RequestCredentials](https://fetch.spec.whatwg.org/#requestcredentials) from the Fetch spec.
+   */
+  enum RequestCredentialsOpts {
+
+     Omit,
+
+     SameOrigin,
+
+     Include
+  }
+
+
+  /**
+   * Acceptable cache option to be associated with a {@link Request}, based on
+   * [RequestCache](https://fetch.spec.whatwg.org/#requestcache) from the Fetch spec.
+   */
+  enum RequestCacheOpts {
+
+     Default,
+
+     NoStore,
+
+     Reload,
+
+     NoCache,
+
+     ForceCache,
+
+     OnlyIfCached
+  }
+
+
+  /**
+   * Acceptable origin modes to be associated with a {@link Request}, based on
+   * [RequestMode](https://fetch.spec.whatwg.org/#requestmode) from the Fetch spec.
+   */
+  enum RequestModesOpts {
+
+     Cors,
+
+     NoCors,
+
+     SameOrigin
+  }
+
+
+  /**
+   * Map-like representation of url search parameters, based on
+   * [URLSearchParams](https://url.spec.whatwg.org/#urlsearchparams) in the url living standard,
+   * with several extensions for merging URLSearchParams objects:
+   *   - setAll()
+   *   - appendAll()
+   *   - replaceAll()
+   */
+  class URLSearchParams {
+
+     paramsMap: Map<string, string[]>;
+
+     rawParams: string;
+
+     clone(): URLSearchParams;
+
+     has(param: string): boolean;
+
+     get(param: string): string;
+
+     getAll(param: string): string[];
+
+     set(param: string, val: string): void;
+
+     setAll(searchParams: URLSearchParams): void;
+
+     append(param: string, val: string): void;
+
+     appendAll(searchParams: URLSearchParams): void;
+
+     replaceAll(searchParams: URLSearchParams): void;
+
+     toString(): string;
+
+     delete(param: string): void;
+  }
+
+
+  /**
+   * Provides a basic set of injectables to use the {@link Http} service in any application.
+   *
+   * #Example
+   *
+   * ```
+   * import {HTTP_BINDINGS, Http} from 'http/http';
+   * @Component({selector: 'http-app', viewBindings: [HTTP_BINDINGS]})
+   * @View({template: '{{data}}'})
+   * class MyApp {
+   *   constructor(http:Http) {
+   *     http.request('data.txt').subscribe(res => this.data = res.text());
+   *   }
+   * }
+   * ```
+   */
+  const HTTP_BINDINGS : any[] ;
+
+  const JSONP_BINDINGS : any[] ;
+
+}
+
+declare module "angular2/http" {
+  export = ngHttp;
+}
+
+
diff --git a/angular2/http.d.ts b/angular2/http.d.ts
new file mode 100644
index 0000000000..b1f284954c
--- /dev/null
+++ b/angular2/http.d.ts
@@ -0,0 +1,1007 @@
+// Type definitions for Angular v2.0.0-alpha.37
+// Project: http://angular.io/
+// Definitions by: angular team <https://github.com/angular/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// ***********************************************************
+// This file is generated by the Angular build process.
+// Please do not create manual edits or send pull requests
+// modifying this file.
+// ***********************************************************
+
+// angular2/http depends transitively on these libraries.
+// If you don't have them installed you can install them using TSD
+// https://github.com/DefinitelyTyped/tsd
+
+///<reference path="./angular2.d.ts"/>
+
+
+
+
+/**
+ * @module
+ * @description
+ * The http module provides services to perform http requests. To get started, see the {@link Http}
+ * class.
+ */
+declare module ngHttp {
+
+  /**
+   * Mock Connection to represent a {@link Connection} for tests.
+   */
+  class MockConnection implements Connection {
+
+
+    /**
+     * Describes the state of the connection, based on `XMLHttpRequest.readyState`, but with
+     * additional states. For example, state 5 indicates an aborted connection.
+     */
+     readyState: ReadyStates;
+
+
+    /**
+     * {@link Request} instance used to create the connection.
+     */
+     request: Request;
+
+
+    /**
+     * {@link EventEmitter} of {@link Response}. Can be subscribed to in order to be notified when a
+     * response is available.
+     */
+     response: ng.EventEmitter;
+
+
+    /**
+     * Changes the `readyState` of the connection to a custom state of 5 (cancelled).
+     */
+     dispose(): void;
+
+
+    /**
+     * Sends a mock response to the connection. This response is the value that is emitted to the
+     * {@link EventEmitter} returned by {@link Http}.
+     *
+     * #Example
+     *
+     * ```
+     * var connection;
+     * backend.connections.subscribe(c => connection = c);
+     * http.request('data.json').subscribe(res => console.log(res.text()));
+     * connection.mockRespond(new Response('fake response')); //logs 'fake response'
+     * ```
+     */
+     mockRespond(res: Response): void;
+
+
+    /**
+     * Not yet implemented!
+     *
+     * Sends the provided {@link Response} to the `downloadObserver` of the `Request`
+     * associated with this connection.
+     */
+     mockDownload(res: Response): void;
+
+
+    /**
+     * Emits the provided error object as an error to the {@link Response} {@link EventEmitter}
+     * returned
+     * from {@link Http}.
+     */
+     mockError(err?: Error): void;
+  }
+
+
+  /**
+   * A mock backend for testing the {@link Http} service.
+   *
+   * This class can be injected in tests, and should be used to override bindings
+   * to other backends, such as {@link XHRBackend}.
+   *
+   * #Example
+   *
+   * ```
+   * import {MockBackend, DefaultOptions, Http} from 'angular2/http';
+   * it('should get some data', inject([AsyncTestCompleter], (async) => {
+   *   var connection;
+   *   var injector = Injector.resolveAndCreate([
+   *     MockBackend,
+   *     bind(Http).toFactory((backend, defaultOptions) => {
+   *       return new Http(backend, defaultOptions)
+   *     }, [MockBackend, DefaultOptions])]);
+   *   var http = injector.get(Http);
+   *   var backend = injector.get(MockBackend);
+   *   //Assign any newly-created connection to local variable
+   *   backend.connections.subscribe(c => connection = c);
+   *   http.request('data.json').subscribe((res) => {
+   *     expect(res.text()).toBe('awesome');
+   *     async.done();
+   *   });
+   *   connection.mockRespond(new Response('awesome'));
+   * }));
+   * ```
+   *
+   * This method only exists in the mock implementation, not in real Backends.
+   */
+  class MockBackend implements ConnectionBackend {
+
+
+    /**
+     * {@link EventEmitter}
+     * of {@link MockConnection} instances that have been created by this backend. Can be subscribed
+     * to in order to respond to connections.
+     *
+     * #Example
+     *
+     * ```
+     * import {MockBackend, Http, BaseRequestOptions} from 'angular2/http';
+     * import {Injector} from 'angular2/di';
+     *
+     * it('should get a response', () => {
+     *   var connection; //this will be set when a new connection is emitted from the backend.
+     *   var text; //this will be set from mock response
+     *   var injector = Injector.resolveAndCreate([
+     *     MockBackend,
+     *     bind(Http).toFactory(backend, options) {
+     *       return new Http(backend, options);
+     *     }, [MockBackend, BaseRequestOptions]]);
+     *   var backend = injector.get(MockBackend);
+     *   var http = injector.get(Http);
+     *   backend.connections.subscribe(c => connection = c);
+     *   http.request('something.json').subscribe(res => {
+     *     text = res.text();
+     *   });
+     *   connection.mockRespond(new Response({body: 'Something'}));
+     *   expect(text).toBe('Something');
+     * });
+     * ```
+     *
+     * This property only exists in the mock implementation, not in real Backends.
+     */
+     connections: ng.EventEmitter;
+
+
+    /**
+     * An array representation of `connections`. This array will be updated with each connection that
+     * is created by this backend.
+     *
+     * This property only exists in the mock implementation, not in real Backends.
+     */
+     connectionsArray: MockConnection[];
+
+
+    /**
+     * {@link EventEmitter} of {@link MockConnection} instances that haven't yet been resolved (i.e.
+     * with a `readyState`
+     * less than 4). Used internally to verify that no connections are pending via the
+     * `verifyNoPendingRequests` method.
+     *
+     * This property only exists in the mock implementation, not in real Backends.
+     */
+     pendingConnections: ng.EventEmitter;
+
+
+    /**
+     * Checks all connections, and raises an exception if any connection has not received a response.
+     *
+     * This method only exists in the mock implementation, not in real Backends.
+     */
+     verifyNoPendingRequests(): void;
+
+
+    /**
+     * Can be used in conjunction with `verifyNoPendingRequests` to resolve any not-yet-resolve
+     * connections, if it's expected that there are connections that have not yet received a response.
+     *
+     * This method only exists in the mock implementation, not in real Backends.
+     */
+     resolveAllConnections(): void;
+
+
+    /**
+     * Creates a new {@link MockConnection}. This is equivalent to calling `new
+     * MockConnection()`, except that it also will emit the new `Connection` to the `connections`
+     * emitter of this `MockBackend` instance. This method will usually only be used by tests
+     * against the framework itself, not by end-users.
+     */
+     createConnection(req: Request): Connection;
+  }
+
+
+  /**
+   * Creates `Request` instances from provided values.
+   *
+   * The Request's interface is inspired by the Request constructor defined in the [Fetch
+   * Spec](https://fetch.spec.whatwg.org/#request-class),
+   * but is considered a static value whose body can be accessed many times. There are other
+   * differences in the implementation, but this is the most significant.
+   */
+  class Request {
+
+
+    /**
+     * Http method with which to perform the request.
+     *
+     * Defaults to GET.
+     */
+     method: RequestMethods;
+
+     mode: RequestModesOpts;
+
+     credentials: RequestCredentialsOpts;
+
+
+    /**
+     * Headers object based on the `Headers` class in the [Fetch
+     * Spec](https://fetch.spec.whatwg.org/#headers-class). {@link Headers} class reference.
+     */
+     headers: Headers;
+
+
+    /**
+     * Url of the remote resource
+     */
+     url: string;
+
+     cache: RequestCacheOpts;
+
+
+    /**
+     * Returns the request's body as string, assuming that body exists. If body is undefined, return
+     * empty
+     * string.
+     */
+     text(): String;
+  }
+
+
+  /**
+   * Creates `Response` instances from provided values.
+   *
+   * Though this object isn't
+   * usually instantiated by end-users, it is the primary object interacted with when it comes time to
+   * add data to a view.
+   *
+   * #Example
+   *
+   * ```
+   * http.request('my-friends.txt').subscribe(response => this.friends = response.text());
+   * ```
+   *
+   * The Response's interface is inspired by the Response constructor defined in the [Fetch
+   * Spec](https://fetch.spec.whatwg.org/#response-class), but is considered a static value whose body
+   * can be accessed many times. There are other differences in the implementation, but this is the
+   * most significant.
+   */
+  class Response {
+
+
+    /**
+     * One of "basic", "cors", "default", "error, or "opaque".
+     *
+     * Defaults to "default".
+     */
+     type: ResponseTypes;
+
+
+    /**
+     * True if the response's status is within 200-299
+     */
+     ok: boolean;
+
+
+    /**
+     * URL of response.
+     *
+     * Defaults to empty string.
+     */
+     url: string;
+
+
+    /**
+     * Status code returned by server.
+     *
+     * Defaults to 200.
+     */
+     status: number;
+
+
+    /**
+     * Text representing the corresponding reason phrase to the `status`, as defined in [ietf rfc 2616
+     * section 6.1.1](https://tools.ietf.org/html/rfc2616#section-6.1.1)
+     *
+     * Defaults to "OK"
+     */
+     statusText: string;
+
+
+    /**
+     * Non-standard property
+     *
+     * Denotes how many of the response body's bytes have been loaded, for example if the response is
+     * the result of a progress event.
+     */
+     bytesLoaded: number;
+
+
+    /**
+     * Non-standard property
+     *
+     * Denotes how many bytes are expected in the final response body.
+     */
+     totalBytes: number;
+
+
+    /**
+     * Headers object based on the `Headers` class in the [Fetch
+     * Spec](https://fetch.spec.whatwg.org/#headers-class).
+     */
+     headers: Headers;
+
+
+    /**
+     * Not yet implemented
+     */
+     blob(): any;
+
+
+    /**
+     * Attempts to return body as parsed `JSON` object, or raises an exception.
+     */
+     json(): Object;
+
+
+    /**
+     * Returns the body as a string, presuming `toString()` can be called on the response body.
+     */
+     text(): string;
+
+
+    /**
+     * Not yet implemented
+     */
+     arrayBuffer(): any;
+  }
+
+
+  /**
+   * Interface for options to construct a Request, based on
+   * [RequestInit](https://fetch.spec.whatwg.org/#requestinit) from the Fetch spec.
+   */
+  interface RequestOptionsArgs {
+
+     url?: string;
+
+     method?: RequestMethods;
+
+     search?: string | URLSearchParams;
+
+     headers?: Headers;
+
+     body?: string;
+
+     mode?: RequestModesOpts;
+
+     credentials?: RequestCredentialsOpts;
+
+     cache?: RequestCacheOpts;
+  }
+
+
+  /**
+   * Interface for options to construct a Response, based on
+   * [ResponseInit](https://fetch.spec.whatwg.org/#responseinit) from the Fetch spec.
+   */
+  interface ResponseOptionsArgs {
+
+     body?: string | Object | FormData;
+
+     status?: number;
+
+     statusText?: string;
+
+     headers?: Headers;
+
+     type?: ResponseTypes;
+
+     url?: string;
+  }
+
+
+  /**
+   * Abstract class from which real connections are derived.
+   */
+  class Connection {
+
+     readyState: ReadyStates;
+
+     request: Request;
+
+     response: ng.EventEmitter;
+
+     dispose(): void;
+  }
+
+
+  /**
+   * Abstract class from which real backends are derived.
+   *
+   * The primary purpose of a `ConnectionBackend` is to create new connections to fulfill a given
+   * {@link Request}.
+   */
+  class ConnectionBackend {
+
+     createConnection(request: any): Connection;
+  }
+
+  class BrowserXhr {
+
+     build(): any;
+  }
+
+
+  /**
+   * Injectable version of {@link RequestOptions}, with overridable default values.
+   *
+   * #Example
+   *
+   * ```
+   * import {Http, BaseRequestOptions, Request} from 'angular2/http';
+   * ...
+   * class MyComponent {
+   *   constructor(baseRequestOptions:BaseRequestOptions, http:Http) {
+   *     var options = baseRequestOptions.merge({body: 'foobar', url: 'https://foo'});
+   *     var request = new Request(options);
+   *     http.request(request).subscribe(res => this.bars = res.json());
+   *   }
+   * }
+   *
+   * ```
+   */
+  class BaseRequestOptions extends RequestOptions {
+  }
+
+
+  /**
+   * Creates a request options object similar to the `RequestInit` description
+   * in the [Fetch
+   * Spec](https://fetch.spec.whatwg.org/#requestinit) to be optionally provided when instantiating a
+   * {@link Request}.
+   *
+   * All values are null by default.
+   */
+  class RequestOptions {
+
+
+    /**
+     * Http method with which to execute the request.
+     *
+     * Defaults to "GET".
+     */
+     method: RequestMethods;
+
+
+    /**
+     * Headers object based on the `Headers` class in the [Fetch
+     * Spec](https://fetch.spec.whatwg.org/#headers-class).
+     */
+     headers: Headers;
+
+
+    /**
+     * Body to be used when creating the request.
+     */
+     body: string;
+
+     mode: RequestModesOpts;
+
+     credentials: RequestCredentialsOpts;
+
+     cache: RequestCacheOpts;
+
+     url: string;
+
+     search: URLSearchParams;
+
+
+    /**
+     * Creates a copy of the `RequestOptions` instance, using the optional input as values to override
+     * existing values.
+     */
+     merge(options?: RequestOptionsArgs): RequestOptions;
+  }
+
+
+  /**
+   * Injectable version of {@link ResponseOptions}, with overridable default values.
+   */
+  class BaseResponseOptions extends ResponseOptions {
+
+     body: string | Object | ArrayBuffer | JSON | FormData | Blob;
+
+     status: number;
+
+     headers: Headers;
+
+     statusText: string;
+
+     type: ResponseTypes;
+
+     url: string;
+  }
+
+
+  /**
+   * Creates a response options object similar to the
+   * [ResponseInit](https://fetch.spec.whatwg.org/#responseinit) description
+   * in the Fetch
+   * Spec to be optionally provided when instantiating a
+   * {@link Response}.
+   *
+   * All values are null by default.
+   */
+  class ResponseOptions {
+
+     body: string | Object;
+
+     status: number;
+
+     headers: Headers;
+
+     statusText: string;
+
+     type: ResponseTypes;
+
+     url: string;
+
+     merge(options?: ResponseOptionsArgs): ResponseOptions;
+  }
+
+
+  /**
+   * Creates {@link XHRConnection} instances.
+   *
+   * This class would typically not be used by end users, but could be
+   * overridden if a different backend implementation should be used,
+   * such as in a node backend.
+   *
+   * #Example
+   *
+   * ```
+   * import {Http, MyNodeBackend, HTTP_BINDINGS, BaseRequestOptions} from 'angular2/http';
+   * @Component({
+   *   viewBindings: [
+   *     HTTP_BINDINGS,
+   *     bind(Http).toFactory((backend, options) => {
+   *       return new Http(backend, options);
+   *     }, [MyNodeBackend, BaseRequestOptions])]
+   * })
+   * class MyComponent {
+   *   constructor(http:Http) {
+   *     http('people.json').subscribe(res => this.people = res.json());
+   *   }
+   * }
+   * ```
+   */
+  class XHRBackend implements ConnectionBackend {
+
+     createConnection(request: Request): XHRConnection;
+  }
+
+
+  /**
+   * Creates connections using `XMLHttpRequest`. Given a fully-qualified
+   * request, an `XHRConnection` will immediately create an `XMLHttpRequest` object and send the
+   * request.
+   *
+   * This class would typically not be created or interacted with directly inside applications, though
+   * the {@link MockConnection} may be interacted with in tests.
+   */
+  class XHRConnection implements Connection {
+
+     request: Request;
+
+
+    /**
+     * Response {@link EventEmitter} which emits a single {@link Response} value on load event of
+     * `XMLHttpRequest`.
+     */
+     response: ng.EventEmitter;
+
+     readyState: ReadyStates;
+
+
+    /**
+     * Calls abort on the underlying XMLHttpRequest.
+     */
+     dispose(): void;
+  }
+
+  class JSONPBackend implements ConnectionBackend {
+
+     createConnection(request: Request): JSONPConnection;
+  }
+
+  class JSONPConnection implements Connection {
+
+     readyState: ReadyStates;
+
+     request: Request;
+
+     response: ng.EventEmitter;
+
+     baseResponseOptions: ResponseOptions;
+
+     finished(data?: any): void;
+
+     dispose(): void;
+  }
+
+
+  /**
+   * Performs http requests using `XMLHttpRequest` as the default backend.
+   *
+   * `Http` is available as an injectable class, with methods to perform http requests. Calling
+   * `request` returns an {@link EventEmitter} which will emit a single {@link Response} when a
+   * response is received.
+   *
+   *
+   * ## Breaking Change
+   *
+   * Previously, methods of `Http` would return an RxJS Observable directly. For now,
+   * the `toRx()` method of {@link EventEmitter} needs to be called in order to get the RxJS
+   * Subject. `EventEmitter` does not provide combinators like `map`, and has different semantics for
+   * subscribing/observing. This is temporary; the result of all `Http` method calls will be either an
+   * Observable
+   * or Dart Stream when [issue #2794](https://github.com/angular/angular/issues/2794) is resolved.
+   *
+   * #Example
+   *
+   * ```
+   * import {Http, HTTP_BINDINGS} from 'angular2/http';
+   * @Component({selector: 'http-app', viewBindings: [HTTP_BINDINGS]})
+   * @View({templateUrl: 'people.html'})
+   * class PeopleComponent {
+   *   constructor(http: Http) {
+   *     http.get('people.json')
+   *       //Get the RxJS Subject
+   *       .toRx()
+   *       // Call map on the response observable to get the parsed people object
+   *       .map(res => res.json())
+   *       // Subscribe to the observable to get the parsed people object and attach it to the
+   *       // component
+   *       .subscribe(people => this.people = people);
+   *   }
+   * }
+   * ```
+   *
+   * To use the {@link EventEmitter} returned by `Http`, simply pass a generator (See "interface
+   * Generator" in the Async Generator spec: https://github.com/jhusain/asyncgenerator) to the
+   * `observer` method of the returned emitter, with optional methods of `next`, `throw`, and `return`.
+   *
+   * #Example
+   *
+   * ```
+   * http.get('people.json').observer({next: (value) => this.people = people});
+   * ```
+   *
+   * The default construct used to perform requests, `XMLHttpRequest`, is abstracted as a "Backend" (
+   * {@link XHRBackend} in this case), which could be mocked with dependency injection by replacing
+   * the {@link XHRBackend} binding, as in the following example:
+   *
+   * #Example
+   *
+   * ```
+   * import {MockBackend, BaseRequestOptions, Http} from 'angular2/http';
+   * var injector = Injector.resolveAndCreate([
+   *   BaseRequestOptions,
+   *   MockBackend,
+   *   bind(Http).toFactory(
+   *       function(backend, defaultOptions) {
+   *         return new Http(backend, defaultOptions);
+   *       },
+   *       [MockBackend, BaseRequestOptions])
+   * ]);
+   * var http = injector.get(Http);
+   * http.get('request-from-mock-backend.json').toRx().subscribe((res:Response) => doSomething(res));
+   * ```
+   */
+  class Http {
+
+
+    /**
+     * Performs any type of http request. First argument is required, and can either be a url or
+     * a {@link Request} instance. If the first argument is a url, an optional {@link RequestOptions}
+     * object can be provided as the 2nd argument. The options object will be merged with the values
+     * of {@link BaseRequestOptions} before performing the request.
+     */
+     request(url: string | Request, options?: RequestOptionsArgs): ng.EventEmitter;
+
+
+    /**
+     * Performs a request with `get` http method.
+     */
+     get(url: string, options?: RequestOptionsArgs): ng.EventEmitter;
+
+
+    /**
+     * Performs a request with `post` http method.
+     */
+     post(url: string, body: string, options?: RequestOptionsArgs): ng.EventEmitter;
+
+
+    /**
+     * Performs a request with `put` http method.
+     */
+     put(url: string, body: string, options?: RequestOptionsArgs): ng.EventEmitter;
+
+
+    /**
+     * Performs a request with `delete` http method.
+     */
+     delete(url: string, options?: RequestOptionsArgs): ng.EventEmitter;
+
+
+    /**
+     * Performs a request with `patch` http method.
+     */
+     patch(url: string, body: string, options?: RequestOptionsArgs): ng.EventEmitter;
+
+
+    /**
+     * Performs a request with `head` http method.
+     */
+     head(url: string, options?: RequestOptionsArgs): ng.EventEmitter;
+  }
+
+  class Jsonp extends Http {
+
+
+    /**
+     * Performs any type of http request. First argument is required, and can either be a url or
+     * a {@link Request} instance. If the first argument is a url, an optional {@link RequestOptions}
+     * object can be provided as the 2nd argument. The options object will be merged with the values
+     * of {@link BaseRequestOptions} before performing the request.
+     */
+     request(url: string | Request, options?: RequestOptionsArgs): ng.EventEmitter;
+  }
+
+
+  /**
+   * Polyfill for [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers/Headers), as
+   * specified in the [Fetch Spec](https://fetch.spec.whatwg.org/#headers-class). The only known
+   * difference from the spec is the lack of an `entries` method.
+   */
+  class Headers {
+
+
+    /**
+     * Appends a header to existing list of header values for a given header name.
+     */
+     append(name: string, value: string): void;
+
+
+    /**
+     * Deletes all header values for the given name.
+     */
+     delete(name: string): void;
+
+     forEach(fn: Function): void;
+
+
+    /**
+     * Returns first header that matches given name.
+     */
+     get(header: string): string;
+
+
+    /**
+     * Check for existence of header by given name.
+     */
+     has(header: string): boolean;
+
+
+    /**
+     * Provides names of set headers
+     */
+     keys(): string[];
+
+
+    /**
+     * Sets or overrides header value for given name.
+     */
+     set(header: string, value: string | string[]): void;
+
+
+    /**
+     * Returns values of all headers.
+     */
+     values(): string[][];
+
+
+    /**
+     * Returns list of header values for a given name.
+     */
+     getAll(header: string): string[];
+
+
+    /**
+     * This method is not implemented.
+     */
+     entries(): void;
+  }
+
+
+  /**
+   * Acceptable response types to be associated with a {@link Response}, based on
+   * [ResponseType](https://fetch.spec.whatwg.org/#responsetype) from the Fetch spec.
+   */
+  enum ResponseTypes {
+
+     Basic,
+
+     Cors,
+
+     Default,
+
+     Error,
+
+     Opaque
+  }
+
+
+  /**
+   * All possible states in which a connection can be, based on
+   * [States](http://www.w3.org/TR/XMLHttpRequest/#states) from the `XMLHttpRequest` spec, but with an
+   * additional "CANCELLED" state.
+   */
+  enum ReadyStates {
+
+     Unsent,
+
+     Open,
+
+     HeadersReceived,
+
+     Loading,
+
+     Done,
+
+     Cancelled
+  }
+
+
+  /**
+   * Supported http methods.
+   */
+  enum RequestMethods {
+
+     Get,
+
+     Post,
+
+     Put,
+
+     Delete,
+
+     Options,
+
+     Head,
+
+     Patch
+  }
+
+
+  /**
+   * Acceptable credentials option to be associated with a {@link Request}, based on
+   * [RequestCredentials](https://fetch.spec.whatwg.org/#requestcredentials) from the Fetch spec.
+   */
+  enum RequestCredentialsOpts {
+
+     Omit,
+
+     SameOrigin,
+
+     Include
+  }
+
+
+  /**
+   * Acceptable cache option to be associated with a {@link Request}, based on
+   * [RequestCache](https://fetch.spec.whatwg.org/#requestcache) from the Fetch spec.
+   */
+  enum RequestCacheOpts {
+
+     Default,
+
+     NoStore,
+
+     Reload,
+
+     NoCache,
+
+     ForceCache,
+
+     OnlyIfCached
+  }
+
+
+  /**
+   * Acceptable origin modes to be associated with a {@link Request}, based on
+   * [RequestMode](https://fetch.spec.whatwg.org/#requestmode) from the Fetch spec.
+   */
+  enum RequestModesOpts {
+
+     Cors,
+
+     NoCors,
+
+     SameOrigin
+  }
+
+
+  /**
+   * Map-like representation of url search parameters, based on
+   * [URLSearchParams](https://url.spec.whatwg.org/#urlsearchparams) in the url living standard,
+   * with several extensions for merging URLSearchParams objects:
+   *   - setAll()
+   *   - appendAll()
+   *   - replaceAll()
+   */
+  class URLSearchParams {
+
+     paramsMap: Map<string, string[]>;
+
+     rawParams: string;
+
+     clone(): URLSearchParams;
+
+     has(param: string): boolean;
+
+     get(param: string): string;
+
+     getAll(param: string): string[];
+
+     set(param: string, val: string): void;
+
+     setAll(searchParams: URLSearchParams): void;
+
+     append(param: string, val: string): void;
+
+     appendAll(searchParams: URLSearchParams): void;
+
+     replaceAll(searchParams: URLSearchParams): void;
+
+     toString(): string;
+
+     delete(param: string): void;
+  }
+
+
+  /**
+   * Provides a basic set of injectables to use the {@link Http} service in any application.
+   *
+   * #Example
+   *
+   * ```
+   * import {HTTP_BINDINGS, Http} from 'http/http';
+   * @Component({selector: 'http-app', viewBindings: [HTTP_BINDINGS]})
+   * @View({template: '{{data}}'})
+   * class MyApp {
+   *   constructor(http:Http) {
+   *     http.request('data.txt').subscribe(res => this.data = res.text());
+   *   }
+   * }
+   * ```
+   */
+  const HTTP_BINDINGS : any[] ;
+
+  const JSONP_BINDINGS : any[] ;
+
+}
+
+declare module "angular2/http" {
+  export = ngHttp;
+}
+
+
diff --git a/angular2/router-2.0.0-alpha.35.d.ts b/angular2/router-2.0.0-alpha.35.d.ts
index 295593850e..0bba14cbbc 100644
--- a/angular2/router-2.0.0-alpha.35.d.ts
+++ b/angular2/router-2.0.0-alpha.35.d.ts
@@ -81,7 +81,7 @@ declare module ngRouter {
      * ]);
      * ```
      */
-     config(definitions: List<RouteDefinition>): Promise<any>;
+     config(definitions: Array<RouteDefinition>): Promise<any>;
     
 
     /**
@@ -135,7 +135,7 @@ declare module ngRouter {
      * Generate a URL from a component name and optional map of parameters. The URL is relative to the
      * app's base href.
      */
-     generate(linkParams: List<any>): Instruction;
+     generate(linkParams: Array<any>): Instruction;
   }
   
   class RootRouter extends Router {
@@ -258,7 +258,7 @@ declare module ngRouter {
      * Given a normalized list with component names and params like: `['user', {id: 3 }]`
      * generates a url with a leading slash relative to the provided `parentComponent`.
      */
-     generate(linkParams: List<any>, parentComponent: any): Instruction;
+     generate(linkParams: Array<any>, parentComponent: any): Instruction;
   }
   
   class LocationStrategy {
@@ -343,7 +343,7 @@ declare module ngRouter {
    */
   class Pipeline {
     
-     steps: List<Function>;
+     steps: Array<Function>;
     
      process(instruction: Instruction): Promise<any>;
   }
@@ -547,7 +547,7 @@ declare module ngRouter {
     
      urlPath: string;
     
-     urlParams: List<string>;
+     urlParams: Array<string>;
     
      params: StringMap<string, any>;
     
@@ -568,7 +568,7 @@ declare module ngRouter {
     
      child: Url;
     
-     auxiliary: List<Url>;
+     auxiliary: Array<Url>;
     
      params: StringMap<string, any>;
     
@@ -594,9 +594,9 @@ declare module ngRouter {
   
   }
   
-  const routerDirectives : List<any> ;
+  const routerDirectives : Array<any> ;
   
-  var routerInjectables : List<any> ;
+  var routerInjectables : Array<any> ;
   
   class Route implements RouteDefinition {
     
@@ -669,7 +669,7 @@ declare module ngRouter {
   
   const ROUTE_DATA : OpaqueToken ;
   
-  var RouteConfig : (configs: List<RouteDefinition>) => ClassDecorator ;
+  var RouteConfig : (configs: Array<RouteDefinition>) => ClassDecorator ;
   
   interface ComponentDefinition {
     
diff --git a/angular2/router-2.0.0-alpha.36.d.ts b/angular2/router-2.0.0-alpha.36.d.ts
index fd5891af9f..c862376384 100644
--- a/angular2/router-2.0.0-alpha.36.d.ts
+++ b/angular2/router-2.0.0-alpha.36.d.ts
@@ -81,7 +81,7 @@ declare module ngRouter {
      * ]);
      * ```
      */
-     config(definitions: List<RouteDefinition>): Promise<any>;
+     config(definitions: Array<RouteDefinition>): Promise<any>;
     
 
     /**
@@ -135,7 +135,7 @@ declare module ngRouter {
      * Generate a URL from a component name and optional map of parameters. The URL is relative to the
      * app's base href.
      */
-     generate(linkParams: List<any>): Instruction;
+     generate(linkParams: Array<any>): Instruction;
   }
   
   class RootRouter extends Router {
@@ -258,7 +258,7 @@ declare module ngRouter {
      * Given a normalized list with component names and params like: `['user', {id: 3 }]`
      * generates a url with a leading slash relative to the provided `parentComponent`.
      */
-     generate(linkParams: List<any>, parentComponent: any): Instruction;
+     generate(linkParams: Array<any>, parentComponent: any): Instruction;
   }
   
   class LocationStrategy {
@@ -343,7 +343,7 @@ declare module ngRouter {
    */
   class Pipeline {
     
-     steps: List<Function>;
+     steps: Array<Function>;
     
      process(instruction: Instruction): Promise<any>;
   }
@@ -547,7 +547,7 @@ declare module ngRouter {
     
      urlPath: string;
     
-     urlParams: List<string>;
+     urlParams: Array<string>;
     
      params: StringMap<string, any>;
     
@@ -568,7 +568,7 @@ declare module ngRouter {
     
      child: Url;
     
-     auxiliary: List<Url>;
+     auxiliary: Array<Url>;
     
      params: StringMap<string, any>;
     
@@ -596,9 +596,9 @@ declare module ngRouter {
   
   const ROUTE_DATA : OpaqueToken ;
   
-  const ROUTER_DIRECTIVES : List<any> ;
+  const ROUTER_DIRECTIVES : Array<any> ;
   
-  const ROUTER_BINDINGS : List<any> ;
+  const ROUTER_BINDINGS : Array<any> ;
   
   class Route implements RouteDefinition {
     
@@ -669,7 +669,7 @@ declare module ngRouter {
      data?: any;
   }
   
-  var RouteConfig : (configs: List<RouteDefinition>) => ClassDecorator ;
+  var RouteConfig : (configs: Array<RouteDefinition>) => ClassDecorator ;
   
   interface ComponentDefinition {
     
diff --git a/angular2/router-2.0.0-alpha.37.d.ts b/angular2/router-2.0.0-alpha.37.d.ts
new file mode 100644
index 0000000000..69ea2a5afa
--- /dev/null
+++ b/angular2/router-2.0.0-alpha.37.d.ts
@@ -0,0 +1,738 @@
+// Type definitions for Angular v2.0.0-alpha.37
+// Project: http://angular.io/
+// Definitions by: angular team <https://github.com/angular/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// ***********************************************************
+// This file is generated by the Angular build process.
+// Please do not create manual edits or send pull requests
+// modifying this file.
+// ***********************************************************
+
+// angular2/router depends transitively on these libraries.
+// If you don't have them installed you can install them using TSD
+// https://github.com/DefinitelyTyped/tsd
+
+///<reference path="./angular2.d.ts"/>
+
+
+
+
+/**
+ * @module
+ * @description
+ * Maps application URLs into application states, to support deep-linking and navigation.
+ */
+declare module ngRouter {
+
+  /**
+   * # Router
+   * The router is responsible for mapping URLs to components.
+   *
+   * You can see the state of the router by inspecting the read-only field `router.navigating`.
+   * This may be useful for showing a spinner, for instance.
+   *
+   * ## Concepts
+   * Routers and component instances have a 1:1 correspondence.
+   *
+   * The router holds reference to a number of "outlets." An outlet is a placeholder that the
+   * router dynamically fills in depending on the current URL.
+   *
+   * When the router navigates from a URL, it must first recognizes it and serialize it into an
+   * `Instruction`.
+   * The router uses the `RouteRegistry` to get an `Instruction`.
+   */
+  class Router {
+
+     navigating: boolean;
+
+     lastNavigationAttempt: string;
+
+     registry: RouteRegistry;
+
+     parent: Router;
+
+     hostComponent: any;
+
+
+    /**
+     * Constructs a child router. You probably don't need to use this unless you're writing a reusable
+     * component.
+     */
+     childRouter(hostComponent: any): Router;
+
+
+    /**
+     * Constructs a child router. You probably don't need to use this unless you're writing a reusable
+     * component.
+     */
+     auxRouter(hostComponent: any): Router;
+
+
+    /**
+     * Register an outlet to notified of primary route changes.
+     *
+     * You probably don't need to use this unless you're writing a reusable component.
+     */
+     registerPrimaryOutlet(outlet: RouterOutlet): Promise<boolean>;
+
+
+    /**
+     * Register an outlet to notified of auxiliary route changes.
+     *
+     * You probably don't need to use this unless you're writing a reusable component.
+     */
+     registerAuxOutlet(outlet: RouterOutlet): Promise<boolean>;
+
+
+    /**
+     * Given an instruction, returns `true` if the instruction is currently active,
+     * otherwise `false`.
+     */
+     isRouteActive(instruction: Instruction): boolean;
+
+
+    /**
+     * Dynamically update the routing configuration and trigger a navigation.
+     *
+     * # Usage
+     *
+     * ```
+     * router.config([
+     *   { 'path': '/', 'component': IndexComp },
+     *   { 'path': '/user/:id', 'component': UserComp },
+     * ]);
+     * ```
+     */
+     config(definitions: RouteDefinition[]): Promise<any>;
+
+
+    /**
+     * Navigate to a URL. Returns a promise that resolves when navigation is complete.
+     *
+     * If the given URL begins with a `/`, router will navigate absolutely.
+     * If the given URL does not begin with `/`, the router will navigate relative to this component.
+     */
+     navigate(url: string, _skipLocationChange?: boolean): Promise<any>;
+
+
+    /**
+     * Navigate via the provided instruction. Returns a promise that resolves when navigation is
+     * complete.
+     */
+     navigateInstruction(instruction: Instruction, _skipLocationChange?: boolean): Promise<any>;
+
+
+    /**
+     * Updates this router and all descendant routers according to the given instruction
+     */
+     commit(instruction: Instruction, _skipLocationChange?: boolean): Promise<any>;
+
+
+    /**
+     * Subscribe to URL updates from the router
+     */
+     subscribe(onNext: (value: any) => void): Object;
+
+
+    /**
+     * Removes the contents of this router's outlet and all descendant outlets
+     */
+     deactivate(instruction: Instruction): Promise<any>;
+
+
+    /**
+     * Given a URL, returns an instruction representing the component graph
+     */
+     recognize(url: string): Promise<Instruction>;
+
+
+    /**
+     * Navigates to either the last URL successfully navigated to, or the last URL requested if the
+     * router has yet to successfully navigate.
+     */
+     renavigate(): Promise<any>;
+
+
+    /**
+     * Generate a URL from a component name and optional map of parameters. The URL is relative to the
+     * app's base href.
+     */
+     generate(linkParams: any[]): Instruction;
+  }
+
+  class RootRouter extends Router {
+
+     commit(instruction: Instruction, _skipLocationChange?: boolean): Promise<any>;
+  }
+
+
+  /**
+   * A router outlet is a placeholder that Angular dynamically fills based on the application's route.
+   *
+   * ## Use
+   *
+   * ```
+   * <router-outlet></router-outlet>
+   * ```
+   */
+  class RouterOutlet {
+
+     name: string;
+
+
+    /**
+     * Called by the Router to instantiate a new component during the commit phase of a navigation.
+     * This method in turn is responsible for calling the `onActivate` hook of its child.
+     */
+     activate(nextInstruction: ComponentInstruction): Promise<any>;
+
+
+    /**
+     * Called by the {@link Router} during the commit phase of a navigation when an outlet
+     * reuses a component between different routes.
+     * This method in turn is responsible for calling the `onReuse` hook of its child.
+     */
+     reuse(nextInstruction: ComponentInstruction): Promise<any>;
+
+
+    /**
+     * Called by the {@link Router} when an outlet reuses a component across navigations.
+     * This method in turn is responsible for calling the `onReuse` hook of its child.
+     */
+     deactivate(nextInstruction: ComponentInstruction): Promise<any>;
+
+
+    /**
+     * Called by the {@link Router} during recognition phase of a navigation.
+     *
+     * If this resolves to `false`, the given navigation is cancelled.
+     *
+     * This method delegates to the child component's `canDeactivate` hook if it exists,
+     * and otherwise resolves to true.
+     */
+     canDeactivate(nextInstruction: ComponentInstruction): Promise<boolean>;
+
+
+    /**
+     * Called by the {@link Router} during recognition phase of a navigation.
+     *
+     * If the new child component has a different Type than the existing child component,
+     * this will resolve to `false`. You can't reuse an old component when the new component
+     * is of a different Type.
+     *
+     * Otherwise, this method delegates to the child component's `canReuse` hook if it exists,
+     * or resolves to true if the hook is not present.
+     */
+     canReuse(nextInstruction: ComponentInstruction): Promise<boolean>;
+  }
+
+
+  /**
+   * The RouterLink directive lets you link to specific parts of your app.
+   *
+   * Consider the following route configuration:
+   *
+   * ```
+   * @RouteConfig([
+   *   { path: '/user', component: UserCmp, as: 'user' }
+   * ]);
+   * class MyComp {}
+   * ```
+   *
+   * When linking to this `user` route, you can write:
+   *
+   * ```
+   * <a [router-link]="['./user']">link to user component</a>
+   * ```
+   *
+   * RouterLink expects the value to be an array of route names, followed by the params
+   * for that level of routing. For instance `['/team', {teamId: 1}, 'user', {userId: 2}]`
+   * means that we want to generate a link for the `team` route with params `{teamId: 1}`,
+   * and with a child route `user` with params `{userId: 2}`.
+   *
+   * The first route name should be prepended with `/`, `./`, or `../`.
+   * If the route begins with `/`, the router will look up the route from the root of the app.
+   * If the route begins with `./`, the router will instead look in the current component's
+   * children for the route. And if the route begins with `../`, the router will look at the
+   * current component's parent.
+   */
+  class RouterLink {
+
+     visibleHref: string;
+
+     isRouteActive: boolean;
+
+     routeParams: any;
+
+     onClick(): boolean;
+  }
+
+  class RouteParams {
+
+     params: StringMap<string, string>;
+
+     get(param: string): string;
+  }
+
+
+  /**
+   * The RouteRegistry holds route configurations for each component in an Angular app.
+   * It is responsible for creating Instructions from URLs, and generating URLs based on route and
+   * parameters.
+   */
+  class RouteRegistry {
+
+
+    /**
+     * Given a component and a configuration object, add the route to this registry
+     */
+     config(parentComponent: any, config: RouteDefinition): void;
+
+
+    /**
+     * Reads the annotations of a component and configures the registry based on them
+     */
+     configFromComponent(component: any): void;
+
+
+    /**
+     * Given a URL and a parent component, return the most specific instruction for navigating
+     * the application into the state specified by the url
+     */
+     recognize(url: string, parentComponent: any): Promise<Instruction>;
+
+
+    /**
+     * Given a normalized list with component names and params like: `['user', {id: 3 }]`
+     * generates a url with a leading slash relative to the provided `parentComponent`.
+     */
+     generate(linkParams: any[], parentComponent: any): Instruction;
+  }
+
+  class LocationStrategy {
+
+     path(): string;
+
+     pushState(ctx: any, title: string, url: string): void;
+
+     forward(): void;
+
+     back(): void;
+
+     onPopState(fn: (_: any) => any): void;
+
+     getBaseHref(): string;
+  }
+
+  class HashLocationStrategy extends LocationStrategy {
+
+     onPopState(fn: EventListener): void;
+
+     getBaseHref(): string;
+
+     path(): string;
+
+     pushState(state: any, title: string, url: string): void;
+
+     forward(): void;
+
+     back(): void;
+  }
+
+  class PathLocationStrategy extends LocationStrategy {
+
+     onPopState(fn: EventListener): void;
+
+     getBaseHref(): string;
+
+     path(): string;
+
+     pushState(state: any, title: string, url: string): void;
+
+     forward(): void;
+
+     back(): void;
+  }
+
+
+  /**
+   * This is the service that an application developer will directly interact with.
+   *
+   * Responsible for normalizing the URL against the application's base href.
+   * A normalized URL is absolute from the URL host, includes the application's base href, and has no
+   * trailing slash:
+   * - `/my/app/user/123` is normalized
+   * - `my/app/user/123` **is not** normalized
+   * - `/my/app/user/123/` **is not** normalized
+   */
+  class Location {
+
+     platformStrategy: LocationStrategy;
+
+     path(): string;
+
+     normalize(url: string): string;
+
+     normalizeAbsolutely(url: string): string;
+
+     go(url: string): void;
+
+     forward(): void;
+
+     back(): void;
+
+     subscribe(onNext: (value: any) => void, onThrow?: (exception: any) => void, onReturn?: () => void): void;
+  }
+
+  const APP_BASE_HREF : OpaqueToken ;
+
+
+  /**
+   * Responsible for performing each step of navigation.
+   * "Steps" are conceptually similar to "middleware"
+   */
+  class Pipeline {
+
+     steps: Function[];
+
+     process(instruction: Instruction): Promise<any>;
+  }
+
+
+  /**
+   * Defines route lifecycle method [onActivate], which is called by the router at the end of a
+   * successful route navigation.
+   *
+   * For a single component's navigation, only one of either [onActivate] or [onReuse] will be called,
+   * depending on the result of [canReuse].
+   *
+   * If `onActivate` returns a promise, the route change will wait until the promise settles to
+   * instantiate and activate child components.
+   *
+   * ## Example
+   * ```
+   * @Directive({
+   *   selector: 'my-cmp'
+   * })
+   * class MyCmp implements OnActivate {
+   *   onActivate(next, prev) {
+   *     this.log = 'Finished navigating from ' + prev.urlPath + ' to ' + next.urlPath;
+   *   }
+   * }
+   *  ```
+   */
+  interface OnActivate {
+
+     onActivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+  }
+
+
+  /**
+   * Defines route lifecycle method [onDeactivate], which is called by the router before destroying
+   * a component as part of a route change.
+   *
+   * If `onDeactivate` returns a promise, the route change will wait until the promise settles.
+   *
+   * ## Example
+   * ```
+   * @Directive({
+   *   selector: 'my-cmp'
+   * })
+   * class MyCmp implements CanReuse, OnReuse {
+   *   canReuse() {
+   *     return true;
+   *   }
+   *
+   *   onReuse(next, prev) {
+   *     this.params = next.params;
+   *   }
+   * }
+   *  ```
+   */
+  interface OnDeactivate {
+
+     onDeactivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+  }
+
+
+  /**
+   * Defines route lifecycle method [onReuse], which is called by the router at the end of a
+   * successful route navigation when [canReuse] is implemented and returns or resolves to true.
+   *
+   * For a single component's navigation, only one of either [onActivate] or [onReuse] will be called,
+   * depending on the result of [canReuse].
+   *
+   * ## Example
+   * ```
+   * @Directive({
+   *   selector: 'my-cmp'
+   * })
+   * class MyCmp implements CanReuse, OnReuse {
+   *   canReuse() {
+   *     return true;
+   *   }
+   *
+   *   onReuse(next, prev) {
+   *     this.params = next.params;
+   *   }
+   * }
+   *  ```
+   */
+  interface OnReuse {
+
+     onReuse(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+  }
+
+
+  /**
+   * Defines route lifecycle method [canDeactivate], which is called by the router to determine
+   * if a component can be removed as part of a navigation.
+   *
+   * If `canDeactivate` returns or resolves to `false`, the navigation is cancelled.
+   *
+   * If `canDeactivate` throws or rejects, the navigation is also cancelled.
+   *
+   * ## Example
+   * ```
+   * @Directive({
+   *   selector: 'my-cmp'
+   * })
+   * class MyCmp implements CanDeactivate {
+   *   canDeactivate(next, prev) {
+   *     return askUserIfTheyAreSureTheyWantToQuit();
+   *   }
+   * }
+   *  ```
+   */
+  interface CanDeactivate {
+
+     canDeactivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+  }
+
+
+  /**
+   * Defines route lifecycle method [canReuse], which is called by the router to determine whether a
+   * component should be reused across routes, or whether to destroy and instantiate a new component.
+   *
+   * If `canReuse` returns or resolves to `true`, the component instance will be reused.
+   *
+   * If `canReuse` throws or rejects, the navigation will be cancelled.
+   *
+   * ## Example
+   * ```
+   * @Directive({
+   *   selector: 'my-cmp'
+   * })
+   * class MyCmp implements CanReuse, OnReuse {
+   *   canReuse(next, prev) {
+   *     return next.params.id == prev.params.id;
+   *   }
+   *
+   *   onReuse(next, prev) {
+   *     this.id = next.params.id;
+   *   }
+   * }
+   *  ```
+   */
+  interface CanReuse {
+
+     canReuse(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+  }
+
+
+  /**
+   * Defines route lifecycle method [canActivate], which is called by the router to determine
+   * if a component can be instantiated as part of a navigation.
+   *
+   * Note that unlike other lifecycle hooks, this one uses an annotation rather than an interface.
+   * This is because [canActivate] is called before the component is instantiated.
+   *
+   * If `canActivate` returns or resolves to `false`, the navigation is cancelled.
+   *
+   * If `canActivate` throws or rejects, the navigation is also cancelled.
+   *
+   * ## Example
+   * ```
+   * @Directive({
+   *   selector: 'control-panel-cmp'
+   * })
+   * @CanActivate(() => checkIfUserIsLoggedIn())
+   * class ControlPanelCmp {
+   *   // ...
+   * }
+   *  ```
+   */
+  var CanActivate : (hook: (next: ComponentInstruction, prev: ComponentInstruction) => Promise<boolean>| boolean) =>
+        ClassDecorator ;
+
+
+  /**
+   * `Instruction` is a tree of `ComponentInstructions`, with all the information needed
+   * to transition each component in the app to a given route, including all auxiliary routes.
+   *
+   * This is a public API.
+   */
+  class Instruction {
+
+     component: ComponentInstruction;
+
+     child: Instruction;
+
+     auxInstruction: StringMap<string, Instruction>;
+
+     replaceChild(child: Instruction): Instruction;
+  }
+
+
+  /**
+   * A `ComponentInstruction` represents the route state for a single component. An `Instruction` is
+   * composed of a tree of these `ComponentInstruction`s.
+   *
+   * `ComponentInstructions` is a public API. Instances of `ComponentInstruction` are passed
+   * to route lifecycle hooks, like {@link CanActivate}.
+   *
+   * `ComponentInstruction`s are [https://en.wikipedia.org/wiki/Hash_consing](hash consed). You should
+   * never construct one yourself with "new." Instead, rely on {@link PathRecognizer} to construct
+   * `ComponentInstruction`s.
+   *
+   * You should not modify this object. It should be treated as immutable.
+   */
+  class ComponentInstruction {
+
+     reuse: boolean;
+
+     urlPath: string;
+
+     urlParams: string[];
+
+     params: StringMap<string, any>;
+
+     componentType: any;
+
+     resolveComponentType(): Promise<ng.Type>;
+
+     specificity: any;
+
+     terminal: any;
+
+     routeData(): Object;
+  }
+
+
+  /**
+   * This class represents a parsed URL
+   */
+  class Url {
+
+     path: string;
+
+     child: Url;
+
+     auxiliary: Url[];
+
+     params: StringMap<string, any>;
+
+     toString(): string;
+
+     segmentToString(): string;
+  }
+
+  class OpaqueToken {
+
+     toString(): string;
+  }
+
+  const ROUTE_DATA : OpaqueToken ;
+
+  const ROUTER_DIRECTIVES : any[] ;
+
+  const ROUTER_BINDINGS : any[] ;
+
+  class Route implements RouteDefinition {
+
+     data: any;
+
+     path: string;
+
+     component: ng.Type;
+
+     as: string;
+
+     loader: Function;
+
+     redirectTo: string;
+  }
+
+  class Redirect implements RouteDefinition {
+
+     path: string;
+
+     redirectTo: string;
+
+     as: string;
+
+     loader: Function;
+
+     data: any;
+  }
+
+  class AuxRoute implements RouteDefinition {
+
+     data: any;
+
+     path: string;
+
+     component: ng.Type;
+
+     as: string;
+
+     loader: Function;
+
+     redirectTo: string;
+  }
+
+  class AsyncRoute implements RouteDefinition {
+
+     data: any;
+
+     path: string;
+
+     loader: Function;
+
+     as: string;
+  }
+
+  interface RouteDefinition {
+
+     path: string;
+
+     component?: ng.Type | ComponentDefinition;
+
+     loader?: Function;
+
+     redirectTo?: string;
+
+     as?: string;
+
+     data?: any;
+  }
+
+  var RouteConfig : (configs: RouteDefinition[]) => ClassDecorator ;
+
+  interface ComponentDefinition {
+
+     type: string;
+
+     loader?: Function;
+
+     component?: ng.Type;
+  }
+
+}
+
+declare module "angular2/router" {
+  export = ngRouter;
+}
+
+
diff --git a/angular2/router.d.ts b/angular2/router.d.ts
index fd5891af9f..69ea2a5afa 100644
--- a/angular2/router.d.ts
+++ b/angular2/router.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Angular v2.0.0-alpha.36
+// Type definitions for Angular v2.0.0-alpha.37
 // Project: http://angular.io/
 // Definitions by: angular team <https://github.com/angular/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -28,52 +28,75 @@ declare module ngRouter {
   /**
    * # Router
    * The router is responsible for mapping URLs to components.
-   * 
+   *
    * You can see the state of the router by inspecting the read-only field `router.navigating`.
    * This may be useful for showing a spinner, for instance.
-   * 
+   *
    * ## Concepts
    * Routers and component instances have a 1:1 correspondence.
-   * 
+   *
    * The router holds reference to a number of "outlets." An outlet is a placeholder that the
    * router dynamically fills in depending on the current URL.
-   * 
+   *
    * When the router navigates from a URL, it must first recognizes it and serialize it into an
    * `Instruction`.
    * The router uses the `RouteRegistry` to get an `Instruction`.
    */
   class Router {
-    
+
      navigating: boolean;
-    
+
      lastNavigationAttempt: string;
-    
+
      registry: RouteRegistry;
-    
+
      parent: Router;
-    
+
      hostComponent: any;
-    
+
 
     /**
      * Constructs a child router. You probably don't need to use this unless you're writing a reusable
      * component.
      */
      childRouter(hostComponent: any): Router;
-    
+
 
     /**
-     * Register an object to notify of route changes. You probably don't need to use this unless
-     * you're writing a reusable component.
+     * Constructs a child router. You probably don't need to use this unless you're writing a reusable
+     * component.
      */
-     registerOutlet(outlet: RouterOutlet): Promise<boolean>;
-    
+     auxRouter(hostComponent: any): Router;
+
+
+    /**
+     * Register an outlet to notified of primary route changes.
+     *
+     * You probably don't need to use this unless you're writing a reusable component.
+     */
+     registerPrimaryOutlet(outlet: RouterOutlet): Promise<boolean>;
+
+
+    /**
+     * Register an outlet to notified of auxiliary route changes.
+     *
+     * You probably don't need to use this unless you're writing a reusable component.
+     */
+     registerAuxOutlet(outlet: RouterOutlet): Promise<boolean>;
+
+
+    /**
+     * Given an instruction, returns `true` if the instruction is currently active,
+     * otherwise `false`.
+     */
+     isRouteActive(instruction: Instruction): boolean;
+
 
     /**
      * Dynamically update the routing configuration and trigger a navigation.
-     * 
+     *
      * # Usage
-     * 
+     *
      * ```
      * router.config([
      *   { 'path': '/', 'component': IndexComp },
@@ -81,129 +104,153 @@ declare module ngRouter {
      * ]);
      * ```
      */
-     config(definitions: List<RouteDefinition>): Promise<any>;
-    
+     config(definitions: RouteDefinition[]): Promise<any>;
+
 
     /**
      * Navigate to a URL. Returns a promise that resolves when navigation is complete.
-     * 
+     *
      * If the given URL begins with a `/`, router will navigate absolutely.
      * If the given URL does not begin with `/`, the router will navigate relative to this component.
      */
      navigate(url: string, _skipLocationChange?: boolean): Promise<any>;
-    
+
 
     /**
      * Navigate via the provided instruction. Returns a promise that resolves when navigation is
      * complete.
      */
      navigateInstruction(instruction: Instruction, _skipLocationChange?: boolean): Promise<any>;
-    
+
 
     /**
      * Updates this router and all descendant routers according to the given instruction
      */
      commit(instruction: Instruction, _skipLocationChange?: boolean): Promise<any>;
-    
+
 
     /**
      * Subscribe to URL updates from the router
      */
      subscribe(onNext: (value: any) => void): Object;
-    
+
 
     /**
      * Removes the contents of this router's outlet and all descendant outlets
      */
      deactivate(instruction: Instruction): Promise<any>;
-    
+
 
     /**
      * Given a URL, returns an instruction representing the component graph
      */
      recognize(url: string): Promise<Instruction>;
-    
+
 
     /**
      * Navigates to either the last URL successfully navigated to, or the last URL requested if the
      * router has yet to successfully navigate.
      */
      renavigate(): Promise<any>;
-    
+
 
     /**
      * Generate a URL from a component name and optional map of parameters. The URL is relative to the
      * app's base href.
      */
-     generate(linkParams: List<any>): Instruction;
+     generate(linkParams: any[]): Instruction;
   }
-  
+
   class RootRouter extends Router {
-    
+
      commit(instruction: Instruction, _skipLocationChange?: boolean): Promise<any>;
   }
-  
+
 
   /**
    * A router outlet is a placeholder that Angular dynamically fills based on the application's route.
-   * 
+   *
    * ## Use
-   * 
+   *
    * ```
    * <router-outlet></router-outlet>
    * ```
    */
   class RouterOutlet {
-    
-     childRouter: Router;
-    
+
      name: string;
-    
+
 
     /**
-     * Given an instruction, update the contents of this outlet.
+     * Called by the Router to instantiate a new component during the commit phase of a navigation.
+     * This method in turn is responsible for calling the `onActivate` hook of its child.
      */
-     commit(instruction: Instruction): Promise<any>;
-    
+     activate(nextInstruction: ComponentInstruction): Promise<any>;
+
 
     /**
-     * Called by Router during recognition phase
+     * Called by the {@link Router} during the commit phase of a navigation when an outlet
+     * reuses a component between different routes.
+     * This method in turn is responsible for calling the `onReuse` hook of its child.
      */
-     canDeactivate(nextInstruction: Instruction): Promise<boolean>;
-    
+     reuse(nextInstruction: ComponentInstruction): Promise<any>;
+
 
     /**
-     * Called by Router during recognition phase
+     * Called by the {@link Router} when an outlet reuses a component across navigations.
+     * This method in turn is responsible for calling the `onReuse` hook of its child.
      */
-     canReuse(nextInstruction: Instruction): Promise<boolean>;
-    
-     deactivate(nextInstruction: Instruction): Promise<any>;
+     deactivate(nextInstruction: ComponentInstruction): Promise<any>;
+
+
+    /**
+     * Called by the {@link Router} during recognition phase of a navigation.
+     *
+     * If this resolves to `false`, the given navigation is cancelled.
+     *
+     * This method delegates to the child component's `canDeactivate` hook if it exists,
+     * and otherwise resolves to true.
+     */
+     canDeactivate(nextInstruction: ComponentInstruction): Promise<boolean>;
+
+
+    /**
+     * Called by the {@link Router} during recognition phase of a navigation.
+     *
+     * If the new child component has a different Type than the existing child component,
+     * this will resolve to `false`. You can't reuse an old component when the new component
+     * is of a different Type.
+     *
+     * Otherwise, this method delegates to the child component's `canReuse` hook if it exists,
+     * or resolves to true if the hook is not present.
+     */
+     canReuse(nextInstruction: ComponentInstruction): Promise<boolean>;
   }
-  
+
 
   /**
    * The RouterLink directive lets you link to specific parts of your app.
-   * 
+   *
    * Consider the following route configuration:
-   * 
+   *
    * ```
    * @RouteConfig([
    *   { path: '/user', component: UserCmp, as: 'user' }
    * ]);
    * class MyComp {}
    * ```
-   * 
+   *
    * When linking to this `user` route, you can write:
-   * 
+   *
    * ```
    * <a [router-link]="['./user']">link to user component</a>
    * ```
-   * 
+   *
    * RouterLink expects the value to be an array of route names, followed by the params
    * for that level of routing. For instance `['/team', {teamId: 1}, 'user', {userId: 2}]`
    * means that we want to generate a link for the `team` route with params `{teamId: 1}`,
    * and with a child route `user` with params `{userId: 2}`.
-   * 
+   *
    * The first route name should be prepended with `/`, `./`, or `../`.
    * If the route begins with `/`, the router will look up the route from the root of the app.
    * If the route begins with `./`, the router will instead look in the current component's
@@ -211,21 +258,23 @@ declare module ngRouter {
    * current component's parent.
    */
   class RouterLink {
-    
+
      visibleHref: string;
-    
+
+     isRouteActive: boolean;
+
      routeParams: any;
-    
+
      onClick(): boolean;
   }
-  
+
   class RouteParams {
-    
+
      params: StringMap<string, string>;
-    
+
      get(param: string): string;
   }
-  
+
 
   /**
    * The RouteRegistry holds route configurations for each component in an Angular app.
@@ -233,83 +282,83 @@ declare module ngRouter {
    * parameters.
    */
   class RouteRegistry {
-    
+
 
     /**
      * Given a component and a configuration object, add the route to this registry
      */
      config(parentComponent: any, config: RouteDefinition): void;
-    
+
 
     /**
      * Reads the annotations of a component and configures the registry based on them
      */
      configFromComponent(component: any): void;
-    
+
 
     /**
      * Given a URL and a parent component, return the most specific instruction for navigating
      * the application into the state specified by the url
      */
      recognize(url: string, parentComponent: any): Promise<Instruction>;
-    
+
 
     /**
      * Given a normalized list with component names and params like: `['user', {id: 3 }]`
      * generates a url with a leading slash relative to the provided `parentComponent`.
      */
-     generate(linkParams: List<any>, parentComponent: any): Instruction;
+     generate(linkParams: any[], parentComponent: any): Instruction;
   }
-  
+
   class LocationStrategy {
-    
+
      path(): string;
-    
+
      pushState(ctx: any, title: string, url: string): void;
-    
+
      forward(): void;
-    
+
      back(): void;
-    
+
      onPopState(fn: (_: any) => any): void;
-    
+
      getBaseHref(): string;
   }
-  
+
   class HashLocationStrategy extends LocationStrategy {
-    
+
      onPopState(fn: EventListener): void;
-    
+
      getBaseHref(): string;
-    
+
      path(): string;
-    
+
      pushState(state: any, title: string, url: string): void;
-    
+
      forward(): void;
-    
+
      back(): void;
   }
-  
+
   class PathLocationStrategy extends LocationStrategy {
-    
+
      onPopState(fn: EventListener): void;
-    
+
      getBaseHref(): string;
-    
+
      path(): string;
-    
+
      pushState(state: any, title: string, url: string): void;
-    
+
      forward(): void;
-    
+
      back(): void;
   }
-  
+
 
   /**
    * This is the service that an application developer will directly interact with.
-   * 
+   *
    * Responsible for normalizing the URL against the application's base href.
    * A normalized URL is absolute from the URL host, includes the application's base href, and has no
    * trailing slash:
@@ -318,47 +367,49 @@ declare module ngRouter {
    * - `/my/app/user/123/` **is not** normalized
    */
   class Location {
-    
+
+     platformStrategy: LocationStrategy;
+
      path(): string;
-    
+
      normalize(url: string): string;
-    
+
      normalizeAbsolutely(url: string): string;
-    
+
      go(url: string): void;
-    
+
      forward(): void;
-    
+
      back(): void;
-    
+
      subscribe(onNext: (value: any) => void, onThrow?: (exception: any) => void, onReturn?: () => void): void;
   }
-  
+
   const APP_BASE_HREF : OpaqueToken ;
-  
+
 
   /**
    * Responsible for performing each step of navigation.
    * "Steps" are conceptually similar to "middleware"
    */
   class Pipeline {
-    
-     steps: List<Function>;
-    
+
+     steps: Function[];
+
      process(instruction: Instruction): Promise<any>;
   }
-  
+
 
   /**
    * Defines route lifecycle method [onActivate], which is called by the router at the end of a
    * successful route navigation.
-   * 
+   *
    * For a single component's navigation, only one of either [onActivate] or [onReuse] will be called,
    * depending on the result of [canReuse].
-   * 
+   *
    * If `onActivate` returns a promise, the route change will wait until the promise settles to
    * instantiate and activate child components.
-   * 
+   *
    * ## Example
    * ```
    * @Directive({
@@ -372,17 +423,17 @@ declare module ngRouter {
    *  ```
    */
   interface OnActivate {
-    
+
      onActivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
   }
-  
+
 
   /**
    * Defines route lifecycle method [onDeactivate], which is called by the router before destroying
    * a component as part of a route change.
-   * 
+   *
    * If `onDeactivate` returns a promise, the route change will wait until the promise settles.
-   * 
+   *
    * ## Example
    * ```
    * @Directive({
@@ -392,7 +443,7 @@ declare module ngRouter {
    *   canReuse() {
    *     return true;
    *   }
-   * 
+   *
    *   onReuse(next, prev) {
    *     this.params = next.params;
    *   }
@@ -400,18 +451,18 @@ declare module ngRouter {
    *  ```
    */
   interface OnDeactivate {
-    
+
      onDeactivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
   }
-  
+
 
   /**
    * Defines route lifecycle method [onReuse], which is called by the router at the end of a
    * successful route navigation when [canReuse] is implemented and returns or resolves to true.
-   * 
+   *
    * For a single component's navigation, only one of either [onActivate] or [onReuse] will be called,
    * depending on the result of [canReuse].
-   * 
+   *
    * ## Example
    * ```
    * @Directive({
@@ -421,7 +472,7 @@ declare module ngRouter {
    *   canReuse() {
    *     return true;
    *   }
-   * 
+   *
    *   onReuse(next, prev) {
    *     this.params = next.params;
    *   }
@@ -429,19 +480,19 @@ declare module ngRouter {
    *  ```
    */
   interface OnReuse {
-    
+
      onReuse(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
   }
-  
+
 
   /**
    * Defines route lifecycle method [canDeactivate], which is called by the router to determine
    * if a component can be removed as part of a navigation.
-   * 
+   *
    * If `canDeactivate` returns or resolves to `false`, the navigation is cancelled.
-   * 
+   *
    * If `canDeactivate` throws or rejects, the navigation is also cancelled.
-   * 
+   *
    * ## Example
    * ```
    * @Directive({
@@ -455,19 +506,19 @@ declare module ngRouter {
    *  ```
    */
   interface CanDeactivate {
-    
+
      canDeactivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
   }
-  
+
 
   /**
    * Defines route lifecycle method [canReuse], which is called by the router to determine whether a
    * component should be reused across routes, or whether to destroy and instantiate a new component.
-   * 
+   *
    * If `canReuse` returns or resolves to `true`, the component instance will be reused.
-   * 
+   *
    * If `canReuse` throws or rejects, the navigation will be cancelled.
-   * 
+   *
    * ## Example
    * ```
    * @Directive({
@@ -477,7 +528,7 @@ declare module ngRouter {
    *   canReuse(next, prev) {
    *     return next.params.id == prev.params.id;
    *   }
-   * 
+   *
    *   onReuse(next, prev) {
    *     this.id = next.params.id;
    *   }
@@ -485,22 +536,22 @@ declare module ngRouter {
    *  ```
    */
   interface CanReuse {
-    
+
      canReuse(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
   }
-  
+
 
   /**
    * Defines route lifecycle method [canActivate], which is called by the router to determine
    * if a component can be instantiated as part of a navigation.
-   * 
+   *
    * Note that unlike other lifecycle hooks, this one uses an annotation rather than an interface.
    * This is because [canActivate] is called before the component is instantiated.
-   * 
+   *
    * If `canActivate` returns or resolves to `false`, the navigation is cancelled.
-   * 
+   *
    * If `canActivate` throws or rejects, the navigation is also cancelled.
-   * 
+   *
    * ## Example
    * ```
    * @Directive({
@@ -514,172 +565,170 @@ declare module ngRouter {
    */
   var CanActivate : (hook: (next: ComponentInstruction, prev: ComponentInstruction) => Promise<boolean>| boolean) =>
         ClassDecorator ;
-  
+
 
   /**
    * `Instruction` is a tree of `ComponentInstructions`, with all the information needed
    * to transition each component in the app to a given route, including all auxiliary routes.
-   * 
+   *
    * This is a public API.
    */
   class Instruction {
-    
+
      component: ComponentInstruction;
-    
+
      child: Instruction;
-    
+
      auxInstruction: StringMap<string, Instruction>;
-    
+
      replaceChild(child: Instruction): Instruction;
   }
-  
+
 
   /**
    * A `ComponentInstruction` represents the route state for a single component. An `Instruction` is
    * composed of a tree of these `ComponentInstruction`s.
-   * 
+   *
    * `ComponentInstructions` is a public API. Instances of `ComponentInstruction` are passed
    * to route lifecycle hooks, like {@link CanActivate}.
+   *
+   * `ComponentInstruction`s are [https://en.wikipedia.org/wiki/Hash_consing](hash consed). You should
+   * never construct one yourself with "new." Instead, rely on {@link PathRecognizer} to construct
+   * `ComponentInstruction`s.
+   *
+   * You should not modify this object. It should be treated as immutable.
    */
   class ComponentInstruction {
-    
+
      reuse: boolean;
-    
+
      urlPath: string;
-    
-     urlParams: List<string>;
-    
+
+     urlParams: string[];
+
      params: StringMap<string, any>;
-    
+
      componentType: any;
-    
-     resolveComponentType(): Promise<Type>;
-    
+
+     resolveComponentType(): Promise<ng.Type>;
+
      specificity: any;
-    
+
      terminal: any;
-    
+
      routeData(): Object;
   }
-  
-  class Url {
-    
-     path: string;
-    
-     child: Url;
-    
-     auxiliary: List<Url>;
-    
-     params: StringMap<string, any>;
-    
-     toString(): string;
-    
-     segmentToString(): string;
-  }
-  
-  class OpaqueToken {
-    
-     toString(): string;
-  }
-  
+
 
   /**
-   * Runtime representation of a type.
-   * 
-   * In JavaScript a Type is a constructor function.
+   * This class represents a parsed URL
    */
-  interface Type extends Function {
-    
-     new(args: any): any;
-  
+  class Url {
+
+     path: string;
+
+     child: Url;
+
+     auxiliary: Url[];
+
+     params: StringMap<string, any>;
+
+     toString(): string;
+
+     segmentToString(): string;
   }
-  
+
+  class OpaqueToken {
+
+     toString(): string;
+  }
+
   const ROUTE_DATA : OpaqueToken ;
-  
-  const ROUTER_DIRECTIVES : List<any> ;
-  
-  const ROUTER_BINDINGS : List<any> ;
-  
+
+  const ROUTER_DIRECTIVES : any[] ;
+
+  const ROUTER_BINDINGS : any[] ;
+
   class Route implements RouteDefinition {
-    
+
      data: any;
-    
+
      path: string;
-    
-     component: Type;
-    
+
+     component: ng.Type;
+
      as: string;
-    
+
      loader: Function;
-    
+
      redirectTo: string;
   }
-  
+
   class Redirect implements RouteDefinition {
-    
+
      path: string;
-    
+
      redirectTo: string;
-    
+
      as: string;
-    
+
      loader: Function;
-    
+
      data: any;
   }
-  
+
   class AuxRoute implements RouteDefinition {
-    
+
      data: any;
-    
+
      path: string;
-    
-     component: Type;
-    
+
+     component: ng.Type;
+
      as: string;
-    
+
      loader: Function;
-    
+
      redirectTo: string;
   }
-  
+
   class AsyncRoute implements RouteDefinition {
-    
+
      data: any;
-    
+
      path: string;
-    
+
      loader: Function;
-    
+
      as: string;
   }
-  
+
   interface RouteDefinition {
-    
+
      path: string;
-    
-     component?: Type | ComponentDefinition;
-    
+
+     component?: ng.Type | ComponentDefinition;
+
      loader?: Function;
-    
+
      redirectTo?: string;
-    
+
      as?: string;
-    
+
      data?: any;
   }
-  
-  var RouteConfig : (configs: List<RouteDefinition>) => ClassDecorator ;
-  
+
+  var RouteConfig : (configs: RouteDefinition[]) => ClassDecorator ;
+
   interface ComponentDefinition {
-    
+
      type: string;
-    
+
      loader?: Function;
-    
-     component?: Type;
+
+     component?: ng.Type;
   }
-  
+
 }
 
 declare module "angular2/router" {
diff --git a/angularjs-toaster/angularjs-toaster.d.ts b/angularjs-toaster/angularjs-toaster.d.ts
index 3987045141..9f450b14bb 100644
--- a/angularjs-toaster/angularjs-toaster.d.ts
+++ b/angularjs-toaster/angularjs-toaster.d.ts
@@ -16,7 +16,7 @@ declare module ngtoaster {
     error(params: IPopParams): void
     error(title?:string, body?:string, timeout?:number, bodyOutputType?:string, clickHandler?:EventListener,
         toasterId?:number): void
-    into(params: IPopParams): void
+    info(params: IPopParams): void
     info(title?:string, body?:string, timeout?:number, bodyOutputType?:string, clickHandler?:EventListener,
         toasterId?:number): void
     wait(params: IPopParams): void
diff --git a/angularjs/angular-animate.d.ts b/angularjs/angular-animate.d.ts
index 1ecc3d0d76..35fe10ca98 100644
--- a/angularjs/angular-animate.d.ts
+++ b/angularjs/angular-animate.d.ts
@@ -30,11 +30,11 @@ declare module angular.animate {
         /**
         * Globally enables / disables animations.
         *
-        * @param value If provided then set the animation on or off.
         * @param element If provided then the element will be used to represent the enable/disable operation.
+        * @param value If provided then set the animation on or off.
         * @returns current animation state
         */
-        enabled(value?: boolean, element?: JQuery): boolean;
+        enabled(element?: JQuery, value?: boolean): boolean;
 
         /**
          * Performs an inline animation on the element.
diff --git a/angularjs/angular-mocks.d.ts b/angularjs/angular-mocks.d.ts
index 84b6d7262a..d943372738 100644
--- a/angularjs/angular-mocks.d.ts
+++ b/angularjs/angular-mocks.d.ts
@@ -10,6 +10,11 @@ declare module "angular-mocks/ngMock" {
     export = _;
 }
 
+declare module "angular-mocks/ngMockE2E" {
+    var _: string;
+    export = _;
+}
+
 declare module "angular-mocks/ngAnimateMock" {
     var _: string;
     export = _;
diff --git a/angularjs/angular.d.ts b/angularjs/angular.d.ts
index dc7f5dae86..9770b5a2b4 100644
--- a/angularjs/angular.d.ts
+++ b/angularjs/angular.d.ts
@@ -1313,51 +1313,25 @@ declare module angular {
         /**
          * Runtime equivalent of the $httpProvider.defaults property. Allows configuration of default headers, withCredentials as well as request and response transformations.
          */
-        defaults: IRequestConfig;
+        defaults: IHttpProviderDefaults;
 
         /**
          * Array of config objects for currently pending requests. This is primarily meant to be used for debugging purposes.
          */
-        pendingRequests: any[];
+        pendingRequests: IRequestConfig[];
     }
 
     /**
      * Object describing the request to be made and how it should be processed.
      * see http://docs.angularjs.org/api/ng/service/$http#usage
      */
-    interface IRequestShortcutConfig {
+    interface IRequestShortcutConfig extends IHttpProviderDefaults {
         /**
          * {Object.<string|Object>}
          * Map of strings or objects which will be turned to ?key1=value1&key2=value2 after the url. If the value is not a string, it will be JSONified.
          */
         params?: any;
 
-        /**
-         * Map of strings or functions which return strings representing HTTP headers to send to the server. If the return value of a function is null, the header will not be sent.
-         */
-        headers?: any;
-
-        /**
-         * Name of HTTP header to populate with the XSRF token.
-         */
-        xsrfHeaderName?: string;
-
-        /**
-         * Name of cookie containing the XSRF token.
-         */
-        xsrfCookieName?: string;
-
-        /**
-         * {boolean|Cache}
-         * If true, a default $http cache will be used to cache the GET request, otherwise if a cache instance built with $cacheFactory, this cache will be used for caching.
-         */
-        cache?: any;
-
-        /**
-         * whether to to set the withCredentials flag on the XHR object. See [requests with credentials]https://developer.mozilla.org/en/http_access_control#section_5 for more information.
-         */
-        withCredentials?: boolean;
-
         /**
          * {string|Object}
          * Data to be sent as the request message data.
@@ -1365,25 +1339,12 @@ declare module angular {
         data?: any;
 
         /**
-         * {function(data, headersGetter)|Array.<function(data, headersGetter)>}
-         * Transform function or an array of such functions. The transform function takes the http request body and headers and returns its transformed (typically serialized) version.
-         */
-        transformRequest?: any;
-
-        /**
-         * {function(data, headersGetter)|Array.<function(data, headersGetter)>}
-         * Transform function or an array of such functions. The transform function takes the http response body and headers and returns its transformed (typically deserialized) version.
-         */
-        transformResponse?: any;
-
-        /**
-         * {number|Promise}
          * Timeout in milliseconds, or promise that should abort the request when resolved.
          */
-        timeout?: any;
+        timeout?: number|IPromise<any>;
 
         /**
-         * See requestType.
+         * See [XMLHttpRequest.responseType]https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest#xmlhttprequest-responsetype
          */
         responseType?: string;
     }
@@ -1426,31 +1387,98 @@ declare module angular {
         then<TResult>(successCallback: (response: IHttpPromiseCallbackArg<T>) => IPromise<TResult>|TResult, errorCallback?: (response: IHttpPromiseCallbackArg<any>) => any): IPromise<TResult>;
     }
 
+    // See the jsdoc for transformData() at https://github.com/angular/angular.js/blob/master/src/ng/http.js#L228
+    interface IHttpResquestTransformer {
+        (data: any, headersGetter: IHttpHeadersGetter): any;
+    }
+
+    // The definition of fields are the same as IHttpPromiseCallbackArg
+    interface IHttpResponseTransformer {
+        (data: any, headersGetter: IHttpHeadersGetter, status: number): any;
+    }
+
+    interface IHttpRequestConfigHeaders {
+        [requestType: string]: string|(() => string);
+        common?: string|(() => string);
+        get?: string|(() => string);
+        post?: string|(() => string);
+        put?: string|(() => string);
+        patch?: string|(() => string);
+    }
+
     /**
-    * Object that controls the defaults for $http provider
+    * Object that controls the defaults for $http provider. Not all fields of IRequestShortcutConfig can be configured
+    * via defaults and the docs do not say which. The following is based on the inspection of the source code.
     * https://docs.angularjs.org/api/ng/service/$http#defaults
+    * https://docs.angularjs.org/api/ng/service/$http#usage
+    * https://docs.angularjs.org/api/ng/provider/$httpProvider The properties section
     */
     interface IHttpProviderDefaults {
-        cache?: boolean;
+        /**
+         * {boolean|Cache}
+         * If true, a default $http cache will be used to cache the GET request, otherwise if a cache instance built with $cacheFactory, this cache will be used for caching.
+         */
+        cache?: any;
+
         /**
          * Transform function or an array of such functions. The transform function takes the http request body and
          * headers and returns its transformed (typically serialized) version.
+         * @see {@link https://docs.angularjs.org/api/ng/service/$http#transforming-requests-and-responses}
          */
-        transformRequest?: ((data: any, headersGetter?: any) => any)|((data: any, headersGetter?: any) => any)[];
-        xsrfCookieName?: string;
+        transformRequest?: IHttpResquestTransformer |IHttpResquestTransformer[];
+
+        /**
+         * Transform function or an array of such functions. The transform function takes the http response body and
+         * headers and returns its transformed (typically deserialized) version.
+         */
+        transformResponse?: IHttpResponseTransformer | IHttpResponseTransformer[];
+
+        /**
+         * Map of strings or functions which return strings representing HTTP headers to send to the server. If the
+         * return value of a function is null, the header will not be sent.
+         * The key of the map is the request verb in lower case. The "common" key applies to all requests.
+         * @see {@link https://docs.angularjs.org/api/ng/service/$http#setting-http-headers}
+         */
+        headers?: IHttpRequestConfigHeaders;
+
+        /** Name of HTTP header to populate with the XSRF token. */
         xsrfHeaderName?: string;
+
+        /** Name of cookie containing the XSRF token. */
+        xsrfCookieName?: string;
+
+        /**
+         * whether to to set the withCredentials flag on the XHR object. See [requests with credentials]https://developer.mozilla.org/en/http_access_control#section_5 for more information.
+         */
         withCredentials?: boolean;
-        headers?: {
-            common?: any;
-            post?: any;
-            put?: any;
-            patch?: any;
-        }
+
+        /**
+        * A function used to the prepare string representation of request parameters (specified as an object). If
+        * specified as string, it is interpreted as a function registered with the $injector. Defaults to
+        * $httpParamSerializer.
+        */
+        paramSerializer?: string | ((obj: any) => string);
+    }
+
+    interface IHttpInterceptor {
+        request?: (config: IRequestConfig) => IRequestConfig|IPromise<IRequestConfig>;
+        requestError?: (rejection: any) => any;
+        response?: <T>(response: IHttpPromiseCallbackArg<T>) => IPromise<T>|T;
+        responseError?: (rejection: any) => any;
+    }
+
+    interface IHttpInterceptorFactory {
+        (...args: any[]): IHttpInterceptor;
     }
 
     interface IHttpProvider extends IServiceProvider {
         defaults: IHttpProviderDefaults;
-        interceptors: any[];
+
+        /**
+         * Register service factories (names or implementations) for interceptors which are called before and after
+         * each request.
+         */
+        interceptors: (string|IHttpInterceptorFactory|(string|IHttpInterceptorFactory)[])[];
         useApplyAsync(): boolean;
         useApplyAsync(value: boolean): IHttpProvider;
 
@@ -1694,7 +1722,7 @@ declare module angular {
         interface IInjectorService {
             annotate(fn: Function): string[];
             annotate(inlineAnnotatedFunction: any[]): string[];
-            get<T>(name: string): T;
+            get<T>(name: string, caller?: string): T;
             has(name: string): boolean;
             instantiate<T>(typeConstructor: Function, locals?: any): T;
             invoke(inlineAnnotatedFunction: any[]): any;
diff --git a/angulartics/angulartics-tests.ts b/angulartics/angulartics-tests.ts
index cc816a2ab5..af6eb52a36 100644
--- a/angulartics/angulartics-tests.ts
+++ b/angulartics/angulartics-tests.ts
@@ -3,7 +3,7 @@
 
 module Analytics {
     angular.module("angulartics.app", ["angulartics"])
-        .config(["$analyticsProvider", ($analyticsProvider: Angulartics.IAnalyticsServiceProvider) => {
+        .config(["$analyticsProvider", ($analyticsProvider:angulartics.IAnalyticsServiceProvider) => {
             angulartics.waitForVendorApi("location", 1000, (message: string) => {
                 console.log(message);
             });
@@ -17,9 +17,8 @@ module Analytics {
                 console.log(action);
             });
 
-            $analyticsProvider.registerPageTrack((path: string, locationObj: ng.ILocationService) => {
+            $analyticsProvider.registerPageTrack((path:string, locationObj:angular.ILocationService) => {
                 console.log("viewed " + path);
             });
         }]);
 }
-
diff --git a/angulartics/angulartics.d.ts b/angulartics/angulartics.d.ts
index 8c89575698..706ee6713b 100644
--- a/angulartics/angulartics.d.ts
+++ b/angulartics/angulartics.d.ts
@@ -4,16 +4,15 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 /// <reference path="../angularjs/angular.d.ts" />
+declare module angulartics {
 
-interface Angulartics {
-    waitForVendorApi(objectName: string, delay: number, containsField?: any, registerFn?: any, onTimeout?: boolean): void;
-}
-
-declare module Angulartics {
+    interface IAngularticsStatic {
+        waitForVendorApi(objectName:string, delay:number, containsField?:any, registerFn?:any, onTimeout?:boolean): void;
+    }
 
     interface IAnalyticsService {
         eventTrack(eventName: string, properties?: any): any;
-        pageTrack(path: string, location?: ng.ILocationService): any;
+        pageTrack(path:string, location?:angular.ILocationService): any;
         setAlias(alias: string): any;
         setUsername(username: string): any;
         setUserProperties(properties: any): any;
@@ -27,7 +26,7 @@ declare module Angulartics {
         withAutoBase(value: boolean): void;
         developerMode(value: boolean): void;
 
-        registerPageTrack(callback: (path: string, location?: ng.ILocationService) => any): void;
+        registerPageTrack(callback:(path:string, location?:angular.ILocationService) => any): void;
         registerEventTrack(callback: (eventName: string, properties?: any) => any): void;
         registerSetAlias(callback: (alias: string) => any): void
         registerSetUsername(callback: (username: string) => any): void
@@ -36,4 +35,4 @@ declare module Angulartics {
     }
 }
 
-declare var angulartics:Angulartics;
+declare var angulartics:angulartics.IAngularticsStatic;
diff --git a/archiver/archiver-test.ts b/archiver/archiver-test.ts
new file mode 100644
index 0000000000..dcd71ca905
--- /dev/null
+++ b/archiver/archiver-test.ts
@@ -0,0 +1,14 @@
+/// <reference path="archiver.d.ts" />
+/// <reference path="../node/node.d.ts" />
+
+import Archiver = require('archiver');
+import FS = require('fs');
+
+var archiver = Archiver.create('zip');
+
+var writeStream = FS.createWriteStream('./archiver.d.ts');
+var readStream = FS.createReadStream('./archiver.d.ts');
+
+archiver.pipe(writeStream);
+archiver.append(readStream, {name: 'archiver.d.ts'});
+archiver.finalize();
\ No newline at end of file
diff --git a/archiver/archiver.d.ts b/archiver/archiver.d.ts
new file mode 100644
index 0000000000..570e1424a6
--- /dev/null
+++ b/archiver/archiver.d.ts
@@ -0,0 +1,41 @@
+// Type definitions for archiver v0.15.0
+// Project: https://github.com/archiverjs/node-archiver
+// Definitions by: Esri <https://github.com/archiverjs/node-archiver>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/* =================== USAGE ===================
+
+    import Archiver = require('archiver);
+    var archiver = Archiver.create('zip');
+    archiver.pipe(FS.createWriteStream('xxx'));
+    archiver.append(FS.createReadStream('xxx'));
+    archiver.finalize();
+
+ =============================================== */
+
+/// <reference path="../node/node.d.ts" />
+declare module "archiver" {
+    import * as FS from 'fs';
+    
+    interface nameInterface {
+        name?: string;
+    }
+        
+    interface Archiver {
+        pipe(writeStream: FS.WriteStream): void;
+        append(readStream: FS.ReadStream, name: nameInterface): void;
+        finalize(): void;
+    }
+    
+    interface Options {
+        
+    }
+    
+    function archiver(format: string, options?: Options): Archiver;
+    
+    namespace archiver {
+        function create(format: string, options?: Options): Archiver;
+    }
+    
+    export = archiver;
+}
\ No newline at end of file
diff --git a/async/asyncamd-tests.ts b/async/asyncamd-tests.ts
index 4618a67bf5..fc1c254607 100644
--- a/async/asyncamd-tests.ts
+++ b/async/asyncamd-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./async.d.ts" />
+
 import async = require("async");
 
-async.map(["a", "b", "c"], (item, cb) => cb(null, [item.toUpperCase()]), (err, results) => { });
\ No newline at end of file
+async.map(["a", "b", "c"], (item, cb) => cb(null, [item.toUpperCase()]), (err, results) => { });
diff --git a/better-curry/better-curry-tests.ts b/better-curry/better-curry-tests.ts
new file mode 100644
index 0000000000..ba95326f5b
--- /dev/null
+++ b/better-curry/better-curry-tests.ts
@@ -0,0 +1,27 @@
+/// <reference path="better-curry.d.ts" />
+
+import bc = require('better-curry');
+bc.flatten([1,2,3,[1,2],['a']]) === [];
+bc.MAX_OPTIMIZED = 5;
+
+function fn(...args: number[]): number[] {
+    return [].concat([1]);
+}
+
+function fn2(arg1: string, arg2: any): number {
+    return parseInt(arg1 + String(arg2)) + 1;
+}
+
+bc.predefine(fn, [1,2])() === [];
+bc.predefine(fn, [1,2]).__length === 3;
+
+var f = bc.wrap(fn2, {}, 10, true);
+f('1', 2) === 3;
+
+var delegate = bc.delegate({}, 'ok');
+delegate.access('ok') === delegate;
+delegate.getter('getter').setter('setter') === delegate;
+delegate.all(['1','2']);
+delegate.revoke('adsf').access('asdf');
+
+BetterCurry.wrap(fn2, {}, -1, false).__length === 10;
\ No newline at end of file
diff --git a/better-curry/better-curry.d.ts b/better-curry/better-curry.d.ts
new file mode 100644
index 0000000000..59ebe0a37c
--- /dev/null
+++ b/better-curry/better-curry.d.ts
@@ -0,0 +1,50 @@
+// Type definitions for better-curry
+// Project: https://github.com/pocesar/js-bettercurry
+// Definitions by: Paulo Cesar <https://github.com/pocesar>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare var BetterCurry: BetterCurryModule.BetterCurry;
+
+declare module BetterCurryModule {
+
+    export interface DelegateOptions {
+        as?: string;
+        len?: number;
+        args?: any[];
+        name?: string;
+    }
+
+    export class Delegate<T> {
+        proto: T;
+        target: string;
+        methods: any[];
+        getters: any[];
+        setters: any[];
+        all: (skip?: string[]) => void;
+        method: (name: string|DelegateOptions) => Delegate<T>;
+        getter: (name: string|DelegateOptions) => Delegate<T>;
+        setter: (name: string|DelegateOptions) => Delegate<T>;
+        access: (name: string|DelegateOptions) => Delegate<T>;
+        revoke: (name: string) => Delegate<T>;
+        constructor(proto: T, target: string);
+    }
+
+    export interface OriginalFunctionReminder<T> extends Function {
+        __length: number;
+    }
+
+    export interface BetterCurry {
+        predefine: <T extends Function>(fn: T, args: any[], context?: Object, len?: number, checkArguments?: boolean) => OriginalFunctionReminder<T>;
+        wrap: <T extends Function>(fn: T, context?: Object, len?: number, checkArguments?: boolean) => OriginalFunctionReminder<T>;
+        flatten: (...args: Array<Array<any>|any>) => any[];
+        delegate: <T>(proto: T, target: string) => Delegate<T>;
+        MAX_OPTIMIZED: number;
+    }
+
+}
+
+declare module 'better-curry' {
+    var bc: BetterCurryModule.BetterCurry;
+
+    export = bc;
+}
\ No newline at end of file
diff --git a/big.js/big.js.d.ts b/big.js/big.js.d.ts
index 0e4ac48bea..d4ca239e36 100644
--- a/big.js/big.js.d.ts
+++ b/big.js/big.js.d.ts
@@ -6,7 +6,7 @@
 
 declare module BigJsLibrary {
 
-    export enum RoundingMode {
+    export const enum RoundingMode {
         RoundTowardsZero = 0,
         RoundTowardsNearestAwayFromZero = 1,
         RoundTowardsNearestTowardsEven = 2,
@@ -200,4 +200,4 @@ declare module BigJsLibrary {
     }
 }
 
-declare var Big: BigJsLibrary.BigJS;
\ No newline at end of file
+declare var Big: BigJsLibrary.BigJS;
diff --git a/bluebird-retry/bluebird-retry-tests.ts b/bluebird-retry/bluebird-retry-tests.ts
new file mode 100644
index 0000000000..5d8c32dfcb
--- /dev/null
+++ b/bluebird-retry/bluebird-retry-tests.ts
@@ -0,0 +1,35 @@
+/// <reference path="bluebird-retry.d.ts" />
+/// <reference path="../bluebird/bluebird.d.ts" />
+import Promise = require('bluebird');
+import retry = require('bluebird-retry');
+
+function promiseSuccess(text:string) {
+    return Promise.resolve(text);
+};
+
+var count = 0;
+function myfunc() {
+    console.log('myfunc called ' + (++count) + ' times');
+    if (count < 3) {
+        throw new Error('i fail the first two times');
+    } else {
+        return promiseSuccess('i succeed the third time');
+    }
+}
+
+retry(myfunc)
+    .done(function(result) { console.log(result); } );
+
+
+//Options example
+function logFail() {
+    console.log(new Date().toISOString());
+    throw new Error('bail');
+}
+
+var options:retry.Options = {
+    max_tries: 4,
+    interval: 500
+};
+
+retry(logFail, options);
\ No newline at end of file
diff --git a/bluebird-retry/bluebird-retry.d.ts b/bluebird-retry/bluebird-retry.d.ts
new file mode 100644
index 0000000000..3719e5e3ac
--- /dev/null
+++ b/bluebird-retry/bluebird-retry.d.ts
@@ -0,0 +1,24 @@
+// Type definitions for bluebird-retry
+// Project: https://github.com/jut-io/bluebird-retry
+// Definitions by: Pascal Vomhoff <https://github.com/pvomhoff>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../bluebird/bluebird.d.ts" />
+declare module "bluebird-retry" {
+	import Promise = require('bluebird');
+
+	function retry<T>(func:(param:T)=>void, options?:retry.Options):Promise<T>;
+
+	module retry {
+		export interface Options {
+			interval?:number;
+			backoff?:number;
+			max_interval?:number;
+			timeout?:number;
+			max_tries?:number;
+		}
+
+	}
+
+	export = retry;
+}
\ No newline at end of file
diff --git a/bootstrap-slider/bootstrap-slider.d.ts b/bootstrap-slider/bootstrap-slider.d.ts
index 78aeb645ce..d66c85ab10 100644
--- a/bootstrap-slider/bootstrap-slider.d.ts
+++ b/bootstrap-slider/bootstrap-slider.d.ts
@@ -137,6 +137,13 @@ interface JQueryEventObject {
     value: number|ChangeValue;
 }
 
+interface SliderStatics {
+	new (selector: string, opts: SliderOptions): Slider;
+	prototype: Slider;
+}
+
+declare var Slider: SliderStatics;
+
 /**
  * This class is actually not used when using the jQuery version of bootstrap-slider
  * The method documentation is still here thouh.
diff --git a/bowser/bowser-tests.ts b/bowser/bowser-tests.ts
index 07d9f18cba..6006187655 100644
--- a/bowser/bowser-tests.ts
+++ b/bowser/bowser-tests.ts
@@ -1,7 +1,9 @@
+/// <reference path="./bowser.d.ts" />
+
 import Bowser = require('bowser');
 
 Bowser.msedge === true;
 Bowser.test(['msie']) === true;
 Bowser.a === Bowser.c;
 Bowser.osversion > 10;
-Bowser.osversion === '10.1A';
\ No newline at end of file
+Bowser.osversion === '10.1A';
diff --git a/breeze/breeze-tests.ts b/breeze/breeze-tests.ts
index f309462afa..1f9c87dfa9 100644
--- a/breeze/breeze-tests.ts
+++ b/breeze/breeze-tests.ts
@@ -11,7 +11,7 @@ function test_dataType() {
     var x = typ.parentEnum === <breeze.core.IEnum> breeze.DataType;
     var isFalse = breeze.DataType.contains(breeze.DataType.Double);
     var dt = breeze.DataType.fromName("Decimal");
-    
+
 }
 
 function test_dataProperty() {
@@ -33,7 +33,7 @@ function test_dataService() {
     var em = new breeze.EntityManager({
         dataService: ds
     });
-    
+
 }
 
 function test_entityAspect() {
@@ -69,7 +69,7 @@ function test_entityAspect() {
         var errorsAdded = validationChangeArgs.added;
         var errorsCleared = validationChangeArgs.removed;
     });
-    
+
 }
 
 function test_entityKey() {
@@ -132,7 +132,7 @@ function test_entityManager() {
         serviceName: "breeze/NorthwindIBModel",
         metadataStore: metadataStore
     });
-    
+
     return new breeze.QueryOptions({
         mergeStrategy: null,
         fetchStrategy: this.fetchStrategy
@@ -157,7 +157,7 @@ function test_entityManager() {
 
     var cust2 = em1.createEntity("Customer", { companyName: "foo" });
     var cust3 = em1.createEntity("foo", { xxx: 3 }, breeze.EntityState.Added);
-    
+
     em1.attachEntity(cust1, breeze.EntityState.Added);
     em1.clear();
     var em2 = em1.createEmptyCopy();
@@ -246,7 +246,7 @@ function test_entityManager() {
     var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     if (em1.hasChanges([custType, orderType])) { };
-    
+
     var bundle = em1.exportEntities();
     window.localStorage.setItem("myEntityManager", bundle);
     var bundleFromStorage = window.localStorage.getItem("myEntityManager");
@@ -434,7 +434,7 @@ function test_entityState() {
     return es === breeze.EntityState.Unchanged;
     var es = anEntity.entityAspect.entityState;
     return es.isUnchangedOrModified();
-    
+
     return es === breeze.EntityState.Unchanged || es === breeze.EntityState.Modified;
 }
 
@@ -443,12 +443,14 @@ function test_entityType() {
     var myEntityType: breeze.EntityType;
     var dataProperty1: breeze.DataProperty, dataProperty2: breeze.DataProperty, navigationProperty1: breeze.DataProperty;
     var em1: breeze.EntityManager;
+    /* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
     var entityManager = new breeze.EntityType({
         metadataStore: myMetadataStore,
         serviceName: "breeze/NorthwindIBModel",
         name: "person",
         namespace: "myAppNamespace"
     });
+     */
     myEntityType.addProperty(dataProperty1);
     myEntityType.addProperty(dataProperty2);
     myEntityType.addProperty(navigationProperty1);
@@ -759,9 +761,11 @@ function test_validator() {
     orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     var orderDateProperty = orderType.getProperty("OrderDate");
     orderDateProperty.validators.push(breeze.Validator.date());
+    /* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
     var v0 = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" });
     v0.validate("adasdfasdf");
     var errMessage = v0.getMessage();
+     */
     custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var customerIdProperty = custType.getProperty("CustomerID");
     customerIdProperty.validators.push(breeze.Validator.guid());
@@ -788,6 +792,7 @@ function test_validator() {
     regionProperty.validators.push(breeze.Validator.string());
     custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
      regionProperty = custType.getProperty("Region");
+    /* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
     regionProperty.validators.push(breeze.Validator.stringLength({ minLength: 2, maxLength: 5 }));
     var validator = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" });
     var result = validator.validate("asdf");
@@ -796,6 +801,7 @@ function test_validator() {
     var errMsg = result.errorMessage;
     var context = result.context;
     var sameValidator = result.validator;
+     */
     var valFn = function (v: any) {
         if (v == null) return true;
         return (v.substr(0,2) === "US");
diff --git a/chai/chai-2.0.0.d.ts b/chai/chai-2.0.0.d.ts
new file mode 100644
index 0000000000..f693582c59
--- /dev/null
+++ b/chai/chai-2.0.0.d.ts
@@ -0,0 +1,308 @@
+// Type definitions for chai 2.0.0
+// Project: http://chaijs.com/
+// Definitions by: Jed Mao <https://github.com/jedmao/>,
+//                 Bart van der Schoor <https://github.com/Bartvds>,
+//                 Andrew Brown <https://github.com/AGBrown>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module Chai {
+
+    interface ChaiStatic {
+        expect: ExpectStatic;
+        should(): Should;
+        /**
+         * Provides a way to extend the internals of Chai
+         */
+        use(fn: (chai: any, utils: any) => void): any;
+        assert: AssertStatic;
+        config: Config;
+    }
+
+    export interface ExpectStatic extends AssertionStatic {
+    }
+
+    export interface AssertStatic extends Assert {
+    }
+
+    export interface AssertionStatic {
+        (target: any, message?: string): Assertion;
+    }
+
+    interface ShouldAssertion {
+        equal(value1: any, value2: any, message?: string): void;
+        Throw: ShouldThrow;
+        throw: ShouldThrow;
+        exist(value: any, message?: string): void;
+    }
+
+    interface Should extends ShouldAssertion {
+        not: ShouldAssertion;
+        fail(actual: any, expected: any, message?: string, operator?: string): void;
+    }
+
+    interface ShouldThrow {
+        (actual: Function): void;
+        (actual: Function, expected: string|RegExp, message?: string): void;
+        (actual: Function, constructor: Error|Function, expected?: string|RegExp, message?: string): void;
+    }
+
+    interface Assertion extends LanguageChains, NumericComparison, TypeComparison {
+        not: Assertion;
+        deep: Deep;
+        a: TypeComparison;
+        an: TypeComparison;
+        include: Include;
+        contain: Include;
+        ok: Assertion;
+        true: Assertion;
+        false: Assertion;
+        null: Assertion;
+        undefined: Assertion;
+        exist: Assertion;
+        empty: Assertion;
+        arguments: Assertion;
+        Arguments: Assertion;
+        equal: Equal;
+        equals: Equal;
+        eq: Equal;
+        eql: Equal;
+        eqls: Equal;
+        property: Property;
+        ownProperty: OwnProperty;
+        haveOwnProperty: OwnProperty;
+        length: Length;
+        lengthOf: Length;
+        match(regexp: RegExp|string, message?: string): Assertion;
+        string(string: string, message?: string): Assertion;
+        keys: Keys;
+        key(string: string): Assertion;
+        throw: Throw;
+        throws: Throw;
+        Throw: Throw;
+        respondTo(method: string, message?: string): Assertion;
+        itself: Assertion;
+        satisfy(matcher: Function, message?: string): Assertion;
+        closeTo(expected: number, delta: number, message?: string): Assertion;
+        members: Members;
+    }
+
+    interface LanguageChains {
+        to: Assertion;
+        be: Assertion;
+        been: Assertion;
+        is: Assertion;
+        that: Assertion;
+        which: Assertion;
+        and: Assertion;
+        has: Assertion;
+        have: Assertion;
+        with: Assertion;
+        at: Assertion;
+        of: Assertion;
+        same: Assertion;
+    }
+
+    interface NumericComparison {
+        above: NumberComparer;
+        gt: NumberComparer;
+        greaterThan: NumberComparer;
+        least: NumberComparer;
+        gte: NumberComparer;
+        below: NumberComparer;
+        lt: NumberComparer;
+        lessThan: NumberComparer;
+        most: NumberComparer;
+        lte: NumberComparer;
+        within(start: number, finish: number, message?: string): Assertion;
+    }
+
+    interface NumberComparer {
+        (value: number, message?: string): Assertion;
+    }
+
+    interface TypeComparison {
+        (type: string, message?: string): Assertion;
+        instanceof: InstanceOf;
+        instanceOf: InstanceOf;
+    }
+
+    interface InstanceOf {
+        (constructor: Object, message?: string): Assertion;
+    }
+
+    interface Deep {
+        equal: Equal;
+        include: Include;
+        property: Property;
+    }
+
+    interface Equal {
+        (value: any, message?: string): Assertion;
+    }
+
+    interface Property {
+        (name: string, value?: any, message?: string): Assertion;
+    }
+
+    interface OwnProperty {
+        (name: string, message?: string): Assertion;
+    }
+
+    interface Length extends LanguageChains, NumericComparison {
+        (length: number, message?: string): Assertion;
+    }
+
+    interface Include {
+        (value: Object, message?: string): Assertion;
+        (value: string, message?: string): Assertion;
+        (value: number, message?: string): Assertion;
+        keys: Keys;
+        members: Members;
+    }
+
+    interface Keys {
+        (...keys: string[]): Assertion;
+        (keys: any[]): Assertion;
+    }
+
+    interface Throw {
+        (): Assertion;
+        (expected: string, message?: string): Assertion;
+        (expected: RegExp, message?: string): Assertion;
+        (constructor: Error, expected?: string, message?: string): Assertion;
+        (constructor: Error, expected?: RegExp, message?: string): Assertion;
+        (constructor: Function, expected?: string, message?: string): Assertion;
+        (constructor: Function, expected?: RegExp, message?: string): Assertion;
+    }
+
+    interface Members {
+        (set: any[], message?: string): Assertion;
+    }
+
+    export interface Assert {
+        /**
+         * @param expression Expression to test for truthiness.
+         * @param message Message to display on error.
+         */
+        (expression: any, message?: string): void;
+
+        fail(actual?: any, expected?: any, msg?: string, operator?: string): void;
+
+        ok(val: any, msg?: string): void;
+        notOk(val: any, msg?: string): void;
+
+        equal(act: any, exp: any, msg?: string): void;
+        notEqual(act: any, exp: any, msg?: string): void;
+
+        strictEqual(act: any, exp: any, msg?: string): void;
+        notStrictEqual(act: any, exp: any, msg?: string): void;
+
+        deepEqual(act: any, exp: any, msg?: string): void;
+        notDeepEqual(act: any, exp: any, msg?: string): void;
+
+        isTrue(val: any, msg?: string): void;
+        isFalse(val: any, msg?: string): void;
+
+        isNull(val: any, msg?: string): void;
+        isNotNull(val: any, msg?: string): void;
+
+        isUndefined(val: any, msg?: string): void;
+        isDefined(val: any, msg?: string): void;
+
+        isFunction(val: any, msg?: string): void;
+        isNotFunction(val: any, msg?: string): void;
+
+        isObject(val: any, msg?: string): void;
+        isNotObject(val: any, msg?: string): void;
+
+        isArray(val: any, msg?: string): void;
+        isNotArray(val: any, msg?: string): void;
+
+        isString(val: any, msg?: string): void;
+        isNotString(val: any, msg?: string): void;
+
+        isNumber(val: any, msg?: string): void;
+        isNotNumber(val: any, msg?: string): void;
+
+        isBoolean(val: any, msg?: string): void;
+        isNotBoolean(val: any, msg?: string): void;
+
+        typeOf(val: any, type: string, msg?: string): void;
+        notTypeOf(val: any, type: string, msg?: string): void;
+
+        instanceOf(val: any, type: Function, msg?: string): void;
+        notInstanceOf(val: any, type: Function, msg?: string): void;
+
+        include(exp: string, inc: any, msg?: string): void;
+        include(exp: any[], inc: any, msg?: string): void;
+
+        notInclude(exp: string, inc: any, msg?: string): void;
+        notInclude(exp: any[], inc: any, msg?: string): void;
+
+        match(exp: any, re: RegExp, msg?: string): void;
+        notMatch(exp: any, re: RegExp, msg?: string): void;
+
+        property(obj: Object, prop: string, msg?: string): void;
+        notProperty(obj: Object, prop: string, msg?: string): void;
+        deepProperty(obj: Object, prop: string, msg?: string): void;
+        notDeepProperty(obj: Object, prop: string, msg?: string): void;
+
+        propertyVal(obj: Object, prop: string, val: any, msg?: string): void;
+        propertyNotVal(obj: Object, prop: string, val: any, msg?: string): void;
+
+        deepPropertyVal(obj: Object, prop: string, val: any, msg?: string): void;
+        deepPropertyNotVal(obj: Object, prop: string, val: any, msg?: string): void;
+
+        lengthOf(exp: any, len: number, msg?: string): void;
+        //alias frenzy
+        throw(fn: Function, msg?: string): void;
+        throw(fn: Function, regExp: RegExp): void;
+        throw(fn: Function, errType: Function, msg?: string): void;
+        throw(fn: Function, errType: Function, regExp: RegExp): void;
+
+        throws(fn: Function, msg?: string): void;
+        throws(fn: Function, regExp: RegExp): void;
+        throws(fn: Function, errType: Function, msg?: string): void;
+        throws(fn: Function, errType: Function, regExp: RegExp): void;
+
+        Throw(fn: Function, msg?: string): void;
+        Throw(fn: Function, regExp: RegExp): void;
+        Throw(fn: Function, errType: Function, msg?: string): void;
+        Throw(fn: Function, errType: Function, regExp: RegExp): void;
+
+        doesNotThrow(fn: Function, msg?: string): void;
+        doesNotThrow(fn: Function, regExp: RegExp): void;
+        doesNotThrow(fn: Function, errType: Function, msg?: string): void;
+        doesNotThrow(fn: Function, errType: Function, regExp: RegExp): void;
+
+        operator(val: any, operator: string, val2: any, msg?: string): void;
+        closeTo(act: number, exp: number, delta: number, msg?: string): void;
+
+        sameMembers(set1: any[], set2: any[], msg?: string): void;
+        includeMembers(set1: any[], set2: any[], msg?: string): void;
+
+        ifError(val: any, msg?: string): void;
+    }
+
+    export interface Config {
+        includeStack: boolean;
+    }
+
+    export class AssertionError {
+        constructor(message: string, _props?: any, ssf?: Function);
+        name: string;
+        message: string;
+        showDiff: boolean;
+        stack: string;
+    }
+}
+
+declare var chai: Chai.ChaiStatic;
+
+declare module "chai" {
+    export = chai;
+}
+
+interface Object {
+    should: Chai.Assertion;
+}
diff --git a/chai/chai-tests.ts b/chai/chai-tests.ts
index c34b6cdf1d..9b646b1529 100644
--- a/chai/chai-tests.ts
+++ b/chai/chai-tests.ts
@@ -31,6 +31,16 @@ function fail() {
     err(() => {
         should.fail('foo', 'bar', 'should fail', 'equal');
     }, 'expected fail to throw an AssertionError');
+
+    err(() => {
+        expect.fail('foo', 'bar');
+    }, 'expected fail to throw an AssertionError');
+    err(() => {
+        expect.fail('foo', 'bar', 'should fail');
+    }, 'expected fail to throw an AssertionError');
+    err(() => {
+        expect.fail('foo', 'bar', 'should fail', 'equal');
+    }, 'expected fail to throw an AssertionError');
 }
 
 // ReSharper disable once InconsistentNaming
@@ -107,11 +117,20 @@ function _undefined() {
     }, 'expected \'\' to be undefined');
 }
 
+function _NaN() {
+    expect(NaN).to.be.NaN;
+    expect(12).to.be.not.NaN;
+    expect("NaN").to.be.not.NaN;
+    (NaN).should.be.NaN;
+    (12).should.be.not.NaN;
+    ("NaN").should.be.not.NaN;
+}
+
 function exist() {
     var foo = 'bar';
     expect(foo).to.exist;
     should.exist(foo);
-    expect(void(0)).to.not.exist;
+    expect(void (0)).to.not.exist;
     should.not.exist(void (0));
 }
 
@@ -128,8 +147,8 @@ function argumentsTest() {
 }
 
 function equal() {
-    expect(undefined).to.equal(void(0));
-    should.equal(undefined, void(0));
+    expect(undefined).to.equal(void (0));
+    should.equal(undefined, void (0));
 }
 
 function _typeof() {
@@ -372,6 +391,9 @@ function match() {
     expect('foobar').to.not.match(/^bar/);
     'foobar'.should.not.match(/^bar/);
 
+    expect('foobar').matches(/^foo/);
+    'foobar'.should.not.matches(/^bar/);
+
     err(() => {
         expect('foobar').to.match(/^bar/i, 'blah');
         'foobar'.should.match(/^bar/i, 'blah');
@@ -490,8 +512,8 @@ function deepEqual3() {
 function deepInclude() {
     expect(['foo', 'bar']).to.deep.include(['bar', 'foo']);
     ['foo', 'bar'].should.deep.include(['bar', 'foo']);
-    expect(['foo', 'bar']).not.to.deep.equal(['foo', 'baz' ]);
-    ['foo', 'bar'].should.not.deep.equal(['foo', 'baz' ]);
+    expect(['foo', 'bar']).not.to.deep.equal(['foo', 'baz']);
+    ['foo', 'bar'].should.not.deep.equal(['foo', 'baz']);
 }
 
 class FakeArgs {
@@ -670,6 +692,20 @@ function ownProperty() {
     }, 'blah: expected { length: 12 } to not have own property \'length\'');
 }
 
+function ownPropertyDescriptor() {
+    expect('test').to.have.ownPropertyDescriptor('length');
+    expect('test').to.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 4 });
+    expect('test').not.to.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 3 });
+    expect('test').to.haveOwnPropertyDescriptor('length').to.have.property('enumerable', false);
+    expect('test').to.haveOwnPropertyDescriptor('length').to.contain.keys('value');
+
+    'test'.should.have.ownPropertyDescriptor('length');
+    'test'.should.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 4 });
+    'test'.should.not.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 3 });
+    'test'.should.haveOwnPropertyDescriptor('length').to.have.property('enumerable', false);
+    'test'.should.haveOwnPropertyDescriptor('length').to.contain.keys('value');
+}
+
 function string() {
     expect('foobar').to.have.string('bar');
     'foobar'.should.have.string('bar');
@@ -707,6 +743,10 @@ function include() {
     ['foo', 'bar'].should.not.include('baz');
     expect(['foo', 'bar']).to.not.include(1);
     ['foo', 'bar'].should.not.include(1);
+    // alias
+
+    expect(['foo', 'bar']).includes('foo');
+    ['foo', 'bar'].should.includes('foo');
 
     err(() => {
         expect(['foo']).to.include('bar', 'blah');
@@ -732,6 +772,14 @@ function keys() {
     ({ foo: 1, bar: 2, baz: 3 }).should.contain.keys('bar', 'foo');
     expect({ foo: 1, bar: 2, baz: 3 }).to.contain.keys('baz');
     ({ foo: 1, bar: 2, baz: 3 }).should.contain.keys('baz');
+    // alias
+
+    expect({ foo: 1, bar: 2, baz: 3 }).contains.keys('baz');
+
+    expect({ foo: 1, bar: 2 }).to.have.all.keys(['foo', 'bar']);
+    expect({ foo: 1, bar: 2 }).to.have.any.keys(['foo', 'bar']);
+    ({ foo: 1, bar: 2, baz: 3 }).should.contain.all.keys('baz');
+    ({ foo: 1, bar: 2, baz: 3 }).should.contain.any.keys('baz');
 
     expect({ foo: 1, bar: 2 }).to.contain.keys('foo');
     ({ foo: 1, bar: 2 }).should.contain.keys('foo');
@@ -830,7 +878,28 @@ function chaining() {
     tea.should.be.a('object').and.have.property('name', 'chai');
 }
 
-class PoorlyConstructedError {}
+function exxtensible() {
+    expect({}).to.be.extensible;
+    expect(Object.preventExtensions({})).to.be.not.extensible;
+    ({}).should.be.extensible;
+    Object.preventExtensions({}).should.not.be.extensible;
+}
+function sealed() {
+    expect({}).to.be.not.sealed;
+    expect(Object.seal({})).to.be.sealed;
+    ({}).should.be.not.sealed;
+    Object.seal({}).should.be.sealed;
+}
+
+function frozen() {
+    expect({}).to.be.not.frozen;
+    expect(Object.freeze({})).to.be.frozen;
+    ({}).should.be.not.frozen;
+    Object.freeze({}).should.be.frozen;
+}
+
+
+class PoorlyConstructedError { }
 function _throw() {
     // See GH-45: some poorly-constructed custom errors don't have useful names
     // on either their constructor or their constructor prototype, but instead
@@ -1023,34 +1092,44 @@ function _throw() {
     }, 'blah: expected [Function] to throw error including \'hello\' but got \'testing\'');
 }
 
-function use(){
+function use() {
     // ReSharper disable once InconsistentNaming
     chai.use((_chai) => {
-      _chai.can.use.any();
+        _chai.can.use.any();
     });
 }
 
+class Klass {
+    val: number;
+    constructor() { this.val = 0; }
+    bar() { }
+
+    static baz() { }
+}
+
 function respondTo() {
-    var bar = {};
+    var obj = new Klass();
 
-    expect(Foo).to.respondTo('bar');
-    Foo.should.respondTo('bar');
-    expect(Foo).to.not.respondTo('foo');
-    Foo.should.not.respondTo('foo');
-    expect(Foo).itself.to.respondTo('func');
-    expect(Foo).itself.not.to.respondTo('bar');
+    expect(Klass).to.respondTo('bar');
+    expect(obj).respondsTo('bar');
+    Klass.should.respondTo('bar');
+    Klass.should.respondsTo('bar');
+    expect(Klass).to.not.respondTo('foo');
+    Klass.should.not.respondTo('foo');
+    expect(Klass).itself.to.respondTo('func');
+    expect(Klass).itself.not.to.respondTo('bar');
 
-    expect(bar).to.respondTo('foo');
-    bar.should.respondTo('foo');
+    expect(obj).not.to.respondTo('foo');
+    obj.should.not.respondTo('foo');
 
     err(() => {
-        expect(Foo).to.respondTo('baz', 'constructor');
-        Foo.should.respondTo('baz', 'constructor');
-    }, /^(constructor: expected)(.*)(\[Function: Foo\])(.*)(to respond to \'baz\')$/);
+        expect(Klass).to.respondTo('baz', 'constructor');
+        Klass.should.respondTo('baz', 'constructor');
+    }, /^(constructor: expected)(.*)(\[Function: Klass\])(.*)(to respond to \'baz\')$/);
 
     err(() => {
-        expect(bar).to.respondTo('baz', 'object');
-        bar.should.respondTo('baz', 'object');
+        expect(obj).to.respondTo('baz', 'object');
+        obj.should.respondTo('baz', 'object');
     }, /^(object: expected)(.*)(\{ foo: \[Function\] \}|\{ Object \()(.*)(to respond to \'baz\')$/);
 }
 
@@ -1116,6 +1195,23 @@ function sameMembers() {
     [5, 4].should.not.have.same.members([6, 3]);
     expect([5, 4]).to.not.have.same.members([5, 4, 2]);
     [5, 4].should.not.have.same.members([5, 4, 2]);
+
+    assert.sameMembers([5, 4], [4, 5]);
+}
+function sameDeepMembers() {
+    expect([{ id: 5 }, { id: 4 }]).to.have.same.deep.members([{ id: 4 }, { id: 5 }]);
+    [{ id: 5 }, { id: 4 }].should.have.same.deep.members([{ id: 4 }, { id: 5 }]);
+    expect([{ id: 5 }, { id: 4 }]).to.have.same.members([{ id: 5 }, { id: 4 }]);
+    [{ id: 5 }, { id: 4 }].should.have.same.members([{ id: 5 }, { id: 4 }]);
+
+    expect([{ id: 5 }, { id: 4 }]).to.not.have.same.members([]);
+    [{ id: 5 }, { id: 4 }].should.not.have.same.members([]);
+    expect([{ id: 5 }, { id: 4 }]).to.not.have.same.members([{ id: 6 }, { id: 3 }]);
+    [{ id: 5 }, { id: 4 }].should.not.have.same.members([{ id: 6 }, { id: 3 }]);
+    expect([{ id: 5 }, { id: 4 }]).to.not.have.same.members([{ id: 5 }, { id: 4 }, { id: 2 }]);
+    [{ id: 5 }, { id: 4 }].should.not.have.same.members([{ id: 5 }, { id: 4 }, { id: 2 }]);
+
+    assert.sameDeepMembers([{ id: 5 }, { id: 4 }], [{ id: 4 }, { id: 5 }]);
 }
 
 function members() {
@@ -1127,16 +1223,48 @@ function members() {
     expect([5, 4]).not.members([5, 4, 2]);
 }
 
+function increaseDecreaseChange() {
+    var obj = { val: 10 };
+    var inc = () => { obj.val++; };
+    var dec = () => { obj.val--; };
+    var same = () => { };
+
+    expect(inc).to.increase(obj, "val");
+    expect(inc).increases(obj, "val");
+    expect(inc).to.change(obj, "val");
+
+    expect(dec).to.decrease(obj, "val");
+    expect(dec).decreases(obj, "val");
+    expect(dec).to.change(obj, "val");
+    expect(dec).changes(obj, "val");
+
+    expect(inc).to.not.decrease(obj, "val");
+    expect(dec).to.not.increase(obj, "val");
+    expect(same).to.not.increase(obj, "val");
+    expect(same).to.not.decrease(obj, "val");
+    expect(same).to.not.change(obj, "val");
+
+    inc.should.increase(obj, "val");
+    inc.should.change(obj, "val");
+
+    dec.should.decrease(obj, "val");
+    dec.should.change(obj, "val");
+
+    inc.should.not.decrease(obj, "val");
+    dec.should.not.increase(obj, "val");
+    same.should.not.change(obj, "val");
+}
+
 //tdd
-declare function suite(description: string, action: Function):void;
-declare function test(description: string, action: Function):void;
+declare function suite(description: string, action: Function): void;
+declare function test(description: string, action: Function): void;
 
 interface FieldObj {
     field: any;
 }
 
 class CrashyObject {
-    inspect (): void {
+    inspect(): void {
         throw new Error('Arg\'s inspect() called even though the test passed');
     }
 }
@@ -1172,6 +1300,9 @@ suite('assert', () => {
         assert.ok(true);
         assert.ok(1);
         assert.ok('test');
+        assert.isOk(true);
+        assert.isOk(1);
+        assert.isOk('test');
 
         err(() => {
             assert.ok(false);
@@ -1186,6 +1317,27 @@ suite('assert', () => {
         }, 'expected \'\' to be truthy');
     });
 
+    test('notOk', () => {
+        assert.notOk(false);
+        assert.notOk(0);
+        assert.notOk('');
+        assert.isNotOk(false);
+        assert.isNotOk(0);
+        assert.isNotOk('');
+
+        err(() => {
+            assert.notOk(true);
+        }, 'expected true to be falsy');
+
+        err(() => {
+            assert.notOk(1);
+        }, 'expected 1 to be falsy');
+
+        err(() => {
+            assert.notOk('test');
+        }, 'expected \'test\' to be falsy');
+    });
+
     test('isFalse', () => {
         assert.isFalse(false);
 
@@ -1199,7 +1351,7 @@ suite('assert', () => {
     });
 
     test('equal', () => {
-        assert.equal(void(0), undefined);
+        assert.equal(void (0), undefined);
     });
 
     test('typeof / notTypeOf', () => {
@@ -1288,19 +1440,19 @@ suite('assert', () => {
     });
 
     test('deepEqual', () => {
-        assert.deepEqual({tea: 'chai'}, {tea: 'chai'});
+        assert.deepEqual({ tea: 'chai' }, { tea: 'chai' });
 
         err(() => {
-            assert.deepEqual({tea: 'chai'}, {tea: 'black'});
+            assert.deepEqual({ tea: 'chai' }, { tea: 'black' });
         }, 'expected { tea: \'chai\' } to deeply equal { tea: \'black\' }');
 
         var obja = Object.create({ tea: 'chai' })
-        , objb = Object.create({ tea: 'chai' });
+            , objb = Object.create({ tea: 'chai' });
 
         assert.deepEqual(obja, objb);
 
-        var obj1 = Object.create({tea: 'chai'})
-        , obj2 = Object.create({tea: 'black'});
+        var obj1 = Object.create({ tea: 'chai' })
+            , obj2 = Object.create({ tea: 'black' });
 
         err(() => {
             assert.deepEqual(obj1, obj2);
@@ -1309,13 +1461,13 @@ suite('assert', () => {
 
     test('deepEqual (ordering)', () => {
         var a = { a: 'b', c: 'd' }
-        , b = { c: 'd', a: 'b' };
+            , b = { c: 'd', a: 'b' };
         assert.deepEqual(a, b);
     });
 
     test('deepEqual (circular)', () => {
-        var circularObject:any = {}
-        , secondCircularObject:any = {};
+        var circularObject: any = {}
+            , secondCircularObject: any = {};
         circularObject.field = circularObject;
         secondCircularObject.field = secondCircularObject;
 
@@ -1328,15 +1480,15 @@ suite('assert', () => {
     });
 
     test('notDeepEqual', () => {
-        assert.notDeepEqual({tea: 'jasmine'}, {tea: 'chai'});
+        assert.notDeepEqual({ tea: 'jasmine' }, { tea: 'chai' });
         err(() => {
-            assert.notDeepEqual({tea: 'chai'}, {tea: 'chai'});
+            assert.notDeepEqual({ tea: 'chai' }, { tea: 'chai' });
         }, 'expected { tea: \'chai\' } to not deeply equal { tea: \'chai\' }');
     });
 
     test('notDeepEqual (circular)', () => {
-        var circularObject:any = {}
-        , secondCircularObject:any = { tea: 'jasmine' };
+        var circularObject: any = {}
+            , secondCircularObject: any = { tea: 'jasmine' };
         circularObject.field = circularObject;
         secondCircularObject.field = secondCircularObject;
 
@@ -1380,6 +1532,22 @@ suite('assert', () => {
         }, 'expected undefined to not equal undefined');
     });
 
+    test('isNaN', () => {
+        assert.isNaN(NaN);
+
+        err(() => {
+            assert.isNaN(12);
+        }, 'expected 12 to be NaN');
+    });
+
+    test('isNotNaN', () => {
+        assert.isNotNaN(12);
+
+        err(() => {
+            assert.isNotNaN(NaN);
+        }, 'expected NaN to not NaN');
+    });
+
     test('isFunction', () => {
         var func = () => {
         };
@@ -1431,7 +1599,7 @@ suite('assert', () => {
 
     test('isNotString', () => {
         assert.isNotString(3);
-        assert.isNotString([ 'hello' ]);
+        assert.isNotString(['hello']);
 
         err(() => {
             assert.isNotString('hello');
@@ -1449,7 +1617,7 @@ suite('assert', () => {
 
     test('isNotNumber', () => {
         assert.isNotNumber('hello');
-        assert.isNotNumber([ 5 ]);
+        assert.isNotNumber([5]);
 
         err(() => {
             assert.isNotNumber(4);
@@ -1479,7 +1647,7 @@ suite('assert', () => {
 
     test('include', () => {
         assert.include('foobar', 'bar');
-        assert.include([ 1, 2, 3], 3);
+        assert.include([1, 2, 3], 3);
 
         err(() => {
             assert.include('foobar', 'baz');
@@ -1492,7 +1660,7 @@ suite('assert', () => {
 
     test('notInclude', () => {
         assert.notInclude('foobar', 'baz');
-        assert.notInclude([ 1, 2, 3 ], 4);
+        assert.notInclude([1, 2, 3], 4);
 
         err(() => {
             assert.notInclude('foobar', 'bar');
@@ -1739,4 +1907,42 @@ suite('assert', () => {
         }, 'expected [ 1, 54 ] to have the same members as [ 6, 1, 54 ]');
     });
 
+
+    test('isAbove', () => {
+        assert.isAbove(10, 5);
+
+        err(() => {
+            assert.isAbove(1, 5);
+        }, 'expected 1 to be above 5');
+        err(() => {
+            assert.isAbove(5, 5);
+        }, 'expected 5 to be above 5');
+    });
+
+    test('isBelow', () => {
+        assert.isBelow(5, 10);
+
+        err(() => {
+            assert.isBelow(5, 1);
+        }, 'expected 5 to be above 1');
+        err(() => {
+            assert.isBelow(5, 5);
+        }, 'expected 5 to be below 5');
+    });
+
+    test('extensible', () => { assert.extensible({}); });
+    test('isExtensible', () => { assert.isExtensible({}); });
+    test('notExtensible', () => { assert.notExtensible(Object.preventExtensions({})); });
+    test('isNotExtensible', () => { assert.isNotExtensible(Object.preventExtensions({})); });
+
+    test('sealed', () => { assert.sealed(Object.seal({})); });
+    test('isSealed', () => { assert.isSealed(Object.seal({})); });
+    test('notSealed', () => { assert.notSealed({}); });
+    test('isNotSealed', () => { assert.isNotSealed({}); });
+
+    test('frozen', () => { assert.frozen(Object.freeze({})); });
+    test('isFrozen', () => { assert.isFrozen(Object.freeze({})); });
+    test('notFrozen', () => { assert.notFrozen({}); });
+    test('isNotFrozen', () => { assert.isNotFrozen({}); });
+
 });
diff --git a/chai/chai.d.ts b/chai/chai.d.ts
index f693582c59..da4d718e1b 100644
--- a/chai/chai.d.ts
+++ b/chai/chai.d.ts
@@ -1,10 +1,13 @@
-// Type definitions for chai 2.0.0
+// Type definitions for chai 3.2.0
 // Project: http://chaijs.com/
 // Definitions by: Jed Mao <https://github.com/jedmao/>,
 //                 Bart van der Schoor <https://github.com/Bartvds>,
-//                 Andrew Brown <https://github.com/AGBrown>
+//                 Andrew Brown <https://github.com/AGBrown>,
+//                 Olivier Chevet <https://github.com/olivr70>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
+// <reference path="../assertion-error/assertion-error.d.ts"/>
+
 declare module Chai {
 
     interface ChaiStatic {
@@ -16,9 +19,11 @@ declare module Chai {
         use(fn: (chai: any, utils: any) => void): any;
         assert: AssertStatic;
         config: Config;
+        AssertionError: AssertionError;
     }
 
     export interface ExpectStatic extends AssertionStatic {
+        fail(actual?: any, expected?: any, message?: string, operator?: string): void;
     }
 
     export interface AssertStatic extends Assert {
@@ -49,15 +54,20 @@ declare module Chai {
     interface Assertion extends LanguageChains, NumericComparison, TypeComparison {
         not: Assertion;
         deep: Deep;
+        any: KeyFilter;
+        all: KeyFilter;
         a: TypeComparison;
         an: TypeComparison;
         include: Include;
+        includes: Include;
         contain: Include;
+        contains: Include;
         ok: Assertion;
         true: Assertion;
         false: Assertion;
         null: Assertion;
         undefined: Assertion;
+        NaN: Assertion;
         exist: Assertion;
         empty: Assertion;
         arguments: Assertion;
@@ -70,20 +80,35 @@ declare module Chai {
         property: Property;
         ownProperty: OwnProperty;
         haveOwnProperty: OwnProperty;
+        ownPropertyDescriptor: OwnPropertyDescriptor;
+        haveOwnPropertyDescriptor: OwnPropertyDescriptor;
         length: Length;
         lengthOf: Length;
-        match(regexp: RegExp|string, message?: string): Assertion;
+        match: Match;
+        matches: Match;
         string(string: string, message?: string): Assertion;
         keys: Keys;
         key(string: string): Assertion;
         throw: Throw;
         throws: Throw;
         Throw: Throw;
-        respondTo(method: string, message?: string): Assertion;
+        respondTo: RespondTo;
+        respondsTo: RespondTo;
         itself: Assertion;
-        satisfy(matcher: Function, message?: string): Assertion;
+        satisfy: Satisfy;
+        satisfies: Satisfy;
         closeTo(expected: number, delta: number, message?: string): Assertion;
         members: Members;
+        increase: PropertyChange;
+        increases: PropertyChange;
+        decrease: PropertyChange;
+        decreases: PropertyChange;
+        change: PropertyChange;
+        changes: PropertyChange;
+        extensible: Assertion;
+        sealed: Assertion;
+        frozen: Assertion;
+
     }
 
     interface LanguageChains {
@@ -134,6 +159,11 @@ declare module Chai {
         equal: Equal;
         include: Include;
         property: Property;
+        members: Members;
+    }
+
+    interface KeyFilter {
+        keys: Keys;
     }
 
     interface Equal {
@@ -148,6 +178,11 @@ declare module Chai {
         (name: string, message?: string): Assertion;
     }
 
+    interface OwnPropertyDescriptor {
+        (name: string, descriptor: PropertyDescriptor, message?: string): Assertion;
+        (name: string, message?: string): Assertion;
+    }
+
     interface Length extends LanguageChains, NumericComparison {
         (length: number, message?: string): Assertion;
     }
@@ -158,11 +193,18 @@ declare module Chai {
         (value: number, message?: string): Assertion;
         keys: Keys;
         members: Members;
+        any: KeyFilter;
+        all: KeyFilter;
+    }
+
+    interface Match {
+        (regexp: RegExp|string, message?: string): Assertion;
     }
 
     interface Keys {
         (...keys: string[]): Assertion;
         (keys: any[]): Assertion;
+        (keys: Object): Assertion;
     }
 
     interface Throw {
@@ -175,10 +217,22 @@ declare module Chai {
         (constructor: Function, expected?: RegExp, message?: string): Assertion;
     }
 
+    interface RespondTo {
+        (method: string, message?: string): Assertion;
+    }
+
+    interface Satisfy {
+        (matcher: Function, message?: string): Assertion;
+    }
+
     interface Members {
         (set: any[], message?: string): Assertion;
     }
 
+    interface PropertyChange {
+        (object: Object, prop: string, msg?: string): Assertion;
+    }
+
     export interface Assert {
         /**
          * @param expression Expression to test for truthiness.
@@ -189,7 +243,9 @@ declare module Chai {
         fail(actual?: any, expected?: any, msg?: string, operator?: string): void;
 
         ok(val: any, msg?: string): void;
+        isOk(val: any, msg?: string): void;
         notOk(val: any, msg?: string): void;
+        isNotOk(val: any, msg?: string): void;
 
         equal(act: any, exp: any, msg?: string): void;
         notEqual(act: any, exp: any, msg?: string): void;
@@ -209,6 +265,12 @@ declare module Chai {
         isUndefined(val: any, msg?: string): void;
         isDefined(val: any, msg?: string): void;
 
+        isNaN(val: any, msg?: string): void;
+        isNotNaN(val: any, msg?: string): void;
+
+        isAbove(val: number, abv: number, msg?: string): void;
+        isBelow(val: number, blw: number, msg?: string): void;
+
         isFunction(val: any, msg?: string): void;
         isNotFunction(val: any, msg?: string): void;
 
@@ -279,9 +341,27 @@ declare module Chai {
         closeTo(act: number, exp: number, delta: number, msg?: string): void;
 
         sameMembers(set1: any[], set2: any[], msg?: string): void;
-        includeMembers(set1: any[], set2: any[], msg?: string): void;
+        sameDeepMembers(set1: any[], set2: any[], msg?: string): void;
+        includeMembers(superset: any[], subset: any[], msg?: string): void;
 
         ifError(val: any, msg?: string): void;
+
+        isExtensible(obj: {}, msg?: string): void;
+        extensible(obj: {}, msg?: string): void;
+        isNotExtensible(obj: {}, msg?: string): void;
+        notExtensible(obj: {}, msg?: string): void;
+
+        isSealed(obj: {}, msg?: string): void;
+        sealed(obj: {}, msg?: string): void;
+        isNotSealed(obj: {}, msg?: string): void;
+        notSealed(obj: {}, msg?: string): void;
+
+        isFrozen(obj: Object, msg?: string): void;
+        frozen(obj: Object, msg?: string): void;
+        isNotFrozen(obj: Object, msg?: string): void;
+        notFrozen(obj: Object, msg?: string): void;
+
+
     }
 
     export interface Config {
@@ -305,4 +385,4 @@ declare module "chai" {
 
 interface Object {
     should: Chai.Assertion;
-}
+}
diff --git a/cheerio/cheerio-tests.ts b/cheerio/cheerio-tests.ts
index c41939a301..cb74619d40 100644
--- a/cheerio/cheerio-tests.ts
+++ b/cheerio/cheerio-tests.ts
@@ -1,6 +1,6 @@
 /// <reference path="cheerio.d.ts" />
 
-import cheerio from 'cheerio';
+import * as cheerio from 'cheerio';
 
 /*
  * LOADING
@@ -29,7 +29,7 @@ $ = cheerio.load(html, {
     normalizeWhitespace: true,
     xmlMode: true,
     decodeEntities: true,
-    lowercaseTags: true,
+    lowerCaseTags: true,
     lowerCaseAttributeNames: true,
     recognizeCDATA: true,
     recognizeSelfClosing: true
diff --git a/cheerio/cheerio.d.ts b/cheerio/cheerio.d.ts
index 57d526d1b2..3b5b998d9a 100644
--- a/cheerio/cheerio.d.ts
+++ b/cheerio/cheerio.d.ts
@@ -262,5 +262,5 @@ interface CheerioAPI extends CheerioSelector {
 declare var cheerio:CheerioAPI;
 
 declare module "cheerio" {
-    export default cheerio;
+    export = cheerio;
 }
diff --git a/classnames/classnames.d.ts b/classnames/classnames.d.ts
index 8200436860..22ab1858ae 100644
--- a/classnames/classnames.d.ts
+++ b/classnames/classnames.d.ts
@@ -1,13 +1,18 @@
 // Type definitions for classnames
 // Project: https://github.com/JedWatson/classnames
-// Definitions by: Dave Keen <http://www.keendevelopment.ch>
+// Definitions by: Dave Keen <http://www.keendevelopment.ch>, Adi Dahiya <https://github.com/adidahiya>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 interface ClassDictionary {
 	[id: string]: boolean;
 }
 
+interface ClassNamesFn {
+	(...classes: (string | ClassDictionary)[]): string;
+}
+
+declare var classNames: ClassNamesFn;
+
 declare module "classnames" {
-	function classNames(...classes: (string|ClassDictionary)[]): string;
 	export = classNames
-}
\ No newline at end of file
+}
diff --git a/clone/clone-tests.ts b/clone/clone-tests.ts
index 6a25fb7c30..8cb0681fd6 100644
--- a/clone/clone-tests.ts
+++ b/clone/clone-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./clone.d.ts" />
+
 import clone = require("clone");
 
 var original = {
diff --git a/codemirror/showhint-tests.ts b/codemirror/codemirror-showhint-tests.ts
similarity index 93%
rename from codemirror/showhint-tests.ts
rename to codemirror/codemirror-showhint-tests.ts
index b7378e0d68..b00333b29e 100644
--- a/codemirror/showhint-tests.ts
+++ b/codemirror/codemirror-showhint-tests.ts
@@ -1,5 +1,5 @@
 /// <reference path="codemirror.d.ts" />
-/// <reference path="showhint.d.ts" />
+/// <reference path="codemirror-showhint.d.ts" />
 var doc = new CodeMirror.Doc('text');
 var pos = new CodeMirror.Pos(2, 3);
 CodeMirror.showHint(doc);
diff --git a/codemirror/showhint.d.ts b/codemirror/codemirror-showhint.d.ts
similarity index 68%
rename from codemirror/showhint.d.ts
rename to codemirror/codemirror-showhint.d.ts
index 340871db4b..48a904a3bb 100644
--- a/codemirror/showhint.d.ts
+++ b/codemirror/codemirror-showhint.d.ts
@@ -1,10 +1,12 @@
 // Type definitions for CodeMirror
 // Project: https://github.com/marijnh/CodeMirror
-// Definitions by: jacqt <https://github.com/jacqt>
+// Definitions by: jacqt <https://github.com/jacqt>, basarat <https://github.com/basarat>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
+// See docs https://codemirror.net/doc/manual.html#addon_show-hint
+
 declare module CodeMirror {
-    var commands : any;
+    var commands: any;
 
     /** Provides a framework for showing autocompletion hints. Defines editor.showHint, which takes an optional
     options object, and pops up a widget that allows the user to select a completion. Finding hints is done with
@@ -12,13 +14,12 @@ declare module CodeMirror {
     and return a {list, from, to} object, where list is an array of strings or objects (the completions), and
     from and to give the start and end of the token that is being completed as {line, ch} objects. An optional
     selectedHint property (an integer) can be added to the completion object to control the initially selected hint. */
-    function showHint (cm: CodeMirror.Doc, hinter?: (doc : CodeMirror.Doc) => Hints, options?: IShowHintOptions) : void;
-
+    function showHint(cm: CodeMirror.Doc, hinter?: (doc: CodeMirror.Doc) => Hints, options?: ShowHintOptions): void;
 
     interface Hints {
         from: Position;
         to: Position;
-        list: Hint[] | string[];
+        list: (Hint | string)[];
     }
 
     /** Interface used by showHint.js Codemirror add-on
@@ -28,25 +29,27 @@ declare module CodeMirror {
         className?: string;
         displayText?: string;
         from?: Position;
-        render?: (element: any, self: any, data: any) => void;
+        /** Called if a completion is picked. If provided *you* are responsible for applying the completion */
+        hint?: (cm: any, data: Hints, cur: Hint) => void;
+        render?: (element: HTMLLIElement, data: Hints, cur: Hint) => void;
         to?: Position;
     }
 
     interface Editor {
         /** An extension of the existing CodeMirror typings for the Editor.on("keyup", func) syntax */
-        on(eventName: string, handler: (doc: CodeMirror.Doc, event : any ) => void ): void;
-        off(eventName: string, handler: (doc: CodeMirror.Doc, event : any) => void ): void;
+        on(eventName: string, handler: (doc: CodeMirror.Doc, event: any) => void): void;
+        off(eventName: string, handler: (doc: CodeMirror.Doc, event: any) => void): void;
     }
 
     /** Extend CodeMirror.Doc with a state object, so that the Doc.state.completionActive property is reachable*/
     interface Doc {
         state: any;
-        showHint: (options: IShowHintOptions) => void;
+        showHint: (options: ShowHintOptions) => void;
     }
 
-    interface IShowHintOptions {
+    interface ShowHintOptions {
         completeSingle: boolean;
-        hint: (doc : CodeMirror.Doc) => Hints;
+        hint: (doc: CodeMirror.Doc) => Hints;
     }
 
     /** The Handle used to interact with the autocomplete dialog box.*/
@@ -59,4 +62,13 @@ declare module CodeMirror {
         pick(): void;
         data: any;
     }
+
+    interface EditorConfiguration {
+        showHint?: boolean;
+        hintOptions?: ShowHintOptions;
+    }
+}
+
+declare module "codemirror/addon/hint/show-hint" {
+    export = CodeMirror;
 }
diff --git a/codemirror/codemirror.d.ts b/codemirror/codemirror.d.ts
index 06361684da..0f548a3fa9 100644
--- a/codemirror/codemirror.d.ts
+++ b/codemirror/codemirror.d.ts
@@ -1090,3 +1090,7 @@ declare module CodeMirror {
         to?: Position;
     }
 }
+
+declare module "codemirror" {
+    export = CodeMirror;
+}
diff --git a/codemirror/searchcursor-tests.ts b/codemirror/searchcursor-tests.ts
new file mode 100644
index 0000000000..2e87a8b599
--- /dev/null
+++ b/codemirror/searchcursor-tests.ts
@@ -0,0 +1,16 @@
+/// <reference path="codemirror.d.ts" />
+/// <reference path="searchcursor.d.ts" />
+
+var doc = new CodeMirror.Doc('text some string and another text match');
+var cursor = doc.getSearchCursor('text', new CodeMirror.Pos(0,0), false);
+cursor = doc.getSearchCursor('text', new CodeMirror.Pos(0,0));
+cursor = doc.getSearchCursor('text');
+
+
+cursor.find(false);
+cursor.findNext();
+cursor.findPrevious();
+cursor.from();
+cursor.to();
+cursor.replace("blah");
+cursor.replace("text", "origin");
diff --git a/codemirror/searchcursor.d.ts b/codemirror/searchcursor.d.ts
new file mode 100644
index 0000000000..ed7af7a250
--- /dev/null
+++ b/codemirror/searchcursor.d.ts
@@ -0,0 +1,45 @@
+// Type definitions for CodeMirror
+// Project: https://github.com/marijnh/CodeMirror
+// Definitions by: jacqt <https://github.com/jacqt>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module CodeMirror {
+    interface Doc {
+        /** This method can be used to implement search/replace functionality.
+         *  `query`: This can be a regular * expression or a string (only strings will match across lines -
+         *          if they contain newlines).
+         *  `start`: This provides the starting position of the search. It can be a `{line, ch} object,
+         *          or can be left off to default to the start of the document
+         *  `caseFold`: This is only relevant when matching a string. IT will cause the search to be case-insenstive */
+        getSearchCursor(query: string | RegExp, start?: Position, caseFold?: boolean): SearchCursor;
+    }
+
+    interface SearchCursor {
+        /** Searches forward or backward from the current position. The return value indicates whether a match was
+         * found. If matching a regular expression, the return value will be the array returned by the match method, in case
+         * you want to extract matched groups */
+        find(reverse: boolean): boolean | any[];
+
+        /** Searches forward from the current position. The return value indicates whether a match was
+         * found. If matching a regular expression, the return value will be the array returned by the match method, in case
+         * you want to extract matched groups */
+        findNext(): boolean | any[];
+
+        /** Searches backward from the current position. The return value indicates whether a match was
+         * found. If matching a regular expression, the return value will be the array returned by the match method, in case
+         * you want to extract matched groups */
+        findPrevious(): boolean | any[];
+
+        /** Only valid when the last call to find, findNext, or findPrevious did not return false. Returns {line, ch}
+         * objects pointing the start of the match. */
+        from(): Position;
+
+        /** Only valid when the last call to find, findNext, or findPrevious did not return false. Returns {line, ch}
+         * objects pointing the end of the match. */
+        to(): Position;
+
+
+        /** Replaces the currently found match with the given text and adjusts the cursor position to reflect the deplacement. */
+        replace(text: string, origin?: string): void;
+    }
+}
diff --git a/config/config-tests.ts b/config/config-tests.ts
new file mode 100644
index 0000000000..2f53b76d60
--- /dev/null
+++ b/config/config-tests.ts
@@ -0,0 +1,30 @@
+/// <reference path="config.d.ts" />
+
+import config = require('config');
+
+var value1: string = config.get<string>("");
+var value2: any = config.get("");
+
+var has: boolean = config.has("");
+
+// util tests:
+var extended1: any = config.util.extendDeep({}, {});
+var extended2: any = config.util.extendDeep({}, {}, 20);
+
+var clone1: any = config.util.cloneDeep({});
+var clone2: any = config.util.cloneDeep({}, 20);
+
+var equals1: boolean = config.util.equalsDeep({}, {});
+var equals2: boolean = config.util.equalsDeep({}, {}, 20);
+
+var diff1: any = config.util.diffDeep({}, {});
+var diff2: any = config.util.diffDeep({}, {}, 20);
+
+var immutable1: any = config.util.makeImmutable({});
+var immutable2: any = config.util.makeImmutable({}, "");
+var immutable3: any = config.util.makeImmutable({}, "", "");
+
+var hidden1: any = config.util.makeHidden({}, "");
+var hidden2: any = config.util.makeHidden({}, "", "");
+
+var env: string = config.util.getEnv("");
diff --git a/config/config.d.ts b/config/config.d.ts
new file mode 100644
index 0000000000..c37eddae9e
--- /dev/null
+++ b/config/config.d.ts
@@ -0,0 +1,34 @@
+// Type definitions for node-config
+// Project: https://github.com/lorenwest/node-config
+// Definitions by: Roman Korneev <https://github.com/RWander>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "config" {
+	// see https://github.com/lorenwest/node-config/wiki/Using-Config-Utilities
+	interface IUtil {
+		// Extend an object (and any object it contains) with one or more objects (and objects contained in them).
+		extendDeep(mergeInto: any, mergeFrom: any, depth?: number): any;
+
+		// Return a deep copy of the specified object.
+		cloneDeep(copyFrom: any, depth?: number): any;
+
+		// Return true if two objects have equal contents.
+		equalsDeep(object1: any, object2: any, dept?: number): boolean;
+
+		// Returns an object containing all elements that differ between two objects.
+		diffDeep(object1: any, object2: any, depth?: number): any;
+
+		// Make a javascript object property immutable (assuring it cannot be changed from the current value).
+		makeImmutable(object: any, propertyName?: string, propertyValue?: string): any;
+
+		// Make an object property hidden so it doesn't appear when enumerating elements of the object.
+		makeHidden(object: any, propertyName: string, propertyValue?: string): any;
+
+		// Get the current value of a config environment variable
+		getEnv(varName: string): string;
+	}
+
+	export function get<T>(setting: string): T;
+	export function has(setting: string): boolean;
+	export var util: IUtil;
+}
diff --git a/connect-slashes/connect-slashes-tests.ts b/connect-slashes/connect-slashes-tests.ts
index 6fc66bbc03..f4c8ac965c 100644
--- a/connect-slashes/connect-slashes-tests.ts
+++ b/connect-slashes/connect-slashes-tests.ts
@@ -1,4 +1,4 @@
-/// <reference path="../express/express.d.ts"/>
+/// <reference path="./connect-slashes.d.ts"/>
 
 import express = require('express');
 import slashes = require('connect-slashes');
diff --git a/contextjs/contextjs-tests.ts b/contextjs/contextjs-tests.ts
index 0b0d55d094..abfc643efa 100644
--- a/contextjs/contextjs-tests.ts
+++ b/contextjs/contextjs-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./contextjs.d.ts" />
+
 import context = require("contextjs");
 
 context.init();
diff --git a/convert-source-map/convert-source-map-tests.ts b/convert-source-map/convert-source-map-tests.ts
index a89cfb7127..1701e0065e 100644
--- a/convert-source-map/convert-source-map-tests.ts
+++ b/convert-source-map/convert-source-map-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./convert-source-map.d.ts" />
+
 import convert = require("convert-source-map");
 
 var json = convert
@@ -10,4 +12,4 @@ var modified = convert
 	.toJSON();
 
 console.log(json);
-console.log(modified);
\ No newline at end of file
+console.log(modified);
diff --git a/cookie-parser/cookie-parser.d.ts b/cookie-parser/cookie-parser.d.ts
index a4897c5e7e..dd18bdc235 100644
--- a/cookie-parser/cookie-parser.d.ts
+++ b/cookie-parser/cookie-parser.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for cookie-parser
+// Type definitions for cookie-parser v1.3.4
 // Project: https://github.com/expressjs/cookie-parser
 // Definitions by: Santi Albo <https://github.com/santialbo/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -8,5 +8,6 @@
 declare module "cookie-parser" {
     import express = require('express');
     function e(secret?: string, options?: any): express.RequestHandler;
+    namespace e{}
     export = e;
 }
\ No newline at end of file
diff --git a/cordova-ionic/cordova-ionic-tests.ts b/cordova-ionic/cordova-ionic-tests.ts
index 69d1a3d829..a88c9c5809 100644
--- a/cordova-ionic/cordova-ionic-tests.ts
+++ b/cordova-ionic/cordova-ionic-tests.ts
@@ -7,4 +7,6 @@ cordova.plugins.Keyboard.hideKeyboardAccessoryBar(false);
 cordova.plugins.Keyboard.close();
 cordova.plugins.Keyboard.disableScroll(true);
 cordova.plugins.Keyboard.disableScroll(false);
+cordova.plugins.Keyboard.show();
+cordova.plugins.Keyboard.close();
 console.log(cordova.plugins.Keyboard.isVisible);
diff --git a/cordova-ionic/plugins/keyboard.d.ts b/cordova-ionic/plugins/keyboard.d.ts
index 4ff9e293d5..7a1cd38e10 100644
--- a/cordova-ionic/plugins/keyboard.d.ts
+++ b/cordova-ionic/plugins/keyboard.d.ts
@@ -17,6 +17,14 @@ declare module Ionic {
      * Close the keyboard if it is open.
      */
     close(): void;
+    
+    /**
+     * Force keyboard to be shown on Android.
+     * This typically helps if autofocus on a text element does not pop up the keyboard automatically
+     * 
+     * Supported Platforms: Android, Blackberry 10
+     */
+    show(): void;
 
     /**
      * Disable native scrolling, useful if you are using JavaScript to scroll
diff --git a/cordova/plugins/Vibration.d.ts b/cordova/plugins/Vibration.d.ts
index 715f6625f9..65952f8e9b 100644
--- a/cordova/plugins/Vibration.d.ts
+++ b/cordova/plugins/Vibration.d.ts
@@ -1,17 +1,32 @@
 // Type definitions for Apache Cordova Vibration plugin.
 // Project: https://github.com/apache/cordova-plugin-vibration
-// Definitions by: Microsoft Open Technologies, Inc. <http://msopentech.com>
+// Definitions by: Microsoft Open Technologies, Inc. <http://msopentech.com>, Louis Lagrange <https://github.com/Minishlink/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
-// 
+//
 // Copyright (c) Microsoft Open Technologies, Inc.
 // Licensed under the MIT license.
 
+interface Navigator {
+	/**
+	 * Vibrates the device for the specified amount of time.
+	 * @param time Milliseconds to vibrate the device. 0 cancels the vibration. Ignored on iOS.
+	 */
+    vibrate(time: number): void;
+
+    /**
+	 * Vibrates the device with a given pattern.
+	 * @param time Sequence of durations (in milliseconds) for which to turn on or off the vibrator. Ignored on iOS.
+	 */
+    vibrate(time: number[]): void;
+}
+
 interface Notification {
 	/**
 	 * Vibrates the device for the specified amount of time.
 	 * @param time Milliseconds to vibrate the device. Ignored on iOS.
+     * @deprecated
 	 */
-    vibrate(time: number): void
+    vibrate(time: number): void;
     /**
      * Vibrates the device with a given pattern.
      * @param number[] pattern Pattern with which to vibrate the device.
@@ -19,10 +34,12 @@ interface Notification {
      *                         The next value - the number of milliseconds for which to keep the vibrator on before turning it off.
      * @param number  repeat   Optional index into the pattern array at which to start repeating (will repeat until canceled),
      *                         or -1 for no repetition (default).
+     * @deprecated
      */
     vibrateWithPattern(pattern: number[], repeat: number): void;
     /**
      * Immediately cancels any currently running vibration.
+     * @deprecated
      */
     cancelVibration(): void;
-}
\ No newline at end of file
+}
diff --git a/core-js/core-js.d.ts b/core-js/core-js.d.ts
index 476ab99162..9c492e4338 100644
--- a/core-js/core-js.d.ts
+++ b/core-js/core-js.d.ts
@@ -22,13 +22,13 @@ declare type PropertyKey = string | number | symbol;
 
 // #############################################################################################
 // ECMAScript 6: Object & Function
-// Modules: es6.object.assign, es6.object.is, es6.object.set-prototype-of, 
+// Modules: es6.object.assign, es6.object.is, es6.object.set-prototype-of,
 //          es6.object.to-string, es6.function.name and es6.function.has-instance.
 // #############################################################################################
- 
+
 interface ObjectConstructor {
     /**
-      * Copy the values of all of the enumerable own properties from one or more source objects to a 
+      * Copy the values of all of the enumerable own properties from one or more source objects to a
       * target object. Returns the target object.
       * @param target The target object to copy to.
       * @param sources One or more source objects to copy properties from.
@@ -57,10 +57,10 @@ interface Function {
       */
     name: string;
 
-    /** 
-      * Determines if a constructor object recognizes an object as one of the 
+    /**
+      * Determines if a constructor object recognizes an object as one of the
       * constructor’s instances.
-      * @param value The object to test. 
+      * @param value The object to test.
       */
     [Symbol.hasInstance](value: any): boolean;
 }
@@ -71,30 +71,25 @@ interface Function {
 //          and es6.array.find-index
 // #############################################################################################
 
-interface ArrayLike<T> {
-    length: number;
-    [n: number]: T;
-}
-
 interface Array<T> {
-    /** 
-      * Returns the value of the first element in the array where predicate is true, and undefined 
+    /**
+      * Returns the value of the first element in the array where predicate is true, and undefined
       * otherwise.
-      * @param predicate find calls predicate once for each element of the array, in ascending 
-      * order, until it finds one where predicate returns true. If such an element is found, find 
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
       * immediately returns that element value. Otherwise, find returns undefined.
-      * @param thisArg If provided, it will be used as the this value for each invocation of 
+      * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
     find(predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): T;
 
-    /** 
-      * Returns the index of the first element in the array where predicate is true, and undefined 
+    /**
+      * Returns the index of the first element in the array where predicate is true, and undefined
       * otherwise.
-      * @param predicate find calls predicate once for each element of the array, in ascending 
-      * order, until it finds one where predicate returns true. If such an element is found, find 
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
       * immediately returns that element value. Otherwise, find returns undefined.
-      * @param thisArg If provided, it will be used as the this value for each invocation of 
+      * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
     findIndex(predicate: (value: T) => boolean, thisArg?: any): number;
@@ -102,21 +97,21 @@ interface Array<T> {
     /**
       * Returns the this object after filling the section identified by start and end with value
       * @param value value to fill array section with
-      * @param start index to start filling the array at. If start is negative, it is treated as 
-      * length+start where length is the length of the array. 
-      * @param end index to stop filling the array at. If end is negative, it is treated as 
+      * @param start index to start filling the array at. If start is negative, it is treated as
+      * length+start where length is the length of the array.
+      * @param end index to stop filling the array at. If end is negative, it is treated as
       * length+end.
       */
     fill(value: T, start?: number, end?: number): T[];
 
-    /** 
+    /**
       * Returns the this object after copying a section of the array identified by start and end
       * to the same array starting at position target
-      * @param target If target is negative, it is treated as length+target where length is the 
-      * length of the array. 
-      * @param start If start is negative, it is treated as length+start. If end is negative, it 
+      * @param target If target is negative, it is treated as length+target where length is the
+      * length of the array.
+      * @param start If start is negative, it is treated as length+start. If end is negative, it
       * is treated as length+end.
-      * @param end If not specified, length of the this object is used as its default value. 
+      * @param end If not specified, length of the this object is used as its default value.
       */
     copyWithin(target: number, start: number, end?: number): T[];
 
@@ -161,47 +156,47 @@ interface ArrayConstructor {
 
 // #############################################################################################
 // ECMAScript 6: String & RegExp
-// Modules: es6.string.from-code-point, es6.string.raw, es6.string.code-point-at, 
-//          es6.string.ends-with, es6.string.includes, es6.string.repeat, 
+// Modules: es6.string.from-code-point, es6.string.raw, es6.string.code-point-at,
+//          es6.string.ends-with, es6.string.includes, es6.string.repeat,
 //          es6.string.starts-with, and es6.regexp
 // #############################################################################################
 
 interface String {
     /**
-      * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point 
-      * value of the UTF-16 encoded code point starting at the string element at position pos in 
-      * the String resulting from converting this object to a String. 
-      * If there is no element at that position, the result is undefined. 
+      * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point
+      * value of the UTF-16 encoded code point starting at the string element at position pos in
+      * the String resulting from converting this object to a String.
+      * If there is no element at that position, the result is undefined.
       * If a valid UTF-16 surrogate pair does not begin at pos, the result is the code unit at pos.
       */
     codePointAt(pos: number): number;
 
     /**
-      * Returns true if searchString appears as a substring of the result of converting this 
-      * object to a String, at one or more positions that are 
+      * Returns true if searchString appears as a substring of the result of converting this
+      * object to a String, at one or more positions that are
       * greater than or equal to position; otherwise, returns false.
-      * @param searchString search string 
+      * @param searchString search string
       * @param position If position is undefined, 0 is assumed, so as to search all of the String.
       */
     includes(searchString: string, position?: number): boolean;
 
     /**
-      * Returns true if the sequence of elements of searchString converted to a String is the 
-      * same as the corresponding elements of this object (converted to a String) starting at 
+      * Returns true if the sequence of elements of searchString converted to a String is the
+      * same as the corresponding elements of this object (converted to a String) starting at
       * endPosition – length(this). Otherwise returns false.
       */
     endsWith(searchString: string, endPosition?: number): boolean;
 
     /**
-      * Returns a String value that is made from count copies appended together. If count is 0, 
+      * Returns a String value that is made from count copies appended together. If count is 0,
       * T is the empty String is returned.
       * @param count number of copies to append
       */
     repeat(count: number): string;
 
     /**
-      * Returns true if the sequence of elements of searchString converted to a String is the 
-      * same as the corresponding elements of this object (converted to a String) starting at 
+      * Returns true if the sequence of elements of searchString converted to a String is the
+      * same as the corresponding elements of this object (converted to a String) starting at
       * position. Otherwise returns false.
       */
     startsWith(searchString: string, position?: number): boolean;
@@ -216,7 +211,7 @@ interface StringConstructor {
 
     /**
       * String.raw is intended for use as a tag function of a Tagged Template String. When called
-      * as such the first argument will be a well formed template call site object and the rest 
+      * as such the first argument will be a well formed template call site object and the rest
       * parameter will contain the substitution values.
       * @param template A well-formed template string call site representation.
       * @param substitutions A set of substitution values.
@@ -248,14 +243,14 @@ interface RegExp {
 interface NumberConstructor {
     /**
       * The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1
-      * that is representable as a Number value, which is approximately: 
+      * that is representable as a Number value, which is approximately:
       * 2.2204460492503130808472633361816 x 10‍−‍16.
       */
     EPSILON: number;
 
     /**
       * Returns true if passed value is finite.
-      * Unlike the global isFininte, Number.isFinite doesn't forcibly convert the parameter to a 
+      * Unlike the global isFininte, Number.isFinite doesn't forcibly convert the parameter to a
       * number. Only finite values of the type number, result in true.
       * @param number A numeric value.
       */
@@ -268,7 +263,7 @@ interface NumberConstructor {
     isInteger(number: number): boolean;
 
     /**
-      * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a 
+      * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a
       * number). Unlike the global isNaN(), Number.isNaN() doesn't forcefully convert the parameter
       * to a number. Only values of the type number, that are also NaN, result in true.
       * @param number A numeric value.
@@ -281,30 +276,30 @@ interface NumberConstructor {
       */
     isSafeInteger(number: number): boolean;
 
-    /** 
-      * The value of the largest integer n such that n and n + 1 are both exactly representable as 
-      * a Number value. 
+    /**
+      * The value of the largest integer n such that n and n + 1 are both exactly representable as
+      * a Number value.
       * The value of Number.MIN_SAFE_INTEGER is 9007199254740991 2^53 − 1.
       */
     MAX_SAFE_INTEGER: number;
 
-    /** 
-      * The value of the smallest integer n such that n and n − 1 are both exactly representable as 
-      * a Number value. 
+    /**
+      * The value of the smallest integer n such that n and n − 1 are both exactly representable as
+      * a Number value.
       * The value of Number.MIN_SAFE_INTEGER is −9007199254740991 (−(2^53 − 1)).
       */
     MIN_SAFE_INTEGER: number;
 
     /**
-      * Converts a string to a floating-point number. 
-      * @param string A string that contains a floating-point number. 
+      * Converts a string to a floating-point number.
+      * @param string A string that contains a floating-point number.
       */
     parseFloat(string: string): number;
 
     /**
       * Converts A string to an integer.
       * @param s A string to convert into a number.
-      * @param radix A value between 2 and 36 that specifies the base of the number in numString. 
+      * @param radix A value between 2 and 36 that specifies the base of the number in numString.
       * If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal.
       * All other strings are considered decimal.
       */
@@ -350,7 +345,7 @@ interface Math {
     log1p(x: number): number;
 
     /**
-      * Returns the result of (e^x - 1) of x (e raised to the power of x, where e is the base of 
+      * Returns the result of (e^x - 1) of x (e raised to the power of x, where e is the base of
       * the natural logarithms).
       * @param x A numeric expression.
       */
@@ -436,8 +431,8 @@ interface Symbol {
 }
 
 interface SymbolConstructor {
-    /** 
-      * A reference to the prototype. 
+    /**
+      * A reference to the prototype.
       */
     prototype: Symbol;
 
@@ -448,14 +443,14 @@ interface SymbolConstructor {
     (description?: string|number): symbol;
 
     /**
-      * Returns a Symbol object from the global symbol registry matching the given key if found. 
+      * Returns a Symbol object from the global symbol registry matching the given key if found.
       * Otherwise, returns a new symbol with this key.
       * @param key key to search for.
       */
     for(key: string): symbol;
 
     /**
-      * Returns a key from the global symbol registry matching the given Symbol if found. 
+      * Returns a key from the global symbol registry matching the given Symbol if found.
       * Otherwise, returns a undefined.
       * @param sym Symbol to find the key for.
       */
@@ -463,72 +458,72 @@ interface SymbolConstructor {
 
     // Well-known Symbols
 
-    /** 
-      * A method that determines if a constructor object recognizes an object as one of the 
-      * constructor’s instances. Called by the semantics of the instanceof operator. 
+    /**
+      * A method that determines if a constructor object recognizes an object as one of the
+      * constructor’s instances. Called by the semantics of the instanceof operator.
       */
     hasInstance: symbol;
 
-    /** 
+    /**
       * A Boolean value that if true indicates that an object should flatten to its array elements
       * by Array.prototype.concat.
       */
     isConcatSpreadable: symbol;
 
-    /** 
-      * A method that returns the default iterator for an object. Called by the semantics of the 
+    /**
+      * A method that returns the default iterator for an object. Called by the semantics of the
       * for-of statement.
       */
     iterator: symbol;
 
     /**
-      * A regular expression method that matches the regular expression against a string. Called 
-      * by the String.prototype.match method. 
+      * A regular expression method that matches the regular expression against a string. Called
+      * by the String.prototype.match method.
       */
     match: symbol;
 
-    /** 
-      * A regular expression method that replaces matched substrings of a string. Called by the 
+    /**
+      * A regular expression method that replaces matched substrings of a string. Called by the
       * String.prototype.replace method.
       */
     replace: symbol;
 
     /**
-      * A regular expression method that returns the index within a string that matches the 
+      * A regular expression method that returns the index within a string that matches the
       * regular expression. Called by the String.prototype.search method.
       */
     search: symbol;
 
-    /** 
-      * A function valued property that is the constructor function that is used to create 
+    /**
+      * A function valued property that is the constructor function that is used to create
       * derived objects.
       */
     species: symbol;
 
     /**
-      * A regular expression method that splits a string at the indices that match the regular 
+      * A regular expression method that splits a string at the indices that match the regular
       * expression. Called by the String.prototype.split method.
       */
     split: symbol;
 
-    /** 
+    /**
       * A method that converts an object to a corresponding primitive value.Called by the ToPrimitive
       * abstract operation.
       */
     toPrimitive: symbol;
 
-    /** 
+    /**
       * A String value that is used in the creation of the default string description of an object.
       * Called by the built-in method Object.prototype.toString.
       */
     toStringTag: symbol;
 
-    /** 
-      * An Object whose own property names are property names that are excluded from the with 
+    /**
+      * An Object whose own property names are property names that are excluded from the with
       * environment bindings of the associated objects.
       */
     unscopables: symbol;
-    
+
     /**
       * Non-standard. Use simple mode for core-js symbols. See https://github.com/zloirock/core-js/#caveats-when-using-symbol-polyfill
       */
@@ -544,12 +539,12 @@ declare var Symbol: SymbolConstructor;
 
 interface Object {
     /**
-      * Determines whether an object has a property with the specified name. 
+      * Determines whether an object has a property with the specified name.
       * @param v A property name.
       */
     hasOwnProperty(v: PropertyKey): boolean;
 
-    /** 
+    /**
       * Determines whether a specified property is enumerable.
       * @param v A property name.
       */
@@ -564,17 +559,17 @@ interface ObjectConstructor {
     getOwnPropertySymbols(o: any): symbol[];
 
     /**
-      * Gets the own property descriptor of the specified object. 
-      * An own property descriptor is one that is defined directly on the object and is not 
-      * inherited from the object's prototype. 
+      * Gets the own property descriptor of the specified object.
+      * An own property descriptor is one that is defined directly on the object and is not
+      * inherited from the object's prototype.
       * @param o Object that contains the property.
       * @param p Name of the property.
     */
     getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
 
     /**
-      * Adds a property to an object, or modifies attributes of an existing property. 
-      * @param o Object on which to add or modify the property. This can be a native JavaScript 
+      * Adds a property to an object, or modifies attributes of an existing property.
+      * @param o Object on which to add or modify the property. This can be a native JavaScript
       * object (that is, a user-defined object or a built in object) or a DOM object.
       * @param p The property name.
       * @param attributes Descriptor for the property. It can be for a data property or an accessor
@@ -693,17 +688,17 @@ interface Array<T> {
     /** Iterator */
     [Symbol.iterator](): IterableIterator<T>;
 
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIterator<[number, T]>;
 
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIterator<number>;
 
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIterator<T>;
@@ -776,21 +771,21 @@ interface Promise<T> {
 }
 
 interface PromiseConstructor {
-    /** 
-      * A reference to the prototype. 
+    /**
+      * A reference to the prototype.
       */
     prototype: Promise<any>;
 
     /**
      * Creates a new Promise.
-     * @param executor A callback used to initialize the promise. This callback is passed two arguments: 
-     * a resolve callback used resolve the promise with a value or the result of another promise, 
+     * @param executor A callback used to initialize the promise. This callback is passed two arguments:
+     * a resolve callback used resolve the promise with a value or the result of another promise,
      * and a reject callback used to reject the promise with a provided reason or error.
      */
     new <T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
 
     /**
-     * Creates a Promise that is resolved with an array of results when all of the provided Promises 
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
      * resolve, or rejected when any Promise is rejected.
      * @param values An array of Promises.
      * @returns A new Promise.
@@ -798,7 +793,7 @@ interface PromiseConstructor {
     all<T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>;
 
     /**
-     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved 
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
      * or rejected.
      * @param values An array of Promises.
      * @returns A new Promise.
@@ -859,7 +854,7 @@ declare module Reflect {
 
 // #############################################################################################
 // ECMAScript 7
-// Modules: es7.array.includes, es7.string.at, es7.string.lpad, es7.string.rpad, 
+// Modules: es7.array.includes, es7.string.at, es7.string.lpad, es7.string.rpad,
 //          es7.object.to-array, es7.object.get-own-property-descriptors, es7.regexp.escape,
 //          es7.map.to-json, and es7.set.to-json
 // #############################################################################################
@@ -918,14 +913,14 @@ interface ArrayConstructor {
       */
     join<T>(array: ArrayLike<T>, separator?: string): string;
     /**
-      * Reverses the elements in an Array. 
+      * Reverses the elements in an Array.
       */
     reverse<T>(array: ArrayLike<T>): T[];
     /**
       * Removes the first element from an array and returns it.
       */
     shift<T>(array: ArrayLike<T>): T;
-    /** 
+    /**
       * Returns a section of an array.
       * @param start The beginning of the specified portion of the array.
       * @param end The end of the specified portion of the array.
@@ -988,21 +983,21 @@ interface ArrayConstructor {
 
     /**
       * Performs the specified action for each element in an array.
-      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. 
+      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
     forEach<T>(array: ArrayLike<T>, callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
 
     /**
       * Calls a defined callback function on each element of an array, and returns an array that contains the results.
-      * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. 
+      * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
     map<T, U>(array: ArrayLike<T>, callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
 
     /**
-      * Returns the elements of an array that meet the condition specified in a callback function. 
-      * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array. 
+      * Returns the elements of an array that meet the condition specified in a callback function.
+      * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
     filter<T>(array: ArrayLike<T>, callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];
@@ -1021,53 +1016,53 @@ interface ArrayConstructor {
       */
     reduce<T>(array: ArrayLike<T>, callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
 
-    /** 
+    /**
       * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
-      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. 
+      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
       * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
       */
     reduceRight<T, U>(array: ArrayLike<T>, callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
 
-    /** 
+    /**
       * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
-      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. 
+      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
       * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
       */
     reduceRight<T>(array: ArrayLike<T>, callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
 
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
 
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys<T>(array: ArrayLike<T>): IterableIterator<number>;
 
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values<T>(array: ArrayLike<T>): IterableIterator<T>;
 
-    /** 
-      * Returns the value of the first element in the array where predicate is true, and undefined 
+    /**
+      * Returns the value of the first element in the array where predicate is true, and undefined
       * otherwise.
-      * @param predicate find calls predicate once for each element of the array, in ascending 
-      * order, until it finds one where predicate returns true. If such an element is found, find 
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
       * immediately returns that element value. Otherwise, find returns undefined.
-      * @param thisArg If provided, it will be used as the this value for each invocation of 
+      * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
     find<T>(array: ArrayLike<T>, predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): T;
 
-    /** 
-      * Returns the index of the first element in the array where predicate is true, and undefined 
+    /**
+      * Returns the index of the first element in the array where predicate is true, and undefined
       * otherwise.
-      * @param predicate find calls predicate once for each element of the array, in ascending 
-      * order, until it finds one where predicate returns true. If such an element is found, find 
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
       * immediately returns that element value. Otherwise, find returns undefined.
-      * @param thisArg If provided, it will be used as the this value for each invocation of 
+      * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
     findIndex<T>(array: ArrayLike<T>, predicate: (value: T) => boolean, thisArg?: any): number;
@@ -1075,21 +1070,21 @@ interface ArrayConstructor {
     /**
       * Returns the this object after filling the section identified by start and end with value
       * @param value value to fill array section with
-      * @param start index to start filling the array at. If start is negative, it is treated as 
-      * length+start where length is the length of the array. 
-      * @param end index to stop filling the array at. If end is negative, it is treated as 
+      * @param start index to start filling the array at. If start is negative, it is treated as
+      * length+start where length is the length of the array.
+      * @param end index to stop filling the array at. If end is negative, it is treated as
       * length+end.
       */
     fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
 
-    /** 
+    /**
       * Returns the this object after copying a section of the array identified by start and end
       * to the same array starting at position target
-      * @param target If target is negative, it is treated as length+target where length is the 
-      * length of the array. 
-      * @param start If start is negative, it is treated as length+start. If end is negative, it 
+      * @param target If target is negative, it is treated as length+target where length is the
+      * length of the array.
+      * @param start If start is negative, it is treated as length+start. If end is negative, it
       * is treated as length+end.
-      * @param end If not specified, length of the this object is used as its default value. 
+      * @param end If not specified, length of the this object is used as its default value.
       */
     copyWithin<T>(array: ArrayLike<T>, target: number, start: number, end?: number): T[];
 
@@ -1113,7 +1108,7 @@ interface ObjectConstructor {
       * Non-standard.
       */
     classof(value: any): string;
-    
+
     /**
       * Non-standard.
       */
@@ -1477,13 +1472,13 @@ declare module core {
 }
 
 declare module "core-js" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/shim" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/core" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/core/$for" {
     import $for = core.$for;
@@ -2149,10 +2144,10 @@ declare module "core-js/fn/symbol/unscopables" {
     export = unscopables;
 }
 declare module "core-js/es5" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/es6" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/es6/array" {
     var Array: typeof core.Array;
@@ -2211,7 +2206,7 @@ declare module "core-js/es6/weak-set" {
     export = WeakSet;
 }
 declare module "core-js/es7" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/es7/array" {
     var Array: typeof core.Array;
@@ -2238,32 +2233,32 @@ declare module "core-js/es7/string" {
     export = String;
 }
 declare module "core-js/js" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/js/array" {
     var Array: typeof core.Array;
     export = Array;
 }
 declare module "core-js/web" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/web/dom" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/web/immediate" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/web/timers" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/shim" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/core" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/core/$for" {
     import $for = core.$for;
@@ -2928,10 +2923,10 @@ declare module "core-js/libary/fn/symbol/unscopables" {
     export = unscopables;
 }
 declare module "core-js/libary/es5" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/es6" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/es6/array" {
     var Array: typeof core.Array;
@@ -2990,7 +2985,7 @@ declare module "core-js/libary/es6/weak-set" {
     export = WeakSet;
 }
 declare module "core-js/libary/es7" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/es7/array" {
     var Array: typeof core.Array;
@@ -3017,21 +3012,21 @@ declare module "core-js/libary/es7/string" {
     export = String;
 }
 declare module "core-js/libary/js" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/js/array" {
     var Array: typeof core.Array;
     export = Array;
 }
 declare module "core-js/libary/web" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/web/dom" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/web/immediate" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/web/timers" {
-    export = core; 
+    export = core;
 }
diff --git a/devextreme/dx.devextreme-tests.ts b/devextreme/dx.devextreme-tests.ts
index a17372847a..78b09d15ae 100644
--- a/devextreme/dx.devextreme-tests.ts
+++ b/devextreme/dx.devextreme-tests.ts
@@ -5,7 +5,7 @@ module Tests.ui {
         activeStateEnabled: true,
         allowColumnReordering: true,
         allowColumnResizing: true,
-        onCellClick: function () { },
+        onCellClick: function() { },
         cellHintEnabled: true,
         columnAutoWidth: true,
         columnChooser: {
@@ -17,67 +17,52 @@ module Tests.ui {
         },
         columns: [
             {
-                text: '5 columns with custom css class', value: [
-                    { dataField: 'Processed', dataType: 'boolean', allowSorting: false },
-                    { dataField: 'CustomerID', cssClass: 'customCssClass' },
-                    'OrderDate',
-                    { dataField: 'Freight', validationRules: [{ type: "range", min: 1, max: 100 }] },
-                    { dataField: 'ShipName', validationRules: [{ type: 'required' }] },
-                    'ShipCity']
-            },
-            {
-                text: 'with show editor always', value: [
-                    { dataField: 'Processed', dataType: 'boolean', allowSorting: false, showEditorAlways: true },
-                    { dataField: 'OrderDate', dataType: 'date', showEditorAlways: true },
-                    { dataField: 'CustomerID', showEditorAlways: true },
-                    { dataField: 'Freight', showEditorAlways: true },
-                    { dataField: 'ShipName', showEditorAlways: true }]
-            },
-            {
-                text: 'custom template/edit/header template', value: [
-                    'CustomerID',
-                    'OrderDate',
-                    'Freight',
-                    {
-                        dataField: 'ShipVia',
-                        editCellTemplate: function (container: JQuery, options: { value: number }) {
-                            container.addClass('dx-editor-cell');
-                            container.append($('<div />').dxSelectBox({
-                                value: options.value,
-                                dataSource: [
-                                    { ShipperID: 1, CompanyName: 'Speedy Express' },
-                                    { ShipperID: 2, CompanyName: 'United Package' },
-                                    { ShipperID: 3, CompanyName: 'Federal Shipping' }
-                                ],
-                                valueExpr: 'ShipperID',
-                                displayExpr: 'CompanyName'
-                            }));
-                        },
-                        cellTemplate: function (container: JQuery, options: { value: number }) {
-                            container.text(String(options.value));
-                        },
-                        headerCellTemplate: function (container: JQuery, options: { headerCaption: string }) {
-                            container.append($('<div/>').css({ border: '1px solid red' }).text(options.headerCaption));
-                        }
-                    },
-                    'ShipName',
-                    'ShipCity']
-            },
-            { text: 'none', value: '' },
-            {
-                text: 'custom template/header hogan template', value: [
-                    'CustomerID',
-                    'OrderDate',
-                    'Freight',
-                    {
-                        dataField: 'ShipVia',
-                        cellTemplate: '#hoganColumnTemplate',
-                        headerCellTemplate: $('#hoganHeaderColumnTemplate')
-                    },
-                    'ShipName',
-                    'ShipCity']
-            }],
-        customizeColumns: function (columns) {
+                alignment: "center",
+                allowFixing: true,
+                allowEditing: true,
+                allowFiltering: true,
+                allowGrouping: true,
+                allowHiding: true,
+                allowReordering: true,
+                allowResizing: true,
+                allowSearch: true,
+                allowSorting: true,
+                autoExpandGroup: true,
+                calculateCellValue: function(rowData: Object) { return "test-value"; },
+                calculateFilterExpression: function(filterValue: any, selectedFilterOperation: string) { return []; },
+                caption: "Test column",
+                cellTemplate: function(container: JQuery, options: Object) { $("<span>Template</span>").appendTo(container); },
+                cssClass: "test-ccs-class-name",
+                customizeText: function(cellInfo: { value: any, valueText: string; }) { return "New text" },
+                dataField: "Test",
+                dataType: "string",
+                encodeHtml: true,
+                falseText: "FALSE",
+                filterOperations: ["contains", "notcontains"],
+                filterType: "exclude",
+                filterValue: "Test-filter-value",
+                fixed: true,
+                fixedPosition: "right",
+                groupIndex: 0,
+                lookup: {
+                    allowClearing: true,
+                    dataSource: ["first", "second"],
+                    displayExpr: "this",
+                    valueExpr: "this"
+                },
+                name: "test-column-name",
+                showEditorAlways: true,
+                showInColumnChooser: true,
+                showWhenGrouped: true,
+                sortIndex: 1,
+                sortOrder: "desc",
+                trueText: "TRUE",
+                visible: true,
+                visibleIndex: 0,
+                width: "100%"
+            }
+        ],
+        customizeColumns: function(columns) {
             var i: number;
             for (i = 0; i < columns.length; i++) {
                 if (columns[i].dataField.indexOf('Date') > 0) {
@@ -94,16 +79,16 @@ module Tests.ui {
                         valueExpr: 'CustomerID',
                         displayExpr: 'ContactName'
                     }
-                        }
+                }
                 if (columns[i].dataField === 'EmployeeID') {
                     columns[i].lookup = {
                         dataSource: { store: [], sort: 'LastName' },
                         valueExpr: 'EmployeeID',
-                        displayExpr: function (data: any) {
+                        displayExpr: function(data: any) {
                             return data.LastName + ' ' + data.FirstName;
                         }
                     }
-                        }
+                }
                 if (columns[i].dataField === 'ShipVia') {
                     columns[i].lookup = {
                         dataSource: [
@@ -114,14 +99,14 @@ module Tests.ui {
                         valueExpr: 'ShipperID',
                         displayExpr: 'CompanyName'
                     }
-                        }
+                }
                 if (columns[i].dataField === 'ShipCity') {
-                    columns[i].editCellTemplate = function (container: JQuery, options: { value: string; setValue: Function }) {
+                    columns[i].editCellTemplate = function(container: JQuery, options: { value: string; setValue: Function }) {
                         $('<div/>').dxAutocomplete({
-                            items: ["Bern", "Lyon", "Lander"],
+                            dataSource: ["Bern", "Lyon", "Lander"],
                             value: options.value,
-                            onValueChanged: function (e:{ value: string }) {
-                                options.setValue(e.value);
+                            onValueChanged: function() {
+                                options.setValue("test-value");
                             }
                         }).appendTo(container);
                     }
@@ -242,10 +227,10 @@ module Tests.viz {
             { valueField: 's8' }
         ],
         title: 'Long Chart\'s Title',
-        onPointClick: function (arg: any) {
+        onPointClick: function(arg: any) {
             arg.target.isSelected() ? arg.target.clearSelection() : arg.target.select();
         },
-        onSeriesClick: function (arg: any) {
+        onSeriesClick: function(arg: any) {
             arg.target.isVisible() ? arg.target.hide() : arg.target.show();
         }
     };
@@ -313,8 +298,8 @@ module Tests.data {
         pageSize: 25,
         paginate: true,
 
-        map: function (item) { return item; },
-        postProcess: function (data) { return data; },
+        map: function(item) { return item; },
+        postProcess: function(data) { return data; },
         searchExpr: "expr",
         searchOperation: "contains",
         searchValue: "somevalue",
@@ -328,7 +313,7 @@ module Tests.data {
     });
 
     new DevExpress.data.CustomStore(<DevExpress.data.CustomStoreOptions>{
-        load: function () {
+        load: function() {
             return $.Deferred().promise();
         }
     });
diff --git a/devextreme/dx.devextreme.d.ts b/devextreme/dx.devextreme.d.ts
index ac0639b0a5..c2bf7a1a22 100644
--- a/devextreme/dx.devextreme.d.ts
+++ b/devextreme/dx.devextreme.d.ts
@@ -35,7 +35,7 @@ declare module DevExpress {
             brokenRules: any[];
             validators: IValidator[];
         }
-        export interface GroupConfig extends EventsMixin<GroupConfig>  {
+        export interface GroupConfig extends EventsMixin<GroupConfig> {
             group: any;
             validators: IValidator[];
             validate(): ValidationGroupValidationResult;
@@ -56,7 +56,7 @@ declare module DevExpress {
         /** Validates the rules that are defined within the dxValidator objects that are registered for the specified ViewModel. */
         export function validateModel(model: Object): ValidationGroupValidationResult;
         /** Registers all the dxValidator objects by which the fields of the specified ViewModel are extended. */
-        export function registerModelForValidation(model: Object) : void;
+        export function registerModelForValidation(model: Object): void;
     }
     export var hardwareBackButton: JQueryCallback;
     /** Processes the hardware back button click. */
@@ -1789,7 +1789,7 @@ declare module DevExpress.ui {
         interval?: number;
         /** Specifies the maximum zoom level of a calendar, which is used to pick the date. */
         maxZoomLevel?: string;
-    /** Specifies the minimal zoom level of a calendar, which is used to pick the date. */
+        /** Specifies the minimal zoom level of a calendar, which is used to pick the date. */
         minZoomLevel?: string;
         /** Specifies the type of date/time picker. */
         pickerType?: string;
@@ -1869,7 +1869,7 @@ declare module DevExpress.ui {
     /** A container widget used to arrange inner elements. */
     export class dxBox extends CollectionWidget {
         constructor(element: JQuery, options?: dxBoxOptions);
-        constructor(element: Element, options?: dxBoxOptions);    
+        constructor(element: Element, options?: dxBoxOptions);
     }
     export interface dxResponsiveBoxOptions extends CollectionWidgetOptions {
         /** Specifies the collection of rows for the grid used to position layout elements. */
@@ -3041,7 +3041,7 @@ declare module DevExpress.ui {
         lookup?: {
             /** Specifies whether or not a user can nullify values of a lookup column. */
             allowClearing?: boolean;
-            /** 
+            /**
              * Specifies the data source providing data for a lookup column.
              */
             dataSource?: any;
@@ -3076,6 +3076,9 @@ declare module DevExpress.ui {
         showInColumnChooser?: boolean;
         /** Specifies the identifier of the column. */
         name?: string;
+        // NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
+        text?: string;
+        value?: any;
     }
     export interface dxDataGridOptions extends WidgetOptions {
         /** Specifies whether the outer borders of the grid are visible or not. */
@@ -3171,7 +3174,7 @@ declare module DevExpress.ui {
                 cancel?: string;
             }
         };
-        /** 
+        /**
          * An array of grid columns.
          */
         columns?: dxDataGridColumn[];
@@ -3271,7 +3274,7 @@ declare module DevExpress.ui {
             autoExpandAll?: boolean;
             /** Specifies the message displayed in a group row when the corresponding group is continued from the previous page. */
             groupContinuedMessage?: string;
-            /** 
+            /**
              * Specifies the message displayed in a group row when the corresponding group continues on the next page.
              */
             groupContinuesMessage?: string;
@@ -3653,7 +3656,7 @@ declare module DevExpress.ui {
         removeRow(rowIndex: number): void;
         /** Saves changes made in a grid. */
         saveEditData(): void;
-        /** 
+        /**
          * Searches grid records by a search string.
          */
         searchByText(text: string): void;
@@ -4332,16 +4335,16 @@ declare module DevExpress.viz.core {
         }) => void;
         /** A handler for the incidentOccurred event. */
         onIncidentOccurred?: (
-            component: BaseWidget,
-            element: Element,
-            target: {
-                id: string;
-                type: string;
-                args: any;
-                text: string;
-                widget: string;
-                version: string;
-            }
+        component: BaseWidget,
+        element: Element,
+        target: {
+            id: string;
+            type: string;
+            args: any;
+            text: string;
+            widget: string;
+            version: string;
+        }
         ) => void;
         /** Notifies a widget that it is embedded into an HTML page that uses a path modifier. */
         pathModified?: boolean;
@@ -4656,59 +4659,59 @@ declare module DevExpress.viz.charts {
         };
     }
     export interface CommonPointOptions {
-            /** Specifies border options for points in the line and area series. */
+        /** Specifies border options for points in the line and area series. */
+        border?: viz.core.Border;
+        /** Specifies the points color. */
+        color?: string;
+        /** Specifies what series points to highlight when a point is hovered over. */
+        hoverMode?: string;
+        /** An object defining configuration options for a hovered point. */
+        hoverStyle?: {
+            /** An object defining the border options for a hovered point. */
             border?: viz.core.Border;
-            /** Specifies the points color. */
+            /** Sets a color for a point when it is hovered over. */
             color?: string;
-            /** Specifies what series points to highlight when a point is hovered over. */
-            hoverMode?: string;
-            /** An object defining configuration options for a hovered point. */
-            hoverStyle?: {
-                /** An object defining the border options for a hovered point. */
-                border?: viz.core.Border;
-                /** Sets a color for a point when it is hovered over. */
-                color?: string;
-                /** Specifies the diameter of a hovered point in the series that represents data points as symbols (not as bars for instance). */
-                size?: number;
-            };
-            /** Specifies what series points to highlight when a point is selected. */
-            selectionMode?: string;
-            /** An object defining configuration options for a selected point. */
-            selectionStyle?: {
-                /** An object defining the border options for a selected point. */
-                border?: viz.core.Border;
-                /** <p>Sets a color for a point when it is selected.</p> */
-                color?: string;
-                /** Specifies the diameter of a selected point in the series that represents data points as symbols (not as bars for instance). */
-                size?: number;
-            };
-            /** Specifies the point diameter in pixels for those series that represent data points as symbols (not as bars for instance). */
+            /** Specifies the diameter of a hovered point in the series that represents data points as symbols (not as bars for instance). */
             size?: number;
-            /** Specifies a symbol for presenting points of the line and area series. */
-            symbol?: string;
-            visible?: boolean;
+        };
+        /** Specifies what series points to highlight when a point is selected. */
+        selectionMode?: string;
+        /** An object defining configuration options for a selected point. */
+        selectionStyle?: {
+            /** An object defining the border options for a selected point. */
+            border?: viz.core.Border;
+            /** <p>Sets a color for a point when it is selected.</p> */
+            color?: string;
+            /** Specifies the diameter of a selected point in the series that represents data points as symbols (not as bars for instance). */
+            size?: number;
+        };
+        /** Specifies the point diameter in pixels for those series that represent data points as symbols (not as bars for instance). */
+        size?: number;
+        /** Specifies a symbol for presenting points of the line and area series. */
+        symbol?: string;
+        visible?: boolean;
     }
     export interface ChartCommonPointOptions extends CommonPointOptions {
-            /** An object specifying the parameters of an image that is used as a point marker. */
-            image?: {
-                /** Specifies the height of an image that is used as a point marker. */
-                height?: any;
-                /** Specifies a URL leading to the image to be used as a point marker. */
-                url?: any;
-                /** Specifies the width of an image that is used as a point marker. */
-                width?: any;
-            };
+        /** An object specifying the parameters of an image that is used as a point marker. */
+        image?: {
+            /** Specifies the height of an image that is used as a point marker. */
+            height?: any;
+            /** Specifies a URL leading to the image to be used as a point marker. */
+            url?: any;
+            /** Specifies the width of an image that is used as a point marker. */
+            width?: any;
+        };
     }
     export interface PolarCommonPointOptions extends CommonPointOptions {
-            /** An object specifying the parameters of an image that is used as a point marker. */
-            image?: {
-                /** Specifies the height of an image that is used as a point marker. */
-                height?: number;
-                /** Specifies a URL leading to the image to be used as a point marker. */
-                url?: string;
-                /** Specifies the width of an image that is used as a point marker. */
-                width?: number;
-            };
+        /** An object specifying the parameters of an image that is used as a point marker. */
+        image?: {
+            /** Specifies the height of an image that is used as a point marker. */
+            height?: number;
+            /** Specifies a URL leading to the image to be used as a point marker. */
+            url?: string;
+            /** Specifies the width of an image that is used as a point marker. */
+            width?: number;
+        };
     }
     /** An object that defines configuration options for chart series. */
     export interface CommonSeriesConfig extends BaseCommonSeriesConfig {
@@ -5091,17 +5094,17 @@ declare module DevExpress.viz.charts {
         text?: string;
     }
     export interface AxisLabel {
-          /** Specifies the text for a hint that appears when a user hovers the mouse pointer over a label on the value axis. */
+        /** Specifies the text for a hint that appears when a user hovers the mouse pointer over a label on the value axis. */
         customizeHint?: (argument: { value: any; valueText: string }) => string;
-          /** Specifies a callback function that returns the text to be displayed in value axis labels. */
+        /** Specifies a callback function that returns the text to be displayed in value axis labels. */
         customizeText?: (argument: { value: any; valueText: string }) => string;
-          /** Specifies a format for the text displayed by axis labels. */
+        /** Specifies a format for the text displayed by axis labels. */
         format?: string;
-          /** Specifies a precision for the formatted value displayed in the axis labels. */
+        /** Specifies a precision for the formatted value displayed in the axis labels. */
         precision?: number;
     }
-    export interface ChartAxisLabel extends ChartCommonAxisLabel, AxisLabel {}
-    export interface PolarAxisLabel extends PolarCommonAxisLabel, AxisLabel {}
+    export interface ChartAxisLabel extends ChartCommonAxisLabel, AxisLabel { }
+    export interface PolarAxisLabel extends PolarCommonAxisLabel, AxisLabel { }
     export interface AxisTitle extends CommonAxisTitle {
         /** Specifies the text for the value axis title. */
         text?: string;
@@ -5117,7 +5120,7 @@ declare module DevExpress.viz.charts {
         value?: any;
     }
     export interface PolarConstantLine extends PolarCommonConstantLineStyle {
-    /** An object defining constant line label options. */
+        /** An object defining constant line label options. */
         label?: PolarConstantLineLabel;
         /** Specifies a value to be displayed by a constant line. */
         value?: any;
@@ -5170,7 +5173,7 @@ declare module DevExpress.viz.charts {
         /** Specifies the elements that will be highlighted when the argument axis is hovered over. */
         hoverMode?: string;
     }
-    export interface ChartArgumentAxis extends ChartAxis, ArgumentAxis {}
+    export interface ChartArgumentAxis extends ChartAxis, ArgumentAxis { }
     export interface PolarArgumentAxis extends PolarAxis, ArgumentAxis {
         /** Specifies a start angle for the argument axis in degrees. */
         startAngle?: number;
@@ -5186,7 +5189,7 @@ declare module DevExpress.viz.charts {
         showZero?: boolean;
         /** Specifies the desired type of axis values. */
         valueType?: string;
-        }
+    }
     export interface ChartValueAxis extends ChartAxis, ValueAxis {
         /** Specifies the spacing, in pixels, between multiple value axes in a chart. */
         multipleAxesSpacing?: number;
@@ -5385,7 +5388,7 @@ declare module DevExpress.viz.charts {
         /** Specifies whether a single series or multiple series can be selected in the chart. */
         seriesSelectionMode?: string;
         /** Specifies how the chart must behave when series point labels overlap. */
-        resolveLabelOverlapping?: string; 
+        resolveLabelOverlapping?: string;
     }
     export interface Legend extends AdvancedLegend {
         /** Specifies whether the legend is located outside or inside the chart's plot. */
@@ -5580,7 +5583,7 @@ declare module DevExpress.viz.charts {
         onLegendClick?: any;
         legendClick?: any;
         /** Specifies how the chart must behave when series point labels overlap. */
-        resolveLabelOverlapping?: string; 
+        resolveLabelOverlapping?: string;
     }
     /** A circular chart widget for HTML JS applications. */
     export class dxPieChart extends BaseChart {
@@ -5952,7 +5955,7 @@ declare module DevExpress.viz.rangeSelector {
         behavior?: {
             /** Indicates whether or not you can swap sliders. */
             allowSlidersSwap?: boolean;
-            /** 
+            /**
 Indicates whether or not animation is enabled.
  */
             animationEnabled?: boolean;
@@ -6067,7 +6070,7 @@ Indicates whether or not animation is enabled.
             maxRange?: any;
             /** Specifies the number of minor ticks between neighboring major ticks. */
             minorTickCount?: number;
-            /** 
+            /**
 Specifies an interval between minor ticks.
  */
             minorTickInterval?: any;
diff --git a/dragula/dragula-amd-tests.ts b/dragula/dragula-amd-tests.ts
index 99cb5e043f..0dcca91e23 100644
--- a/dragula/dragula-amd-tests.ts
+++ b/dragula/dragula-amd-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./dragula.d.ts" />
+
 import dragula = require("dragula");
 
 // containers
diff --git a/es6-shim/es6-shim.d.ts b/es6-shim/es6-shim.d.ts
index cff5a9b7e4..30621b372e 100644
--- a/es6-shim/es6-shim.d.ts
+++ b/es6-shim/es6-shim.d.ts
@@ -12,7 +12,7 @@ interface IteratorResult<T> {
 
 interface IterableShim<T> {
     /**
-      * Shim for an ES6 iterable. Not intended for direct use by user code. 
+      * Shim for an ES6 iterable. Not intended for direct use by user code.
       */
     "_es6-shim iterator_"(): Iterator<T>;
 }
@@ -39,7 +39,7 @@ interface StringConstructor {
 
     /**
       * String.raw is intended for use as a tag function of a Tagged Template String. When called
-      * as such the first argument will be a well formed template call site object and the rest 
+      * as such the first argument will be a well formed template call site object and the rest
       * parameter will contain the substitution values.
       * @param template A well-formed template string call site representation.
       * @param substitutions A set of substitution values.
@@ -49,40 +49,40 @@ interface StringConstructor {
 
 interface String {
     /**
-      * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point 
-      * value of the UTF-16 encoded code point starting at the string element at position pos in 
-      * the String resulting from converting this object to a String. 
-      * If there is no element at that position, the result is undefined. 
+      * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point
+      * value of the UTF-16 encoded code point starting at the string element at position pos in
+      * the String resulting from converting this object to a String.
+      * If there is no element at that position, the result is undefined.
       * If a valid UTF-16 surrogate pair does not begin at pos, the result is the code unit at pos.
       */
     codePointAt(pos: number): number;
 
     /**
-      * Returns true if searchString appears as a substring of the result of converting this 
-      * object to a String, at one or more positions that are 
+      * Returns true if searchString appears as a substring of the result of converting this
+      * object to a String, at one or more positions that are
       * greater than or equal to position; otherwise, returns false.
-      * @param searchString search string 
+      * @param searchString search string
       * @param position If position is undefined, 0 is assumed, so as to search all of the String.
       */
     includes(searchString: string, position?: number): boolean;
 
     /**
-      * Returns true if the sequence of elements of searchString converted to a String is the 
-      * same as the corresponding elements of this object (converted to a String) starting at 
+      * Returns true if the sequence of elements of searchString converted to a String is the
+      * same as the corresponding elements of this object (converted to a String) starting at
       * endPosition – length(this). Otherwise returns false.
       */
     endsWith(searchString: string, endPosition?: number): boolean;
 
     /**
-      * Returns a String value that is made from count copies appended together. If count is 0, 
+      * Returns a String value that is made from count copies appended together. If count is 0,
       * T is the empty String is returned.
       * @param count number of copies to append
       */
     repeat(count: number): string;
 
     /**
-      * Returns true if the sequence of elements of searchString converted to a String is the 
-      * same as the corresponding elements of this object (converted to a String) starting at 
+      * Returns true if the sequence of elements of searchString converted to a String is the
+      * same as the corresponding elements of this object (converted to a String) starting at
       * position. Otherwise returns false.
       */
     startsWith(searchString: string, position?: number): boolean;
@@ -130,19 +130,14 @@ interface String {
     sub(): string;
 
     /** Returns a <sup> HTML element */
-    sup(): string;    
+    sup(): string;
 
     /**
-      * Shim for an ES6 iterable. Not intended for direct use by user code. 
+      * Shim for an ES6 iterable. Not intended for direct use by user code.
       */
     "_es6-shim iterator_"(): IterableIteratorShim<string>;
 }
 
-interface ArrayLike<T> {
-    length: number;
-    [n: number]: T;
-}
-
 interface ArrayConstructor {
     /**
       * Creates an array from an array-like object.
@@ -180,24 +175,24 @@ interface ArrayConstructor {
 }
 
 interface Array<T> {
-    /** 
-      * Returns the value of the first element in the array where predicate is true, and undefined 
+    /**
+      * Returns the value of the first element in the array where predicate is true, and undefined
       * otherwise.
-      * @param predicate find calls predicate once for each element of the array, in ascending 
-      * order, until it finds one where predicate returns true. If such an element is found, find 
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
       * immediately returns that element value. Otherwise, find returns undefined.
-      * @param thisArg If provided, it will be used as the this value for each invocation of 
+      * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
     find(predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): T;
 
-    /** 
-      * Returns the index of the first element in the array where predicate is true, and undefined 
+    /**
+      * Returns the index of the first element in the array where predicate is true, and undefined
       * otherwise.
-      * @param predicate find calls predicate once for each element of the array, in ascending 
-      * order, until it finds one where predicate returns true. If such an element is found, find 
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
       * immediately returns that element value. Otherwise, find returns undefined.
-      * @param thisArg If provided, it will be used as the this value for each invocation of 
+      * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
     findIndex(predicate: (value: T) => boolean, thisArg?: any): number;
@@ -205,41 +200,41 @@ interface Array<T> {
     /**
       * Returns the this object after filling the section identified by start and end with value
       * @param value value to fill array section with
-      * @param start index to start filling the array at. If start is negative, it is treated as 
-      * length+start where length is the length of the array. 
-      * @param end index to stop filling the array at. If end is negative, it is treated as 
+      * @param start index to start filling the array at. If start is negative, it is treated as
+      * length+start where length is the length of the array.
+      * @param end index to stop filling the array at. If end is negative, it is treated as
       * length+end.
       */
     fill(value: T, start?: number, end?: number): T[];
 
-    /** 
+    /**
       * Returns the this object after copying a section of the array identified by start and end
       * to the same array starting at position target
-      * @param target If target is negative, it is treated as length+target where length is the 
-      * length of the array. 
-      * @param start If start is negative, it is treated as length+start. If end is negative, it 
+      * @param target If target is negative, it is treated as length+target where length is the
+      * length of the array.
+      * @param start If start is negative, it is treated as length+start. If end is negative, it
       * is treated as length+end.
-      * @param end If not specified, length of the this object is used as its default value. 
+      * @param end If not specified, length of the this object is used as its default value.
       */
     copyWithin(target: number, start: number, end?: number): T[];
 
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIteratorShim<[number, T]>;
 
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIteratorShim<number>;
 
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIteratorShim<T>;
 
     /**
-      * Shim for an ES6 iterable. Not intended for direct use by user code. 
+      * Shim for an ES6 iterable. Not intended for direct use by user code.
       */
     "_es6-shim iterator_"(): IterableIteratorShim<T>;
 }
@@ -247,14 +242,14 @@ interface Array<T> {
 interface NumberConstructor {
     /**
       * The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1
-      * that is representable as a Number value, which is approximately: 
+      * that is representable as a Number value, which is approximately:
       * 2.2204460492503130808472633361816 x 10‍−‍16.
       */
     EPSILON: number;
 
     /**
       * Returns true if passed value is finite.
-      * Unlike the global isFininte, Number.isFinite doesn't forcibly convert the parameter to a 
+      * Unlike the global isFininte, Number.isFinite doesn't forcibly convert the parameter to a
       * number. Only finite values of the type number, result in true.
       * @param number A numeric value.
       */
@@ -267,7 +262,7 @@ interface NumberConstructor {
     isInteger(number: number): boolean;
 
     /**
-      * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a 
+      * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a
       * number). Unlike the global isNaN(), Number.isNaN() doesn't forcefully convert the parameter
       * to a number. Only values of the type number, that are also NaN, result in true.
       * @param number A numeric value.
@@ -280,30 +275,30 @@ interface NumberConstructor {
       */
     isSafeInteger(number: number): boolean;
 
-    /** 
-      * The value of the largest integer n such that n and n + 1 are both exactly representable as 
-      * a Number value. 
+    /**
+      * The value of the largest integer n such that n and n + 1 are both exactly representable as
+      * a Number value.
       * The value of Number.MIN_SAFE_INTEGER is 9007199254740991 2^53 − 1.
       */
     MAX_SAFE_INTEGER: number;
 
-    /** 
-      * The value of the smallest integer n such that n and n − 1 are both exactly representable as 
-      * a Number value. 
+    /**
+      * The value of the smallest integer n such that n and n − 1 are both exactly representable as
+      * a Number value.
       * The value of Number.MIN_SAFE_INTEGER is −9007199254740991 (−(2^53 − 1)).
       */
     MIN_SAFE_INTEGER: number;
 
     /**
-      * Converts a string to a floating-point number. 
-      * @param string A string that contains a floating-point number. 
+      * Converts a string to a floating-point number.
+      * @param string A string that contains a floating-point number.
       */
     parseFloat(string: string): number;
 
     /**
       * Converts A string to an integer.
       * @param s A string to convert into a number.
-      * @param radix A value between 2 and 36 that specifies the base of the number in numString. 
+      * @param radix A value between 2 and 36 that specifies the base of the number in numString.
       * If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal.
       * All other strings are considered decimal.
       */
@@ -312,7 +307,7 @@ interface NumberConstructor {
 
 interface ObjectConstructor {
     /**
-      * Copy the values of all of the enumerable own properties from one or more source objects to a 
+      * Copy the values of all of the enumerable own properties from one or more source objects to a
       * target object. Returns the target object.
       * @param target The target object to copy to.
       * @param sources One or more source objects to copy properties from.
@@ -390,7 +385,7 @@ interface Math {
     log1p(x: number): number;
 
     /**
-      * Returns the result of (e^x - 1) of x (e raised to the power of x, where e is the base of 
+      * Returns the result of (e^x - 1) of x (e raised to the power of x, where e is the base of
       * the natural logarithms).
       * @param x A numeric expression.
       */
@@ -497,21 +492,21 @@ interface Promise<T> {
 }
 
 interface PromiseConstructor {
-    /** 
-      * A reference to the prototype. 
+    /**
+      * A reference to the prototype.
       */
     prototype: Promise<any>;
 
     /**
      * Creates a new Promise.
-     * @param executor A callback used to initialize the promise. This callback is passed two arguments: 
-     * a resolve callback used resolve the promise with a value or the result of another promise, 
+     * @param executor A callback used to initialize the promise. This callback is passed two arguments:
+     * a resolve callback used resolve the promise with a value or the result of another promise,
      * and a reject callback used to reject the promise with a provided reason or error.
      */
     new <T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
 
     /**
-     * Creates a Promise that is resolved with an array of results when all of the provided Promises 
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
      * resolve, or rejected when any Promise is rejected.
      * @param values An array of Promises.
      * @returns A new Promise.
@@ -519,7 +514,7 @@ interface PromiseConstructor {
     all<T>(values: IterableShim<T | PromiseLike<T>>): Promise<T[]>;
 
     /**
-     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved 
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
      * or rejected.
      * @param values An array of Promises.
      * @returns A new Promise.
@@ -670,4 +665,4 @@ declare module "es6-shim" {
         function set(target: any, propertyKey: PropertyKey, value: any, receiver?: any): boolean;
         function setPrototypeOf(target: any, proto: any): boolean;
     }
-}
\ No newline at end of file
+}
diff --git a/express/express.d.ts b/express/express.d.ts
index b54f6e2fb7..973d45fc72 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -106,6 +106,8 @@ declare module "express" {
             use(handler: ErrorRequestHandler): T;
             use(path: string, ...handler: RequestHandler[]): T;
             use(path: string, handler: ErrorRequestHandler): T;
+            use(path: string[], ...handler: RequestHandler[]): T;
+            use(path: string[], handler: ErrorRequestHandler[]): T;
         }
 
         export function Router(options?: any): Router;
@@ -410,6 +412,10 @@ declare module "express" {
             originalUrl: string;
 
             url: string;
+            
+            baseUrl: string;
+            
+            app: Application;
         }
 
         interface MediaType {
diff --git a/faker/faker-tests.ts b/faker/faker-tests.ts
new file mode 100644
index 0000000000..94cb3b30a2
--- /dev/null
+++ b/faker/faker-tests.ts
@@ -0,0 +1,156 @@
+/// <reference path="faker.d.ts" />
+
+import faker = require('faker');
+
+faker.address.zipCode();
+faker.address.zipCode('###');
+faker.address.city();
+faker.address.city(0);
+faker.address.cityPrefix();
+faker.address.citySuffix();
+faker.address.streetName();
+faker.address.streetAddress();
+faker.address.streetAddress(false);;
+faker.address.streetSuffix();
+faker.address.streetPrefix();
+faker.address.secondaryAddress();
+faker.address.county();
+faker.address.country();
+faker.address.countryCode();
+faker.address.state();
+faker.address.state(false);
+faker.address.stateAbbr();
+faker.address.latitude();
+faker.address.longitude();
+
+faker.commerce.color();
+faker.commerce.department();
+faker.commerce.productName();
+faker.commerce.price();
+faker.commerce.price(0, 0, 0, '#');
+faker.commerce.productAdjective();
+faker.commerce.productMaterial();
+faker.commerce.product();
+
+faker.company.suffixes();
+faker.company.companyName();
+faker.company.companyName(0);
+faker.company.companySuffix();
+faker.company.catchPhrase();
+faker.company.bs();
+faker.company.catchPhraseAdjective();
+faker.company.catchPhraseDescriptor();
+faker.company.catchPhraseNoun();
+faker.company.bsAdjective();
+faker.company.bsBuzz();
+faker.company.bsNoun();
+
+faker.date.past();
+faker.date.future();
+faker.date.between('foo', 'bar');
+faker.date.between(new Date(), new Date());
+faker.date.recent();
+faker.date.recent(100);
+faker.date.month();
+faker.date.month({
+	abbr: true,
+	context: true
+});
+faker.date.weekday();
+faker.date.weekday({
+	abbr: true,
+	context: true
+});
+
+faker.finance.account();
+faker.finance.account(0);
+faker.finance.accountName();
+faker.finance.mask();
+faker.finance.mask(0, false, false);
+faker.finance.amount();
+faker.finance.amount(0, 0, 0, '#');
+faker.finance.transactionType();
+faker.finance.currencyCode();
+faker.finance.currencyName();
+faker.finance.currencySymbol();
+
+faker.hacker.abbreviation();
+faker.hacker.adjective();
+faker.hacker.noun();
+faker.hacker.verb();
+faker.hacker.ingverb();
+faker.hacker.phrase();
+
+faker.helpers.randomize();
+faker.helpers.randomize([1,2,3,4]);
+faker.helpers.randomize(['foo', 'bar', 'quux']);
+faker.helpers.slugify('foo bar quux');
+faker.helpers.replaceSymbolWithNumber('foo# bar#');
+faker.helpers.replaceSymbols('foo# bar? quux#');
+faker.helpers.shuffle(['foo', 'bar', 'quux']);
+faker.helpers.mustache('{{foo}}{{bar}}', {foo: 'x', bar: 'y'});
+faker.helpers.createCard();
+faker.helpers.contextualCard();
+faker.helpers.userCard();
+
+faker.internet.avatar();
+faker.internet.email();
+faker.internet.email('foo', 'bar', 'quux');
+faker.internet.protocol();
+faker.internet.url();
+faker.internet.domainName();
+faker.internet.domainSuffix();
+faker.internet.domainWord();
+faker.internet.ip();
+faker.internet.userAgent();
+faker.internet.color();
+faker.internet.color(0, 0, 0);
+faker.internet.mac();
+faker.internet.password();
+faker.internet.password(0, false, '#', 'foo');
+
+faker.lorem.words();
+faker.lorem.words(0);
+faker.lorem.sentence();
+faker.lorem.sentence(0, 0);
+faker.lorem.sentences();
+faker.lorem.sentences(0);
+faker.lorem.paragraph();
+faker.lorem.paragraph(0);
+faker.lorem.paragraphs();
+faker.lorem.paragraphs(0, '');
+
+faker.name.firstName();
+faker.name.firstName(0);
+faker.name.lastName();
+faker.name.lastName(0);
+faker.name.findName();
+faker.name.findName('', '', 0);
+faker.name.jobTitle();
+faker.name.prefix();
+faker.name.suffix();
+faker.name.title();
+faker.name.jobDescriptor();
+faker.name.jobArea();
+faker.name.jobType();
+
+faker.phone.phoneNumber();
+faker.phone.phoneNumber('#');
+faker.phone.phoneNumberFormat();
+// https://github.com/Marak/faker.js/blob/master/lib/phone_number.js#L9-L13
+faker.phone.phoneNumberFormat(0);
+faker.phone.phoneFormats();
+
+faker.random.number();
+faker.random.number(0);
+faker.random.number({
+	min: 0,
+	max: 0,
+	precision: 0
+});
+faker.random.arrayElement();
+faker.random.arrayElement(['foo', 'bar', 'quux'])
+faker.random.objectElement();
+faker.random.objectElement({foo: 'bar', field: 'foo'});
+faker.random.uuid();
+faker.random.boolean();
\ No newline at end of file
diff --git a/faker/faker.d.ts b/faker/faker.d.ts
new file mode 100644
index 0000000000..b337c093e2
--- /dev/null
+++ b/faker/faker.d.ts
@@ -0,0 +1,260 @@
+// Type definitions for faker
+// Project: http://marak.com/faker.js/
+// Definitions by: Bas Pennings <https://github.com/basp/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module Faker {
+	interface Post {
+		words: string;
+		sentence: string;
+		sentences: string;
+		paragraph: string;
+	}
+	
+	interface Address {
+		street: string;
+		suite: string;
+		city: string;
+		zipcode: string;
+		geo: {
+			lat: string;
+			lon: string
+		}
+	}
+	
+	interface Transaction {
+		amount: number,
+		date: Date,
+		business: string,
+		name: string,
+		type: string,
+		account: string
+	}
+	
+	interface Company {
+		name: string;
+		catchPhrase: string;
+		bs: string;
+	}
+	
+	interface Card {
+		name: string;
+		username: string;
+		email: string;
+		address: Address;
+		phone: string,
+		website: string,
+		company: Company;
+		posts: Post[],
+		accountHistory: Transaction[]
+	}
+	
+	interface ContextualCard {
+		name: string;
+		username: string;
+		avatar: string;
+		email: string;
+		dob: Date;
+		phone: string;
+		address: Address;
+		website: string;
+		company: Company;
+	}
+	
+	interface UserCard {
+		name: string;
+		username: string;
+		email: string;
+		address: Address;
+		phone: string;
+		website: string;
+		company: Company;
+	}
+	
+	interface AddressGenerators {
+		zipCode(format?: string): string;
+		city(format?: number): string;
+		cityPrefix(): string;
+		citySuffix(): string;
+		streetName(): string;
+		streetAddress(useFullAddress?: boolean): string;
+		streetSuffix(): string;
+		streetPrefix(): string;
+		secondaryAddress(): string;
+		county(): string;
+		country(): string;
+		countryCode(): string;
+		state(useAbbr?: boolean): string;
+		stateAbbr(): string;
+		latitude(): string;
+		longitude(): string;
+	}
+	
+	interface CommerceGenerators {
+		color(): string;
+		department(): string;
+		productName(): string;
+		price(min?: number, max?: number, dec?: number, symbol?: string): string;
+		productAdjective(): string;
+		productMaterial(): string;
+		product(): string;
+	}
+	
+	interface CompanyGenerators {
+		suffixes(): string[];
+		companyName(format?: number): string;
+		companySuffix(): string;
+		catchPhrase(): string;
+		bs(): string;
+		catchPhraseAdjective(): string;
+		catchPhraseDescriptor(): string;
+		catchPhraseNoun(): string;
+		bsAdjective(): string;
+		bsBuzz(): string;
+		bsNoun(): string;
+	}
+	
+	interface DateGenerators {
+		past(years?: number, refDate?: Date|string): Date;
+		future(years?: number, refDate?: Date|string): Date;
+		between(from: Date|string, to: Date|string): Date; 
+		recent(days?: number): Date;
+		month(options?: {
+			abbr?: boolean, 
+			context?: boolean
+		}): string;
+		weekday(options?: {
+			abbr?: boolean,
+			context?: boolean
+		}): string;
+	}
+	
+	interface FinanceGenerators {
+		account(length?: number): string;
+		accountName(): string;
+		mask(length?: number, parens?: boolean, elipsis?: boolean): string;
+		amount(min?: number, max?: number, dec?: number, symbol?: string): string;
+		transactionType(): string;
+		currencyCode(): string;
+		currencyName(): string;
+		currencySymbol(): string;
+	}
+	
+	interface HackerGenerators {
+		abbreviation(): string;
+		adjective(): string;
+		noun(): string;
+		verb(): string;
+		ingverb(): string;
+		phrase(): string;
+	}
+	
+	interface Helpers {
+		randomize<T>(array?: Array<T>): T;
+		slugify(str: string): string;
+		replaceSymbolWithNumber(s: string, symbol?: string): string;
+		replaceSymbols(str: string): string;
+		shuffle<T>(array: Array<T>): Array<T>;
+		mustache(str: string, data: Object): string;
+		createCard(): Card;
+		contextualCard(): Card;
+		userCard(): UserCard;
+		createTransaction(): Transaction;
+	}
+	
+	interface ImageGenerators {
+		image(): string;
+		avator(): string;
+		imageUrl(width?: number, height?: number, category?: string): string;
+		abstract(width?: number, height?: number): string;
+		animals(width?: number, height?: number): string;
+		business(width?: number, height?: number): string;
+		cats(width?: number, height?: number): string;
+		city(width?: number, height?: number): string;
+		food(width?: number, height?: number): string;
+		nightlife(width?: number, height?: number): string;
+		fashion(width?: number, height?: number): string;
+		people(width?: number, height?: number): string;
+		nature(width?: number, height?: number): string;
+		sports(width?: number, height?: number): string;
+		technics(width?: number, height?: number): string;
+		transport(width?: number, height?: number): string;
+	}
+	
+	interface InternetGenerators {
+		avatar(): string;
+		email(firstName?: string, lastName?: string, provider?: string): string;
+		userName(firstName?: string, lastName?: string): string;
+		protocol(): string;
+		url(): string;
+		domainName(): string;
+		domainSuffix(): string;
+		domainWord(): string;
+		ip(): string;
+		userAgent(): string;
+		color(baseRed255?: number, baseGreen255?: number, baseBlue255?: number): string;
+		mac(): string;
+		password(len?: number, memorable?: boolean, pattern?: string, prefix?: string): string;
+	}
+	
+	interface LoremGenerators {
+		words(num?: number): string[];
+		sentence(wordCount?: number, range?: number): string;
+		sentences(sentenceCount?: number): string;
+		paragraph(sentenceCount?: number): string;
+		paragraphs(paragraphCount?: number, separator?: string): string;
+	}
+	
+	interface NameGenerators {
+		firstName(gender?: number): string;
+		lastName(gender?: number): string;
+		findName(firstName?: string, lastName?: string, gender?: number): string;
+		jobTitle(): string;
+		prefix(): string;
+		suffix(): string;
+		title(): string;
+		jobDescriptor(): string;
+		jobArea(): string;
+		jobType(): string;
+	}
+	
+	interface PhoneGenerators {
+		phoneNumber(format?: string): string;
+		// https://github.com/Marak/faker.js/blob/master/lib/phone_number.js#L9-L13
+		phoneNumberFormat(phoneFormatsArrayIndex?: number): string;
+		phoneFormats(): string;
+	}
+	
+	interface RandomGenerators {
+		number(max: number): number;
+		number(options?: {
+			min?: number,
+			max?: number,
+			precision?: number
+		}): number;
+		arrayElement<T>(array?: Array<T>): T;
+		objectElement(object?: Object, field?: string): any;
+		uuid(): string;
+		boolean(): boolean;
+	}	
+}
+
+declare module "faker" {
+	var faker: {
+		address: Faker.AddressGenerators;
+		commerce: Faker.CommerceGenerators;
+		company: Faker.CompanyGenerators;
+		date: Faker.DateGenerators;
+		finance: Faker.FinanceGenerators;
+		hacker: Faker.HackerGenerators;
+		helpers: Faker.Helpers;
+		image: Faker.ImageGenerators;
+		internet: Faker.InternetGenerators;
+		lorem: Faker.LoremGenerators;
+		name: Faker.NameGenerators;
+		phone: Faker.PhoneGenerators;
+		random: Faker.RandomGenerators;
+	}
+	
+	export = faker;
+}
diff --git a/fhir/fhir-tests.ts b/fhir/fhir-tests.disabled.ts
similarity index 100%
rename from fhir/fhir-tests.ts
rename to fhir/fhir-tests.disabled.ts
diff --git a/fontoxml/fontoxml-tests.ts b/fontoxml/fontoxml-tests.ts
new file mode 100644
index 0000000000..7821806cf2
--- /dev/null
+++ b/fontoxml/fontoxml-tests.ts
@@ -0,0 +1,28 @@
+///<reference path='fontoxml.d.ts' />
+
+var workflow:com.fontoxml.IWorkflowInfo = {
+	id:"1",
+	displayName:"workflow"
+}
+
+var user:com.fontoxml.IUserInfo = {
+	id: "123",
+	displayName: "test",
+	roleId: "editor"
+}
+
+var init:com.fontoxml.IInvocator = {
+	documentIds: ["11-22-33","44-55-66"],
+	cmsBaseUrl: "/test/",
+	editSessionToken: "aa-bb-cc-dd-ee",
+	user: user,
+	workflow: workflow,
+	autosave: false,
+	heartbeat: 300	
+}
+
+var simpleinit:com.fontoxml.IInvocator = {
+	documentIds: ["11-22-33","44-55-66"],
+	cmsBaseUrl: "/test/",
+	editSessionToken: "aa-bb-cc-dd-ee"
+}
\ No newline at end of file
diff --git a/fontoxml/fontoxml.d.ts b/fontoxml/fontoxml.d.ts
new file mode 100644
index 0000000000..4d621c234c
--- /dev/null
+++ b/fontoxml/fontoxml.d.ts
@@ -0,0 +1,40 @@
+// Type definitions for FontoXML
+// Project: http://www.fontoxml.com/
+// Definitions by: Roland Zwaga <https://github.com/rolandzwaga>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module com.fontoxml
+{
+	//This is a description of how to invoke the FontoXML editor, and instruct it to load (a) document(s).
+	//Please keep in mind that the URL length may be limited in certain browsers, so a safe limit of 2000 characters
+	//for the whole URL including query parameters should be used.
+	export interface IInvocator
+	{
+		//The document id's of the documents to load from the CMS.
+		documentIds: string[];
+		//The base URL where the CMS endpoints are exposed.
+	        cmsBaseUrl: string;
+	        //The edit session token to use for accessing the CMS endpoints.
+                editSessionToken: string;
+                //User information.
+		user?: IUserInfo;
+		//Workflow information.
+		workflow?: IWorkflowInfo;
+		//Allow/disallow auto-save functionality.
+		autosave?: boolean;
+		//If set to a positive integer, enable the Heartbeat API to send every x seconds.
+		heartbeat?: number;
+	}
+	
+	export interface IWorkflowInfo
+	{
+		id:string;
+		displayName:string;
+	}
+
+	export interface IUserInfo extends IWorkflowInfo
+	{
+		roleId:string;
+	}
+	
+}
\ No newline at end of file
diff --git a/github-electron/github-electron-main-tests.ts b/github-electron/github-electron-main-tests.ts
index a849295b67..4e359e257b 100644
--- a/github-electron/github-electron-main-tests.ts
+++ b/github-electron/github-electron-main-tests.ts
@@ -43,6 +43,8 @@ app.on('ready', () => {
 
 	// and load the index.html of the app.
 	mainWindow.loadUrl(`file://${__dirname}/index.html`);
+	mainWindow.loadUrl('file://foo/bar', {userAgent: 'cool-agent', httpReferrer: 'greateRefferer'});
+	mainWindow.webContents.loadUrl('file://foo/bar', {userAgent: 'cool-agent', httpReferrer: 'greateRefferer'});
 
 	mainWindow.openDevTools()
 	var opened: boolean = mainWindow.isDevToolsOpened()
@@ -409,6 +411,7 @@ app.on('ready', () => {
 	]);
 	appIcon.setToolTip('This is my application.');
 	appIcon.setContextMenu(contextMenu);
+	appIcon.setImage('/path/to/new/icon');
 });
 
 // clipboard
diff --git a/github-electron/github-electron.d.ts b/github-electron/github-electron.d.ts
index fb09805202..92fff65f71 100644
--- a/github-electron/github-electron.d.ts
+++ b/github-electron/github-electron.d.ts
@@ -400,7 +400,10 @@ declare module GitHubElectron {
 		/**
 		 * Same with webContents.loadUrl(url).
 		 */
-		loadUrl(url: string): void;
+		loadUrl(url: string, options?: {
+			httpReferrer?: string;
+			userAgent?: string;
+		}): void;
 		/**
 		 * Same with webContents.reload.
 		 */
@@ -537,7 +540,10 @@ declare module GitHubElectron {
 		 * Loads the url in the window.
 		 * @param url Must contain the protocol prefix (e.g., the http:// or file://).
 		 */
-		loadUrl(url: string): void;
+		loadUrl(url: string, options?: {
+			httpReferrer?: string;
+			userAgent?: string;
+		}): void;
 		/**
 		 * @returns The URL of current web page.
 		 */
@@ -1212,7 +1218,7 @@ declare module GitHubElectron {
 		/**
 		 * Sets the image associated with this tray icon.
 		 */
-		setImage(image: NativeImage): void;
+		setImage(image: NativeImage|string): void;
 		/**
 		 * Sets the image associated with this tray icon when pressed.
 		 */
diff --git a/glidejs/glidejs.d.ts b/glidejs/glidejs.d.ts
index bbf35f7e8a..238f712060 100644
--- a/glidejs/glidejs.d.ts
+++ b/glidejs/glidejs.d.ts
@@ -32,7 +32,7 @@ declare module JQueryGlide {
         /**
          * Default: 500
          * Animation time in ms
-         * @type {Int}
+         * @type {number}
          */
         animationDuration?: number;
         /**
diff --git a/gm/gm.d.ts b/gm/gm.d.ts
index 2373300fee..f1fb40661b 100644
--- a/gm/gm.d.ts
+++ b/gm/gm.d.ts
@@ -13,6 +13,7 @@ declare module "gm" {
 	module m {
 		export interface ClassOptions {
 			imageMagick?: boolean;
+			nativeAutoOrient?: boolean;
 		}
 
 		export interface CompareCallback {
diff --git a/gulp-cheerio/gulp-cheerio-tests.ts b/gulp-cheerio/gulp-cheerio-tests.ts
new file mode 100644
index 0000000000..8a32c57d21
--- /dev/null
+++ b/gulp-cheerio/gulp-cheerio-tests.ts
@@ -0,0 +1,93 @@
+/// <reference path="gulp-cheerio.d.ts" />
+/// <reference path="../vinyl/vinyl.d.ts" />
+/// <reference path="../gulp/gulp.d.ts" />
+/// <reference path="../cheerio/cheerio.d.ts" />
+
+import cheerio = require('gulp-cheerio');
+import gulp = require('gulp');
+import Vinyl = require('vinyl');
+
+//
+// There are two ways to use gulp-cheerio: synchronous and asynchronous. See the following usage examples:
+//
+
+gulp.task('sync', function () {
+    return gulp
+        .src(['src/*.html'])
+        .pipe(cheerio(function ($: CheerioStatic, file: Vinyl) {
+            // Each file will be run through cheerio and each corresponding `$` will be passed here.
+            // `file` is the gulp file object
+            // Make all h1 tags uppercase
+            $('h1').each(function () {
+                var h1 = $(this);
+                h1.text(h1.text().toUpperCase());
+            });
+        }))
+        .pipe(gulp.dest('dist/'));
+});
+gulp.task('async', function () {
+    return gulp
+        .src(['src/*.html'])
+        .pipe(cheerio(function ($: CheerioStatic, file: Vinyl, done: Function) {
+            // The only difference here is the inclusion of a `done` parameter.
+            // Call `done` when everything is finished. `done` accepts an error if applicable.
+            done();
+        }))
+        .pipe(gulp.dest('dist/'));
+});
+//TODO
+
+
+//
+// Additional options can be passed by passing an object as the main argument with your function as the run option:
+//
+
+
+gulp.task('sync', function () {
+    return gulp
+        .src(['src/*.html'])
+        .pipe(cheerio({
+            run: function ($: CheerioStatic, file: Vinyl) {
+                // Each file will be run through cheerio and each corresponding `$` will be passed here.
+                // `file` is the gulp file object
+                // Make all h1 tags uppercase
+                $('h1').each(function () {
+                    var h1 = $(this);
+                    h1.text(h1.text().toUpperCase());
+                });
+            }
+        }))
+        .pipe(gulp.dest('dist/'));
+});
+
+gulp.task('async', function () {
+    return gulp
+        .src(['src/*.html'])
+        .pipe(cheerio({
+            run: function ($: CheerioStatic, file: Vinyl, done: Function) {
+                // The only difference here is the inclusion of a `done` parameter.
+                // Call `done` when everything is finished. `done` accepts an error if applicable.
+                done();
+            }
+        }))
+        .pipe(gulp.dest('dist/'));
+});
+
+cheerio({
+    run: function () {},
+    parserOptions: {
+        // Options here
+    }
+});
+
+
+cheerio({
+    run: function () {},
+    parserOptions: {
+        xmlMode: true
+    }
+});
+
+cheerio({
+    cheerio: require('../cheerio/cheerio.d.ts') as CheerioStatic // special version of `cheerio`
+});
diff --git a/gulp-cheerio/gulp-cheerio.d.ts b/gulp-cheerio/gulp-cheerio.d.ts
new file mode 100644
index 0000000000..3a558ae5b4
--- /dev/null
+++ b/gulp-cheerio/gulp-cheerio.d.ts
@@ -0,0 +1,34 @@
+// Type definitions for gulp-cheerio
+// Project: https://github.com/KenPowers/gulp-cheerio
+// Definitions by: Qubo <https://github.com/tkQubo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../cheerio/cheerio.d.ts" />
+/// <reference path="../node/node.d.ts" />
+/// <reference path="../vinyl/vinyl.d.ts"/>
+
+declare module "gulp-cheerio" {
+    import Vinyl = require('vinyl');
+
+    namespace cheerio {
+        interface Cheerio {
+            (callback: Callback): NodeJS.ReadWriteStream;
+            (option: Option): NodeJS.ReadWriteStream;
+        }
+
+        interface Callback {
+            ($: CheerioStatic, file: Vinyl, done?: Function): any;
+        }
+
+        interface Option {
+            run?: Callback;
+            parserOptions?: CheerioOptionsInterface;
+            cheerio?: CheerioStatic;
+        }
+    }
+
+    var cheerio: cheerio.Cheerio;
+
+    export = cheerio;
+}
+
diff --git a/gulp-coffeelint/gulp-coffeelint-tests.ts b/gulp-coffeelint/gulp-coffeelint-tests.ts
new file mode 100644
index 0000000000..0022f9888f
--- /dev/null
+++ b/gulp-coffeelint/gulp-coffeelint-tests.ts
@@ -0,0 +1,57 @@
+/// <reference path="gulp-coffeelint.d.ts" />
+/// <reference path="../gulp/gulp.d.ts" />
+
+import coffeelint = require('gulp-coffeelint');
+import gulp = require('gulp');
+
+
+gulp.task('lint', function () {
+    gulp.src('./src/*.coffee')
+        .pipe(coffeelint())
+        .pipe(coffeelint.reporter())
+});
+
+gulp.src('./src/*.coffee')
+    .pipe(coffeelint())
+    .pipe(coffeelint.reporter('csv'));
+
+
+declare var stylish: Function;
+
+gulp.src('./src/*.coffee')
+    .pipe(coffeelint())
+    .pipe(coffeelint.reporter(stylish));
+
+gulp.src('./src/*.coffee')
+    .pipe(coffeelint())
+    .pipe(coffeelint.reporter('coffelint-stylish'));
+
+gulp.src('./src/*.coffee')
+    .pipe(coffeelint())
+    .pipe(coffeelint.reporter('coffeelint-stylish'))
+    .pipe(coffeelint.reporter('fail'));
+
+var myReporter = (function() {
+    function MyReporter(errorReport: any) {
+        this.errorReport = errorReport;
+    }
+
+    MyReporter.prototype.publish = function() {
+        var hasError = this.errorReport.hasError();
+        if (hasError) {
+            return console.log('Oh no!');
+        }
+        return console.log('Oh yeah!');
+    };
+
+    return MyReporter;
+})();
+
+gulp.task('lint', function() {
+    return gulp.src('./src/*.coffee')
+        .pipe(coffeelint())
+        .pipe(coffeelint.reporter(myReporter));
+});
+
+
+
diff --git a/gulp-coffeelint/gulp-coffeelint.d.ts b/gulp-coffeelint/gulp-coffeelint.d.ts
new file mode 100644
index 0000000000..2b686574c9
--- /dev/null
+++ b/gulp-coffeelint/gulp-coffeelint.d.ts
@@ -0,0 +1,26 @@
+// Type definitions for gulp-coffeelint
+// Project: https://github.com/janraasch/gulp-coffeelint
+// Definitions by: Qubo <https://github.com/tkQubo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "gulp-coffeelint" {
+    namespace coffeelint {
+        interface Coffeelint {
+            /**
+             * @param optFile Absolute path of a json file containing options for coffeelint.
+             * @param opt Options you wish to send to coffeelint. If optFile is given, this will be ignored.
+             * @param literate Are we dealing with Literate CoffeeScript?
+             * @param rules Add custom rules to coffeelint.
+             */
+            (optFile?: string, opt?: any, literate?: boolean, rules?: Function[]): NodeJS.ReadWriteStream;
+            reporter(reporter?: string|Function): NodeJS.ReadWriteStream;
+        }
+    }
+
+    var coffeelint: coffeelint.Coffeelint;
+
+    export = coffeelint;
+}
+
diff --git a/gulp-concat/gulp-concat-tests.ts b/gulp-concat/gulp-concat-tests.ts
index 68f6e529d8..f8ef7373da 100644
--- a/gulp-concat/gulp-concat-tests.ts
+++ b/gulp-concat/gulp-concat-tests.ts
@@ -2,7 +2,7 @@
 /// <reference path="../gulp/gulp.d.ts" />
 
 import gulp = require("gulp");
-import concat = require("gulp-concat");
+import * as concat from "gulp-concat";
 
 gulp.task("concat:simple", () => {
     gulp.src(["file*.txt"])
diff --git a/gulp-concat/gulp-concat.d.ts b/gulp-concat/gulp-concat.d.ts
index cad21c303d..b622121568 100644
--- a/gulp-concat/gulp-concat.d.ts
+++ b/gulp-concat/gulp-concat.d.ts
@@ -35,8 +35,11 @@ declare module "gulp-concat" {
         contents?: NodeJS.ReadableStream | Buffer;
     }
 
-    function concat(filename: string, options?: IOptions): NodeJS.ReadWriteStream;
-    function concat(options: IVinylOptions): NodeJS.ReadWriteStream;
+    interface IConcat {
+        (filename: string, options?: IOptions): NodeJS.ReadWriteStream;
+        (options: IVinylOptions): NodeJS.ReadWriteStream;
+    }
 
-    export = concat;
+    var _tmp: IConcat;
+    export = _tmp;
 }
diff --git a/gulp-gzip/gulp-gzip-tests.ts b/gulp-gzip/gulp-gzip-tests.ts
new file mode 100644
index 0000000000..295e98b7fe
--- /dev/null
+++ b/gulp-gzip/gulp-gzip-tests.ts
@@ -0,0 +1,27 @@
+/// <reference path="gulp-gzip.d.ts" />
+/// <reference path="../gulp/gulp.d.ts" />
+
+import gulp = require('gulp');
+import gzip = require('gulp-gzip');
+
+gzip({ append: true });
+
+gzip({ extension: 'zip' }); // note that the `.` should not be included in the extension
+
+gzip({ preExtension: 'gz' }); // note that the `.` should not be included in the extension
+
+gzip({ threshold: '1kb' });
+
+gzip({ threshold: 1024 });
+
+gzip({ threshold: true });
+
+gzip({ gzipOptions: { level: 9 } });
+
+gzip({ gzipOptions: { memLevel: 1 } });
+
+gulp.task('compress', function() {
+    gulp.src('./dev/scripts/*.js')
+        .pipe(gzip())
+        .pipe(gulp.dest('./public/scripts'));
+});
diff --git a/gulp-gzip/gulp-gzip.d.ts b/gulp-gzip/gulp-gzip.d.ts
new file mode 100644
index 0000000000..8711153eda
--- /dev/null
+++ b/gulp-gzip/gulp-gzip.d.ts
@@ -0,0 +1,47 @@
+// Type definitions for gulp-gzip
+// Project: https://github.com/jstuckey/gulp-gzip
+// Definitions by: Qubo <https://github.com/tkQubo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "gulp-gzip" {
+    import zlib = require('zlib');
+
+    namespace gzip {
+        interface Gzip {
+            (options?: Options): NodeJS.ReadWriteStream;
+        }
+
+        interface Options {
+            /**
+             * Appends .gz file extension if true.
+             * @default true
+             */
+            append?: boolean;
+            /**
+             * Appends an arbitrary extension to the filename. Disables append and preExtension options.
+             */
+            extension?: string;
+            /**
+             * Appends an arbitrary pre-extension to the filename. Disables append and extension options.
+             */
+            preExtension?: string;
+            /**
+             * Minimum size required to compress a file.
+             * @default false
+             */
+            threshold?: number|string|boolean;
+            /**
+             * Options object to pass through to zlib.Gzip.
+             * See <a href='https://nodejs.org/api/zlib.html#zlib_options'>zlib</a> documentation for more information.
+             */
+            gzipOptions?: zlib.ZlibOptions;
+        }
+    }
+
+    var gzip: gzip.Gzip;
+
+    export = gzip;
+}
+
diff --git a/gulp-ng-annotate/gulp-ng-annotate-tests.ts b/gulp-ng-annotate/gulp-ng-annotate-tests.ts
new file mode 100644
index 0000000000..ef6e696007
--- /dev/null
+++ b/gulp-ng-annotate/gulp-ng-annotate-tests.ts
@@ -0,0 +1,17 @@
+/// <reference path="gulp-ng-annotate.d.ts" />
+/// <reference path="../gulp/gulp.d.ts" />
+
+import ngAnnotate = require('gulp-ng-annotate');
+import gulp = require('gulp');
+
+gulp.task('default', function () {
+    return gulp.src('src/app.js')
+        .pipe(ngAnnotate())
+        .pipe(gulp.dest('dist'));
+});
+
+ngAnnotate({
+    remove: true,
+    add: true,
+    single_quotes: true
+});
diff --git a/gulp-ng-annotate/gulp-ng-annotate.d.ts b/gulp-ng-annotate/gulp-ng-annotate.d.ts
new file mode 100644
index 0000000000..8f25aeebb8
--- /dev/null
+++ b/gulp-ng-annotate/gulp-ng-annotate.d.ts
@@ -0,0 +1,61 @@
+// Type definitions for gulp-ng-annotate
+// Project: https://github.com/Kagami/gulp-ng-annotate
+// Definitions by: Qubo <https://github.com/tkQubo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "gulp-ng-annotate" {
+
+    namespace ngAnnotate {
+        interface NgAnnotate {
+            (option?: Option): NodeJS.ReadWriteStream;
+        }
+
+        //TODO: Should be on ng-annotate module
+        interface Option {
+            /**
+             * Add annotations where non-existing
+             */
+            add?: boolean;
+            /**
+             * Remove all existing annotations
+             */
+            remove?: boolean;
+            /**
+             * List optional matchers
+             */
+            list?: boolean;
+            /**
+             * Restrict matching further or to expand matching
+             */
+            regexp?: string;
+            /**
+             * Enable optional matcher
+             */
+            enable?: boolean;
+            /**
+             * Output '$scope' instead of "$scope".
+             */
+            single_quotes?: boolean;
+            /**
+             * Rename providers (services, factories, controllers, etc.) with a new name when declared and referenced through annotation
+             */
+            rename?: RenameOption[];
+            /**
+             * Load a user plugin with the provided path
+             */
+            plugin?: any[];
+        }
+
+        interface RenameOption {
+            from: string;
+            to: string;
+        }
+    }
+
+    var ngAnnotate: ngAnnotate.NgAnnotate;
+
+    export = ngAnnotate;
+}
+
diff --git a/gulp-nodemon/gulp-nodemon-tests.ts b/gulp-nodemon/gulp-nodemon-tests.ts
new file mode 100644
index 0000000000..6a634558ab
--- /dev/null
+++ b/gulp-nodemon/gulp-nodemon-tests.ts
@@ -0,0 +1,43 @@
+/// <reference path="gulp-nodemon.d.ts" />
+/// <reference path="../gulp/gulp.d.ts" />
+
+import gulp = require('gulp');
+import path = require('path');
+import nodemon = require('gulp-nodemon');
+
+gulp.task('start', function () {
+    nodemon({
+        script: 'server.js'
+        , ext: 'js html'
+        , env: { 'NODE_ENV': 'development' }
+    })
+});
+
+nodemon({
+    script: 'index.js'
+    , tasks: ['browserify']
+});
+
+nodemon({
+    script: './index.js'
+    , ext: 'js css'
+    , tasks: function (changedFiles: string[]): string[] {
+        var tasks: string[] = [];
+        changedFiles.forEach(function (file: string) {
+            if (path.extname(file) === '.js' && !~tasks.indexOf('lint')) tasks.push('lint')
+            if (path.extname(file) === '.css' && !~tasks.indexOf('cssmin')) tasks.push('cssmin')
+        });
+        return tasks
+    }
+});
+
+
+gulp.task('develop', function () {
+    nodemon({ script: 'server.js'
+        , ext: 'html js'
+        , ignore: ['ignored.js']
+        , tasks: ['lint'] })
+        .on('restart', function () {
+            console.log('restarted!')
+        })
+});
diff --git a/gulp-nodemon/gulp-nodemon.d.ts b/gulp-nodemon/gulp-nodemon.d.ts
new file mode 100644
index 0000000000..98db475fee
--- /dev/null
+++ b/gulp-nodemon/gulp-nodemon.d.ts
@@ -0,0 +1,88 @@
+// Type definitions for gulp-nodemon
+// Project: https://github.com/JacksonGariety/gulp-nodemon
+// Definitions by: Qubo <https://github.com/tkQubo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "gulp-nodemon" {
+    namespace nodemon {
+
+        interface Nodemon {
+            (option?: Option): EventEmitter;
+        }
+
+        interface Option extends _Option {
+            tasks?: string[]|((changedFiles: string[]) => string[]);
+        }
+
+        // TODO: Properties may be insufficient
+        // TODO: In future this interface should be moved to nodemon.d.ts
+        interface _Option {
+            env?:  { [key: string]: string|boolean|number; };
+            script?: string;
+            /**
+             * Extensions to look for, ie. js,jade,hbs.
+             */
+            ext?: string;
+            /**
+             * Execute script with "app", ie. -x "python -v".
+             */
+            exec?: string;
+            /**
+             * Watch directory "dir" or files. use once for each directory or file to watch.
+             */
+            watch?: string[];
+            /**
+             * Ignore specific files or directories.
+             */
+            ignore?: string[];
+            /**
+             * Minimise nodemon messages to start/stop only.
+             */
+            quiet?: boolean;
+            /**
+             * Show detail on what is causing restarts.
+             */
+            verbose?: boolean;
+            /**
+             * Try to read from stdin.
+             */
+            stdin?: boolean;
+            stdout?: boolean;
+            /**
+             * Execute script on change only, not startup
+             */
+            runOnChangeOnly?: boolean;
+            /**
+             * Debounce restart in seconds.
+             */
+            delay?: number;
+            /**
+             * Forces node to use the most compatible version for watching file changes.
+             */
+            legacyWatch?: boolean;
+            /**
+             * Exit on crash, allows use of nodemon with daemon tools like forever.js.
+             */
+            exitcrash?: boolean;
+            execMap?: { [key: string]: string|boolean|number; };
+            events?:  { [key: string]: string; };
+            restartable?: string;
+        }
+
+        interface EventEmitter extends NodeJS.EventEmitter {
+            addListener(event: string, listener: Function): EventEmitter;
+            addListener(event: string, tasks: string[]): EventEmitter;
+            on(event: string, listener: Function): EventEmitter;
+            on(event: string, tasks: string[]): EventEmitter;
+            once(event: string, listener: Function): EventEmitter;
+            once(event: string, tasks: string[]): EventEmitter;
+        }
+    }
+
+    var nodemon: nodemon.Nodemon;
+
+    export = nodemon;
+}
+
diff --git a/gulp-sass/gulp-sass-tests.ts b/gulp-sass/gulp-sass-tests.ts
index b566b4cdf6..429df6572d 100644
--- a/gulp-sass/gulp-sass-tests.ts
+++ b/gulp-sass/gulp-sass-tests.ts
@@ -1,7 +1,7 @@
 /// <reference path="./gulp-sass.d.ts"/>
 /// <reference path="../gulp/gulp.d.ts"/>
 import gulp = require("gulp");
-import sass = require("gulp-sass");
+import * as sass from "gulp-sass"; 
 
 gulp.task('sass', function () {
     gulp.src('./scss/*.scss')
diff --git a/gulp-sass/gulp-sass.d.ts b/gulp-sass/gulp-sass.d.ts
index 8d6d4c0557..781df0af75 100644
--- a/gulp-sass/gulp-sass.d.ts
+++ b/gulp-sass/gulp-sass.d.ts
@@ -43,7 +43,10 @@ declare module "gulp-sass" {
         sync?: boolean;
     }
 
-    function sass(opts?: Options): NodeJS.ReadWriteStream;
+    interface Sass {
+        (opts?: Options): NodeJS.ReadWriteStream;
+    }
 
-    export = sass;
+    var _tmp: Sass;
+    export = _tmp;
 }
\ No newline at end of file
diff --git a/gulp-shell/gulp-shell-tests.ts b/gulp-shell/gulp-shell-tests.ts
new file mode 100644
index 0000000000..eb3d1a5a47
--- /dev/null
+++ b/gulp-shell/gulp-shell-tests.ts
@@ -0,0 +1,42 @@
+/// <reference path="gulp-shell.d.ts" />
+/// <reference path="../gulp/gulp.d.ts" />
+
+import shell = require('gulp-shell');
+import gulp = require('gulp');
+
+gulp.task('example', function () {
+    return gulp.src('*.js', {read: false})
+        .pipe(shell([
+        'echo <%= f(file.path) %>',
+        'ls -l <%= file.path %>'
+    ], {
+        templateData: {
+            f: function (s: string) {
+                return s.replace(/$/, '.bak')
+            }
+        }
+    }))
+});
+
+gulp.task('shorthand', shell.task([
+    'echo hello',
+    'echo world'
+]));
+
+var paths: any = {
+    js: ['*.js', 'test/*.js']
+};
+
+gulp.task('test', shell.task('mocha -R spec'));
+
+gulp.task('coverage', ['test'], shell.task('istanbul cover _mocha -- -R spec'));
+
+gulp.task('coveralls', ['coverage'], shell.task('cat coverage/lcov.info | coveralls'));
+
+gulp.task('lint', shell.task('eslint ' + paths.js.join(' ')));
+
+gulp.task('default', ['coverage', 'lint']);
+
+gulp.task('watch', function () {
+    gulp.watch(paths.js, ['default'])
+});
diff --git a/gulp-shell/gulp-shell.d.ts b/gulp-shell/gulp-shell.d.ts
new file mode 100644
index 0000000000..d88f27ed6a
--- /dev/null
+++ b/gulp-shell/gulp-shell.d.ts
@@ -0,0 +1,68 @@
+// Type definitions for gulp-shell
+// Project: https://github.com/sun-zheng-an/gulp-shell
+// Definitions by: Qubo <https://github.com/tkqubo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "gulp-shell" {
+
+    namespace shell {
+        interface Shell {
+            (commands: string|string[], options?: Option): NodeJS.ReadWriteStream;
+            task(commands: string|string[], options?: Option): () => NodeJS.ReadWriteStream;
+        }
+
+        interface Option {
+            /**
+             * You can add a custom error message for when the command fails. This can be a template which can be
+             * interpolated with the current command, some file info (e.g. file.path) and some error info
+             * (e.g. error.code).
+             * @default 'Command `<%= command %>` failed with exit code <%= error.code %>'
+             */
+            errorMessage?: string;
+            /**
+             * By default, it will emit an error event when the command finishes unsuccessfully.
+             * @default false
+             */
+            ignoreErrors?: boolean;
+            /**
+             * By default, it will print the command output.
+             * @default false
+             */
+            quiet?: boolean;
+            /**
+             * Sets the current working directory for the command.
+             * @default process.cwd()
+             */
+            cwd?: string;
+            /**
+             * The data that can be accessed in template.
+             */
+            templateData?: any;
+            /**
+             * You won't need to set this option unless you encounter a "stdout maxBuffer exceeded" error.
+             * @default 16MB(16 * 1024 * 1024)
+             */
+            maxBuffer?: number;
+            /**
+             * The maximum amount of time in milliseconds the process is allowed to run.
+             * @default
+             */
+            timeout?: number;
+            /**
+             * By default, all the commands will be executed in an environment with all the variables in process.env
+             * and PATH prepended by ./node_modules/.bin (allowing you to run executables in your Node's dependencies).
+             * You can override any environment variables with this option.
+             * For example, setting it to {PATH: process.env.PATH} will reset the PATH
+             * if the default one brings your some troubles.
+             */
+            env?: any;
+        }
+    }
+
+    var shell: shell.Shell;
+
+    export = shell;
+}
+
diff --git a/handlebars/handlebars-tests.ts b/handlebars/handlebars-tests.ts
index 7ca58ff02a..264d70103c 100644
--- a/handlebars/handlebars-tests.ts
+++ b/handlebars/handlebars-tests.ts
@@ -80,3 +80,5 @@ Handlebars.registerHelper('fullName', (person: typeof context.author) => {
 });
 
 var escapedExpression = Handlebars.Utils.escapeExpression('<script>alert(\'xss\');</script>');
+
+Handlebars.helpers !== undefined;
diff --git a/handlebars/handlebars.d.ts b/handlebars/handlebars.d.ts
index 6526857240..9a0aa510ac 100644
--- a/handlebars/handlebars.d.ts
+++ b/handlebars/handlebars.d.ts
@@ -18,6 +18,7 @@ declare module Handlebars {
     export var Utils: typeof hbs.Utils;
     export var logger: Logger;
     export var templates: HandlebarsTemplates;
+    export var helpers: any;
 
     export module AST {
         export var helpers: hbs.AST.helpers;
diff --git a/highcharts-ng/highcharts-ng-tests.ts b/highcharts-ng/highcharts-ng-tests.ts
index 5f05b33731..493d0f94ff 100644
--- a/highcharts-ng/highcharts-ng-tests.ts
+++ b/highcharts-ng/highcharts-ng-tests.ts
@@ -37,4 +37,4 @@ class AppController {
     }
 }
 
-app.controller("AppController", AppController);
\ No newline at end of file
+app.controller("AppController", AppController);
diff --git a/highcharts-ng/highcharts-ng.d.ts b/highcharts-ng/highcharts-ng.d.ts
index d0a3405594..61dfef31d6 100644
--- a/highcharts-ng/highcharts-ng.d.ts
+++ b/highcharts-ng/highcharts-ng.d.ts
@@ -6,11 +6,11 @@
 /// <reference path="../highcharts/highcharts.d.ts" />
 
 interface HighChartsNGConfig {
-    options: HighchartsChartOptions;
+    options: HighchartsOptions;
     //The below properties are watched separately for changes.
 
     //Series object (optional) - a list of series using normal highcharts series options.
-    series?: number[]|[number, number][]| HighchartsDataPoint[];
+    series?: number[]|[number, number][]| HighchartsDataPoint[] | {data:number[];}[];
     //Title configuration (optional)
     title?: {
         text?: string;
@@ -24,7 +24,7 @@ interface HighChartsNGConfig {
         currentMin?: number;
         currentMax?: number;
         title?: { text?: string }
-    },
+    };
     //Whether to use HighStocks instead of HighCharts (optional). Defaults to false.
     useHighStocks?: boolean;
     //size (optional) if left out the chart will default to size of the div or something sensible.
@@ -40,4 +40,4 @@ interface HighChartsNGConfig {
 interface HighChartsNGChart extends HighChartsNGConfig {
     //This is a simple way to access all the Highcharts API that is not currently managed by this directive.
     getHighcharts(): HighchartsChartObject;
-}
\ No newline at end of file
+}
diff --git a/highcharts/highcharts.d.ts b/highcharts/highcharts.d.ts
index 2341f87693..f654b97496 100644
--- a/highcharts/highcharts.d.ts
+++ b/highcharts/highcharts.d.ts
@@ -249,7 +249,7 @@ interface HighchartsCSSObject {
     fontWeight?: string;
     left?: string;
     opacity?: number;
-    padding?: string;
+    padding?: string | number;
     position?: string;
     top?: string;
 }
diff --git a/i18n-node/i18n-node.d.ts b/i18n-node/i18n-node.d.ts
index 348c2f2689..79dda8b758 100644
--- a/i18n-node/i18n-node.d.ts
+++ b/i18n-node/i18n-node.d.ts
@@ -22,29 +22,34 @@ declare module i18n {
          */
         directory?: string;
 
-        /** 
+        /**
          * whether to write new locale information to disk
          * @default true
          */
         updateFiles?: boolean;
 
-        /** 
+        /**
          * What to use as the indentation unit
          * @default "\t"
          */
         indent?: string;
 
-        /** 
+        /**
          * Setting extension of json files (you might want to set this to '.js' according to webtranslateit)
          * @default ".json"
          */
         extension?: string;
 
-        /** 
+        /**
          * Enable object notation
          * @default false
          */
         objectNotation?: boolean;
+
+        /**
+         * json files prefix
+         */
+        prefix?: string;
     }
     export interface TranslateOptions {
         phrase: string;
diff --git a/i18next/i18next.d.ts b/i18next/i18next.d.ts
index feb6658c83..38d91b603e 100644
--- a/i18next/i18next.d.ts
+++ b/i18next/i18next.d.ts
@@ -19,6 +19,12 @@ interface IResourceStoreKey {
 
 interface I18nTranslateOptions extends I18nextOptions {
     defaultValue?: any; // normally a string
+    // NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
+    toAdd?: any;
+    child?: any;
+    sprintf?: any;
+    count?: any;
+    context?: any;
 }
 
 interface I18nextOptions {
@@ -66,6 +72,9 @@ interface I18nextOptions {
     cookieName?: string;                    // Default value: 'i18next'
 
     postProcess?: string;                   // Default value: undefined
+
+    // NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
+    replace?: any;
 }
 
 interface I18nextStatic {
diff --git a/inquirer/inquirer-tests.ts b/inquirer/inquirer-tests.ts
new file mode 100644
index 0000000000..dd770e2367
--- /dev/null
+++ b/inquirer/inquirer-tests.ts
@@ -0,0 +1,528 @@
+/// <reference path="../node/node.d.ts" />
+/// <reference path="inquirer.d.ts" />
+
+import inquirer = require('inquirer');
+
+
+inquirer.prompt([/* Pass your questions in here */], function( answers: inquirer.Answers ) {
+    // Use user feedback for... whatever!!
+});
+
+//
+// examples/bottom-bar.js
+//
+
+//var BottomBar = require("../lib/ui/bottom-bar");
+var BottomBar = inquirer.ui.BottomBar;
+declare var cmdify: any;
+
+var loader = [
+    "/ Installing",
+    "| Installing",
+    "\\ Installing",
+    "- Installing"
+];
+var i = 4;
+var ui = new BottomBar({ bottomBar: loader[i % 4] });
+
+setInterval(function() {
+    ui.updateBottomBar( loader[i++ % 4] );
+}, 300 );
+
+var spawn = require("child_process").spawn;
+
+var cmd = spawn(cmdify("npm"), [ "-g", "install", "inquirer" ], { stdio: "pipe" });
+cmd.stdout.pipe( ui.log );
+cmd.on( "close", function() {
+    ui.updateBottomBar("Installation done!\n");
+    process.exit();
+});
+
+
+//
+// examples/checkbox.js
+//
+
+/**
+ * Checkbox list examples
+ */
+
+"use strict";
+//var inquirer = require("../lib/inquirer");
+
+inquirer.prompt([
+    {
+        type: "checkbox",
+        message: "Select toppings",
+        name: "toppings",
+        choices: [
+            new inquirer.Separator("The usual:"),
+            {
+                name: "Peperonni"
+            },
+            {
+                name: "Cheese",
+                checked: true
+            },
+            {
+                name: "Mushroom"
+            },
+            new inquirer.Separator("The extras:"),
+            {
+                name: "Pineapple",
+            },
+            {
+                name: "Bacon"
+            },
+            {
+                name: "Olives",
+                disabled: "out of stock"
+            },
+            {
+                name: "Extra cheese"
+            }
+        ],
+        validate: function( answer ) {
+            if ( answer.length < 1 ) {
+                return "You must choose at least one topping.";
+            }
+            return true;
+        }
+    }
+], function( answers: inquirer.Answers ) {
+    console.log( JSON.stringify(answers, null, "  ") );
+});
+
+
+//
+// examples/expand.js
+//
+
+/**
+ * Expand list examples
+ */
+
+"use strict";
+//var inquirer = require("../lib/inquirer");
+
+inquirer.prompt([
+    {
+        type: "expand",
+        message: "Conflict on `file.js`: ",
+        name: "overwrite",
+        choices: [
+            {
+                key: "y",
+                name: "Overwrite",
+                value: "overwrite"
+            },
+            {
+                key: "a",
+                name: "Overwrite this one and all next",
+                value: "overwrite_all"
+            },
+            {
+                key: "d",
+                name: "Show diff",
+                value: "diff"
+            },
+            new inquirer.Separator(),
+            {
+                key: "x",
+                name: "Abort",
+                value: "abort"
+            }
+        ]
+    }
+], function( answers: inquirer.Answers ) {
+    console.log( JSON.stringify(answers, null, "  ") );
+});
+
+
+//
+// examples/input.js
+//
+
+/**
+ * Input prompt example
+ */
+
+"use strict";
+//var inquirer = require("../lib/inquirer");
+
+var questions = [
+    {
+        type: "input",
+        name: "first_name",
+        message: "What's your first name"
+    },
+    {
+        type: "input",
+        name: "last_name",
+        message: "What's your last name",
+        default: function () { return "Doe"; }
+    },
+    {
+        type: "input",
+        name: "phone",
+        message: "What's your phone number",
+        validate: function( value: string ): string|boolean {
+            var pass = value.match(/^([01]{1})?[\-\.\s]?\(?(\d{3})\)?[\-\.\s]?(\d{3})[\-\.\s]?(\d{4})\s?((?:#|ext\.?\s?|x\.?\s?){1}(?:\d+)?)?$/i);
+            if (pass) {
+                return true;
+            } else {
+                return "Please enter a valid phone number";
+            }
+        }
+    }
+];
+
+inquirer.prompt( questions, function( answers ) {
+    console.log( JSON.stringify(answers, null, "  ") );
+});
+
+//
+// examples/list.js
+//
+
+
+/**
+ * List prompt example
+ */
+
+"use strict";
+//var inquirer = require("../lib/inquirer");
+
+inquirer.prompt([
+    {
+        type: "list",
+        name: "theme",
+        message: "What do you want to do?",
+        choices: [
+            "Order a pizza",
+            "Make a reservation",
+            new inquirer.Separator(),
+            "Ask opening hours",
+            "Talk to the receptionnist"
+        ]
+    },
+    {
+        type: "list",
+        name: "size",
+        message: "What size do you need",
+        choices: [ "Jumbo", "Large", "Standard", "Medium", "Small", "Micro" ],
+        filter: function( val: string ) { return val.toLowerCase(); }
+    }
+], function( answers: inquirer.Answers ) {
+    console.log( JSON.stringify(answers, null, "  ") );
+});
+
+//
+// examples/long-list.js
+//
+
+/**
+ * Paginated list
+ */
+
+"use strict";
+//var inquirer = require("../lib/inquirer");
+
+var choices = Array.apply(0, new Array(26)).map(function(x: number,y: number) {
+    return String.fromCharCode(y + 65);
+});
+choices.push("Multiline option \n  super cool feature");
+choices.push("Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo. Nullam dictum felis eu pede mollis pretium.");
+
+inquirer.prompt([
+    {
+        type      : "list",
+        name      : "letter",
+        message   : "What's your favorite letter?",
+        paginated : true,
+        choices   : choices
+    },
+    {
+        type      : "checkbox",
+        name      : "name",
+        message   : "Select the letter contained in your name:",
+        paginated : true,
+        choices   : choices
+    }
+], function( answers: inquirer.Answers ) {
+    console.log( JSON.stringify(answers, null, "  ") );
+});
+
+//
+// examples/nested-call.js
+//
+
+/**
+ * Nested Inquirer call
+ */
+
+"use strict";
+//var inquirer = require("../lib/inquirer");
+
+inquirer.prompt({
+    type: "list",
+    name: "chocolate",
+    message: "What's your favorite chocolate?",
+    choices: [ "Mars", "Oh Henry", "Hershey" ]
+}, function( answers: inquirer.Answers ) {
+    inquirer.prompt({
+        type: "list",
+        name: "beverage",
+        message: "And your favorite beverage?",
+        choices: [ "Pepsi", "Coke", "7up", "Mountain Dew", "Red Bull" ]
+    });
+});
+
+//
+// examples/password.js
+//
+
+/**
+ * Password prompt example
+ */
+
+"use strict";
+//var inquirer = require("../lib/inquirer");
+
+inquirer.prompt([
+    {
+        type: "password",
+        message: "Enter your git password",
+        name: "password"
+    }
+], function( answers: inquirer.Answers ) {
+    console.log( JSON.stringify(answers, null, "  ") );
+});
+
+//
+// examples/pizza.js
+//
+
+/**
+ * Pizza delivery prompt example
+ * run example by writing `node pizza.js` in your console
+ */
+
+"use strict";
+//var inquirer = require("../lib/inquirer");
+
+console.log("Hi, welcome to Node Pizza");
+
+var questions2 = [
+    {
+        type: "confirm",
+        name: "toBeDelivered",
+        message: "Is it for a delivery",
+        default: false
+    },
+    {
+        type: "input",
+        name: "phone",
+        message: "What's your phone number",
+        validate: function( value: string ): string|boolean {
+            var pass = value.match(/^([01]{1})?[\-\.\s]?\(?(\d{3})\)?[\-\.\s]?(\d{3})[\-\.\s]?(\d{4})\s?((?:#|ext\.?\s?|x\.?\s?){1}(?:\d+)?)?$/i);
+            if (pass) {
+                return true;
+            } else {
+                return "Please enter a valid phone number";
+            }
+        }
+    },
+    {
+        type: "list",
+        name: "size",
+        message: "What size do you need",
+        choices: [ "Large", "Medium", "Small" ],
+        filter: function( val: string ) { return val.toLowerCase(); }
+    },
+    {
+        type: "input",
+        name: "quantity",
+        message: "How many do you need",
+        validate: function( value: string ) {
+            var valid = !isNaN(parseFloat(value));
+            return valid || "Please enter a number";
+        },
+        filter: Number
+    },
+    {
+        type: "expand",
+        name: "toppings",
+        message: "What about the toping",
+        choices: [
+            {
+                key: "p",
+                name: "Peperonni and chesse",
+                value: "PeperonniChesse"
+            },
+            {
+                key: "a",
+                name: "All dressed",
+                value: "alldressed"
+            },
+            {
+                key: "w",
+                name: "Hawaïan",
+                value: "hawaian"
+            }
+        ]
+    },
+    {
+        type: "rawlist",
+        name: "beverage",
+        message: "You also get a free 2L beverage",
+        choices: [ "Pepsi", "7up", "Coke" ]
+    },
+    {
+        type: "input",
+        name: "comments",
+        message: "Any comments on your purchase experience",
+        default: "Nope, all good!"
+    },
+    {
+        type: "list",
+        name: "prize",
+        message: "For leaving a comments, you get a freebie",
+        choices: [ "cake", "fries" ],
+        when: function( answers: inquirer.Answers ) {
+            return answers['comments'] !== "Nope, all good!";
+        }
+    }
+];
+
+inquirer.prompt( questions, function( answers ) {
+    console.log("\nOrder receipt:");
+    console.log( JSON.stringify(answers, null, "  ") );
+});
+
+//
+// examples/rawlist.js
+//
+
+/**
+ * Raw List prompt example
+ */
+
+"use strict";
+//var inquirer = require("../lib/inquirer");
+
+inquirer.prompt([
+    {
+        type: "rawlist",
+        name: "theme",
+        message: "What do you want to do?",
+        choices: [
+            "Order a pizza",
+            "Make a reservation",
+            new inquirer.Separator(),
+            "Ask opening hours",
+            "Talk to the receptionnist"
+        ]
+    },
+    {
+        type: "rawlist",
+        name: "size",
+        message: "What size do you need",
+        choices: [ "Jumbo", "Large", "Standard", "Medium", "Small", "Micro" ],
+        filter: function( val: string ) { return val.toLowerCase(); }
+    }
+], function( answers: inquirer.Answers ) {
+    console.log( JSON.stringify(answers, null, "  ") );
+});
+
+//
+// examples/recursive.js
+//
+
+/**
+ * Recursive prompt example
+ * Allows user to choose when to exit prompt
+ */
+
+"use strict";
+//var inquirer = require("../lib/inquirer");
+var output2: (string|boolean)[] = [];
+
+var questions3 = [
+    {
+        type: "input",
+        name: "tvShow",
+        message: "What's your favorite TV show?"
+    },
+    {
+        type: "confirm",
+        name: "askAgain",
+        message: "Want to enter another TV show favorite (just hit enter for YES)?",
+        default: true
+    }
+];
+
+function ask() {
+    inquirer.prompt( questions3, function( answers: inquirer.Answers ) {
+        output2.push( answers['tvShow'] );
+        if ( answers['askAgain'] ) {
+            ask();
+        } else {
+            console.log( "Your favorite TV Shows:", output2.join(", ") );
+        }
+    });
+}
+
+ask();
+
+//
+// examples/when.js
+//
+
+
+/**
+ * When example
+ */
+
+"use strict";
+//var inquirer = require("../lib/inquirer");
+
+var questions4 = [
+    {
+        type: "confirm",
+        name: "bacon",
+        message: "Do you like bacon?"
+    },
+    {
+        type: "input",
+        name: "favorite",
+        message: "Bacon lover, what is your favorite type of bacon?",
+        when: function ( answers: inquirer.Answers ) {
+            return answers['bacon'];
+        }
+    },
+    {
+        type: "confirm",
+        name: "pizza",
+        message: "Ok... Do you like pizza?",
+        when: function (answers: inquirer.Answers) {
+            return !likesFood( "bacon" )(answers);
+        }
+    },
+    {
+        type: "input",
+        name: "favorite",
+        message: "Whew! What is your favorite type of pizza?",
+        when: likesFood( "pizza" )
+    }
+];
+
+function likesFood ( aFood: string ) {
+    return function ( answers: inquirer.Answers ) {
+        return answers[ aFood ];
+    }
+}
+
+inquirer.prompt(questions, function (answers) {
+    console.log( JSON.stringify(answers, null, "  ") );
+});
diff --git a/inquirer/inquirer.d.ts b/inquirer/inquirer.d.ts
new file mode 100644
index 0000000000..0eb89781e0
--- /dev/null
+++ b/inquirer/inquirer.d.ts
@@ -0,0 +1,299 @@
+// Type definitions for Inquirer.js
+// Project: https://github.com/SBoudrias/Inquirer.js
+// Definitions by: Qubo <https://github.com/tkQubo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../rx/rx-lite.d.ts" />
+/// <reference path="../through/through.d.ts" />
+
+declare module "inquirer" {
+    import through = require('through');
+
+    namespace inquirer {
+        type Prompts = { [name: string]: PromptModule };
+        type ChoiceType = string|objects.ChoiceOption|objects.Separator;
+        type Questions = Question|Question[]|Rx.Observable<Question>;
+
+        interface Inquirer {
+            restoreDefaultPrompts(): void;
+            /**
+             * Expose helper functions on the top level for easiest usage by common users
+             * @param name
+             * @param prompt
+             */
+            registerPrompt(name: string, prompt: PromptModule): void;
+            /**
+             * Create a new self-contained prompt module.
+             */
+            createPromptModule(): PromptModule;
+            /**
+             * Public CLI helper interface
+             * @param questions Questions settings array
+             * @param cb Callback being passed the user answers
+             * @return
+             */
+            prompt(questions: Questions, cb?: (answers: Answers) => any): ui.Prompt;
+            prompts: Prompts;
+            Separator: objects.SeparatorStatic;
+            ui: {
+                BottomBar: ui.BottomBar;
+                Prompt: ui.Prompt;
+            }
+        }
+
+        interface PromptModule {
+            (questions: Questions, cb: (answers: Answers) => any): ui.Prompt;
+            /**
+             * Register a prompt type
+             * @param name Prompt type name
+             * @param prompt Prompt constructor
+             */
+            registerPrompt(name: string, prompt: PromptModule): ui.Prompt;
+            /**
+             * Register the defaults provider prompts
+             */
+            restoreDefaultPrompts(): void;
+        }
+
+        interface Question {
+            /**
+             * Type of the prompt.
+             * Possible values:
+             * <ul>
+             *      <li>input</li>
+             *      <li>confirm</li>
+             *      <li>list</li>
+             *      <li>rawlist</li>
+             *      <li>password</li>
+             * </ul>
+             * @defaults: 'input'
+             */
+            type?: string;
+            /**
+             * The name to use when storing the answer in the anwers hash.
+             */
+            name?: string;
+            /**
+             * The question to print. If defined as a function,
+             * the first parameter will be the current inquirer session answers.
+             */
+            message?: string|((answers: Answers) => string);
+            /**
+             * Default value(s) to use if nothing is entered, or a function that returns the default value(s).
+             * If defined as a function, the first parameter will be the current inquirer session answers.
+             */
+            default?: any|((answers: Answers) => any);
+            /**
+             * Choices array or a function returning a choices array. If defined as a function,
+             * the first parameter will be the current inquirer session answers.
+             * Array values can be simple strings, or objects containing a name (to display) and a value properties
+             * (to save in the answers hash). Values can also be a Separator.
+             */
+            choices?: ChoiceType[]|((answers: Answers) => ChoiceType[]);
+            /**
+             * Receive the user input and should return true if the value is valid, and an error message (String)
+             * otherwise. If false is returned, a default error message is provided.
+             */
+            validate?(input: string): boolean|string;
+            /**
+             * Receive the user input and return the filtered value to be used inside the program.
+             * The value returned will be added to the Answers hash.
+             */
+            filter?(input: string): string;
+            /**
+             * Receive the current user answers hash and should return true or false depending on whether or
+             * not this question should be asked. The value can also be a simple boolean.
+             */
+            when?: boolean|((answers: Answers) => boolean);
+            paginated?: boolean;
+        }
+
+        /**
+         * A key/value hash containing the client answers in each prompt.
+         */
+        interface Answers {
+            [key: string]: string|boolean;
+        }
+
+        namespace ui {
+            /**
+             * Base interface class other can inherits from
+             */
+            interface Prompt extends BaseUI<Prompts> {
+                new(promptModule: Prompts): Prompt;
+                /**
+                 * Once all prompt are over
+                 */
+                onCompletion(): void;
+                processQuestion(question: Question): any;
+                fetchAnswer(question: Question): any;
+                setDefaultType(question: Question): any;
+                filterIfRunnable(question: Question): any;
+            }
+
+            /**
+             * Sticky bottom bar user interface
+             */
+            interface BottomBar extends BaseUI<BottomBarOption> {
+                new(opt?: BottomBarOption): BottomBar;
+                /**
+                 * Render the prompt to screen
+                 * @return self
+                 */
+                render(): BottomBar;
+                /**
+                 * Update the bottom bar content and rerender
+                 * @param bottomBar Bottom bar content
+                 * @return self
+                 */
+                updateBottomBar(bottomBar: string): BottomBar;
+                /**
+                 * Rerender the prompt
+                 * @return self
+                 */
+                writeLog(data: any): BottomBar;
+                /**
+                 * Make sure line end on a line feed
+                 * @param str Input string
+                 * @return The input string with a final line feed
+                 */
+                enforceLF(str: string): string;
+                /**
+                 * Helper for writing message in Prompt
+                 * @param message The message to be output
+                 */
+                write(message: string): void;
+                log: through.ThroughStream;
+            }
+
+            interface BottomBarOption {
+                bottomBar?: string;
+            }
+            /**
+             * Base interface class other can inherits from
+             */
+            interface BaseUI<TOpt> {
+                new(opt: TOpt): void;
+                /**
+                 * Handle the ^C exit
+                 * @return {null}
+                 */
+                onForceClose(): void;
+                /**
+                 * Close the interface and cleanup listeners
+                 */
+                close(): void;
+                /**
+                 * Handle and propagate keypress events
+                 */
+                onKeypress(s: string, key: Key): void;
+            }
+
+            interface Key {
+                sequence: string;
+                name: string;
+                meta: boolean;
+                shift: boolean;
+                ctrl: boolean;
+            }
+        }
+
+        namespace objects {
+            /**
+             * Choice object
+             * Normalize input as choice object
+             * @constructor
+             * @param {String|Object} val  Choice value. If an object is passed, it should contains
+             *                             at least one of `value` or `name` property
+             */
+            interface Choice {
+                new(str: string): Choice;
+                new(separator: Separator): Choice;
+                new(option: ChoiceOption): Choice;
+            }
+
+            interface ChoiceOption {
+                name?: string;
+                value?: string;
+                type?: string;
+                extra?: any;
+                key?: string;
+                checked?: boolean;
+                disabled?: string|((answers: Answers) => any);
+            }
+
+            /**
+             * Choices collection
+             * Collection of multiple `choice` object
+             * @constructor
+             * @param choices  All `choice` to keep in the collection
+             */
+            interface Choices {
+                new(choices: (string|Separator|ChoiceOption)[], answers?: Answers): Choices;
+                choices: Choice[];
+                realChoices: Choice[];
+                length: number;
+                realLength: number;
+                /**
+                 * Get a valid choice from the collection
+                 * @param selector The selected choice index
+                 * @return Return the matched choice or undefined
+                 */
+                getChoice(selector: number): Choice;
+                /**
+                 * Get a raw element from the collection
+                 * @param selector The selected index value
+                 * @return Return the matched choice or undefined
+                 */
+                get(selector: number): Choice;
+                /**
+                 * Match the valid choices against a where clause
+                 * @param whereClause Lodash `where` clause
+                 * @return Matching choices or empty array
+                 */
+                where<U extends {}>(whereClause: U): Choice[];
+                /**
+                 * Pluck a particular key from the choices
+                 * @param propertyName Property name to select
+                 * @return Selected properties
+                 */
+                pluck(propertyName: string): any[];
+                forEach<T>(application: (choice: Choice) => T): T[];
+            }
+
+            interface SeparatorStatic {
+                /**
+                 * @param line Separation line content (facultative)
+                 */
+                new(line?: string): Separator;
+                /**
+                 * Helper function returning false if object is a separator
+                 * @param obj object to test against
+                 * @return `false` if object is a separator
+                 */
+                exclude(obj: any): boolean;
+            }
+
+            /**
+             * Separator object
+             * Used to space/separate choices group
+             * @constructor
+             * @param {String} line   Separation line content (facultative)
+             */
+            interface Separator {
+                type: string;
+                line: string;
+                /**
+                 * Stringify separator
+                 * @return {String} the separator display string
+                 */
+                toString(): string;
+            }
+        }
+    }
+
+    var inquirer: inquirer.Inquirer;
+
+    export = inquirer;
+}
+
diff --git a/jasmine/jasmine.d.ts b/jasmine/jasmine.d.ts
index 581353b348..184875fa2d 100644
--- a/jasmine/jasmine.d.ts
+++ b/jasmine/jasmine.d.ts
@@ -58,7 +58,7 @@ declare module jasmine {
     function addMatchers(matchers: CustomMatcherFactories): void;
     function stringMatching(str: string): Any;
     function stringMatching(str: RegExp): Any;
-    
+
     interface Any {
 
         new (expectedClass: any): any;
@@ -72,7 +72,7 @@ declare module jasmine {
         length: number;
         [n: number]: T;
     }
-    
+
     interface ArrayContaining {
         new (sample: any[]): any;
 
@@ -279,21 +279,21 @@ declare module jasmine {
         isNot?: boolean;
         message(): any;
 
-        toBe(expected: any): boolean;
-        toEqual(expected: any): boolean;
-        toMatch(expected: any): boolean;
-        toBeDefined(): boolean;
-        toBeUndefined(): boolean;
-        toBeNull(): boolean;
+        toBe(expected: any, expectationFailOutput?: any): boolean;
+        toEqual(expected: any, expectationFailOutput?: any): boolean;
+        toMatch(expected: any, expectationFailOutput?: any): boolean;
+        toBeDefined(expectationFailOutput?: any): boolean;
+        toBeUndefined(expectationFailOutput?: any): boolean;
+        toBeNull(expectationFailOutput?: any): boolean;
         toBeNaN(): boolean;
-        toBeTruthy(): boolean;
-        toBeFalsy(): boolean;
+        toBeTruthy(expectationFailOutput?: any): boolean;
+        toBeFalsy(expectationFailOutput?: any): boolean;
         toHaveBeenCalled(): boolean;
         toHaveBeenCalledWith(...params: any[]): boolean;
-        toContain(expected: any): boolean;
-        toBeLessThan(expected: any): boolean;
-        toBeGreaterThan(expected: any): boolean;
-        toBeCloseTo(expected: any, precision: any): boolean;
+        toContain(expected: any, expectationFailOutput?: any): boolean;
+        toBeLessThan(expected: any, expectationFailOutput?: any): boolean;
+        toBeGreaterThan(expected: any, expectationFailOutput?: any): boolean;
+        toBeCloseTo(expected: any, precision: any, expectationFailOutput?: any): boolean;
         toContainHtml(expected: string): boolean;
         toContainText(expected: string): boolean;
         toThrow(expected?: any): boolean;
@@ -450,7 +450,7 @@ declare module jasmine {
         /** By chaining the spy with calls.reset(), will clears all tracking for a spy **/
         reset(): void;
     }
-    
+
     interface CallInfo {
         /** The context (the this) for the call */
         object: any;
diff --git a/jquery-ajax-chain/jquery-ajax-chain-tests.ts b/jquery-ajax-chain/jquery-ajax-chain-tests.ts
new file mode 100644
index 0000000000..8a484fa633
--- /dev/null
+++ b/jquery-ajax-chain/jquery-ajax-chain-tests.ts
@@ -0,0 +1,287 @@
+/// <reference path="../jquery-ajax-chain/jquery-ajax-chain.d.ts" />
+/// <reference path="../jquery/jquery.d.ts" />
+/// <reference path="../core-js/core-js.d.ts" />
+
+function test_public_methods(): void {
+
+    let ajaxChain: ajaxChain.JQueryAjaxChain,
+        configurationObj1: ajaxChain.AjaxChainConfiguration,
+        configurationObj2: ajaxChain.AjaxChainConfiguration;
+
+    configurationObj1 = {
+
+        ajaxSettings: {
+
+            type: 'GET',
+            dataType: 'xml',
+            url: '/endpoint1'
+
+        }
+
+    };
+
+    configurationObj2 = {
+
+        ajaxSettings: {
+
+            type: 'GET',
+            dataType: 'xml',
+            url: '/endpoint2'
+
+        }
+
+    };
+
+    ajaxChain.enqueue(configurationObj1);
+    ajaxChain.clearQueue();
+    ajaxChain.enqueue([configurationObj1, configurationObj2]);
+    ajaxChain.dequeue().then(doneResult => { console.log(doneResult); },
+                             failResult => { console.log(failResult); },
+                             progressResult => { console.log(progressResult); });
+
+}
+
+function test_optional_parameters(): void {
+
+    let itemsCollectionCache: XMLDocument = null,
+        itemDetailCacheMap: WeakMap<String, XMLDocument> = new WeakMap<String, XMLDocument>(),
+        ajaxChain: ajaxChain.JQueryAjaxChain,
+        configurationObj1: ajaxChain.AjaxChainConfiguration,
+        configurationObj2: ajaxChain.AjaxChainConfiguration,
+        configurationObj3: ajaxChain.AjaxChainConfiguration,
+        configurationObj4: ajaxChain.AjaxChainConfiguration;
+
+    ajaxChain = new $.AjaxChain();
+
+    configurationObj1 = {
+
+        ajaxSettings: {
+
+            type: 'GET',
+            dataType: 'xml',
+            url: '/items',
+            success: function (xmlResponse): void {
+
+                itemsCollectionCache = xmlResponse;
+
+            },
+
+        },
+
+        hasHaltingCapabilities: function (xmlResponse): Boolean {
+
+            let $tempXmlResponse: JQuery;
+
+            $tempXmlResponse = $(xmlResponse);
+
+            if (!$tempXmlResponse.find('item').length) {
+
+                return true;
+
+            }
+
+            return false;
+
+        },
+
+        hasCache: function (xmlResponse): XMLDocument {
+
+            if (itemsCollectionCache) {
+
+                return itemsCollectionCache;
+
+            };
+
+            return null;
+        },
+
+        transform: function (xmlResponse): Object {
+
+            let $tempXmlResponse: JQuery,
+                $tempItems: JQuery,
+                nextCallDataObj: Object;
+
+            $tempXmlResponse = $(xmlResponse);
+            $tempItems = $tempXmlResponse.find('item');
+
+            if ($tempItems.length) {
+
+                nextCallDataObj = {
+
+                    id: $tempItems.first()
+                                  .attr('id')
+
+                };
+
+                return nextCallDataObj;
+
+            }
+
+            return null;
+
+        }
+
+    };
+
+    configurationObj2 = {
+
+        ajaxSettings: {
+
+            type: 'GET',
+            dataType: 'xml',
+            url: '/item',
+            success: function (xmlResponse): void {
+
+                let $tempXmlResponse: JQuery,
+                    itemId: String;
+
+                $tempXmlResponse = $(xmlResponse);
+
+                itemId = $tempXmlResponse.find('id')
+                                         .text();
+
+                if (itemId && !itemDetailCacheMap.has(itemId)) {
+
+                    itemDetailCacheMap.set(itemId, xmlResponse);
+
+                }
+
+            }
+
+        },
+
+        transform: function (xmlResponse): String {
+
+            let $tempXmlResponse: JQuery,
+                tempTrackingCode: String,
+                nextCallDataStr: String = "";
+
+            $tempXmlResponse = $(xmlResponse);
+
+            tempTrackingCode = $tempXmlResponse.find('code')
+                                               .text();
+
+            if (tempTrackingCode) {
+
+                nextCallDataStr = "tracking=" + tempTrackingCode;
+
+            }
+
+            return nextCallDataStr;
+
+        },
+
+        hasCache: function (xmlResponse): XMLDocument {
+            
+            let $tempXmlResponse: JQuery,
+                itemId: String;
+
+            $tempXmlResponse = $(xmlResponse);
+
+            itemId = $tempXmlResponse.find('id')
+                                     .text();
+
+            if (itemDetailCacheMap.has(itemId)) {
+
+                return itemDetailCacheMap.get(itemId);
+
+            }
+
+            return null;
+
+        },
+
+        hasErrors: function (xmlResponse): String {
+
+            var $tempXmlResponse: JQuery,
+                categoryFilter: string = '1';
+
+            $tempXmlResponse = $(xmlResponse);
+
+            if ($tempXmlResponse.find('categoryId')
+                                .text() === categoryFilter) {
+
+                return '[Exception] forbidden category id: ' + categoryFilter;
+
+            }
+
+            return '';
+
+        },
+
+        appendToUrl: function (xmlResponse): String {
+
+            let $tempXmlResponse: JQuery,
+                categoryId: string = '';
+
+            $tempXmlResponse = $(xmlResponse);
+            categoryId = $tempXmlResponse.find('categoryId')
+                                         .text();
+
+            return (categoryId) ? ('/' + categoryId) : '';
+
+        }
+
+    };
+
+    configurationObj3 = {
+
+        ajaxSettings: {
+
+            type: 'GET',
+            dataType: 'xml',
+            url: '/categories'
+
+        },
+
+        isSkippable: function (xmlResponse): Boolean {
+
+            return true;
+
+        },
+
+        transform: function (xmlResponse): Object[] {
+
+            let $tempXmlResponse: JQuery,
+                nextCallDataArr: Object[] = [];
+
+            $tempXmlResponse = $(xmlResponse);
+
+            $tempXmlResponse.find('subCategory').each(function (index, node) {
+
+                let $tempIdNode = $(node).find('id');
+
+                nextCallDataArr.push({
+
+                    name: $tempIdNode.attr('name'),
+                    value: $tempIdNode.text()
+
+                });
+
+            });
+
+            return nextCallDataArr;
+
+        }
+
+    };
+
+    configurationObj4 = {
+
+        ajaxSettings: {
+
+            type: 'GET',
+            dataType: 'xml',
+            url: '/subcategories'
+
+        }
+
+    };
+
+    ajaxChain.enqueue([configurationObj1, configurationObj2, configurationObj3, configurationObj4])
+             .dequeue()
+             .then(doneResult => { console.log(doneResult); },
+                   failResult => { console.log(failResult); },
+                   progressResult => { console.log(progressResult); });
+
+}
diff --git a/jquery-ajax-chain/jquery-ajax-chain.d.ts b/jquery-ajax-chain/jquery-ajax-chain.d.ts
new file mode 100644
index 0000000000..3d67e3742b
--- /dev/null
+++ b/jquery-ajax-chain/jquery-ajax-chain.d.ts
@@ -0,0 +1,97 @@
+// Type definitions for jquery-ajax-chain v 1.0.4
+// Project: https://github.com/humana-fragilitas/jQuery-Ajax-Chain/
+// Definitions by: Andrea Blasio <https://github.com/humana-fragilitas>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../jquery/jquery.d.ts" />
+
+declare module ajaxChain {
+
+    /**
+     * Static members of JQueryAjaxChain
+     */
+    interface JQueryAjaxChainStatic {
+
+        new (): JQueryAjaxChain
+
+    }
+
+    /**
+     * Instance members of JQueryAjaxChain
+     */
+    interface JQueryAjaxChain extends JQueryPromise<any> {
+
+        /**
+         * Enqueues one or more configuration objects for later processing.
+         */
+        enqueue(confObj: AjaxChainConfiguration | AjaxChainConfiguration[]): JQueryAjaxChain;
+        /**
+         * Sequentially and synchronously dequeues the configuration objects enqueued via enqueue() method
+         * in the order they were added, triggering the related Ajax calls.
+         */
+        dequeue(): JQueryAjaxChain;
+        /**
+         * Clears the currently queued configuration objects.
+         */
+        clearQueue(): JQueryAjaxChain;
+
+    }
+
+    /**
+     * A set of key/value pairs that configure the AjaxChain request; 'ajaxSettings' is mandatory.
+     */
+    interface AjaxChainConfiguration {
+
+        /**
+         * jQuery $.ajax method settings (required).
+         */
+        ajaxSettings: JQueryAjaxSettings;
+        /**
+         * Configuration object label (optional).
+         */
+        label?: String;
+        /**
+         * Returning a truthy value (Object) allows to arbitrarily overwrite the next queued Ajax call
+         * 'data' property value specified in the original jQuery $.ajax method configuration
+         * object ('ajaxSettings') (optional).
+         */
+        transform?: (response: any) => String | Object | Object[];
+        /**
+         * Returning a truthy value (String) allows to append a string to the next queued
+         * Ajax call 'url' property value specified in original jQuery $.ajax method configuration
+         * object ('ajaxSettings') (optional).
+         */
+        appendToUrl?: (response: any) => String;
+        /**
+         * Returning a truthy value determines any registered fail callback(s) to be called immediately,
+         * passing the former as an argument to the latter; the queue is then rejected (optional).
+         */
+        hasErrors?: (response: any) => any;
+        /**
+         * Returning a truthy value allows to prevent the related Ajax call from being executed,
+         * passing the former as a parameter to any registered handler(s); useful to create
+         * caching mechanisms (optional).
+         */
+        hasCache?: (response: any) => any;
+        /**
+         * Returning a truthy value prevents the queue from further progressing to the succeeding
+         * Ajax calls; the queue is then resolved (optional).
+         */
+        hasHaltingCapabilities?: (response: any) => Boolean;
+        /**
+         * Returning a truthy value prevents the queue from being halted in case of Ajax error (optional).
+         */
+        isSkippable?: (response: any) => Boolean;
+
+    }
+
+}
+
+interface JQueryStatic {
+
+    /**
+     * JQueryAjaxChain constructor
+     */
+    AjaxChain: ajaxChain.JQueryAjaxChainStatic; 
+
+}
\ No newline at end of file
diff --git a/jquery.ajaxfile/jquery.ajaxFile-tests.ts b/jquery.ajaxfile/jquery.ajaxFile-tests.ts
index 4a98706a46..e5f82fb00a 100644
--- a/jquery.ajaxfile/jquery.ajaxFile-tests.ts
+++ b/jquery.ajaxfile/jquery.ajaxFile-tests.ts
@@ -4,7 +4,7 @@
 
 function testRawApi(){
 	var inputElement:HTMLInputElement = null;
-	var resultPromise = AjaxFile.send({
+	var resultPromise = AjaxFile.send<number>({
 		method: 'POST',
 		url: '/',
 		desiredResponseDataType: JQueryAjaxFile.DataType.Json,
@@ -42,7 +42,7 @@ function testJQuery() {
         global: true,
         timeout: 60
     };
-    extension.ajaxWithFile(option);
+    extension.ajaxWithFile<number>(option);
 }
 
 function testKnockoutExtension(){
diff --git a/jquery.ajaxfile/jquery.ajaxFile.d.ts b/jquery.ajaxfile/jquery.ajaxFile.d.ts
index 459287a278..ff0a18a596 100644
--- a/jquery.ajaxfile/jquery.ajaxFile.d.ts
+++ b/jquery.ajaxfile/jquery.ajaxFile.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for jquery.ajaxfile v0.1.0
+// Type definitions for jquery.ajaxfile v0.2.0
 // Project: https://github.com/fpellet/jquery.ajaxFile
 // Definitions by: Florent PELLET <https://github.com/fpellet/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -35,27 +35,28 @@ declare namespace JQueryAjaxFile {
 		isSuccess: boolean;
 	}
 
-	interface IAjaxFileResult {
+	interface IAjaxFileResult<T> {
 		error?: any;
 		data?: any;
 		status?: IResponseStatus;
 	}
 
-	interface IAjaxFileResultCallback {
-		(result: IAjaxFileResult): void;
+	interface IAjaxFileResultCallback<T> {
+		(result: IAjaxFileResult<T>): void;
 	}
 
-	interface IAjaxFilePromise {
-		then(success: IAjaxFileResultCallback, error?: IAjaxFileResultCallback): IAjaxFilePromise;
-		done(success: IAjaxFileResultCallback): IAjaxFilePromise;
-		fail(error: IAjaxFileResultCallback): IAjaxFilePromise;
-		always(error: IAjaxFileResultCallback): IAjaxFilePromise;
+	interface IAjaxFilePromise<T> {
+		then(success: IAjaxFileResultCallback<T>, error?: IAjaxFileResultCallback<T>): IAjaxFilePromise<T>;
+		done(success: IAjaxFileResultCallback<T>): IAjaxFilePromise<T>;
+		fail(error: IAjaxFileResultCallback<T>): IAjaxFilePromise<T>;
+		always(error: IAjaxFileResultCallback<T>): IAjaxFilePromise<T>;
 
 		abord(): void;
 	}
 
 	interface IAjaxFileStatic {
-		send(option: IOption): IAjaxFilePromise;
+		DataType: typeof DataType;
+		send<T>(option: IOption): IAjaxFilePromise<T>;
 	}
 	
 	interface IJQueryXHR {
@@ -97,7 +98,7 @@ declare namespace JQueryAjaxFile {
     }
 
     interface IAjaxFileJQueryExtension {
-        ajaxWithFile(jqueryOption: IJQueryOption): JQueryDeferred<any>;
+        ajaxWithFile<T>(jqueryOption: IJQueryOption): JQueryDeferred<T>;
     }
 }
 
diff --git a/jqueryui/jqueryui-tests.ts b/jqueryui/jqueryui-tests.ts
index 34f1f4b7e7..bc84cb475a 100644
--- a/jqueryui/jqueryui-tests.ts
+++ b/jqueryui/jqueryui-tests.ts
@@ -1438,6 +1438,7 @@ function test_dialog() {
     });
     $(".selector").dialog({ autoOpen: false });
     $(".selector").dialog({ buttons: { Ok: function () { $(this).dialog("close"); } } });
+    $(".selector").dialog({ buttons: [ { text: "Ok", click: function () { $(this).dialog("close"); } } ] } );
     $(".selector").dialog({ closeOnEscape: false });
     $(".selector").dialog({ closeText: "hide" });
     $(".selector").dialog({ dialogClass: "alert" });
diff --git a/jqueryui/jqueryui.d.ts b/jqueryui/jqueryui.d.ts
index d5e60cd0de..a5f77eaded 100644
--- a/jqueryui/jqueryui.d.ts
+++ b/jqueryui/jqueryui.d.ts
@@ -86,7 +86,8 @@ declare module JQueryUI {
         disabled?: boolean;
         icons?: any;
         label?: string;
-        text?: boolean;
+        text?: string|boolean;
+        click?: (event?: Event) => void;
     }
 
     interface Button extends Widget, ButtonOptions {
diff --git a/js-data-http/js-data-http-tests.ts b/js-data-http/js-data-http-tests.ts
index d7c07d654e..00457d7142 100644
--- a/js-data-http/js-data-http-tests.ts
+++ b/js-data-http/js-data-http-tests.ts
@@ -28,7 +28,7 @@ ADocument.inject({ id: 5, author: 'John' });
 ADocument.inject({ id: 6, author: 'John' });
 
 // bypass the data store
-adapter.updateAll(ADocument, { author: 'Johnny' }, { author: 'John' }).then(function (documents) {
+adapter.updateAll<{ id?: number; author: string; }>(ADocument, { author: 'Johnny' }, { author: 'John' }).then(function (documents) {
     documents[0]; // { id: 5, author: 'Johnny' }
 
     // The updated documents have NOT been injected into the data store because we bypassed the data store
@@ -37,7 +37,7 @@ adapter.updateAll(ADocument, { author: 'Johnny' }, { author: 'John' }).then(func
 });
 
 // Normally you would just go through the data store
-ADocument.updateAll({ author: 'Johnny' }, { author: 'John' }).then(function (documents) {
+ADocument.updateAll<{ id?: number; author: string; }>({ author: 'Johnny' }, { author: 'John' }).then(function (documents) {
     documents[0]; // { id: 5, author: 'Johnny' }
 
     // the updated documents have been injected into the data store
@@ -164,4 +164,4 @@ ADocument.create({ author: 'John' }).then(function (document:any) {
 
     // the new document has been injected into the data store
     ADocument.get(document.id); // { id: 5, author: 'John' }
-});
\ No newline at end of file
+});
diff --git a/js-data/js-data.d.ts b/js-data/js-data.d.ts
index e17c4ae0d4..604b70e6c4 100644
--- a/js-data/js-data.d.ts
+++ b/js-data/js-data.d.ts
@@ -153,7 +153,7 @@ declare module JSData {
         findAll<T>(params?:DSFilterParams, options?:DSAdapterOperationConfiguration):JSDataPromise<Array<T>>;
         loadRelations<T>(idOrInstance:string | number | Object, relations:string | Array<string>, options?:DSAdapterOperationConfiguration):JSDataPromise<T>;
         update<T>(id:string | number, attrs:Object, options?:DSSaveConfiguration):JSDataPromise<T>;
-        updateAll<T>(attrs:Object, params?:DSFilterParams, options?:DSAdapterOperationConfiguration):JSDataPromise<Array<T>>;
+        updateAll<T>(attrs:Object, params?:DSFilterParams & T, options?:DSAdapterOperationConfiguration):JSDataPromise<Array<T>>;
         reap(resourceNametions?:DSConfiguration):JSDataPromise<any>;
         refresh<T>(id:string | number, options?:DSAdapterOperationConfiguration):JSDataPromise<T>;
         save<T>(id:string | number, options?:DSSaveConfiguration):JSDataPromise<T>;
@@ -283,7 +283,7 @@ declare module JSData {
 
         update<T>(config:DSResourceDefinition<T>, id:string | number, attrs:Object, options?:DSConfiguration):JSDataPromise<T>;
 
-        updateAll<T>(config:DSResourceDefinition<T>, attrs:Object, params?:DSFilterParams, options?:DSConfiguration):JSDataPromise<T>;
+        updateAll<T>(config:DSResourceDefinition<T>, attrs:Object, params?:DSFilterParams & T, options?:DSConfiguration):JSDataPromise<T[]>;
     }
 }
 
@@ -297,4 +297,4 @@ declare var JSData:{
 declare module 'js-data' {
 
     export = JSData;
-}
\ No newline at end of file
+}
diff --git a/jsdom/jsdom-tests.ts b/jsdom/jsdom-tests.ts
index 504f1f0641..1f0d04a0b5 100644
--- a/jsdom/jsdom-tests.ts
+++ b/jsdom/jsdom-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./jsdom.d.ts" />
+
 import jsdom = require("jsdom");
 
 jsdom.defaultDocumentFeatures.FetchExternalResources = ["img"];
diff --git a/karma/karma-0.12.d.ts b/karma/karma-0.12.d.ts
new file mode 100644
index 0000000000..c66e6fe06a
--- /dev/null
+++ b/karma/karma-0.12.d.ts
@@ -0,0 +1,24 @@
+// Type definitions for karma v0.12.37
+// Project: https://github.com/karma-runner/karma
+// Definitions by: Tanguy Krotoff <https://github.com/tkrotoff>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'karma' {
+    // See Karma public API https://karma-runner.github.io/0.12/dev/public-api.html
+
+    interface IKarmaServer {
+        start(options?: any, callback?: (exitCode: number) => void): void;
+    }
+
+    interface IKarmaRunner {
+        run(options?: any, callback?: (exitCode: number) => void): void;
+    }
+
+    interface IKarma {
+        server: IKarmaServer;
+        runner: IKarmaRunner;
+    }
+
+    var karma: IKarma;
+    export = karma;
+}
diff --git a/karma/karma-tests-0.12.ts b/karma/karma-tests-0.12.ts
new file mode 100644
index 0000000000..b402c08049
--- /dev/null
+++ b/karma/karma-tests-0.12.ts
@@ -0,0 +1,26 @@
+/// <reference path="karma-0.12.d.ts" />
+/// <reference path="../gulp/gulp.d.ts" />
+
+import gulp = require('gulp');
+import karma = require('karma');
+
+function runKarma(singleRun: boolean): void {
+  karma.server.start({
+    configFile: __dirname + '/karma.conf.js',
+    singleRun: singleRun
+  });
+}
+
+gulp.task('test:unit:karma', ['build:test:unit'], () => runKarma(true));
+
+
+karma.server.start({port: 9876}, (exitCode: number) => {
+  console.log('Karma has exited with ' + exitCode);
+  process.exit(exitCode);
+});
+
+
+karma.runner.run({port: 9876}, (exitCode: number) => {
+  console.log('Karma has exited with ' + exitCode);
+  process.exit(exitCode);
+});
diff --git a/karma/karma-tests.ts b/karma/karma-tests.ts
index b70e7273be..dd571f8ae5 100644
--- a/karma/karma-tests.ts
+++ b/karma/karma-tests.ts
@@ -4,23 +4,51 @@
 import gulp = require('gulp');
 import karma = require('karma');
 
+
 function runKarma(singleRun: boolean): void {
-  karma.server.start({
-    configFile: __dirname + '/karma.conf.js',
-    singleRun: singleRun
-  });
+    // MEMO: `start` method is deprecated since 0.13. It will be removed in 0.14.
+    karma.server.start({
+        configFile: __dirname + '/karma.conf.js',
+        singleRun: singleRun
+    });
 }
 
 gulp.task('test:unit:karma', ['build:test:unit'], () => runKarma(true));
 
 
-karma.server.start({port: 9876}, (exitCode) => {
+
+karma.server.start({port: 9876}, (exitCode: number) => {
   console.log('Karma has exited with ' + exitCode);
   process.exit(exitCode);
 });
 
 
-karma.runner.run({port: 9876}, (exitCode) => {
+karma.runner.run({port: 9876}, (exitCode: number) => {
   console.log('Karma has exited with ' + exitCode);
   process.exit(exitCode);
 });
+
+
+var Server = require('karma').Server;
+var server = new Server({port: 9876}, function(exitCode: number) {
+    console.log('Karma has exited with ' + exitCode);
+    process.exit(exitCode);
+});
+
+server.start();
+
+server.refreshFiles();
+
+server.on('browser_register', function (browser: any) {
+    console.log('A new browser was registered');
+});
+
+var runner = require('karma').runner;
+runner.run({port: 9876}, function(exitCode: number) {
+    console.log('Karma has exited with ' + exitCode);
+    process.exit(exitCode);
+});
+
+//
+
+var captured: boolean = karma.launcher.areAllCaptured();
diff --git a/karma/karma.d.ts b/karma/karma.d.ts
index c66e6fe06a..cad9eb6ba6 100644
--- a/karma/karma.d.ts
+++ b/karma/karma.d.ts
@@ -1,24 +1,368 @@
-// Type definitions for karma v0.12.37
+// Type definitions for karma v0.13.9
 // Project: https://github.com/karma-runner/karma
 // Definitions by: Tanguy Krotoff <https://github.com/tkrotoff>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
+/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../node/node.d.ts" />
+/// <reference path="../log4js/log4js.d.ts" />
+
 declare module 'karma' {
     // See Karma public API https://karma-runner.github.io/0.12/dev/public-api.html
+    import Promise = require('bluebird');
+    import https = require('https');
+    import log4js = require('log4js');
 
-    interface IKarmaServer {
-        start(options?: any, callback?: (exitCode: number) => void): void;
+    namespace karma {
+        interface Karma {
+            /**
+             * `start` method is deprecated since 0.13. It will be removed in 0.14.
+             * Please use
+             * <code>
+             *     server = new Server(config, [done])
+             *     server.start()
+             * </code>
+             * instead.
+             */
+            server: DeprecatedServer;
+            Server: Server;
+            runner: Runner;
+            launcher: Launcher;
+            VERSION: string;
+        }
+
+        interface LauncherStatic {
+            generateId(): string;
+            //TODO: injector should be of type `di.Injector`
+            new(emitter: NodeJS.EventEmitter, injector: any): Launcher;
+        }
+
+        interface Launcher {
+            Launcher: LauncherStatic;
+            //TODO: Can this return value ever be typified?
+            launch(names: string[], protocol: string, hostname: string, port: number, urlRoot: string): any[];
+            kill(id: string, callback: Function): boolean;
+            restart(id: string): boolean;
+            killAll(callback: Function): void;
+            areAllCaptured(): boolean;
+            markCaptured(id: string): void;
+        }
+
+        interface DeprecatedServer {
+            start(options?: any, callback?: ServerCallback): void;
+        }
+
+        interface Runner {
+            run(options?: Config, callback?: ServerCallback): void;
+        }
+
+        interface Server extends NodeJS.EventEmitter {
+            new(options?: Config, callback?: ServerCallback): Server;
+            /**
+             * Start the server
+             */
+            start(): void;
+            /**
+             * Get properties from the injector
+             * @param token
+             */
+            get(token: string): any;
+            /**
+             * Force a refresh of the file list
+             */
+            refreshFiles(): Promise<any>;
+
+            ///**
+            // * Backward-compatibility with karma-intellij bundled with WebStorm.
+            // * Deprecated since version 0.13, to be removed in 0.14
+            // */
+            //static start(): void;
+        }
+
+        interface ServerCallback {
+            (exitCode: number): void;
+        }
+
+        interface Config {
+            /**
+             * @description Enable or disable watching files and executing the tests whenever one of these files changes.
+             * @default true
+             */
+            autoWatch?: boolean;
+            /**
+             * @description When Karma is watching the files for changes, it tries to batch multiple changes into a single run
+             * so that the test runner doesn't try to start and restart running tests more than it should.
+             * The configuration setting tells Karma how long to wait (in milliseconds) after any changes have occurred
+             * before starting the test process again.
+             * @default 250
+             */
+            autoWatchBatchDelay?: number;
+            /**
+             * @default ''
+             * @description The root path location that will be used to resolve all relative paths defined in <code>files</code> and <code>exclude</code>.
+             * If the basePath configuration is a relative path then it will be resolved to
+             * the <code>__dirname</code> of the configuration file.
+             */
+            basePath?: string;
+            /**
+             * @default 2000
+             * @description How long does Karma wait for a browser to reconnect (in ms).
+             * <p>
+             * With a flaky connection it is pretty common that the browser disconnects,
+             * but the actual test execution is still running without any problems. Karma does not treat a disconnection
+             * as immediate failure and will wait <code>browserDisconnectTimeout</code> (ms).
+             * If the browser reconnects during that time, everything is fine.
+             * </p>
+             */
+            browserDisconnectTimeout?: number;
+            /**
+             * @default 0
+             * @description The number of disconnections tolerated.
+             * <p>
+             * The <code>disconnectTolerance</code> value represents the maximum number of tries a browser will attempt
+             * in the case of a disconnection. Usually any disconnection is considered a failure,
+             * but this option allows you to define a tolerance level when there is a flaky network link between
+             * the Karma server and the browsers.
+             * </p>
+             */
+            browserDisconnectTolerance?: number;
+            /**
+             * @default 10000
+             * @description How long will Karma wait for a message from a browser before disconnecting from it (in ms).
+             * <p>
+             * If, during test execution, Karma does not receive any message from a browser within
+             * <code>browserNoActivityTimeout</code> (ms), it will disconnect from the browser
+             * </p>
+             */
+            browserNoActivityTimeout?: number;
+            /**
+             * @default []
+             * Possible Values:
+             * <ul>
+             *     <li>Chrome (launcher comes installed with Karma)</li>
+             *     <li>ChromeCanary (launcher comes installed with Karma)</li>
+             *     <li>PhantomJS (launcher comes installed with Karma)</li>
+             *     <li>Firefox (launcher requires karma-firefox-launcher plugin)</li>
+             *     <li>Opera (launcher requires karma-opera-launcher plugin)</li>
+             *     <li>Internet Explorer (launcher requires karma-ie-launcher plugin)</li>
+             *     <li>Safari (launcher requires karma-safari-launcher plugin)</li>
+             * </ul>
+             * @description A list of browsers to launch and capture. When Karma starts up, it will also start up each browser
+             * which is placed within this setting. Once Karma is shut down, it will shut down these browsers as well.
+             * You can capture any browser manually by opening the browser and visiting the URL where
+             * the Karma web server is listening (by default it is <code>http://localhost:9876/</code>).
+             */
+            browsers?: string[];
+            /**
+             * @default 60000
+             * @description Timeout for capturing a browser (in ms).
+             * <p>
+             * The <code>captureTimeout</code> value represents the maximum boot-up time allowed for a
+             * browser to start and connect to Karma. If any browser does not get captured within the timeout, Karma
+             * will kill it and try to launch it again and, after three attempts to capture it, Karma will give up.
+             * </p>
+             */
+            captureTimeout?: number;
+            client?: ClientConfig;
+            /**
+             * @default true
+             * @description Enable or disable colors in the output (reporters and logs).
+             */
+            colors?: boolean;
+            /**
+             * @default []
+             * @description List of files/patterns to exclude from loaded files.
+             */
+            exclude?: string[];
+            /**
+             * @default []
+             * @description List of files/patterns to load in the browser.
+             */
+            files?: (FilePattern|string)[];
+            /**
+             * @default []
+             * @description List of test frameworks you want to use. Typically, you will set this to ['jasmine'], ['mocha'] or ['qunit']...
+             * Please note just about all frameworks in Karma require an additional plugin/framework library to be installed (via NPM).
+             */
+            frameworks?: string[];
+            /**
+             * @default 'localhost'
+             * @description Hostname to be used when capturing browsers.
+             */
+            hostname?: string;
+            /**
+             * @default {}
+             * @description Options object to be used by Node's https class.
+             * Object description can be found in the
+             * [NodeJS.org API docs](https://nodejs.org/api/tls.html#tls_tls_createserver_options_secureconnectionlistener)
+             */
+            httpsServerOptions?: https.ServerOptions;
+            /**
+             * @default config.LOG_INFO
+             * Possible values:
+             * <ul>
+             *   <li>config.LOG_DISABLE</li>
+             *   <li>config.LOG_ERROR</li>
+             *   <li>config.LOG_WARN</li>
+             *   <li>config.LOG_INFO</li>
+             *   <li>config.LOG_DEBUG</li>
+             * </ul>
+             * @description Level of logging.
+             */
+            logLevel?: string;
+            /**
+             * @default [{type: 'console'}]
+             * @description A list of log appenders to be used. See the documentation for [log4js] for more information.
+             */
+            loggers?: log4js.AppenderConfigBase[];
+            /**
+             * @default ['karma-*']
+             * @description List of plugins to load. A plugin can be a string (in which case it will be required
+             * by Karma) or an inlined plugin - Object.
+             * By default, Karma loads all sibling NPM modules which have a name starting with karma-*.
+             * Note: Just about all plugins in Karma require an additional library to be installed (via NPM).
+             */
+            plugins?: any[];
+            /**
+             * @default 9876
+             * @description The port where the web server will be listening.
+             */
+            port?: number;
+            /**
+             * @default {'**\/*.coffee': 'coffee'}
+             * @description A map of preprocessors to use.
+             *
+             * Preprocessors can be loaded through [plugins].
+             *
+             * Note: Just about all preprocessors in Karma (other than CoffeeScript and some other defaults)
+             * require an additional library to be installed (via NPM).
+             *
+             * Be aware that preprocessors may be transforming the files and file types that are available at run time. For instance,
+             * if you are using the "coverage" preprocessor on your source files, if you then attempt to interactively debug
+             * your tests, you'll discover that your expected source code is completely changed from what you expected.  Because
+             * of that, you'll want to engineer this so that your automated builds use the coverage entry in the "reporters" list,
+             * but your interactive debugging does not.
+             *
+             */
+            preprocessors?: { [name: string]: string|string[] }
+            /**
+             * @default 'http:'
+             * Possible Values:
+             * <ul>
+             *   <li>http:</li>
+             *   <li>https:</li>
+             * </ul>
+             * @description Protocol used for running the Karma webserver.
+             * Determines the use of the Node http or https class.
+             * Note: Using <code>'https:'</code> requires you to specify <code>httpsServerOptions</code>.
+             */
+            protocol?: string;
+            /**
+             * @default {}
+             * @description A map of path-proxy pairs.
+             */
+            proxies?: { [path: string]: string }
+            /**
+             * @default true
+             * @description Whether or not Karma or any browsers should raise an error when an inavlid SSL certificate is found.
+             */
+            proxyValidateSSL?: boolean;
+            /**
+             * @default 0
+             * @description Karma will report all the tests that are slower than given time limit (in ms).
+             * This is disabled by default (since the default value is 0).
+             */
+            reportSlowerThan?: number;
+            /**
+             * @default ['progress']
+             * Possible Values:
+             * <ul>
+             *   <li>dots</li>
+             *   <li>progress</li>
+             * </ul>
+             * @description A list of reporters to use.
+             * Additional reporters, such as growl, junit, teamcity or coverage can be loaded through plugins.
+             * Note: Just about all additional reporters in Karma (other than progress) require an additional library to be installed (via NPM).
+             */
+            reporters?: string[];
+            /**
+             * @default false
+             * @description Continuous Integration mode.
+             * If true, Karma will start and capture all configured browsers, run tests and then exit with an exit code of 0 or 1 depending
+             * on whether all tests passed or any tests failed.
+             */
+            singleRun?: boolean;
+            /**
+             * @default ['polling', 'websocket']
+             * @description An array of allowed transport methods between the browser and testing server. This configuration setting
+             * is handed off to [socket.io](http://socket.io/) (which manages the communication
+             * between browsers and the testing server).
+             */
+            transports?: string[];
+            /**
+             * @default '/'
+             * @description The base url, where Karma runs.
+             * All of Karma's urls get prefixed with the urlRoot. This is helpful when using proxies, as
+             * sometimes you might want to proxy a url that is already taken by Karma.
+             */
+            urlRoot?: string;
+        }
+
+        interface ClientConfig {
+            /**
+             * @default undefined
+             * @description When karma run is passed additional arguments on the command-line, they
+             * are passed through to the test adapter as karma.config.args (an array of strings).
+             * The client.args option allows you to set this value for actions other than run.
+             * How this value is used is up to your test adapter - you should check your adapter's
+             * documentation to see how (and if) it uses this value.
+             */
+            args?: string[];
+            /**
+             * @default true
+             * @description Run the tests inside an iFrame or a new window
+             * If true, Karma runs the tests inside an iFrame. If false, Karma runs the tests in a new window. Some tests may not run in an
+             * iFrame and may need a new window to run.
+             */
+            useIframe?: boolean;
+            /**
+             * @default true
+             * @description Capture all console output and pipe it to the terminal.
+             */
+            captureConsole?: boolean;
+        }
+
+        interface FilePattern {
+            /**
+             * The pattern to use for matching. This property is mandatory.
+             */
+            pattern: string;
+            /**
+             * @default true
+             * @description If <code>autoWatch</code> is true all files that have set watched to true will be watched
+             * for changes.
+             */
+            watched?: boolean;
+            /**
+             * @default true
+             * @description Should the files be included in the browser using <script> tag? Use false if you want to
+             * load them manually, eg. using Require.js.
+             */
+            included?: boolean;
+            /**
+             * @default true
+             * @description Should the files be served by Karma's webserver?
+             */
+            served?: boolean;
+            /**
+             * @default false
+             * @description Should the files be served from disk on each request by Karma's webserver?
+             */
+            nocache?: boolean;
+        }
     }
 
-    interface IKarmaRunner {
-        run(options?: any, callback?: (exitCode: number) => void): void;
-    }
+    var karma: karma.Karma;
 
-    interface IKarma {
-        server: IKarmaServer;
-        runner: IKarmaRunner;
-    }
-
-    var karma: IKarma;
     export = karma;
 }
diff --git a/kefir/kefir-tests.ts b/kefir/kefir-tests.ts
new file mode 100644
index 0000000000..c423a3dfe3
--- /dev/null
+++ b/kefir/kefir-tests.ts
@@ -0,0 +1,222 @@
+/// <reference path="./kefir.d.ts" />
+
+import * as Kefir from 'kefir';
+import { Observable, ObservablePool, Stream, Property, Event, Emitter } from 'kefir';
+
+//Create a stream
+{
+	let stream01: Stream<void, void> = Kefir.never();
+	let stream02: Stream<number, void> = Kefir.later(1000, 1);
+	let stream03: Stream<number, void> = Kefir.interval(1000, 1);
+	let stream04: Stream<number, void> = Kefir.sequentially(1000, [1, 2, 3]);
+	{
+		let start = +new Date();
+		let stream05: Stream<number, void> = Kefir.fromPoll(1000, () => +new Date() - start);
+	}
+	{
+		let start = +new Date();
+		let stream06: Stream<number, void> = Kefir.withInterval<number, void>(1000, function(emitter) {
+			var time = +new Date() - start;
+			if (time < 4000) {
+				emitter.emit(time);
+			} else {
+				emitter.end();
+			}
+		});
+	}
+	let stream07: Stream<number, void> = Kefir.fromCallback<number>(callback => setTimeout(() => callback(1), 1000));
+	let stream08: Stream<number, void> = Kefir.fromNodeCallback<number, void>(callback => setTimeout(() => callback(null, 1), 1000));
+	let stream09: Stream<MouseEvent, void> = Kefir.fromEvents<MouseEvent, void>(document.body, 'click');
+	let stream10: Stream<number, void> = Kefir.stream<number, void>(emitter => {
+		let count = 0;
+		emitter.emit(count);
+	
+		let intervalId = setInterval(() => {
+			count++;
+			if (count < 4) {
+				emitter.emit(count);
+			} else {
+				emitter.end();
+			}
+		}, 1000);
+	
+		return () => clearInterval(intervalId);
+	});
+}
+
+// Create a property
+{
+	let property01: Property<number, void> = Kefir.constant(1);
+	let property02: Property<void, number> = Kefir.constantError(1);
+	let property03: Property<number, void> = Kefir.fromPromise<number, void>(new Promise<number>(fulfill => fulfill(1)));
+}
+
+// Convert observables
+{
+	let property: Property<number, void> = Kefir.sequentially(100, [1, 2, 3]).toProperty(() => 0);
+	let stream: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).toProperty(() => 0).changes();
+}
+
+// Subscribe / add side effects
+{
+	Kefir.sequentially(1000, [1, 2]).onValue(x => console.log('value:', x));
+	Kefir.sequentially(1000, [1, 2]).offValue(x => console.log('value:', x));
+	Kefir.sequentially(1000, [1, 2]).valuesToErrors().onValue(x => console.log('error:', x));
+	Kefir.sequentially(1000, [1, 2]).valuesToErrors().offValue(x => console.log('error:', x));
+	Kefir.sequentially(1000, [1, 2]).onEnd(() => console.log('stream ended'));
+	Kefir.sequentially(1000, [1, 2]).offEnd(() => console.log('stream ended'));
+	Kefir.sequentially(1000, [1, 2]).onAny(event => console.log('event:', event));
+	Kefir.sequentially(1000, [1, 2]).offAny(event => console.log('event:', event));
+	Kefir.sequentially(1000, [1, 2]).log('my stream');
+	Kefir.sequentially(1000, [1, 2]).offLog('my stream');
+	Kefir.sequentially(1000, [1, 2]).toPromise().then(x => console.log('fulfilled with:', x));
+}
+
+// Modify an observable
+{
+	let observable01: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).map(x => x + 1);
+	let observable02: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).filter(x => x > 1);
+	let observable03: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).take(2);
+	let observable04: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).takeWhile(x => x < 3);
+	let observable05: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).last();
+	let observable06: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).skip(2);
+	let observable07: Stream<number, void> = Kefir.sequentially(100, [1, 3, 2]).skipWhile(x => x < 3);
+	let observable08: Stream<number, void> = Kefir.sequentially(100, [1, 2, 2, 3, 1]).skipDuplicates();
+	let observable09: Stream<number, void> = Kefir.sequentially(100, [1, 2, 2.1, 3, 1]).skipDuplicates((a, b) => Math.round(a) === Math.round(b));
+	let observable10: Stream<number, void> = Kefir.sequentially(100, [1, 2, 2, 3]).diff((prev, next) => next - prev, 0);
+	let observable11: Stream<number, void> = Kefir.sequentially(100, [1, 2, 2, 3]).scan((prev, next) => next + prev, 0);
+	let observable12: Stream<number, void> = Kefir.sequentially(100, [[1], [], [2,3]]).flatten<number>();
+	let observable13: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3, 4]).flatten<number>(x => x % 2 === 0 ? [x * 10] : []);
+	let observable14: Stream<number, void> = Kefir.sequentially(200, [1, 2, 3]).delay(100);
+	let observable15: Stream<number, void> = Kefir.sequentially(750, [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]).throttle(2500);
+	let observable16: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3, 0, 0, 0, 4, 5, 6]).filter(x => x > 0).debounce(250);
+	let observable17: Stream<void, number> = Kefir.sequentially(100, [0, -1, 2, -3]).valuesToErrors<number>(x => {
+		return {convert: x < 0, error: x * 2};
+	});
+	let observable18: Stream<number, void> = Kefir.sequentially(100, [0, -1, 2, -3]).valuesToErrors<number>().errorsToValues<number>((x: number) => {
+		return {convert: x >= 0, value: x * 2};
+	});
+	let observable19: Stream<void, number> = Kefir.sequentially(100, [0, 1, 2, 3]).valuesToErrors<number>().mapErrors((x: number) => x * 2);
+	let observable20: Stream<void, number> = Kefir.sequentially(100, [0, 1, 2, 3]).valuesToErrors<number>().filterErrors((x: number) => (x % 2) === 0);
+	let observable21: Stream<void, number> = Kefir.sequentially(100, [0, -1, 2, -3]).valuesToErrors(x => {
+		return {convert: x < 0, error: x};
+	}).endOnError();
+	let observable22: Stream<void, number> = Kefir.sequentially(100, [0, -1, 2, -3]).valuesToErrors(x => {
+		return {convert: x < 0, error: x};
+	}).skipValues();
+	let observable23: Stream<void, void> = Kefir.sequentially(100, [0, -1, 2, -3]).valuesToErrors(x => {
+		return {convert: x < 0, error: x};
+	}).skipErrors();
+	let observable24: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).skipEnd();
+	let ovservable25: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).beforeEnd(() => 0);
+	let observable26: Stream<number[], void> = Kefir.sequentially(100, [1, 2, 3, 4, 5]).slidingWindow(3, 2)
+	let observable27: Stream<number[], void> = Kefir.sequentially(100, [1, 2, 3, 4, 5]).bufferWhile(x => x !== 3);
+	{
+		var myTransducer: any;
+		let observable28: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3, 4, 5, 6]).transduce<number>(myTransducer);
+	}
+	let observable28: Stream<number | string, void> =  Kefir.sequentially(100, [0, 1, 2, 3]).withHandler<number | string, void>((emitter: Emitter<string | number, void>, event: Event<number>) => {
+		if (event.type === 'end') {
+			emitter.emit('bye');
+			emitter.end();
+		}
+		if (event.type === 'value') {
+			for (var i = 0; i < event.value; i++) {
+				emitter.emit(event.value);
+			}
+		}
+	});
+}
+
+// Combine observables
+{
+	{
+		let a: Stream<number, void> = Kefir.sequentially(100, [1, 3]);
+		let b: Stream<number, void> = Kefir.sequentially(100, [2, 4]).delay(40);
+		let observable01: Observable<number, void> = Kefir.combine<number, void, number>([a, b], (a, b) => a + b);
+	}
+	{
+		let a: Stream<number, void> = Kefir.sequentially(100, [1, 3]);
+		let b: Stream<number, void> = Kefir.sequentially(100, [2, 4]).delay(40);
+		let c: Stream<number, void> = Kefir.sequentially(60, [5, 6, 7]);
+		let observable02: Observable<number, void> = Kefir.combine<number, void, number>([a, b], [c], (a, b, c) => a + b + c);
+	}
+	{
+		let a: Stream<number, void> = Kefir.sequentially(100, [0, 1, 2, 3]);
+		let b: Stream<number, void> = Kefir.sequentially(160, [4, 5, 6]);
+		let c: Property<number, void> = Kefir.sequentially(100, [8, 9]).delay(260).toProperty(() => 7);
+		let observable03: Observable<number, void> = Kefir.zip<number, void, number>([a, b, c]);
+	}
+	{
+		let a: Stream<number, void> = Kefir.sequentially(100, [0, 1, 2]);
+		let b: Stream<number, void> = Kefir.sequentially(100, [0, 1, 2]).delay(30);
+		let c: Stream<number, void> = Kefir.sequentially(100, [0, 1, 2]).delay(60);
+		let abc: Observable<number, void> = Kefir.merge<number, void>([a, b, c]);
+	}
+	{
+		let a: Stream<number, void> = Kefir.sequentially(100, [0, 1, 2]);
+		let b: Stream<number, void> = Kefir.sequentially(100, [3, 4, 5]);
+		let abc: Observable<number, void> = Kefir.concat<number, void>([a, b]);
+	}
+	{
+		let a: Stream<number, void> = Kefir.sequentially(100, [0, 1, 2]);
+		let b: Stream<number, void> = Kefir.sequentially(100, [0, 1, 2]).delay(30);
+		let c: Observable<number, void> = Kefir.sequentially(100, [0, 1, 2]).delay(60);
+		let pool: ObservablePool<number, void> = Kefir.pool<number, void>();
+		pool.plug(a);
+		pool.plug(b);
+		pool.plug(c);
+	}
+	let observable04: Observable<number, void> = Kefir.repeat<number, void>(i => {
+		if (i < 3) {
+			return Kefir.sequentially(100, [i, i]);
+		} else {
+			return false;
+		}
+	});
+	let observable05: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).flatMap(x => Kefir.interval(40, x).take(4));
+	let observable06: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).flatMapLatest(x => Kefir.interval(40, x).take(4));
+	let observable07: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).flatMapFirst(x => Kefir.interval(40, x).take(4));
+	let observable08: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).flatMapConcat(x => Kefir.interval(40, x).take(4));
+	let observable09: Stream<number, void> = Kefir.sequentially(100, [1, 2, 3]).flatMapConcurLimit(x => Kefir.interval(40, x).take(6), 2);
+	let observable10: Stream<number, void> = Kefir.sequentially(100, [1, 2]).valuesToErrors().flatMapErrors(x => Kefir.interval(40, x).take(2));
+}
+
+// Combine two observables
+{
+	{
+		let foo: Stream<number, void>  = Kefir.sequentially(100, [1, 2, 3, 4, 5, 6, 7, 8]);
+		let bar: Property<boolean, void>  = Kefir.sequentially(200, [false, true, false]).delay(40).toProperty(() => true);
+		let observable01: Stream<number, void> = foo.filterBy<void>(bar);
+	}
+	{
+		let a: Property<number, void>  = Kefir.sequentially(200, [2, 3]).toProperty(() => 1);
+		let b: Stream<number, void>  = Kefir.interval(100, 0).delay(40).take(5);
+		let observable02: Property<number, void> = a.sampledBy<number, void, number>(b)
+	}
+	{
+		let foo: Stream<number, void>  = Kefir.sequentially(100, [1, 2, 3, 4]);
+		let bar: Stream<number, void>  = Kefir.later(250, 0);
+		let observable03: Stream<number, void> = foo.skipUntilBy<number, void>(bar);
+	}
+	{
+		let foo: Stream<number, void>  = Kefir.sequentially(100, [1, 2, 3, 4]);
+		let bar: Stream<number, void>  = Kefir.later(250, 0);
+		let observable04: Stream<number, void> = foo.takeUntilBy<number, void>(bar);
+	}
+	{
+		let foo: Stream<number, void>  = Kefir.sequentially(100, [1, 2, 3, 4, 5, 6, 7, 8]).delay(40);
+		let bar: Stream<number, void>  = Kefir.sequentially(300, [1, 2])
+		let observable05: Stream<number[], void> = foo.bufferBy<number, void>(bar);
+	}
+	{
+		let foo: Stream<number, void>  = Kefir.sequentially(100, [1, 2, 3, 4, 5, 6, 7, 8]);
+		let bar: Stream<boolean, void>  = Kefir.sequentially(200, [false, true, false]).delay(40);
+		let observable06: Stream<number[], void> = foo.bufferWhileBy<void>(bar);
+	}
+	{
+		let foo: Stream<number, void>  = Kefir.sequentially(100, [1, 2, 3]);
+		let bar: Stream<number, void>  = Kefir.sequentially(100, [1, 2, 3]).delay(40);
+		let observable07: Stream<boolean, void> = foo.awaiting<number, void>(bar);
+	}
+}
diff --git a/kefir/kefir.d.ts b/kefir/kefir.d.ts
new file mode 100644
index 0000000000..6a9544a7ca
--- /dev/null
+++ b/kefir/kefir.d.ts
@@ -0,0 +1,176 @@
+// Type definitions for Kefir 2.8.1
+// Project: http://rpominov.github.io/kefir/
+// Definitions by: Aya Morisawa <https://github.com/AyaMorisawa>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+/// <reference path="../es6-promise/es6-promise.d.ts" />
+
+declare module "kefir" {
+	export interface Observable<T, S> {
+		// Subscribe / add side effects
+		onValue(callback: (value: T) => void): void;
+		offValue(callback: (value: T) => void): void;
+		onError(callback: (error: S) => void): void;
+		offError(callback: (error: S) => void): void;
+		onEnd(callback: () => void): void;
+		offEnd(callback: () => void): void;
+		onAny(callback: (event: Event<T | S>) => void): void;
+		offAny(callback: (event: Event<T | S>) => void): void;
+		log(name?: string): void;
+		offLog(name?: string): void;
+		toPromise(PromiseConstructor?: typeof Promise): Promise<T>;
+	}
+	
+	export interface Stream<T, S> extends Observable<T, S> {
+		toProperty(getCurrent?: () => T): Property<T, S>;
+		
+		// Modify an stream
+		map<U>(fn: (value: T) => U): Stream<U, S>;
+		filter(predicate?: (value: T) => boolean): Stream<T, S>;
+		take(n: number): Stream<T, S>;
+		takeWhile(predicate?: (value: T) => boolean): Stream<T, S>;
+		last(): Stream<T, S>;
+		skip(n: number): Stream<T, S>;
+		skipWhile(predicate?: (value: T) => boolean): Stream<T, S>;
+		skipDuplicates(comparator?: (a: T, b: T) => boolean): Stream<T, S>;
+		diff(fn?: (prev: T, next: T) => T, seed?: T): Stream<T, S>;
+		scan(fn: (prev: T, next: T) => T, seed?: T): Stream<T, S>;
+		flatten<U>(transformer?: (value: T) => U[]): Stream<U, S>;
+		delay(wait: number): Stream<T, S>;
+		throttle(wait: number, options?: {leading: boolean, trailing: boolean}): Stream<T, S>;
+		debounce(wait: number, options?: {immediate: boolean}): Stream<T, S>;
+		valuesToErrors<U>(handler?: (value: T) => {convert: boolean, error: U}): Stream<void, S | U>;
+		errorsToValues<U>(handler?: (error: S) => {convert: boolean, value: U}): Stream<T | U, void>;
+		mapErrors<U>(fn: (error: S) => U): Stream<T, U>;
+		filterErrors(predicate?: (error: S) => boolean): Stream<T, S>;
+		endOnError(): Stream<T, S>;
+		skipValues(): Stream<void, S>;
+		skipErrors(): Stream<T, void>;
+		skipEnd(): Stream<T, S>;
+		beforeEnd<U>(fn: () => U): Stream<T | U, S>;
+		slidingWindow(max: number, mix?: number): Stream<T[], S>;
+		bufferWhile(predicate: (value: T) => boolean): Stream<T[], S>;
+		transduce<U>(transducer: any): Stream<U, S>;
+		withHandler<U, V>(handler: (emitter: Emitter<U, S>, event: Event<T | S>) => void): Stream<U, S>;
+		
+		// Combine streams
+		combine<U, V, W>(otherObs: Stream<U, V>, combinator?: (value: T, ...values: U[]) => W): Stream<W, S | V>;
+		zip<U, V, W>(otherObs: Stream<U, V>, combinator?: (value: T, ...values: U[]) => W): Stream<W, S | V>;
+		merge<U, V>(otherObs: Stream<U, V>): Stream<T | U, S | V>;
+		concat<U, V>(otherObs: Stream<U, V>): Stream<T | U, S | V>;
+		flatMap<U, V>(transform: (value: T) => Stream<U, V>): Stream<U, V>;
+		flatMapLatest<U, V>(fn: (value: T) => Stream<U, V>): Stream<U, V>;
+		flatMapFirst<U, V>(fn: (value: T) => Stream<U, V>): Stream<U, V>;
+		flatMapConcat<U, V>(fn: (value: T) => Stream<U, V>): Stream<U, V>;
+		flatMapConcurLimit<U, V>(fn: (value: T) => Stream<U, V>, limit: number): Stream<U, V>;
+		flatMapErrors<U, V>(transform: (error: S) => Stream<U, V>): Stream<U, V>;
+		
+		// Combine two streams
+		filterBy<U>(otherObs: Observable<boolean, U>): Stream<T, S>;
+		sampledBy<U, V, W>(otherObs: Observable<U, V>, combinator?: (a: T, b: U) => W): Stream<W, S>;
+		skipUntilBy<U, V>(otherObs: Observable<U, V>): Stream<U, V>;
+		takeUntilBy<U, V>(otherObs: Observable<U, V>): Stream<U, V>;
+		bufferBy<U, V>(otherObs: Observable<U, V>, options?: {flushOnEnd: boolean}): Stream<T[], S>;
+		bufferWhileBy<U>(otherObs: Observable<boolean, U>): Stream<T[], S>;
+		awaiting<U, V>(otherObs: Observable<U, V>): Stream<boolean, S>;
+	}
+	
+	export interface Property<T, S> extends Observable<T, S> {
+		changes(): Stream<T, S>;
+		
+		// Modify an property
+		map<U>(fn: (value: T) => U): Property<U, S>;
+		filter(predicate?: (value: T) => boolean): Property<T, S>;
+		take(n: number): Property<T, S>;
+		takeWhile(predicate?: (value: T) => boolean): Property<T, S>;
+		last(): Property<T, S>;
+		skip(n: number): Property<T, S>;
+		skipWhile(predicate?: (value: T) => boolean): Property<T, S>;
+		skipDuplicates(comparator?: (a: T, b: T) => boolean): Property<T, S>;
+		diff(fn?: (prev: T, next: T) => T, seed?: T): Property<T, S>;
+		scan(fn: (prev: T, next: T) => T, seed?: T): Property<T, S>;
+		flatten<U>(transformer?: (value: T) => U[]): Property<U, S>;
+		delay(wait: number): Property<T, S>;
+		throttle(wait: number, options?: {leading: boolean, trailing: boolean}): Property<T, S>;
+		debounce(wait: number, options?: {immediate: boolean}): Property<T, S>;
+		valuesToErrors<U>(handler?: (value: T) => {convert: boolean, error: U}): Property<void, S | U>;
+		errorsToValues<U>(handler?: (error: S) => {convert: boolean, value: U}): Property<T | U, void>;
+		mapErrors<U>(fn: (error: S) => U): Property<T, U>;
+		filterErrors(predicate?: (error: S) => boolean): Property<T, S>;
+		endOnError(): Property<T, S>;
+		skipValues(): Property<void, S>;
+		skipErrors(): Property<T, void>;
+		skipEnd(): Property<T, S>;
+		beforeEnd<U>(fn: () => U): Property<T | U, S>;
+		slidingWindow(max: number, mix?: number): Property<T[], S>;
+		bufferWhile(predicate: (value: T) => boolean): Property<T[], S>;
+		transduce<U>(transducer: any): Property<U, S>;
+		withHandler<U, V>(handler: (emitter: Emitter<T, S>, event: Event<T | S>) => void): Property<U, S>;
+		
+		// Combine properties
+		combine<U, V, W>(otherObs: Property<U, V>, combinator?: (value: T, ...values: U[]) => W): Property<W, S | V>;
+		zip<U, V, W>(otherObs: Property<U, V>, combinator?: (value: T, ...values: U[]) => W): Property<W, S | V>;
+		merge<U, V>(otherObs: Property<U, V>): Property<T | U, S | V>;
+		concat<U, V>(otherObs: Property<U, V>): Property<T | U, S | V>;
+		flatMap<U, V>(transform: (value: T) => Property<U, V>): Property<U, V>;
+		flatMapLatest<U, V>(fn: (value: T) => Property<U, V>): Property<U, V>;
+		flatMapFirst<U, V>(fn: (value: T) => Property<U, V>): Property<U, V>;
+		flatMapConcat<U, V>(fn: (value: T) => Property<U, V>): Property<U, V>;
+		flatMapConcurLimit<U, V>(fn: (value: T) => Property<U, V>, limit: number): Property<U, V>;
+		flatMapErrors<U, V>(transform: (error: S) => Property<U, V>): Property<U, V>;
+		
+		// Combine two properties
+		filterBy<U>(otherObs: Observable<boolean, U>): Property<T, S>;
+		sampledBy<U, V, W>(otherObs: Observable<U, V>, combinator?: (a: T, b: U) => W): Property<W, S>;
+		skipUntilBy<U, V>(otherObs: Observable<U, V>): Property<U, V>;
+		takeUntilBy<U, V>(otherObs: Observable<U, V>): Property<U, V>;
+		bufferBy<U, V>(otherObs: Observable<U, V>, options?: {flushOnEnd: boolean}): Property<T[], S>;
+		bufferWhileBy<U>(otherObs: Observable<boolean, U>): Property<T[], S>;
+		awaiting<U, V>(otherObs: Observable<U, V>): Property<boolean, S>;
+	}
+	
+	export interface ObservablePool<T, S> extends Observable<T, S> {
+		plug(obs: Observable<T, S>): void;
+		unPlug(obs: Observable<T, S>): void;
+	}
+	
+	export interface Event<T> {
+		type: string;
+		value: T;
+		current: boolean;
+	}
+	
+	export interface Emitter<T, S> {
+		emit(value: T): void;
+		error(error: S): void;
+		end(): void;
+		emitEvent(event: {type: string, value: T | S}): void;
+	}
+	
+	// Create a stream
+	export function never(): Stream<void, void>;
+	export function later<T>(wait: number, value: T): Stream<T, void>;
+	export function interval<T>(interval: number, value: T): Stream<T, void>;
+	export function sequentially<T>(interval: number, values: T[]): Stream<T, void>;
+	export function fromPoll<T>(interval: number, fn: () => T): Stream<T, void>;
+	export function withInterval<T, S>(interval: number, handler: (emitter: Emitter<T, S>) => void): Stream<T, S>;
+	export function fromCallback<T>(fn: (callback: (value: T) => void) => void): Stream<T, void>;
+	export function fromNodeCallback<T, S>(fn: (callback: (error: S, result: T) => void) => void): Stream<T, S>;
+	export function fromEvents<T, S>(target: EventTarget | NodeJS.EventEmitter | { on: Function, off: Function }, eventName: string, transform?: (value: T) => S): Stream<T, S>;
+	export function stream<T, S>(subscribe: (emitter: Emitter<T, S>) => Function | void): Stream<T, S>;
+	
+	// Create a property
+	export function constant<T>(value: T): Property<T, void>;
+	export function constantError<T>(error: T): Property<void, T>;
+	export function fromPromise<T, S>(promise: Promise<T>): Property<T, S>;
+	
+	// Combine observables
+	export function combine<T, S, U>(obss: Observable<T, S>[], passiveObss: Observable<T, S>[], combinator?: (...values: T[]) => U): Observable<U, S>;
+	export function combine<T, S, U>(obss: Observable<T, S>[], combinator?: (...values: T[]) => U): Observable<U, S>;
+	export function zip<T, S, U>(obss: Observable<T, S>[], passiveObss?: Observable<T, S>[], combinator?: (...values: T[]) => U): Observable<U, S>;
+	export function merge<T, S>(obss: Observable<T, S>[]): Observable<T, S>;
+	export function concat<T, S>(obss: Observable<T, S>[]): Observable<T, S>;
+	export function pool<T, S>(): ObservablePool<T, S>;
+	export function repeat<T, S>(generator: (i: number) => Observable<T, S> | boolean): Observable<T, S>;
+}
diff --git a/knockout/knockoutamd-tests.ts b/knockout/knockoutamd-tests.ts
index dd2124b70d..447da840e8 100644
--- a/knockout/knockoutamd-tests.ts
+++ b/knockout/knockoutamd-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./knockout.d.ts" />
+
 import ko = require("knockout");
 
 var myArray = ko.observableArray([1, 2, 3]);
@@ -6,4 +8,4 @@ class MyViewModel {
 	name = ko.observable("Jeff");
 }
 
-ko.applyBindings(new MyViewModel());
\ No newline at end of file
+ko.applyBindings(new MyViewModel());
diff --git a/leapmotionTS/LeapMotionTS-tests.ts b/leapmotionTS/LeapMotionTS-tests.ts
index c6db49c3ef..ac392941ef 100755
--- a/leapmotionTS/LeapMotionTS-tests.ts
+++ b/leapmotionTS/LeapMotionTS-tests.ts
@@ -1,6 +1,4 @@
-/// <reference path="LeapMotionTS.d.ts" />
-
-import Leap = require('LeapMotionTS');
+import Leap = require('./LeapMotionTS');
 
 var controller: Leap.Controller = new Leap.Controller();
 controller.addEventListener(Leap.LeapEvent.LEAPMOTION_FRAME, (event: Leap.LeapEvent) => {
diff --git a/level-sublevel/level-sublevel-tests.ts b/level-sublevel/level-sublevel-tests.ts
new file mode 100644
index 0000000000..9887dd70c1
--- /dev/null
+++ b/level-sublevel/level-sublevel-tests.ts
@@ -0,0 +1,28 @@
+/// <reference path="level-sublevel.d.ts" />
+
+import levelup = require('levelup');
+import sublevel = require('level-sublevel');
+
+var db = sublevel(levelup('./tmp/sublevel-example'));
+var sub = db.sublevel('stuff');
+
+db.put('foo', 'bar', err => {});
+
+sub.put('foo', 'bar', err => {});
+
+db.pre((ch, add) => {
+	add({
+		key: ''+Date.now(),
+		value: ch.key,
+		type: 'put',
+		prefix: sub
+	})
+});
+
+var sub1 = db.sublevel('SUB_1');
+var sub2 = db.sublevel('SUM_2');
+
+sub1.batch([
+	{ key: 'key', value: 'Value', type: 'put' },
+	{ key: 'key', value: 'Value', type: 'put', prefix: sub2 }
+], err => {	if (err) throw err; });
\ No newline at end of file
diff --git a/level-sublevel/level-sublevel.d.ts b/level-sublevel/level-sublevel.d.ts
new file mode 100644
index 0000000000..969ada9637
--- /dev/null
+++ b/level-sublevel/level-sublevel.d.ts
@@ -0,0 +1,24 @@
+// Type definitions for level-sublevel
+// Project: https://github.com/dominictarr/level-sublevel
+// Definitions by: Bas Pennings <https://github.com/basp/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../levelup/levelup.d.ts" />
+
+interface Hook {
+	(ch: any, add: (op: Batch|boolean) => void): void;
+}
+
+interface Batch {
+	prefix?: Sublevel;
+}
+
+interface Sublevel extends LevelUp {
+	sublevel(key: string): Sublevel;
+	pre(hook: Hook): Function;
+}
+
+declare module "level-sublevel" {
+	function sublevel(levelup: LevelUp): Sublevel;
+	export = sublevel;		
+}
\ No newline at end of file
diff --git a/levelup/levelup.d.ts b/levelup/levelup.d.ts
index bb5af38be5..d6f62f1841 100644
--- a/levelup/levelup.d.ts
+++ b/levelup/levelup.d.ts
@@ -22,8 +22,8 @@ interface LevelUp {
     del(key: any, options ?: { keyEncoding?: string; sync?: boolean }, callback ?: (error: any) => any): void;
 
 
-    batch(array: Batch[], options?: { keyEncoding?: string; valueEncoding?: string; sync?: boolean }, callback?: (error?: any)=>any);
-    batch(array: Batch[], callback?: (error?: any)=>any);
+    batch(array: Batch[], options?: { keyEncoding?: string; valueEncoding?: string; sync?: boolean }, callback?: (error?: any)=>any): void;
+    batch(array: Batch[], callback?: (error?: any)=>any): void;
     batch():LevelUpChain;
     isOpen():boolean;
     isClosed():boolean;
diff --git a/localForage/localForage-tests.ts b/localForage/localForage-tests.ts
index 15638c1cb2..59e429a76a 100644
--- a/localForage/localForage-tests.ts
+++ b/localForage/localForage-tests.ts
@@ -1,13 +1,6 @@
 /// <reference path="localForage.d.ts" />
 
-declare var localForage: lf.ILocalForage<string>;
-declare var callback: lf.ICallback<string>;
-declare var iterateCallback: lf.IIterateCallback<string>;
-declare var errorCallback: lf.IErrorCallback;
-declare var keyCallback: lf.IKeyCallback;
-declare var keysCallback: lf.IKeysCallback;
-declare var numberCallback: lf.INumberCallback;
-declare var promise: lf.IPromise<string>;
+declare var localForage: LocalForage;
 
 () => {
     localForage.clear((err: any) => {
@@ -25,7 +18,7 @@ declare var promise: lf.IPromise<string>;
         var newNumber: number = num;
     });
 
-    localForage.key(0,(err: any, value: string) => {
+    localForage.key(0, (err: any, value: string) => {
         var newError: any = err;
         var newValue: string = value;
     });
@@ -40,9 +33,8 @@ declare var promise: lf.IPromise<string>;
         var newStr: string = str
     });
 
-    localForage.getItem("key").then((err: any, str: string) => {
-        var newError: any = err;
-        var newStr: string = str
+    localForage.getItem<string>("key").then((str: string) => {
+        var newStr: string = str;
     });
   
     localForage.setItem("key", "value",(err: any, str: string) => {
@@ -50,8 +42,7 @@ declare var promise: lf.IPromise<string>;
         var newStr: string = str
     });
 
-    localForage.setItem("key", "value").then((err: any, str: string) => {
-        var newError: any = err;
+    localForage.setItem("key", "value").then((str: string) => {
         var newStr: string = str;
     });
   
@@ -59,10 +50,6 @@ declare var promise: lf.IPromise<string>;
         var newError: any = err;
     });
 
-    localForage.removeItem("key").then((err: any, str: string) => {
-        var newError: any = err;
-        var newStr: string = str
+    localForage.removeItem("key").then(() => {
     });
-  
-    promise.then(callback);
 }
diff --git a/localForage/localForage.d.ts b/localForage/localForage.d.ts
index b5c40dd616..d169d01e3f 100644
--- a/localForage/localForage.d.ts
+++ b/localForage/localForage.d.ts
@@ -3,71 +3,79 @@
 // Definitions by: yuichi david pichsenmeister <https://github.com/3x14159265>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-declare module lf {
-    interface ILocalForage<T> {
-        /**
-         * Removes every key from the database, returning it to a blank slate.
-         */
-        clear(callback: IErrorCallback): void
-        /**
-         * Iterate over all value/key pairs in datastore.
-         */
-        iterate(iterateCallback: IIterateCallback<T>): void
-        /**
-         * Get the name of a key based on its ID.
-         */
-        key(keyIndex: number, callback: IKeyCallback): void
-        /**
-         * Get the list of all keys in the datastore.
-         */
-        keys(callback: IKeysCallback): void;
-        /**
-         * Gets the number of keys in the offline store (i.e. its “length”).
-         */
-        length(callback: INumberCallback): void
-        /**
-         * Gets an item from the storage library and supplies the result to a callback.
-         * If the key does not exist, getItem() will return null.
-         */
-        getItem(key: string, callback: ICallback<T>): void
-        getItem(key: string): IPromise<T>
-        /**
-         * Saves data to an offline store.
-         */
-        setItem(key: string, value: T, callback: ICallback<T>): void
-        setItem(key: string, value: T): IPromise<T>
-        /**
-         * Removes the value of a key from the offline store.
-         */
-        removeItem(key: string, callback: IErrorCallback): void
-        removeItem(key: string): IPromise<T>
-    }
+/// <reference path="../es6-promise/es6-promise.d.ts" />
 
-    interface ICallback<T> {
-        (err: any, value: T): void
-    }
+interface LocalForageOptions {
+    driver?: LocalForageDriver | LocalForageDriver[];
+    
+    name?: string;
+    
+    size?: number;
+    
+    storeName?: string;
+    
+    version?: string;
+    
+    description?: string;
+}
 
-    interface IIterateCallback<T> {
-        (value: T, key: string, iterationNumber: number): void
-    }
+interface LocalForageDriver {
+    _driver: string;
+    
+    _initStorage(options: LocalForageOptions): void;
+    
+    _support: boolean | Promise<boolean>;
+    
+    clear(callback: (err: any) => void): void;
+    
+    getItem(key: string, callback: (err: any, value: any) => void): void;
+    
+    key(keyIndex: number, callback: (err: any, key: string) => void): void;
+    
+    keys(callback: (err: any, keys: string[]) => void): void;
+    
+    length(callback: (err: any, numberOfKeys: number) => void): void;
+    
+    removeItem(key: string, callback: (err: any) => void): void;
+    
+    setItem(key: string, value: any, callback: (err: any, value: any) => void): void;
+}
 
-    interface IErrorCallback {
-        (err: any): void
-    }
-
-    interface IKeyCallback {
-        (err: any, keyName: string): void
-    }
-
-    interface IKeysCallback {
-        (err: any, keys: Array<string>): void
-    }
-
-    interface INumberCallback {
-        (err: any, numberOfKeys: number): void
-    }
-
-    interface IPromise<T> {
-        then(callback: ICallback<T>): void
-    }
-}
\ No newline at end of file
+interface LocalForage {
+    LOCALSTORAGE: string;
+    WEBSQL: string;
+    INDEXEDDB: string;
+    
+    config(options: LocalForageOptions): void;
+    
+    driver(): LocalForageDriver;
+    setDriver(driver: string | string[]): Promise<void>;
+    setDriver(driver: string | string[], callback: () => void, errorCallback: (error: any) => void): void;
+    defineDriver(driver: LocalForageDriver): Promise<void>;
+    defineDriver(driver: LocalForageDriver, callback: () => void, errorCallback: (error: any) => void): void;
+    
+    getItem<T>(key: string): Promise<T>;
+    getItem<T>(key: string, callback: (err: any, value: T) => void): void;
+    
+    setItem<T>(key: string, value: T): Promise<T>;
+    setItem<T>(key: string, value: T, callback: (err: any, value: T) => void): void;
+    
+    removeItem(key: string): Promise<void>;
+    removeItem(key: string, callback: (err: any) => void): void;
+    
+    clear(): Promise<void>;
+    clear(callback: (err: any) => void): void;
+    
+    length(): Promise<number>;
+    length(callback: (err: any, numberOfKeys: number) => void): void;
+    
+    key(keyIndex: number): Promise<string>;
+    key(keyIndex: number, callback: (err: any, key: string) => void): void;
+    
+    keys(): Promise<string[]>;
+    keys(callback: (err: any, keys: string[]) => void): void;
+    
+    iterate(iteratee: (value: any, key: string, iterationNumber: number) => any): Promise<any>;
+    iterate(iteratee: (value: any, key: string, iterationNumber: number) => any,
+            callback: (err: any, result: any) => void): void;
+}
diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index 4e3bb97dae..fc36241c58 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -403,12 +403,73 @@ result = <number[]>_([1, 2]).zipWith<number>(testZipWithFn, any).value();
 result = <number[]>_([1, 2]).zipWith<number>([1, 2], testZipWithFn, any).value();
 result = <number[]>_([1, 2]).zipWith<number>([1, 2], [1, 2], [1, 2], [1, 2], [1, 2], testZipWithFn, any).value();
 
-// /* *************
-//  * Collections *
-//  ************* */
+/*********
+ * Chain *
+ *********/
 
-result = <string[]>_.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]);
-result = <string[]>_.at(['moe', 'larry', 'curly'], 0, 2);
+// _.thru
+{
+    let result: number;
+    result = _.thru<number, number>(1, (value: number) => value);
+    result = _.thru<number, number>(1, (value: number) => value, any);
+}
+{
+    let result: _.LoDashWrapper<number>;
+    result = _(1).thru<number>((value: number) => value);
+    result = _(1).thru<number>((value: number) => value, any);
+}
+{
+    let result: _.LoDashWrapper<string>;
+    result = _('').thru<string>((value: string) => value);
+    result = _('').thru<string>((value: string) => value, any);
+}
+{
+    let result: _.LoDashWrapper<boolean>;
+    result = _(true).thru<boolean>((value: boolean) => value);
+    result = _(true).thru<boolean>((value: boolean) => value, any);
+}
+{
+    let result: _.LoDashObjectWrapper<any>;
+    result = _({}).thru<Object>((value: Object) => value);
+    result = _({}).thru<Object>((value: Object) => value, any);
+}
+{
+    let result: _.LoDashArrayWrapper<number>;
+    result = _([1, 2, 3]).thru<number>((value: number[]) => value);
+    result = _([1, 2, 3]).thru<number>((value: number[]) => value, any);
+}
+
+// _.prototype.commit
+{
+    let result: _.LoDashWrapper<number>;
+    result = _(42).commit();
+}
+{
+    let result: _.LoDashArrayWrapper<any>;
+    result = _<any>([]).commit();
+}
+{
+    let result: _.LoDashObjectWrapper<any>;
+    result = _({}).commit();
+}
+
+/**************
+ * Collection *
+ **************/
+
+// _.at
+{
+    let testAtArray: TResult[];
+    let testAtList: _.List<TResult>;
+    let testAtDictionary: _.Dictionary<TResult>;
+    let result: TResult[];
+    result = _.at<TResult>(testAtArray, 0, '1', [2], ['3'], [4, '5']);
+    result = _.at<TResult>(testAtList, 0, '1', [2], ['3'], [4, '5']);
+    result = _.at<TResult>(testAtDictionary, 0, '1', [2], ['3'], [4, '5']);
+    result = _(testAtArray).at(0, '1', [2], ['3'], [4, '5']).value();
+    result = _(testAtList).at<TResult>(0, '1', [2], ['3'], [4, '5']).value();
+    result = _(testAtDictionary).at<TResult>(0, '1', [2], ['3'], [4, '5']).value();
+}
 
 result = <boolean>_.contains([1, 2, 3], 1);
 result = <boolean>_.contains([1, 2, 3], 1, 2);
@@ -1482,26 +1543,37 @@ result = <_.LoDashArrayWrapper<string>>_(_).methods();
 
 // _.get
 result = <number>_.get<number>({ 'a': [{ 'b': { 'c': 3 } }] }, 'a[0].b.c');
-// → 3
-result = <number>_.get<number>({ 'a': [{ 'b': { 'c': 3 } }] }, ['a', '0', 'b', 'c']);
-// → 3
-result = <string>_.get<string>({ 'a': [{ 'b': { 'c': 3 } }] }, 'a.b.c', 'default');
-// → 'default'
 
-result = <number>_({ 'a': [{ 'b': { 'c': 3 } }] }).get<number>('a[0].b.c');
-// → 3
-result = <number>_({ 'a': [{ 'b': { 'c': 3 } }] }).get<number>(['a', '0', 'b', 'c']);
-// → 3
-result = <string>_({ 'a': [{ 'b': { 'c': 3 } }] }).get<string>('a.b.c', 'default');
-// → 'default'
+{
+    let result: TResult;
+    result = _.get<TResult>({}, '');
+    result = _.get<TResult>({}, 42);
+    result = _.get<TResult>({}, true);
+    result = _.get<TResult>({}, ['', 42, true]);
+    result = _({}).get<TResult>('');
+    result = _({}).get<TResult>(42);
+    result = _({}).get<TResult>(true);
+    result = _({}).get<TResult>(['', 42, true]);
+}
 
-result = <boolean>_.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');
+// _.has
+result = <boolean>_.has({}, '');
+result = <boolean>_.has({}, 42);
+result = <boolean>_.has({}, true);
+result = <boolean>_.has({}, ['', 42, true]);
+result = <boolean>_({}).has('');
+result = <boolean>_({}).has(42);
+result = <boolean>_({}).has(true);
+result = <boolean>_({}).has(['', 42, true]);
 
-interface FirstSecond {
-    first: string;
-    second: string;
+// _.invert
+{
+    let result: TResult;
+    result = _.invert<Object, TResult>({});
+    result = _.invert<Object, TResult>({}, true);
+    result = _({}).invert<TResult>().value();
+    result = _({}).invert<TResult>(true).value();
 }
-result = <FirstSecond>_.invert({ 'first': 'moe', 'second': 'larry' });
 
 // _.isEqual (alias: _.eq)
 result = <boolean>_.isEqual(1, 1);
@@ -1594,15 +1666,42 @@ result = <HasName>_({ 'name': 'moe', 'age': 40 }).omit(function (value) {
 result = <any[][]>_.pairs({ 'moe': 30, 'larry': 40 });
 result = <any[][]>_({ 'moe': 30, 'larry': 40 }).pairs().value();
 
-result = <HasName>_.pick({ 'name': 'moe', '_userid': 'moe1' }, 'name');
-result = <HasName>_.pick({ 'name': 'moe', '_userid': 'moe1' }, ['name']);
-result = <HasName>_.pick({ 'name': 'moe', '_userid': 'moe1' }, function (value, key) {
-    return key.charAt(0) != '_';
-});
+// _.pick
+interface TestPickFn {
+    (element: any, key: string, collection: any): boolean;
+}
+{
+    let testPickFn: TestPickFn;
+    let result: TResult;
+    result = _.pick<TResult, Object>({}, 0, '1', true, [2], ['3'], [true], [4, '5', true]);
+    result = _.pick<TResult, Object>({}, testPickFn);
+    result = _.pick<TResult, Object>({}, testPickFn, any);
+    result = _({}).pick<TResult>(0, '1', true, [2], ['3'], [true], [4, '5', true]).value();
+    result = _({}).pick<TResult>(testPickFn).value();
+    result = _({}).pick<TResult>(testPickFn, any).value();
+}
+
+// _.result
+{
+    let testResultPath: number|string|boolean|Array<number|string|boolean>;
+    let testResultDefaultValue: TResult;
+    let result: TResult;
+    result = _.result<{}, TResult>({}, testResultPath);
+    result = _.result<{}, TResult>({}, testResultPath, testResultDefaultValue);
+    result = _({}).result<TResult>(testResultPath);
+    result = _({}).result<TResult>(testResultPath, testResultDefaultValue);
+}
 
 // _.set
-result = <{ a: { b: { c: number; }}[]}>_.set({ 'a': [{ 'b': { 'c': 3 } }] }, 'a[0].b.c', 4);
-result = <{ a: { b: { c: number; }}[]}>_({ 'a': [{ 'b': { 'c': 3 } }] }).set('a[0].b.c', 4).value();
+{
+    let testSetObject: TResult;
+    let testSetPath: {toSting(): string};
+    let result: TResult;
+    result = _.set(testSetObject, testSetPath, any);
+    result = _.set(testSetObject, [testSetPath], any);
+    result = _(testSetObject).set(testSetPath, any).value();
+    result = _(testSetObject).set([testSetPath], any).value();
+}
 
 result = <number[]>_.transform([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function (r: number[], num: number) {
     num *= num;
@@ -1652,14 +1751,6 @@ var testAttempFn: TestAttemptFn;
 result = <TResult|Error>_.attempt<TResult>(testAttempFn);
 result = <TResult|Error>_(testAttempFn).attempt<TResult>();
 
-_.mixin({
-    'capitalize': function (string) {
-        return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
-    }
-});
-
-var lodash = <typeof _>_.noConflict();
-
 result = <number>_.random(0, 5);
 result = <number>_.random(5);
 result = <number>_.random(5, true);
@@ -1677,22 +1768,6 @@ result = <void>_<string>([]).noop(true, 'a', 1);
 result = <void>_({}).noop(true, 'a', 1);
 result = <void>_(any).noop(true, 'a', 1);
 
-var object = {
-    'cheese': 'crumpets',
-    'one': 1,
-    'nested': {
-        'two': 2
-    },
-    'stuff': function () {
-        return 'nonsense';
-    }
-};
-
-result = <string>_.result(object, 'cheese');
-result = <string>_.result(object, 'stuff');
-result = _.result<number>(object, 'one');
-result = _.result<number>(object, ['nested', 'two'] );
-
 var tempObject = {};
 result = <typeof _>_.runInContext(tempObject);
 
@@ -1883,9 +1958,32 @@ result = <string[]>_.words('fred, barney, & pebbles', /[^, ]+/g);
 result = <string[]>_('fred, barney, & pebbles').words();
 result = <string[]>_('fred, barney, & pebbles').words(/[^, ]+/g);
 
-/**********
-* Utilities *
-***********/
+/***********
+ * Utility *
+ ***********/
+
+// _.callback
+{
+    let result: (...args: any[]) => TResult;
+    result = _.callback<TResult>(Function);
+    result = _.callback<TResult>(Function, any);
+    result = _(Function).callback<TResult>().value();
+    result = _(Function).callback<TResult>(any).value();
+}
+{
+    let result: (object: any) => TResult;
+    result = _.callback<TResult>('');
+    result = _.callback<TResult>('', any);
+    result = _('').callback<TResult>().value();
+    result = _('').callback<TResult>(any).value();
+}
+{
+    let result: (object: any) => boolean;
+    result = _.callback({});
+    result = _.callback({}, any);
+    result = _({}).callback().value();
+    result = _({}).callback(any).value();
+}
 
 // _.constant
 result = <() => number>_.constant<number>(1);
@@ -1915,6 +2013,29 @@ result = <() => {}>_({}).constant<{}>();
     result = _<boolean>([]).identity();
 }
 
+// _.iteratee
+{
+    let result: (...args: any[]) => TResult;
+    result = _.iteratee<TResult>(Function);
+    result = _.iteratee<TResult>(Function, any);
+    result = _(Function).iteratee<TResult>().value();
+    result = _(Function).iteratee<TResult>(any).value();
+}
+{
+    let result: (object: any) => TResult;
+    result = _.iteratee<TResult>('');
+    result = _.iteratee<TResult>('', any);
+    result = _('').iteratee<TResult>().value();
+    result = _('').iteratee<TResult>(any).value();
+}
+{
+    let result: (object: any) => boolean;
+    result = _.iteratee({});
+    result = _.iteratee({}, any);
+    result = _({}).iteratee().value();
+    result = _({}).iteratee(any).value();
+}
+
 // _.method
 class TestMethod {
     a = {
@@ -1939,6 +2060,30 @@ result = <number>(_.methodOf<number>(TestMethodOfObject, 1, 2))(['a', '0']);
 result = <number>(_(TestMethodOfObject).methodOf<number>(1, 2).value())('a[0]');
 result = <number>(_(TestMethodOfObject).methodOf<number>(1, 2).value())(['a', '0']);
 
+// _.mixin
+{
+    let testMixinSource: _.Dictionary<Function>;
+    let testMixinOptions: {chain?: boolean;}
+    let result: TResult;
+    result = _.mixin<TResult, Object>({}, testMixinSource);
+    result = _.mixin<TResult, Object>({}, testMixinSource, testMixinOptions);
+    result = _.mixin<TResult>(testMixinSource);
+    result = _.mixin<TResult>(testMixinSource, testMixinOptions);
+    result = _({}).mixin<TResult>(testMixinSource).value();
+    result = _({}).mixin<TResult>(testMixinSource, testMixinOptions).value();
+    result = _(testMixinSource).mixin<TResult>().value();
+    result = _(testMixinSource).mixin<TResult>(testMixinOptions).value();
+}
+
+// _.noConflict
+{
+    let result: typeof _;
+    result = _.noConflict();
+    result = _(42).noConflict();
+    result = _<any>([]).noConflict();
+    result = _({}).noConflict();
+}
+
 // _.uniqueId
 result = <string>_.uniqueId();
 result = <string>_.uniqueId('');
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index f54bbbbb4b..db2405580a 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -694,9 +694,9 @@ declare module _ {
         takeWhile<T>(
             array: (Array<T>|List<T>),
             predicate?: ListIterator<T, boolean>,
-            thisArg?: any 
+            thisArg?: any
         ): T[];
-        
+
         /**
          * Takes the first items from an array or list based on a predicate
          * @param array The array or list of items on which the result set will be based
@@ -706,7 +706,7 @@ declare module _ {
             array: (Array<T>|List<T>),
             pluckValue: string
         ): any[];
-        
+
         /**
          * Takes the first items from an array or list based on a predicate
          * @param array The array or list of items on which the result set will be based
@@ -1502,7 +1502,7 @@ declare module _ {
         **/
         union<T>(...arrays: List<T>[]): T[];
     }
-    
+
     interface LoDashArrayWrapper<T> {
         /**
         * @see _.union
@@ -2000,58 +2000,104 @@ declare module _ {
         zipWith<TResult>(...args: any[]): LoDashArrayWrapper<TResult>;
     }
 
-    /* *************
-     * Collections *
-     ************* */
+    /*********
+     * Chain *
+     *********/
+
+    //_.thru
+    interface LoDashStatic {
+        /**
+         * This method is like _.tap except that it returns the result of interceptor.
+         * @param value The value to provide to interceptor.
+         * @param interceptor The function to invoke.
+         * @param thisArg The this binding of interceptor.
+         * @return Returns the result of interceptor.
+         */
+        thru<T, TResult>(
+            value: T,
+            interceptor: (value: T) => TResult,
+            thisArg?: any): TResult;
+    }
+
+    interface LoDashWrapperBase<T, TWrapper> {
+        /**
+         * @see _.thru
+         */
+        thru<TResult extends number>(
+            interceptor: (value: T) => TResult,
+            thisArg?: any): LoDashWrapper<TResult>;
+
+        /**
+         * @see _.thru
+         */
+        thru<TResult extends string>(
+            interceptor: (value: T) => TResult,
+            thisArg?: any): LoDashWrapper<TResult>;
+
+        /**
+         * @see _.thru
+         */
+        thru<TResult extends boolean>(
+            interceptor: (value: T) => TResult,
+            thisArg?: any): LoDashWrapper<TResult>;
+
+        /**
+         * @see _.thru
+         */
+        thru<TResult extends Object>(
+            interceptor: (value: T) => TResult,
+            thisArg?: any): LoDashObjectWrapper<TResult>;
+
+        /**
+         * @see _.thru
+         */
+        thru<TResult>(
+            interceptor: (value: T) => TResult[],
+            thisArg?: any): LoDashArrayWrapper<TResult>;
+    }
+
+    // _.prototype.commit
+    interface LoDashWrapperBase<T, TWrapper> {
+        /**
+         * Executes the chained sequence and returns the wrapped result.
+         *
+         * @return Returns the new lodash wrapper instance.
+         */
+        commit(): TWrapper;
+    }
+
+    /**************
+     * Collection *
+     **************/
 
     //_.at
     interface LoDashStatic {
         /**
-        * Creates an array of elements from the specified indexes, or keys, of the collection.
-        * Indexes may be specified as individual arguments or as arrays of indexes.
-        * @param collection The collection to iterate over.
-        * @param indexes The indexes of collection to retrieve, specified as individual indexes or
-        * arrays of indexes.
-        * @return A new array of elements corresponding to the provided indexes.
-        **/
+         * Creates an array of elements corresponding to the given keys, or indexes, of collection. Keys may be
+         * specified as individual arguments or as arrays of keys.
+         *
+         * @param collection The collection to iterate over.
+         * @param props The property names or indexes of elements to pick, specified individually or in arrays.
+         * @return Returns the new array of picked elements.
+         */
         at<T>(
-            collection: Array<T>,
-            indexes: number[]): T[];
+            collection: List<T>|Dictionary<T>,
+            ...props: Array<number|string|Array<number|string>>
+        ): T[];
+    }
 
+    interface LoDashArrayWrapper<T> {
         /**
-        * @see _.at
-        **/
-        at<T>(
-            collection: List<T>,
-            indexes: number[]): T[];
+         * @see _.at
+         */
+        at(...props: Array<number|string|Array<number|string>>): LoDashArrayWrapper<T>;
+    }
 
+    interface LoDashObjectWrapper<T> {
         /**
-        * @see _.at
-        **/
-        at<T>(
-            collection: Dictionary<T>,
-            indexes: number[]): T[];
-
-        /**
-        * @see _.at
-        **/
-        at<T>(
-            collection: Array<T>,
-            ...indexes: number[]): T[];
-
-        /**
-        * @see _.at
-        **/
-        at<T>(
-            collection: List<T>,
-            ...indexes: number[]): T[];
-
-        /**
-        * @see _.at
-        **/
-        at<T>(
-            collection: Dictionary<T>,
-            ...indexes: number[]): T[];
+         * @see _.at
+         */
+        at<TResult>(...props: Array<number|string|Array<number|string>>): LoDashArrayWrapper<TResult>;
     }
 
     //_.contains
@@ -2514,13 +2560,13 @@ declare module _ {
         /**
         * Iterates over elements of a collection, returning an array of all elements the
         * identity function returns truey for.
-        * 
+        *
         * @param collection The collection to iterate over.
         * @return Returns a new array of elements that passed the callback check.
         **/
         filter<T>(
             collection: (Array<T>|List<T>)): T[];
-            
+
         /**
         * Iterates over elements of a collection, returning an array of all elements the
         * callback returns truey for. The callback is bound to thisArg and invoked with three
@@ -2683,7 +2729,7 @@ declare module _ {
         * @see _.filter
         **/
         filter(): LoDashArrayWrapper<T>;
-            
+
         /**
         * @see _.filter
         **/
@@ -5096,7 +5142,7 @@ declare module _ {
         sortBy<W, T>(
             collection: List<T>,
             whereValue: W): T[];
-            
+
         /**
          * Sorts by all the given arguments, using either ListIterator, pluckValue, or whereValue foramts
          * @param args The rules by which to sort
@@ -5126,7 +5172,7 @@ declare module _ {
         * @param whereValue _.where style callback
         **/
         sortBy<W>(whereValue: W): LoDashArrayWrapper<T>;
-        
+
         /**
          * Sorts by all the given arguments, using either ListIterator, pluckValue, or whereValue foramts
          * @param args The rules by which to sort
@@ -7117,17 +7163,17 @@ declare module _ {
          * @param defaultValue The value returned if the resolved value is undefined.
          * @return Returns the resolved value.
          **/
-        get<T>(object: Object,
-               path: string|string[],
-               defaultValue?:T
-        ): T;
+        get<TResult>(object: Object,
+               path: string|number|boolean|Array<string|number|boolean>,
+               defaultValue?:TResult
+        ): TResult;
     }
 
     interface LoDashObjectWrapper<T> {
         /**
          * @see _.get
          **/
-        get<TResult>(path: string|string[],
+        get<TResult>(path: string|number|boolean|Array<string|number|boolean>,
                      defaultValue?: TResult
         ): TResult;
     }
@@ -7135,22 +7181,40 @@ declare module _ {
     //_.has
     interface LoDashStatic {
         /**
-        * Checks if path is a direct property.
-        * @param object The object to query.
-        * @param path The path to check.
-        * @return True if path is a direct property, else False.
-        **/
-        has(object: any, path: string|string[]): boolean;
+         * Checks if path is a direct property.
+         *
+         * @param object The object to query.
+         * @param path The path to check.
+         * @return Returns true if path is a direct property, else false.
+         */
+        has(object: any, path: string|number|boolean|Array<string|number|boolean>): boolean;
+    }
+
+    interface LoDashObjectWrapper<T> {
+        /**
+         * @see _.has
+         */
+        has(path: string|number|boolean|Array<string|number|boolean>): boolean;
     }
 
     //_.invert
     interface LoDashStatic {
         /**
-        * Creates an object composed of the inverted keys and values of the given object.
-        * @param object The object to invert.
-        * @return The created inverted object.
-        **/
-        invert(object: any): any;
+         * Creates an object composed of the inverted keys and values of object. If object contains duplicate values,
+         * subsequent values overwrite property assignments of previous values unless multiValue is true.
+         *
+         * @param object The object to invert.
+         * @param multiValue Allow multiple values per key.
+         * @return Returns the new inverted object.
+         */
+        invert<T extends {}, TResult extends {}>(object: T, multiValue?: boolean): TResult;
+    }
+
+    interface LoDashObjectWrapper<T> {
+        /**
+         * @see _.invert
+         */
+        invert<TResult extends {}>(multiValue?: boolean): LoDashObjectWrapper<TResult>;
     }
 
     //_.isEqual
@@ -7450,58 +7514,105 @@ declare module _ {
         pairs(): LoDashArrayWrapper<any[]>;
     }
 
-    //_.picks
+    //_.pick
     interface LoDashStatic {
         /**
-        * Creates a shallow clone of object composed of the specified properties. Property names may be
-        * specified as individual arguments or as arrays of property names. If a callback is provided
-        * it will be executed for each property of object picking the properties the callback returns
-        * truey for. The callback is bound to thisArg and invoked with three arguments; (value, key,
-        * object).
-        * @param object Object to strip unwanted key/value pairs.
-        * @param keys Property names to pick
-        * @return An object composed of the picked properties.
-        **/
-        pick<Picked, T>(
+         * Creates an object composed of the picked object properties. Property names may be specified as individual
+         * arguments or as arrays of property names. If predicate is provided it’s invoked for each property of object
+         * picking the properties predicate returns truthy for. The predicate is bound to thisArg and invoked with
+         * three arguments: (value, key, object).
+         *
+         * @param object The source object.
+         * @param predicate The function invoked per iteration or property names to pick, specified as individual
+         * property names or arrays of property names.
+         * @param thisArg The this binding of predicate.
+         * @return An object composed of the picked properties.
+         */
+        pick<TResult extends Object, T extends Object>(
             object: T,
-            ...keys: string[]): Picked;
+            predicate: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): TResult;
 
         /**
-        * @see _.pick
-        **/
-        pick<Picked, T>(
+         * @see _.pick
+         */
+        pick<TResult extends Object, T extends Object>(
             object: T,
-            keys: string[]): Picked;
+            ...predicate: Array<string|number|boolean|Array<string|number|boolean>>
+        ): TResult;
+    }
+
+    interface LoDashObjectWrapper<T> {
+        /**
+         * @see _.pick
+         */
+        pick<TResult extends Object>(
+            predicate: ObjectIterator<any, boolean>,
+            thisArg?: any
+        ): LoDashObjectWrapper<TResult>;
 
         /**
-        * @see _.pick
-        **/
-        pick<Picked, T>(
-            object: T,
-            callback: ObjectIterator<any, boolean>,
-            thisArg?: any): Picked;
+         * @see _.pick
+         */
+        pick<TResult extends Object>(
+            ...predicate: Array<string|number|boolean|Array<string|number|boolean>>
+        ): LoDashObjectWrapper<TResult>;
+    }
+
+    //_.result
+    interface LoDashStatic {
+        /**
+         * This method is like _.get except that if the resolved value is a function it’s invoked with the this binding
+         * of its parent object and its result is returned.
+         *
+         * @param object The object to query.
+         * @param path The path of the property to resolve.
+         * @param defaultValue The value returned if the resolved value is undefined.
+         * @return Returns the resolved value.
+         */
+        result<TObject, TResult>(
+            object: TObject,
+            path: number|string|boolean|Array<number|string|boolean>,
+            defaultValue?: TResult
+        ): TResult;
+    }
+
+    interface LoDashWrapperBase<T, TWrapper> {
+        /**
+         * @see _.result
+         */
+        result<TResult>(
+            path: number|string|boolean|Array<number|string|boolean>,
+            defaultValue?: TResult
+        ): TResult;
     }
 
     //_.set
     interface LoDashStatic {
         /**
-         * Sets the property value of path on object. If a portion of path does not exist it is created.
+         * Sets the property value of path on object. If a portion of path does not exist it’s created.
+         *
          * @param object The object to augment.
          * @param path The path of the property to set.
          * @param value The value to set.
          * @return Returns object.
-         **/
-        set<T>(object: T,
-            path: string|string[],
-            value: any): T;
+         */
+        set<T>(
+            object: T,
+            path: StringRepresentable|StringRepresentable[],
+            value: any
+        ): T;
     }
 
     interface LoDashObjectWrapper<T> {
         /**
          * @see _.set
-         **/
-        set(path: string|string[],
-            value: any): LoDashObjectWrapper<T>;
+         */
+        set(
+            path: StringRepresentable|StringRepresentable[],
+            value: any
+        ): LoDashObjectWrapper<T>;
     }
 
     //_.transform
@@ -8059,6 +8170,64 @@ declare module _ {
         attempt<TResult>(): TResult|Error;
     }
 
+    //_.callback
+    interface LoDashStatic {
+        /**
+         * Creates a function that invokes func with the this binding of thisArg and arguments of the created function.
+         * If func is a property name the created callback returns the property value for a given element. If func is
+         * an object the created callback returns true for elements that contain the equivalent object properties,
+         * otherwise it returns false.
+         *
+         * @param func The value to convert to a callback.
+         * @param thisArg The this binding of func.
+         * @result Returns the callback.
+         */
+        callback<TResult>(
+            func: Function,
+            thisArg?: any
+        ): (...args: any[]) => TResult;
+
+        /**
+         * @see _.callback
+         */
+        callback<TResult>(
+            func: string,
+            thisArg?: any
+        ): (object: any) => TResult;
+
+        /**
+         * @see _.callback
+         */
+        callback(
+            func: Object,
+            thisArg?: any
+        ): (object: any) => boolean;
+
+        /**
+         * @see _.callback
+         */
+        callback<TResult>(): (value: TResult) => TResult;
+    }
+
+    interface LoDashWrapper<T> {
+        /**
+         * @see _.callback
+         */
+        callback<TResult>(thisArg?: any): LoDashObjectWrapper<(object: any) => TResult>;
+    }
+
+    interface LoDashObjectWrapper<T> {
+        /**
+         * @see _.callback
+         */
+        callback(thisArg?: any): LoDashObjectWrapper<(object: any) => boolean>;
+
+        /**
+         * @see _.callback
+         */
+        callback<TResult>(thisArg?: any): LoDashObjectWrapper<(...args: any[]) => TResult>;
+    }
+
     //_.identity
     interface LoDashStatic {
         /**
@@ -8090,6 +8259,57 @@ declare module _ {
         identity(): T;
     }
 
+    //_.iteratee
+    interface LoDashStatic {
+        /**
+         * @see _.callback
+         */
+        iteratee<TResult>(
+            func: Function,
+            thisArg?: any
+        ): (...args: any[]) => TResult;
+
+        /**
+         * @see _.callback
+         */
+        iteratee<TResult>(
+            func: string,
+            thisArg?: any
+        ): (object: any) => TResult;
+
+        /**
+         * @see _.callback
+         */
+        iteratee(
+            func: Object,
+            thisArg?: any
+        ): (object: any) => boolean;
+
+        /**
+         * @see _.callback
+         */
+        iteratee<TResult>(): (value: TResult) => TResult;
+    }
+
+    interface LoDashWrapper<T> {
+        /**
+         * @see _.callback
+         */
+        iteratee<TResult>(thisArg?: any): LoDashObjectWrapper<(object: any) => TResult>;
+    }
+
+    interface LoDashObjectWrapper<T> {
+        /**
+         * @see _.callback
+         */
+        iteratee(thisArg?: any): LoDashObjectWrapper<(object: any) => boolean>;
+
+        /**
+         * @see _.callback
+         */
+        iteratee<TResult>(thisArg?: any): LoDashObjectWrapper<(...args: any[]) => TResult>;
+    }
+
     //_.method
     interface LoDashStatic {
         /**
@@ -8151,20 +8371,70 @@ declare module _ {
     }
 
     //_.mixin
+    interface MixinOptions {
+        chain?: boolean;
+    }
+
     interface LoDashStatic {
         /**
-        * Adds function properties of a source object to the lodash function and chainable wrapper.
-        * @param object The object of function properties to add to lodash.
-        **/
-        mixin(object?: Dictionary<(value: any) => any>): void;
+         * Adds all own enumerable function properties of a source object to the destination object. If object is a
+         * function then methods are added to its prototype as well.
+         *
+         * Note: Use _.runInContext to create a pristine lodash function to avoid conflicts caused by modifying
+         * the original.
+         *
+         * @param object The destination object.
+         * @param source The object of functions to add.
+         * @param options The options object.
+         * @param options.chain Specify whether the functions added are chainable.
+         * @return Returns object.
+         */
+        mixin<TResult, TObject>(
+            object: TObject,
+            source: Dictionary<Function>,
+            options?: MixinOptions
+        ): TResult;
+
+        /**
+         * @see _.mixin
+         */
+        mixin<TResult>(
+            source: Dictionary<Function>,
+            options?: MixinOptions
+        ): TResult;
+    }
+
+    interface LoDashObjectWrapper<T> {
+        /**
+         * @see _.mixin
+         */
+        mixin<TResult>(
+            source: Dictionary<Function>,
+            options?: MixinOptions
+        ): LoDashObjectWrapper<TResult>;
+
+        /**
+         * @see _.mixin
+         */
+        mixin<TResult>(
+            options?: MixinOptions
+        ): LoDashObjectWrapper<TResult>;
     }
 
     //_.noConflict
     interface LoDashStatic {
         /**
-        * Reverts the '_' variable to its previous value and returns a reference to the lodash function.
-        * @return The lodash function.
-        **/
+         * Reverts the _ variable to its previous value and returns a reference to the lodash function.
+         *
+         * @return Returns the lodash function.
+         */
+        noConflict(): typeof _;
+    }
+
+    interface LoDashWrapperBase<T, TWrapper> {
+        /**
+         * @see _.noConflict
+         */
         noConflict(): typeof _;
     }
 
@@ -8279,21 +8549,6 @@ declare module _ {
         random(min: number, max: number, floating?: boolean): number;
     }
 
-    //_.result
-    interface LoDashStatic {
-        /**
-        * Resolves the value of property on object. If property is a function it will be invoked with
-        * the this binding of object and its result returned, else the property value is returned. If
-        * object is false then undefined is returned.
-        * @param object The object to query.
-        * @param path The path of the property to resolve.
-        * @param defaultValue The value returned if the resolved value is undefined.
-        * @return The resolved value.
-        **/
-
-        result<T>(object: any, path: string|string[], defaultValue?: T): T;
-    }
-
     //_.runInContext
     interface LoDashStatic {
         /**
@@ -8414,6 +8669,10 @@ declare module _ {
     interface Dictionary<T> {
         [index: string]: T;
     }
+
+    interface StringRepresentable {
+        toString(): string;
+    }
 }
 
 declare module "lodash" {
diff --git a/log4javascript/log4javascript.d.ts b/log4javascript/log4javascript.d.ts
index 0a4026c85d..98f23d1f72 100644
--- a/log4javascript/log4javascript.d.ts
+++ b/log4javascript/log4javascript.d.ts
@@ -253,6 +253,8 @@ declare module log4javascript {
 		 * Asserts the given expression is true or evaluates to true. If so, nothing is logged. If not, an error is logged at the ERROR level.
 		 */
 		assert(expr: any): void;
+
+		name: string;
 	}
 
 	// #endregion
@@ -262,7 +264,20 @@ declare module log4javascript {
 	/**
 	 * Logging event.
 	 */
-	export class LoggingEvent { }
+	export class LoggingEvent {
+		logger: Logger;
+		timeStamp: Date;
+		timeStampInMilliseconds: number;
+		timeStampInSeconds: number;
+		milliseconds: number;
+		level: Level;
+		messages: any[];
+		exception: Error;
+
+		getThrowableStrRep: () => string;
+		getCombinedMessages: () => string;
+		toString: () => string;
+	}
 
 	/**
 	 * There are methods common to all appenders, as listed below.
@@ -920,6 +935,8 @@ declare module log4javascript {
 		 * Returns whether the layout has any custom fields.
 		 */
 		hasCustomFields(): boolean;
+
+		formatWithException(loggingEvent: LoggingEvent): string;
 	}
 
 	/**
diff --git a/lovefield/lovefield-tests.ts b/lovefield/lovefield-tests.ts
index aa77f5b2c1..26e7c8e247 100644
--- a/lovefield/lovefield-tests.ts
+++ b/lovefield/lovefield-tests.ts
@@ -43,6 +43,8 @@ function main(): void {
       }).then(
       function() {
         return todoDb.select(lf.fn.count()).from(itemSchema).exec();
+      }).then(function() {
+        return todoDb.export();
       });
 }
 
diff --git a/lovefield/lovefield.d.ts b/lovefield/lovefield.d.ts
index b692a414fa..02fdc5da04 100644
--- a/lovefield/lovefield.d.ts
+++ b/lovefield/lovefield.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Lovefield v2.0.56
+// Type definitions for Lovefield v2.0.62
 // Project: http://google.github.io/lovefield/
 // Definitions by: freshp86 <https://github.com/freshp86>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -18,6 +18,16 @@ declare module lf {
     STRING
   }
 
+  export enum ConstraintAction {
+    RESTRICT,
+    CASCADE
+  }
+
+  export enum ConstraintTiming {
+    IMMEDIATE,
+    DEFERRABLE
+  }
+
   export interface Binder {
     getIndex(): number
   }
@@ -56,7 +66,9 @@ declare module lf {
     close(): void
     createTransaction(type?: TransactionType): Transaction
     delete(): query.Delete
+    export(): Promise<Object>
     getSchema(): schema.Database
+    import(data: Object): Promise<void>
     insertOrReplace(): query.Insert
     insert(): query.Insert
     observe(query: query.Select, callback: Function): void
@@ -174,9 +186,16 @@ declare module lf {
       order: Order
     }
 
+    type RawForeignKeySpec = {
+      local: string
+      ref: string
+      action: lf.ConstraintAction
+      timing: lf.ConstraintAction
+    }
+
     export interface TableBuilder {
       addColumn(name: string, type: lf.Type): TableBuilder
-      addForeignKey(): TableBuilder
+      addForeignKey(name: string, spec: RawForeignKeySpec): TableBuilder
       addIndex(
           name: string, columns: Array<string>|Array<IndexedColumn>,
           unique?: boolean, order?: Order): TableBuilder
diff --git a/lscache/lscache.d.ts b/lscache/lscache.d.ts
index 24c34bd8da..ed5d133a53 100644
--- a/lscache/lscache.d.ts
+++ b/lscache/lscache.d.ts
@@ -1,13 +1,49 @@
-// Type definitions for lscache v1.0.2
+// Type definitions for lscache v1.0.5
 // Project: https://github.com/pamelafox/lscache
 // Definitions by: Chris Martinez <https://github.com/Chris-Martinezz>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 interface LSCache {
 
+    /**
+    * Stores the value in localStorage. Expires after specified number of minutes.
+    * @param {string} key
+    * @param {Object|string} value
+    * @param {number} time
+    */
     set(key: string, value: any, time?: number): void;
+    /**
+    * Retrieves specified value from localStorage, if not expired.
+    * @param {string} key
+    * @return {string|Object}
+    */
     get(key: string): any;
+    /**
+    * Removes a value from localStorage.
+    * Equivalent to 'delete' in memcache, but that's a keyword in JS.
+    * @param {string} key
+    */
     remove(key: string): void;
+    /**
+    * Flushes all lscache items and expiry markers without affecting rest of localStorage
+    */
+    flush(): void;
+    /**
+    * Flushes expired lscache items and expiry markers without affecting rest of localStorage
+    */
+    flushExpired(): void;
+    /**
+    * Appends CACHE_PREFIX so lscache will partition data in to different buckets.
+    * @param {string} bucket
+    */
+    setBucket(bucket: string):void;
+    /**
+    * Resets the string being appended to CACHE_PREFIX so lscache will use the default storage behavior.
+    */
+    resetBucket(): void;
+}
+declare var lscache:LSCache;
+declare module 'lscache' {
+    var lscache: LSCache;
+    export = lscache;
 }
-
-declare var lscache: LSCache;
\ No newline at end of file
diff --git a/mailparser/mailparser-tests.ts b/mailparser/mailparser-tests.ts
index 51d5627889..b7df9adb44 100644
--- a/mailparser/mailparser-tests.ts
+++ b/mailparser/mailparser-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./mailparser.d.ts" />
+
 import mailparser_mod = require("mailparser");
 import MailParser = mailparser_mod.MailParser;
 import ParsedMail = mailparser_mod.ParsedMail;
@@ -12,25 +14,25 @@ mailparser.on("headers", function(headers){
 });
 
 mailparser.on("end", function(mail){
-    mail; // object structure for parsed e-mail 
+    mail; // object structure for parsed e-mail
 });
-    
+
 
 // Decode a simple e-mail
 // This example decodes an e-mail from a string
- 
+
 var email = "From: 'Sender Name' <sender@example.com>\r\n"+
             "To: 'Receiver Name' <receiver@example.com>\r\n"+
             "Subject: Hello world!\r\n"+
             "\r\n"+
             "How are you today?";
-    // setup an event listener when the parsing finishes 
+    // setup an event listener when the parsing finishes
 mailparser.on("end", function(mail_object){
-    console.log("From:", mail_object.from); //[{address:'sender@example.com',name:'Sender Name'}] 
-    console.log("Subject:", mail_object.subject); // Hello world! 
-    console.log("Text body:", mail_object.text); // How are you today? 
+    console.log("From:", mail_object.from); //[{address:'sender@example.com',name:'Sender Name'}]
+    console.log("Subject:", mail_object.subject); // Hello world!
+    console.log("Text body:", mail_object.text); // How are you today?
 });
-    // send the email source to the parser 
+    // send the email source to the parser
 mailparser.write(email);
 mailparser.end();
 
@@ -42,7 +44,7 @@ import fs = require("fs");
 mailparser.on("end", function(mail_object){
     console.log("Subject:", mail_object.subject);
 });
- 
+
 fs.createReadStream("email.eml").pipe(mailparser);
 
 
@@ -63,7 +65,3 @@ mp.on("attachment", function(attachment, mail){
     var output = fs.createWriteStream(attachment.generatedFileName);
     attachment.stream.pipe(output);
 });
-
-
-
-
diff --git a/mariasql/mariasql-tests.ts b/mariasql/mariasql-tests.ts
index 76819feba8..c3ab5c848c 100644
--- a/mariasql/mariasql-tests.ts
+++ b/mariasql/mariasql-tests.ts
@@ -1,7 +1,8 @@
 // These are the examples from the node-mariasql README transposed to TypeScript
 // https://github.com/mscdex/node-mariasql
 
-/// <reference path="../node/node-0.10.d.ts" />
+/// <reference path="./mariasql.d.ts" />
+/// <reference path="../node/node.d.ts" />
 
 // Example 1 - SHOW DATABASES
 import util = require('util');
@@ -198,4 +199,4 @@ c.end();
  Query #3 finished successfully
  Done with all queries
  Client closed
- */
\ No newline at end of file
+ */
diff --git a/merge2/merge2-tests.ts b/merge2/merge2-tests.ts
index bba0dd0a34..b1c4b4e546 100644
--- a/merge2/merge2-tests.ts
+++ b/merge2/merge2-tests.ts
@@ -2,7 +2,7 @@
 /// <reference path="../gulp/gulp.d.ts" />
 
 import gulp = require('gulp');
-import merge2 = require('merge2');
+import * as merge2 from "merge2"; 
 
 gulp.task('app-js', () =>
   merge2(
diff --git a/merge2/merge2.d.ts b/merge2/merge2.d.ts
index ebf1df758f..095af7a2c4 100644
--- a/merge2/merge2.d.ts
+++ b/merge2/merge2.d.ts
@@ -12,10 +12,13 @@ declare module 'merge2' {
     }
 
     interface IMerge2Stream extends NodeJS.ReadWriteStream {
-      add(...args: Array<NodeJS.ReadWriteStream | IMerge2Stream | Array<NodeJS.ReadWriteStream | IMerge2Stream | IOptions>>): IMerge2Stream;
+        add(...args: Array<NodeJS.ReadWriteStream | IMerge2Stream | Array<NodeJS.ReadWriteStream | IMerge2Stream | IOptions>>): IMerge2Stream;
     }
 
-    function merge2(...args: Array<NodeJS.ReadWriteStream | IMerge2Stream | Array<NodeJS.ReadWriteStream | IMerge2Stream> | IOptions>): IMerge2Stream;
+    interface IMerge2 {
+        (...args: Array<NodeJS.ReadWriteStream | IMerge2Stream | Array<NodeJS.ReadWriteStream | IMerge2Stream> | IOptions>): IMerge2Stream;
+    }
 
-    export = merge2;
+    var _tmp: IMerge2;
+    export = _tmp;
 }
diff --git a/mongodb/mongodb.d.ts b/mongodb/mongodb.d.ts
index 84d0098e72..2fc3f0227f 100644
--- a/mongodb/mongodb.d.ts
+++ b/mongodb/mongodb.d.ts
@@ -527,6 +527,7 @@ declare module "mongodb" {
   export interface MongoCollectionOptions {
     safe?: any;
     serializeFunctions?: any;
+    strict?: boolean;
     raw?: boolean;
     pkFactory?: any;
     readPreference?: string;
diff --git a/mssql/mssql-tests.ts b/mssql/mssql-tests.ts
index 453b2b4e3f..e508ec3547 100644
--- a/mssql/mssql-tests.ts
+++ b/mssql/mssql-tests.ts
@@ -71,8 +71,74 @@ var connection: sql.Connection = new sql.Connection(config, function (err: any)
                 console.error('Error happened calling Query: ' + err.name + " " + err.message);
             }
             else {
-                console.info(requestStoredProcedureWithOutput.parameters.output.value);
+                console.info(requestStoredProcedureWithOutput.parameters['output'].value);
             }
         });
     }
 });
+
+function test_table() {
+    var table = new sql.Table('#temp_table');
+
+    table.create = true;
+
+    table.columns.add('name', sql.VarChar(sql.MAX), { nullable: false });
+    table.columns.add('type', sql.Int, { nullable: false });
+    table.columns.add('amount', sql.Decimal(7, 2), { nullable: false });
+
+    table.rows.add('name', 42, 3.50);
+    table.rows.add('name2', 7, 3.14);
+}
+
+
+function test_promise_returns() {
+    // Methods return a promises if the callback is omitted.
+    var connection: sql.Connection = new sql.Connection(config);
+    connection.connect().then(() => { });
+    connection.close().then(() => { });
+
+    var preparedStatment = new sql.PreparedStatement(connection);
+    preparedStatment.prepare("SELECT @myValue").then(() => { });
+    preparedStatment.execute({ myValue: 1 }).then((recordSet) => { });
+    preparedStatment.unprepare().then(() => { });
+
+    var transaction = new sql.Transaction(connection);
+    transaction.begin().then(() => { });
+    transaction.commit().then(() => { });
+    transaction.rollback().then(() => { });
+
+    var request = new sql.Request();
+    request.batch('create procedure #temporary as select * from table').then((recordset) => { });
+    request.bulk(new sql.Table("table_name")).then(() => { });
+    request.query('SELECT 1').then((recordset) => { });
+    request.execute('procedure_name').then((recordset) => { });
+}
+
+
+function test_request_constructor() {
+    // Request can be constructed with a connection, preparedStatment, transaction or no arguments
+    var connection: sql.Connection = new sql.Connection(config);
+    var preparedStatment = new sql.PreparedStatement(connection);
+    var transaction = new sql.Transaction(connection);
+    
+    var request1 = new sql.Request(connection);
+    var request2 = new sql.Request(preparedStatment);
+    var request3 = new sql.Request(transaction);
+    var request4 = new sql.Request();
+}
+
+function test_classes_extend_eventemitter() {
+    var connection: sql.Connection = new sql.Connection(config);
+    var transaction = new sql.Transaction();
+    var request = new sql.Request();
+    var preparedStatment = new sql.PreparedStatement();
+
+    connection.on('connect', () => { });
+    transaction.on('begin', () => { });
+    transaction.on('commit', () => { });
+    transaction.on('rollback', () => { });
+    request.on('done', () => { });
+    request.on('error', () => { });
+
+    preparedStatment.on('error', () => { })
+}
\ No newline at end of file
diff --git a/mssql/mssql.d.ts b/mssql/mssql.d.ts
index 880eb716cb..c434444d3f 100644
--- a/mssql/mssql.d.ts
+++ b/mssql/mssql.d.ts
@@ -1,53 +1,131 @@
-// Type definitions for mssql
+// Type definitions for mssql v2.2.0
 // Project: https://www.npmjs.com/package/mssql
-// Definitions by: COLSA Corporation <http://www.colsa.com/>
+// Definitions by: COLSA Corporation <http://www.colsa.com/>, Ben Farr <https://github.com/jaminfarr>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
+/// <reference path="../node/node.d.ts" />
+/// <reference path="../es6-promise/es6-promise.d.ts" />
+
 declare module "mssql" {
+    import events = require('events'); 
 
-    export var Date: any;
-    export var DateTime: any;
-    export var DateTime2: any;
-    export var DateTimeOffset: any;
-    export var SmallDateTime: any;
-    export var Time: any;
-    export var Char: any;
-    export var VarChar:any;
-    export var NChar: any;
-    export var NVarChar: any;
-    export var Text:any;
-    export var NText:any;
-    export var Xml: any;
-    export var TinyInt:any;
-    export var SmallInt:any;
-    export var Int: any;
-    export var BigInt:any;
-    export var Decimal:any;
-    export var Float:any;
-    export var Real:any;
-    export var SmallMoney:any;
-    export var Money:any;
-    export var Numeric:any;
-    export var Bit: any;
-    export var Binary: any;
-    export var VarBinary: any;
-    export var TVP: any;
-    export var UniqueIdentifier: any;
-    export var Image: any;
-    export var UDT: any;
-    export var Geography: any;
-    export var Geometry: any;
+    type sqlTypeWithNoParams       = { type: sqlTypeFactoryWithNoParams }
+    type sqlTypeWithLength         = { type: sqlTypeFactoryWithLength, length: number }
+    type sqlTypeWithScale          = { type: sqlTypeFactoryWithScale, scale: number }
+    type sqlTypeWithPrecisionScale = { type: sqlTypeFactoryWithPrecisionScale, precision: number, scale: number }
+    type sqlTypeWithTvpType        = { type: sqlTypeFactoryWithTvpType, tvpType: any }
 
-    export interface options {
+    type sqlTypeFactoryWithNoParams       = ()                                   => sqlTypeWithNoParams;
+    type sqlTypeFactoryWithLength         = (length?: number)                    => sqlTypeWithLength;
+    type sqlTypeFactoryWithScale          = (scale?: number)                     => sqlTypeWithScale;
+    type sqlTypeFactoryWithPrecisionScale = (precision?: number, scale?: number) => sqlTypeWithPrecisionScale;
+    type sqlTypeFactoryWithTvpType        = (tvpType: any)                       => sqlTypeWithTvpType;
+
+    export var VarChar:          sqlTypeFactoryWithLength;
+    export var NVarChar:         sqlTypeFactoryWithLength;
+    export var Text:             sqlTypeFactoryWithNoParams;
+    export var Int:              sqlTypeFactoryWithNoParams;
+    export var BigInt:           sqlTypeFactoryWithNoParams;
+    export var TinyInt:          sqlTypeFactoryWithNoParams;
+    export var SmallInt:         sqlTypeFactoryWithNoParams;
+    export var Bit:              sqlTypeFactoryWithNoParams;
+    export var Float:            sqlTypeFactoryWithNoParams;
+    export var Numeric:          sqlTypeFactoryWithPrecisionScale;
+    export var Decimal:          sqlTypeFactoryWithPrecisionScale;
+    export var Real:             sqlTypeFactoryWithNoParams;
+    export var Date:             sqlTypeFactoryWithNoParams;
+    export var DateTime:         sqlTypeFactoryWithNoParams;
+    export var DateTime2:        sqlTypeFactoryWithScale;
+    export var DateTimeOffset:   sqlTypeFactoryWithScale;
+    export var SmallDateTime:    sqlTypeFactoryWithNoParams;
+    export var Time:             sqlTypeFactoryWithScale;
+    export var UniqueIdentifier: sqlTypeFactoryWithNoParams;
+    export var SmallMoney:       sqlTypeFactoryWithNoParams;
+    export var Money:            sqlTypeFactoryWithNoParams;
+    export var Binary:           sqlTypeFactoryWithNoParams;
+    export var VarBinary:        sqlTypeFactoryWithLength;
+    export var Image:            sqlTypeFactoryWithNoParams;
+    export var Xml:              sqlTypeFactoryWithNoParams;
+    export var Char:             sqlTypeFactoryWithLength;
+    export var NChar:            sqlTypeFactoryWithLength;
+    export var NText:            sqlTypeFactoryWithNoParams;
+    export var TVP:              sqlTypeFactoryWithTvpType;
+    export var UDT:              sqlTypeFactoryWithNoParams;
+    export var Geography:        sqlTypeFactoryWithNoParams;
+    export var Geometry:         sqlTypeFactoryWithNoParams;
+
+    export var TYPES: {
+        VarChar:          sqlTypeFactoryWithLength;
+        NVarChar:         sqlTypeFactoryWithLength;
+        Text:             sqlTypeFactoryWithNoParams;
+        Int:              sqlTypeFactoryWithNoParams;
+        BigInt:           sqlTypeFactoryWithNoParams;
+        TinyInt:          sqlTypeFactoryWithNoParams;
+        SmallInt:         sqlTypeFactoryWithNoParams;
+        Bit:              sqlTypeFactoryWithNoParams;
+        Float:            sqlTypeFactoryWithNoParams;
+        Numeric:          sqlTypeFactoryWithPrecisionScale;
+        Decimal:          sqlTypeFactoryWithPrecisionScale;
+        Real:             sqlTypeFactoryWithNoParams;
+        Date:             sqlTypeFactoryWithNoParams;
+        DateTime:         sqlTypeFactoryWithNoParams;
+        DateTime2:        sqlTypeFactoryWithScale;
+        DateTimeOffset:   sqlTypeFactoryWithScale;
+        SmallDateTime:    sqlTypeFactoryWithNoParams;
+        Time:             sqlTypeFactoryWithScale;
+        UniqueIdentifier: sqlTypeFactoryWithNoParams;
+        SmallMoney:       sqlTypeFactoryWithNoParams;
+        Money:            sqlTypeFactoryWithNoParams;
+        Binary:           sqlTypeFactoryWithNoParams;
+        VarBinary:        sqlTypeFactoryWithLength;
+        Image:            sqlTypeFactoryWithNoParams;
+        Xml:              sqlTypeFactoryWithNoParams;
+        Char:             sqlTypeFactoryWithLength;
+        NChar:            sqlTypeFactoryWithLength;
+        NText:            sqlTypeFactoryWithNoParams;
+        TVP:              sqlTypeFactoryWithTvpType;
+        UDT:              sqlTypeFactoryWithNoParams;
+        Geography:        sqlTypeFactoryWithNoParams;
+        Geometry:         sqlTypeFactoryWithNoParams;
+    };
+
+    export var MAX: number;
+    export var fix: boolean;
+    export var Promise: any;
+
+
+    interface IMap extends Array<{js: any, sql: any }> {
+        register(jstype: any, sql: any): void;
+    }
+
+    export var map: IMap;
+
+    export var DRIVERS: string[];
+
+    type recordSet = any;
+    type IIsolationLevel = number;
+
+    export var ISOLATION_LEVEL: {
+        READ_UNCOMMITTED: IIsolationLevel
+        READ_COMMITTED: IIsolationLevel
+        REPEATABLE_READ: IIsolationLevel
+        SERIALIZABLE: IIsolationLevel
+        SNAPSHOT: IIsolationLevel
+    }
+
+    export interface IOptions {
         encrypt: boolean;
     }
 
-    export interface pool {
+
+    export interface IPool {
         min: number;
         max: number;
         idleTimeoutMillis: number;
     }
 
+    export var pool: IPool;
+
     export interface config {
         driver?: string;
         user?: string;
@@ -59,18 +137,26 @@ declare module "mssql" {
         connectionTimeout?: number;
         requestTimeout?: number;
         stream?: boolean;
-        options?: options;
-        pool?: pool;
-
+        options?: IOptions;
+        pool?: IPool;
     }
 
-    export class Connection {
-
+    export class Connection extends events.EventEmitter {
+        public connected: boolean;
+        public connecting: boolean;
+        public driver: string;
         public constructor(config: config, callback?: (err?: any) => void);
+        public connect(): Promise<void>;
+        public connect(callback: (err: any) => void): void;
+        public close(): Promise<void>;
+        public close(callback: (err: any) => void): void;
+    }
 
-        public connect(callback?: (err?: any) => void): void;
-
-        public close(): void;
+    export class ConnectionError implements Error {
+        constructor(message: string, code?: any)
+        public name: string;
+        public message: string;
+        public code: string;
     }
 
     class columns {
@@ -78,7 +164,7 @@ declare module "mssql" {
     }
 
     class rows {
-        public add(row: any): void;
+        public add(...row: any[]): void;
     }
 
     export class Table {
@@ -86,37 +172,97 @@ declare module "mssql" {
         public columns: columns;
         public rows: rows;
         public constructor(tableName: string);
-
     }
 
-    export class Request {
+    interface IRequestParameters {
+        [name: string]: {
+            name: string;
+            type: any;
+            io: number;
+            value: any;
+            length: number;
+            scale: number;
+            precision: number;
+            tvpType: any;
+        }
+    }
+
+    export class Request extends events.EventEmitter {
+        public connection: Connection;
+        public transaction: Transaction;
+        public pstatement: PreparedStatement;
+        public parameters: IRequestParameters;
+        public verbose: boolean;
+        public multiple: boolean;
+        public canceled: boolean;
+        public stream: any;
         public constructor(connection?: Connection);
-        public execute(procedure: string, callback?: (err?: any, recordsets?: any, returnValue?: any) => void): void;
+        public constructor(transaction: Transaction);
+        public constructor(preparedStatement: PreparedStatement);
+        public execute(procedure: string): Promise<recordSet>;
+        public execute(procedure: string, callback: (err?: any, recordsets?: any, returnValue?: any) => void): void;
         public input(name: string, value: any): void;
         public input(name: string, type: any, value: any): void;
         public output(name: string, type: any, value?: any): void;
-        public pipe(stream: any): void;
-        public query(command: string, callback?: (err?: any, recordset?: any) => void): void;
-        public batch(batch: string, callback?: (err?: any, recordset?: any) => void): void;
-        public bulk(table: Table, callback?: (err?: any, rowCount?: any) => void): void;
+        public pipe(stream: NodeJS.WritableStream): void;
+        public query(command: string): Promise<void>;
+        public query(command: string, callback: (err?: any, recordset?: any) => void): void;
+        public batch(batch: string): Promise<recordSet>;
+        public batch(batch: string, callback: (err?: any, recordset?: any) => void): void;
+        public bulk(table: Table): Promise<void>;
+        public bulk(table: Table, callback: (err: any, rowCount: any) => void): void;
         public cancel(): void;
-        public parameters: any;
     }
 
-    export class Transaction {
+    export class RequestError implements Error {
+        constructor(message: string, code?: any)
+        public name: string;
+        public message: string;
+        public code: string;
+    }
+
+    export class Transaction extends events.EventEmitter {
+        public connection: Connection;
+        public isolationLevel: IIsolationLevel;
         public constructor(connection?: Connection);
-        public begin(isolationLevel?: any, callback?: (err?: any) => void): void;
-        public begin(callback?: (err?: any) => void): void;
-        public commit(callback?: (err?: any) => void): void;
-        public rollback(callback?: (err?: any) => void): void;
+        public begin(isolationLevel?: IIsolationLevel): Promise<void>;
+        public begin(isolationLevel?: IIsolationLevel, callback?: (err?: any) => void): void;
+        public commit(): Promise<void>;
+        public commit(callback: (err?: any) => void): void;
+        public rollback(): Promise<void>;
+        public rollback(callback: (err?: any) => void): void;
     }
 
-    export class PreparedStatement {
+    export class TransactionError implements Error {
+        constructor(message: string, code?: any)
+        public name: string;
+        public message: string;
+        public code: string;
+    }
+
+    export class PreparedStatement extends events.EventEmitter {
+        public connection: Connection;
+        public transaction: Transaction;
+        public prepared: boolean;
+        public statement: string;
+        public parameters: IRequestParameters;
+        public multiple: boolean;
+        public stream: any;
         public constructor(connection?: Connection);
         public input(name: string, type: any): void;
         public output(name: string, type: any): void;
-        public prepare(statement: string, callback?: (err?: any) => void): void;
-        public execute(values: any, callback?: (err?: any) => void): void;
-        public unprepare(callback?: (err?: any) => void): void;
+        public prepare(statement?: string): Promise<void>;
+        public prepare(statement?: string, callback?: (err?: any) => void): void;
+        public execute(values: Object): Promise<recordSet>;
+        public execute(values: Object, callback: (err: any, recordSet: recordSet) => void): void;
+        public unprepare(): Promise<void>;
+        public unprepare(callback: (err?: any) => void): void;
+    }
+
+    export class PreparedStatementError implements Error {
+        constructor(message: string, code?: any)
+        public name: string;
+        public message: string;
+        public code: string;
     }
 }
diff --git a/node-imap/imap-tests.ts b/node-imap/imap-tests.ts
index 61f4b2e0c1..3c124ca46d 100644
--- a/node-imap/imap-tests.ts
+++ b/node-imap/imap-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./imap.d.ts" />
+
 import Imap = require('imap');
 var inspect = require('util').inspect;
 
diff --git a/node-jsfl-runner/node-jsfl-runner-tests.ts b/node-jsfl-runner/node-jsfl-runner-tests.ts
index f92f4bfdea..31202b9f71 100644
--- a/node-jsfl-runner/node-jsfl-runner-tests.ts
+++ b/node-jsfl-runner/node-jsfl-runner-tests.ts
@@ -8,11 +8,13 @@ let myJSFL: jsfl.JSFL = {
   }
 }
 
+let flashLocation: string = '';
+
 jsfl.createJSFL(myJSFL, 'fileName.jsfl', ['Hello!'], (err: NodeJS.ErrnoException) => {
 
 });
 
-jsfl.runJSFL('fileName.jsfl', (err: NodeJS.ErrnoException) => {
+jsfl.runJSFL(flashLocation, 'fileName.jsfl', (err: NodeJS.ErrnoException) => {
 
 });
 
diff --git a/node-jsfl-runner/node-jsfl-runner.d.ts b/node-jsfl-runner/node-jsfl-runner.d.ts
index b3f0a86886..f1d11561a2 100644
--- a/node-jsfl-runner/node-jsfl-runner.d.ts
+++ b/node-jsfl-runner/node-jsfl-runner.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for node-jsfl-runner
+// Type definitions for node-jsfl-runner v0.2.4
 // Project: https://www.npmjs.com/package/node-jsfl-runner
 // Definitions by: Michael Randolph <https://github.com/mrand01>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -28,8 +28,9 @@ declare module "node-jsfl-runner" {
   
   /**
    * Runs a JSFL file
+   * @param flashLocation Path to Flash executable
    * @param fileName Path to JSFL file to run
    * @param callback Callback
    */
-  function runJSFL(fileName: string, callback: (err: NodeJS.ErrnoException) => void): void;
+  function runJSFL(flashLocation:string, fileName: string, callback: (err: NodeJS.ErrnoException) => void): void;
 }
\ No newline at end of file
diff --git a/node-mysql-wrapper/node-mysql-wrapper-tests.ts b/node-mysql-wrapper/node-mysql-wrapper-tests.ts
index 35acec27f8..3d26b6e8bc 100644
--- a/node-mysql-wrapper/node-mysql-wrapper-tests.ts
+++ b/node-mysql-wrapper/node-mysql-wrapper-tests.ts
@@ -1,49 +1,80 @@
-///<reference path='./node-mysql-wrapper.d.ts' />
-
-import wrapper = require("node-mysql-wrapper");
-var db = wrapper.wrap("mysql://kataras:pass@127.0.0.1/taglub?debug=false&charset=utf8");
-
-
+/// <reference path="./node-mysql-wrapper.d.ts" />
+/// <reference path="../node/node.d.ts" />
+/// <reference path="../bluebird/bluebird.d.ts" />
 
+var express = require('express');
+var app = express();
+var server = require('http').createServer(app);
+import wrapper2 = require("node-mysql-wrapper");
+var db = wrapper2.wrap("mysql://kataras:pass@127.0.0.1/taglub?debug=false&charset=utf8");
 
 class User { //or interface
     userId: number;
     username: string;
     mail: string;
+    password:string;
     comments: Comment[];
+    myComments: Comment[];
+    info: UserInfo;
 }
 
 interface Comment {
     commentId: number;
     content: string;
+    likes: CommentLike[];
 
 }
+interface CommentLike {
+    commentLikeId: number;
+    userId: number;
+    commentId: number;
+}
+
+interface UserInfo {
+    userInfoId: number;
+    userId: number;
+    hometown: string;
+}
 
 db.ready(() => {
+
+
     var usersDb = db.table<User>("users");
+    
+    //or var usersDb = db.table("users"); if you don't want intel auto complete from your ide/editor
 
     usersDb.findById(16, (_user) => {
+
         console.log("TEST1: \n");
         console.log("FOUND USER WITH USERNAME: " + _user.username);
     });
-    
+
     /* OR   usersDb.findById(18).then(_user=> {
          console.log("FOUND USER WITH USERNAME: " + _user.username);
      }, (err) => { console.log("ERROR ON FETCHING FINDBY ID: " + err) });
    */
 
-    usersDb.find({ userId: 18, comments: { userId: '=' } }, _users=> {
-        var _user = _users[0];
-        console.log("TEST2: \n");
-        console.log(_user.username + " with ");
-        console.log(_user.comments.length + " comments ");
-        _user.comments.forEach(_comment=> {
-            console.log("--------------\n" + _comment.content);
+    usersDb.findSingle(
+        {
+            userId: 18,
+            myComments: {
+                userId: '=',
+                tableRules: { //NEW: SET rules to joined tables too!
+                    table: "comments", //NEW SET table name inside any property u want!
+                    limit: 50,
+                    orderByDesc: "commentId" //give me the first 50 comments ordered by -commentId (DESC) from table 'comments' and put them at 'myComments' property inside the result object.
+                }
+            }
+        }).then(_user=> { // to get this promise use : .promise() 
+        console.log("\n-------------TEST 2 ------------\n");
+            console.log(_user.username + " with ");
+            console.log(_user.myComments.length + " comments ");
+            _user.myComments.forEach(_comment=> {
+                console.log("--------------\n" + _comment.content);
+            });
         });
 
-    });
-
-    usersDb.safeRemove(5620, answer=> {
+    usersDb.remove(5620, answer=> {
         console.log("TEST 3: \n");
         console.log(answer.affectedRows + ' (1) has removed from table:  ' + answer.table);
 
@@ -60,4 +91,109 @@ db.ready(() => {
     });
 
 
+
+    usersDb.find(
+        {
+            yearsOld: 22,
+            comments: {
+                userId: "=",
+                tableRules: {
+                    limit: 2
+                }
+            }
+
+        }, (_users) => {
+         
+            console.log("---------------TEST 6----------------------------------------");
+            _users.forEach(_user=> {
+                console.log(_user.userId + " " + _user.username + " found with " + _user.comments.length + " comments");
+
+            });
+
+        });
+    //if no rules setted to find method  it's uses the table's rules ( if exists)
+    
+    
+    
+    let _criteriaFromBuilder = usersDb.criteria
+        .except("password") // or .exclude(...columns). the only column you cannot except/exclude is the primary key (because it is used at where clause), be careful.
+        .where("userId", 24)
+        .joinAs("info", "userInfos", "userId") 
+        .at("info")
+        .limit(1) //because we make it limit 1 it will return this result as object not as array.
+        .parent()
+        .joinAs("myComments", "comments", "userId")  
+        .at("myComments").limit(2)
+        .joinAs("likes", "commentLikes", "commentId")
+        .original().orderBy("userId", true).build();
+        
+    /* console.dir(_criteriaFromBuilder);
+     prints this object: ( of course you can create your own in order to pass it on .find table methods )
+    {
+        userId:23,
+        
+        myComments:{
+            userId: '=',
+            
+            tableRules:{
+                table: 'comments',
+                limit:2
+               
+            },
+            
+            likes:{
+                commentId: '=',
+                
+                tableRules:{
+                    table: 'commentLikes'
+                }
+               
+            }
+        },
+        
+        tableRules:{ 
+            orderByDesc: 'userId',
+            except: ['password']
+        }
+        
+    }
+    
+    
+    */
+    
+
+
+    usersDb.find(_criteriaFromBuilder).then(_users=> {
+        console.log("\n----------------\nTEST ADVANCED 1\n-------------------\n ");
+        _users.forEach(_user=> {
+            console.log(_user.userId + " " + _user.username);
+
+            if (_user.info !== undefined) {
+                console.log(' from ' + _user.info.hometown);
+                //console.dir(_user.userInfos);
+            }
+
+            if (_user.myComments !== undefined) {
+                _user.myComments.forEach(_comment=> {
+                    console.log(_comment.commentId + " " + _comment.content);
+
+                    if (_comment.likes !== undefined) {
+                        console.log(' with ' + _comment.likes.length + ' likes!');
+                    }
+                });
+            }
+        });
+
+    });
+
+
+});
+
+server.on('uncaughtException', function(err:any) {
+    console.log(err);
+})
+
+var httpPort = 1193;//config.get('Server.port') || 1193;
+server.listen(httpPort, function() {
+    console.log("Server is running on " + httpPort);
 });
diff --git a/node-mysql-wrapper/node-mysql-wrapper.d.ts b/node-mysql-wrapper/node-mysql-wrapper.d.ts
index 6f792d96de..af100bbf4e 100644
--- a/node-mysql-wrapper/node-mysql-wrapper.d.ts
+++ b/node-mysql-wrapper/node-mysql-wrapper.d.ts
@@ -1,5 +1,5 @@
 // Type definitions for node-mysql-wrapper
-// Project: https://github.com/kataras/node-mysql-wrapper
+// Project: https://github.com/nodets/node-mysql-wrapper
 // Definitions by: Makis Maropoulos <https://github.com/kataras>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
@@ -12,120 +12,616 @@ declare module "node-mysql-wrapper" {
     import {EventEmitter} from 'events';
 
     var EQUAL_TO_PROPERTY_SYMBOL: string;
+    var TABLE_RULES_PROPERTY: string;
+
+    type DeleteAnswer = {
+        affectedRows: number;
+        table: string;
+    };
+
+    type RawRules = {
+        table: string,
+        begin: string,
+        orderBy: string,
+        orderByDesc: string,
+        groupBy: string,
+        limit: number, // limit = limitStart  =0 and limitEnd = limit.
+        limitStart: number,
+        limitEnd: number,
+        end: string
+
+    };
+
+    type TableToSearchPart = { tableName: string, propertyName: string };
 
     interface Map<T> {
         [index: string]: T;
     }
 
-    class MysqlUtil {
+    interface IQuery<T> {
+        _table: Table<T>;
+        execute(rawCriteria: any, callback?: (_results: any) => any): Promise<any>;
+    }
+
+    interface IQueryConstructor<T> {
+        new (_table: Table<T>): IQuery<T>;
+    }
+
+
+    class Helper {
+        /** 
+         * Callback like forEach
+         * @name valueCallback
+         * @function
+         * @param {T} the value of the object's key 
+         * @returnTye {U}
+         * @return {U}
+        */
+        
+        /**
+         * Callback like forEach
+         * @name keyCallback
+         * @function
+         * @param {string} the name of the object's key 
+         * @returnTye {U}
+         * @return {U}
+        */
+
         constructor();
+        
+        /**
+         * Create and return a copy of an object.
+         * @param {T} object the object you want to copy.
+         * @returnType {T}
+         * @return {T}
+         */
         static copyObject<T>(object: T): T;
+        
+        /**
+         * Converts any_string to anyString and returns it.
+         * @param {string} columnKey the string you want to convert.
+         * @returnType {string}
+         * @return {string}
+         */
         static toObjectProperty(columnKey: string): string;
+        
+        /**
+         * Converts anyString to any_string and returns it.
+         * @param {string} objectKey the string you want to convert.
+         * @returnType {string}
+         * @return {string}
+         */
         static toRowProperty(objectKey: string): string;
+    
+        /**
+         * Iterate object's keys and return their values to the callback.
+         * @param {Map<T>} map the object.
+         * @param {valueCallback}
+         * @returnType {U}
+         * @return {U}
+         */
         static forEachValue<T, U>(map: Map<T>, callback: (value: T) => U): U;
+
+        /**
+        * Iterate object's keys and return their names to the callback.
+        * @param {Map<T>} map the object.
+        * @param {keyCallback}
+        * @returnType {U}
+        * @return {U}
+        */
+
         static forEachKey<T, U>(map: Map<T>, callback: (key: string) => U): U;
+        
+        /**
+         * Checks if anything is a function.
+         * @param {functionToCheck} the object or function to pass
+         * @return boolean
+         */
+        static isFunction(functionToCheck: any): boolean;
+        
+        /**
+         * Checks if an object has 'tableRules' property.
+         * @param {obj} the object to pass
+         * @return boolean
+         */
+        static hasRules(obj: any): boolean;
     }
 
-    interface ICriteria {
+
+    interface ICriteriaParts {
         rawCriteriaObject: any;
-        tables: string[];
+        tables: TableToSearchPart[];
         noDatabaseProperties: string[];
         whereClause: string;
+
+        selectFromClause<T>(_table: Table<T>): string;
+
     }
-	
-    class Criteria implements ICriteria {
+
+
+
+    class CriteriaParts implements ICriteriaParts {
+        
+        /**
+         * The raw format of the criteria eg: {yearsOld:22}.
+         */
         rawCriteriaObject: any;
-        tables: string[];
+        
+        /**
+         * Which tables to search after the find method of the proto table finish.
+         */
+        tables: TableToSearchPart[];
+        
+        /**
+         * The properties of the criteria which don't belong to the database's table.
+         */
         noDatabaseProperties: string[];
+        
+        /**
+         * The converted/exported where clause. 
+         */
         whereClause: string;
-        constructor(rawCriteriaObject: any, tables: string[], noDatabaseProperties: string[], whereClause: string);
+
+        constructor(rawCriteriaObject: any, tables: TableToSearchPart[], noDatabaseProperties: string[], whereClause: string);
+
+        selectFromClause<T>(_table: Table<T>): string;
     }
-	
-    class CriteriaBuilder<T> {
+
+    class CriteriaDivider<T> {
         private _table;
-        constructor(table: MysqlTable<T>);
-        build(rawCriteriaObject: any): Criteria;
+        constructor(table: Table<T>);
+        
+        /**
+         * Builds the criteria raw object to Criteria object.
+         * @param {any} rawCriteriaObject the criteria at raw format you pass eg: {yearsOld:18}.
+         * @returnType {Criteria}
+         * @return {Criteria}
+         */
+        build(rawCriteriaObject: any): CriteriaParts;
+    }
+
+    class SelectQueryRules {
+        private lastPropertyClauseName: string;
+        manuallyEndClause: string;
+        manuallyBeginClause: string;
+        exceptColumns: string[];
+        orderByColumn: string;
+        orderByDescColumn: string;
+        groupByColumn: string;
+        limitStart: number;
+        limitEnd: number;
+        public tableName: string; //auto den benei oute sto last, oute sto from.
+        static build(): SelectQueryRules;
+        private last(propertyClauseName);
+        except(...columns: string[]): SelectQueryRules;
+        
+        /**
+         * Same as .except(...columns)
+         */
+        exclude(...columns: string[]): SelectQueryRules;
+
+        orderBy(columnKey: string, descending?: boolean): SelectQueryRules;
+        groupBy(columnKey: string): SelectQueryRules;
+        limit(limitRowsOrStart: number, limitEnd?: number): SelectQueryRules;
+        appendToBegin(manualAfterWhereString: string): SelectQueryRules;
+        appendToEnd(manualAfterWhereString: string): SelectQueryRules;
+        append(appendToCurrent: string): SelectQueryRules;
+        clearOrderBy(): SelectQueryRules;
+        clearGroupBy(): SelectQueryRules;
+        clearLimit(): SelectQueryRules;
+        clearEndClause(): SelectQueryRules;
+        clearBeginClause(): SelectQueryRules;
+        clear(): SelectQueryRules;
+        from(parentRule: SelectQueryRules): SelectQueryRules;
+        isEmpty(): boolean;
+        toString(): string;
+        toRawObject(): RawRules;
+        static toString(rules: SelectQueryRules): string;
+        static toRawObject(rules: SelectQueryRules): RawRules;
+        static fromRawObject(obj: RawRules): SelectQueryRules;
+    }
+
+    class CriteriaBuilder<T>{
+
+        private rawCriteria: any;
+        private primaryTable: Table<T>;
+        private parentBuilder: CriteriaBuilder<any>;
+
+        constructor(primaryTable: Table<T>); //to arxiko apo to Table.ts 9a benei
+        constructor(primaryTable: Table<T>, tableName: string, parentBuilder: CriteriaBuilder<any>);// auta 9a benoun apo to parent select query.
+        constructor(primaryTable: Table<T>, tablePropertyName?: string, parentBuilder?: CriteriaBuilder<any>);
+
+        except(...columns: string[]): CriteriaBuilder<T>;
+        
+        /**
+	    * Same as .except(...columns)
+	    */
+        exclude(...columns: string[]): CriteriaBuilder<T>;
+
+        where(key: string, value: any): CriteriaBuilder<T>;
+
+        private createRulesIfNotExists(): void;
+
+        orderBy(column: string, desceding?: boolean): CriteriaBuilder<T>;
+
+        limit(start: number, end?: number): CriteriaBuilder<T>;
+
+        join(realTableName: string, foreignColumnName: string): CriteriaBuilder<T>;
+
+        joinAs(tableNameProperty: string, realTableName: string, foreignColumnName: string): CriteriaBuilder<T>;
+
+        at(tableNameProperty: string): CriteriaBuilder<T>;
+
+        parent(): CriteriaBuilder<T>;
+
+        original(): CriteriaBuilder<T>;
+        
+        /**
+         * Auto kanei kuklous mexri na paei sto primary table kai ekei na epistrepsei to sunoliko raw criteria gia execute i kati allo.
+         */
+        build(): any;
+
+        static from<T>(table: Table<T>): CriteriaBuilder<T>
+
+    }
+
+    class SelectQuery<T> implements IQuery<T> { // T for Table's result type.
+       
+        _table: Table<T>
+        constructor(_table: Table<T>);
+
+        private parseQueryResult(result: any, criteria: ICriteriaParts): Promise<any>;
+
+        /**
+         * Executes the select and returns the Promise.
+         */
+        promise(rawCriteria: any, callback?: (_results: T[]) => any): Promise<T[]>;
+
+        /**
+         * Exactly the same thing as promise().
+         * Executes the select and returns the Promise.
+        */
+        execute(rawCriteria: any, callback?: (_results: T[]) => any): Promise<T[]>;
+    }
+
+    class SaveQuery<T> implements IQuery<T> {
+
+        _table: Table<T>
+        constructor(_table: Table<T>);
+
+        execute(criteriaRawJsObject: any, callback?: (_result: T | any) => any): Promise<T | any>;
+    }
+
+    class DeleteQuery<T> implements IQuery<T>{
+
+        _table: Table<T>
+        constructor(_table: Table<T>);
+
+        execute(criteriaOrID: any | number | string, callback?: (_result: DeleteAnswer) => any): Promise<DeleteAnswer>;
     }
 
 
-    class MysqlConnection extends EventEmitter {
+
+    class Connection extends EventEmitter {
+        
+        /**
+         * The real database connection socket.
+         */
         connection: Mysql.IConnection;
+        
+        /**
+         * Collection of the supported event types for the tables.
+         */
         eventTypes: string[];
+        
+        /**
+         * Force to fetch ONLY these Database table names {array of string}.  
+         */
         tableNamesToUseOnly: any[];
-        tables: MysqlTable<any>[];
+        
+        /**
+         * All tables {MysqlTable} inside this connection's database.
+         */
+        tables: Table<any>[];
+
         constructor(connection: string | Mysql.IConnection);
+        
+        /**
+         * Creates the MysqlConnection from the connection url or the real connection object.
+         * @param {string | Mysql.IConnection} connection the connection url or the real connection object.
+         * @returnType {nothing}
+         * @return {nothing}
+         */
         create(connection: string | Mysql.IConnection): void;
+        
+        /**
+         * Attach a real connection.
+         * @param {Mysql.IConnection} connection the real connection object.
+         * @returnType {nothing}
+         * @return {nothing} 
+         */
         attach(connection: Mysql.IConnection): void;
+        
+        /**
+         * Close the entire real connection and remove all event's listeners (if exist).
+         * @param {function} callback If error occurs when closing the connection, this callback has the responsibility to catch it.
+         * @returnType {nothing}
+         * @return {nothing} 
+         */
         end(callback?: (error: any) => void): void;
+        
+        /**
+         * Close the entire real connection and remove all event's listeners (if exist).
+         * the difference from the 'end' is that this method doesn't care about errors so no callback passing here. 
+         */
         destroy(): void;
+        
+        /**
+         * Link the real connection with this MysqlConnection object.
+         * @param {function} readyCallback when the link operation is done this callback is executed.
+         * @returnType {Promise}
+         * @return {Promise}
+         */
         link(readyCallback?: () => void): Promise<void>;
+        
+        /**
+         * Force to use/fetch information from only certain of database's tables, otherwise all database's tables information will be fetched.
+         * @param {Array} tables the array of the tables  {string}
+         * @returnType {nothing}
+         * @return {nothing}
+         */
         useOnly(...tables: any[]): void;
+        
+        /**
+         * This method has the resposibility of fetching the correct tables from the database ( table = columns' names, primary key name).
+         * @returnType {Promise}
+         * @return {Promise}
+         */
         fetchDatabaseInfornation(): Promise<void>;
+        
+        /**
+         * Escape the query column's value  and return it.
+         * @param {string} val the value which will be escaped. 
+         * @returnType {string}
+         * @return {string}
+         */
         escape(val: string): string;
+        
+        /**
+         * Call when must notify the Database events, SAVE(INSERT,UPDATE), REMOVE(DELETE).
+         * @param {string} tableWhichCalled the table name which event is coming from.
+         * @param {string} queryStr the full parsed query string which used to determinate the type of event to notify.
+         * @param {any[]} parsedResults the parsed results (results after a method parse/edit/export them as objects), these are passing to the watch listener(s).
+         * @returnType {nothing}
+         * @return {nothing}
+         */
         notice(tableWhichCalled: string, queryStr: string, parsedResults: any[]): void;
+        
+        /**
+         * Adds an event listener/watcher on a table for a 'database event'.
+         * @param {string} tableName the table name which you want to add the event listener.
+         * @param {string or string[]} evtType the event(s) type you want to watch, one of these(string) or an array of them(string[]): ["INSERT", "UPDATE", "REMOVE", "SAVE"].
+         * @param {function} callback Callback which has one parameter(typeof any[]) which filled by the parsedResults (results after query executed and exports to object(s)). 
+         * @returnType {nothing}
+         * @return {nothing}
+         */
         watch(tableName: string, evtType: any, callback: (parsedResults: any[]) => void): void;
+        
+        /**
+         * Removes an event listener/watcher from a table for a specific event type.
+         * @param {string} tableName the table name which you want to remove the event listener. 
+         * @param {string} evtType the Event type you want to remove, one of these: "INSERT", "UPDATE", "REMOVE", "SAVE".
+         * @param {function} callbackToRemove the callback that you were used for watch this event type.
+         * @returnType {nothing}
+         * @return {nothing}
+         */
         unwatch(tableName: string, evtType: string, callbackToRemove: (parsedResults: any[]) => void): void;
+        
+        /**
+         * Executes a database query.
+         * @param {string} queryStr the query text/string to be executed.
+         * @param {function} callback the function will be called and fill the one and only parameter when an errors occurs.
+         * @param {any[]} queryArguments (optional) the query arguments you want to pass into query. ['arg1','arg2']...
+         * @returnType {nothing}
+         * @return {nothing} 
+         */
         query(queryStr: string, callback: (err: Mysql.IError, results: any) => any, queryArguments?: any[]): void;
-        table<T>(tableName: string): MysqlTable<T>;
-    }
-	
-    class MysqlTable<T> {
-        private _name;
-        private _connection;
-        private _columns;
-        private _primaryKey;
-        private _criteriaBuilder;
-        constructor(tableName: string, connection: MysqlConnection);
-        columns: string[];
-        primaryKey: string;
-        connection: MysqlConnection;
-        name: string;
-        on(evtType: string, callback: (parsedResults: any[]) => void): void;
-        off(evtType: string, callbackToRemove: (parsedResults: any[]) => void): void;
-        has(extendedFunctionName: string): boolean;
-        extend(functionName: string, theFunction: (...args: any[]) => any): void;
-        objectFromRow(row: any): any;
-        rowFromObject(obj: any): any;
-        getRowAsArray(jsObject: any): Array<any>;
-        getPrimaryKeyValue(jsObject: any): number | string;
-        parseQueryResult(result: any, criteria: ICriteria): Promise<any>;
-        find(criteriaRawJsObject: any, callback?: (_results: T[]) => any): Promise<T[]>;
-        findById(id: number | string, callback?: (result: T) => any): Promise<T>;
-        findAll(callback?: (_results: T[]) => any): Promise<T[]>;
-        save(criteriaRawJsObject: any, callback?: (_result: any) => any): Promise<any>;
-        safeRemove(id: number | string, callback?: (_result: {
-            affectedRows: number;
-            table: string;
-        }) => any): Promise<{
-            affectedRows: number;
-            table: string;
-        }>;
-        remove(criteriaRawJsObject: any, callback?: (_result: {
-            affectedRows: number;
-            table: string;
-        }) => any): Promise<{
-            affectedRows: number;
-            table: string;
-        }>;
+        
+        /**
+         * Returns a MysqlTable object from the database factory. (Note: this method doesn't create anything, just finds and returns the correct table, you don't have to create anything at all. Tables are fetched by the library itself.)
+         * If you are using typescript you can pass a class (generic<T>) in order to use the auto completion assistance on table's results methods(find,findById,findAll,save,remove,safeRemove). 
+         * @param {string} tableName the table name which you want to get, on the form of: 'anyDatabaseTable' OR 'any_database_table' (possible your real table name into your database).
+         * @returnType {MysqlTable}
+         * @return {MysqlTable}
+         */
+        table<T>(tableName: string): Table<T>;
     }
 
-    class MysqlWrapper {
-        connection: MysqlConnection;
+    class Table<T> {
+        private _name: string;
+        private _connection: Connection;
+        private _columns: string[];
+        private _primaryKey: string;
+        private _criteriaDivider: CriteriaDivider<T>;
+        private _rules: SelectQueryRules;
+        private _selectQuery: SelectQuery<T>
+        private _saveQuery: SaveQuery<T>;
+        private _deleteQuery: DeleteQuery<T>;
+        constructor(tableName: string, connection: Connection);
+
+        /**
+         * An array of all columns' names inside this table.
+         */
+        columns: string[];
+        
+        /**
+         * The name of the primary key column which this table is using.
+         */
+        primaryKey: string;
+        
+        /**
+         * The MysqlConnection object which this MysqlTable belongs. 
+         */
+        connection: Connection;
+        
+        /**
+         * The real database name of the table. Autofilled by library. 
+         */
+        name: string;
+        
+        /**
+         * Set of the query rules that will be applied after the 'where clause' on each select query executed by this table. 
+         * @return {SelectQueryRules}
+         */
+        rules: SelectQueryRules;
+        
+        /**
+         * Returns this table's criteria divider class.
+         * @return {CriteriaDivider}
+         */
+        criteriaDivider: CriteriaDivider<T>;
+        
+        /**
+         * Returns new Criteria Builder each time.
+         * Helps you  to make criteria raw js objects ready to use in find,remove and save methods.
+         * @return {CriteriaBuilder}
+         */
+        criteria: CriteriaBuilder<T>;
+        
+        /**
+        * Adds or turn on an event listener/watcher on a table for a 'database event'.
+        * @param {string} evtType the event type you want to watch, one of these: ["INSERT", "UPDATE", "REMOVE", "SAVE"].
+        * @param {function} callback Callback which has one parameter(typeof any[]) which filled by the parsedResults (results after query executed and exports to object(s)). 
+        * @returnType {nothing}
+        * @return {nothing}
+        */
+        on(evtType: string, callback: (parsedResults: any[]) => void): void;
+            
+        /**
+         * Removes or turn off an event listener/watcher from a table for a specific event type.
+         * @param {string} evtType the Event type you want to remove, one of these: "INSERT", "UPDATE", "REMOVE", "SAVE".
+         * @param {function} callbackToRemove the callback that you were used for watch this event type.
+         * @returnType {nothing}
+         * @return {nothing}
+         */
+        off(evtType: string, callbackToRemove: (parsedResults: any[]) => void): void;
+        
+        /**
+         * Use it when you want to check if extended function is exists here.
+         * @param {string} extendedFunctionName the name of the function you want to check.
+         * @returnType {boolean}
+         * @return {boolean}
+         */
+        has(extendedFunctionName: string): boolean;
+        
+        /**
+         * Extends this table's capabilities with a function.
+         * @param {string} functionName the function name you want to use, this is used when you want to call this function later.
+         * @param {function} theFunction the function with any optional parameters you want to pass along.
+         * @returnType {nothing}
+         * @return {nothing} 
+         */
+        extend(functionName: string, theFunction: (...args: any[]) => any): void;
+        
+        /**
+         * Converts and returns an object from this form: { a_property:'dsda', other_property:something, any_property_name:true } to { aProperty:..., otherProperty...,anyPropertyName...}
+         * @param {any} row the raw row object.
+         * @returnType {any}
+         * @return {any}
+         */
+        objectFromRow(row: any): any;
+           
+        /**
+         * Converts and returns an object from this form: { aProperty:'dsda', otherProperty:something, anyPropertyName:true } to { a_property:..., other_property...,any_property_name...}
+         * @param {any} row the raw row object.
+         * @returnType {any}
+         * @return {any}
+         */
+        rowFromObject(obj: any): any;
+        
+        /**
+         * Returns and array of [columns[],values[]]
+         * @param {any} jsObject the raw row object.
+         * @returnType {array}
+         * @return {array}
+         */
+        getRowAsArray(jsObject: any): Array<any>;
+        
+        /**
+         * Returns the primary key's value from an object.
+         * @param {any} jsObject the object which you want to find and return the value of the primary key.
+         * @returnType {number | string}
+         * @return {number | string}
+         */
+        getPrimaryKeyValue(jsObject: any): number | string;
+        
+        /**
+         * 
+         */
+        find(criteriaRawJsObject: any): Promise<T[]>; // only criteria 
+        find(criteriaRawJsObject: any, callback: ((_results: T[]) => any)): Promise<T[]>; // criteria and callback
+        find(criteriaRawJsObject: any, callback?: (_results: T[]) => any): Promise<T[]>;
+
+        findSingle(criteriaRawJsObject: any, callback?: (_result: T) => any): Promise<T>;
+
+        findById(id: number|string): Promise<T>; // without callback
+        findById(id: number | string, callback?: (result: T) => any): Promise<T>;
+
+        findAll(): Promise<T[]>; // only criteria and promise
+        findAll(tableRules: RawRules): Promise<T[]> // only rules and promise
+        findAll(tableRules?: RawRules, callback?: (_results: T[]) => any): Promise<T[]>;
+
+
+        save(criteriaRawJsObject: any): Promise<any>; //without callback
+        save(criteriaRawJsObject: any, callback?: (_result: any) => any): Promise<any>;
+
+        remove(id: number | string): Promise<DeleteAnswer>; // ID without callback
+        remove(criteriaRawObject: any): Promise<DeleteAnswer>; // criteria obj without callback
+        remove(criteriaOrID: any | number | string, callback?: (_result: DeleteAnswer) => any): Promise<DeleteAnswer>;
+
+    }
+
+    class Wrapper {
+        connection: Connection;
         readyListenerCallbacks: Function[];
-        constructor(connection?: MysqlConnection);
+        constructor(connection?: Connection);
         static when(..._promises: Promise<any>[]): Promise<any>;
-        setConnection(connection: MysqlConnection): void;
+        setConnection(connection: Connection): void;
+            
+        /**
+         * Force to use/fetch information from only certain of database's tables, otherwise all database's tables information will be fetched.
+         * @param {Array} tables the array of the tables  {string}
+         * @returnType {nothing}
+         * @return {nothing}
+         */
         useOnly(...useTables: any[]): void;
+
         has(tableName: string, functionName?: string): boolean;
         ready(callback: () => void): void;
-        table<T>(tableName: string): MysqlTable<T>;
+        table<T>(tableName: string): Table<T>;
         noticeReady(): void;
         removeReadyListener(callback: () => void): void;
         query(queryStr: string, callback: (err: Mysql.IError, results: any) => any, queryArguments?: any[]): void;
+        
+        /**
+        * Close the entire real connection and remove all event's listeners (if exist).
+        * the difference from the 'end' is that this method doesn't care about errors so no callback passing here. 
+        */
         destroy(): void;
+        
+        /**
+       * Close the entire real connection and remove all event's listeners (if exist).
+       * @param {function} maybeAcallbackError If error occurs when closing the connection, this callback has the responsibility to catch it.
+       * @returnType {nothing}
+       * @return {nothing} 
+       */
         end(maybeAcallbackError: (err: any) => void): void;
+
+        newTableRules(tableName: string): SelectQueryRules;
+
+        buildRules(): SelectQueryRules;
+        buildRules(parentRules?: SelectQueryRules): SelectQueryRules;
     }
 
-    function wrap(mysqlUrlOrObjectOrMysqlAlreadyConnection: Mysql.IConnection | string, ...useTables: any[]): MysqlWrapper;
-
+    function wrap(mysqlUrlOrObjectOrMysqlAlreadyConnection: Mysql.IConnection | string, ...useTables: any[]): Wrapper;
 }
diff --git a/node-polyglot/node-polyglot-tests.ts b/node-polyglot/node-polyglot-tests.ts
index fee07d79e9..249be95778 100644
--- a/node-polyglot/node-polyglot-tests.ts
+++ b/node-polyglot/node-polyglot-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./node-polyglot.d.ts" />
+
 import Polyglot = require("node-polyglot");
 
 function instantiatePolyglot(): void {
diff --git a/node/node-tests.ts b/node/node-tests.ts
index 19f686ef54..a73a35e223 100644
--- a/node/node-tests.ts
+++ b/node/node-tests.ts
@@ -34,6 +34,8 @@ assert.doesNotThrow(() => {
 fs.writeFile("thebible.txt",
     "Do unto others as you would have them do unto you.",
     assert.ifError);
+    
+fs.write(1234, "test");
 
 fs.writeFile("Harry Potter",
     "\"You be wizzing, Harry,\" jived Dumbledore.",
diff --git a/node/node.d.ts b/node/node.d.ts
index b7edca1f70..c9cd444fd1 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -1062,6 +1062,7 @@ declare module "fs" {
         atime: Date;
         mtime: Date;
         ctime: Date;
+        birthtime: Date;
     }
 
     interface FSWatcher extends events.EventEmitter {
@@ -1214,6 +1215,9 @@ declare module "fs" {
     export function fsyncSync(fd: number): void;
     export function write(fd: number, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: NodeJS.ErrnoException, written: number, buffer: Buffer) => void): void;
     export function write(fd: number, buffer: Buffer, offset: number, length: number, callback?: (err: NodeJS.ErrnoException, written: number, buffer: Buffer) => void): void;
+    export function write(fd: number, data: any, callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void): void;
+    export function write(fd: number, data: any, offset: number, callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void): void;
+    export function write(fd: number, data: any, offset: number, encoding: string, callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void): void;
     export function writeSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number;
     export function read(fd: number, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: NodeJS.ErrnoException, bytesRead: number, buffer: Buffer) => void): void;
     export function readSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number;
@@ -1671,14 +1675,13 @@ declare module "stream" {
         readable: boolean;
         constructor(opts?: ReadableOptions);
         _read(size: number): void;
-        read(size?: number): string|Buffer;
+        read(size?: number): any;
         setEncoding(encoding: string): void;
         pause(): void;
         resume(): void;
         pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
         unpipe<T extends NodeJS.WritableStream>(destination?: T): void;
-        unshift(chunk: string): void;
-        unshift(chunk: Buffer): void;
+        unshift(chunk: any): void;
         wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream;
         push(chunk: any, encoding?: string): boolean;
     }
@@ -1691,15 +1694,12 @@ declare module "stream" {
     export class Writable extends events.EventEmitter implements NodeJS.WritableStream {
         writable: boolean;
         constructor(opts?: WritableOptions);
-        _write(data: Buffer, encoding: string, callback: Function): void;
-        _write(data: string, encoding: string, callback: Function): void;
-        write(buffer: Buffer, cb?: Function): boolean;
-        write(str: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, cb?: Function): boolean;
+        _write(chunk: any, encoding: string, callback: Function): void;
+        write(chunk: any, cb?: Function): boolean;
+        write(chunk: any, encoding?: string, cb?: Function): boolean;
         end(): void;
-        end(buffer: Buffer, cb?: Function): void;
-        end(str: string, cb?: Function): void;
-        end(str: string, encoding?: string, cb?: Function): void;
+        end(chunk: any, cb?: Function): void;
+        end(chunk: any, encoding?: string, cb?: Function): void;
     }
 
     export interface DuplexOptions extends ReadableOptions, WritableOptions {
@@ -1710,15 +1710,12 @@ declare module "stream" {
     export class Duplex extends Readable implements NodeJS.ReadWriteStream {
         writable: boolean;
         constructor(opts?: DuplexOptions);
-        _write(data: Buffer, encoding: string, callback: Function): void;
-        _write(data: string, encoding: string, callback: Function): void;
-        write(buffer: Buffer, cb?: Function): boolean;
-        write(str: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, cb?: Function): boolean;
+        _write(chunk: any, encoding: string, callback: Function): void;
+        write(chunk: any, cb?: Function): boolean;
+        write(chunk: any, encoding?: string, cb?: Function): boolean;
         end(): void;
-        end(buffer: Buffer, cb?: Function): void;
-        end(str: string, cb?: Function): void;
-        end(str: string, encoding?: string, cb?: Function): void;
+        end(chunk: any, cb?: Function): void;
+        end(chunk: any, encoding?: string, cb?: Function): void;
     }
 
     export interface TransformOptions extends ReadableOptions, WritableOptions {}
@@ -1728,8 +1725,7 @@ declare module "stream" {
         readable: boolean;
         writable: boolean;
         constructor(opts?: TransformOptions);
-        _transform(chunk: Buffer, encoding: string, callback: Function): void;
-        _transform(chunk: string, encoding: string, callback: Function): void;
+        _transform(chunk: any, encoding: string, callback: Function): void;
         _flush(callback: Function): void;
         read(size?: number): any;
         setEncoding(encoding: string): void;
@@ -1737,17 +1733,14 @@ declare module "stream" {
         resume(): void;
         pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
         unpipe<T extends NodeJS.WritableStream>(destination?: T): void;
-        unshift(chunk: string): void;
-        unshift(chunk: Buffer): void;
+        unshift(chunk: any): void;
         wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream;
         push(chunk: any, encoding?: string): boolean;
-        write(buffer: Buffer, cb?: Function): boolean;
-        write(str: string, cb?: Function): boolean;
-        write(str: string, encoding?: string, cb?: Function): boolean;
+        write(chunk: any, cb?: Function): boolean;
+        write(chunk: any, encoding?: string, cb?: Function): boolean;
         end(): void;
-        end(buffer: Buffer, cb?: Function): void;
-        end(str: string, cb?: Function): void;
-        end(str: string, encoding?: string, cb?: Function): void;
+        end(chunk: any, cb?: Function): void;
+        end(chunk: any, encoding?: string, cb?: Function): void;
     }
 
     export class PassThrough extends Transform {}
diff --git a/npm-shrinkwrap.json b/npm-shrinkwrap.json
index d332a49ef8..711587001e 100644
--- a/npm-shrinkwrap.json
+++ b/npm-shrinkwrap.json
@@ -8,9 +8,9 @@
       "resolved": "https://registry.npmjs.org/definition-tester/-/definition-tester-0.2.0.tgz",
       "dependencies": {
         "bluebird": {
-          "version": "2.9.34",
+          "version": "2.10.0",
           "from": "bluebird@>=2.5.3 <3.0.0",
-          "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-2.9.34.tgz"
+          "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-2.10.0.tgz"
         },
         "definition-header": {
           "version": "0.1.0",
@@ -23,24 +23,24 @@
               "resolved": "https://registry.npmjs.org/joi/-/joi-4.9.0.tgz",
               "dependencies": {
                 "hoek": {
-                  "version": "2.14.0",
+                  "version": "2.16.2",
                   "from": "hoek@>=2.2.0 <3.0.0",
-                  "resolved": "https://registry.npmjs.org/hoek/-/hoek-2.14.0.tgz"
+                  "resolved": "https://registry.npmjs.org/hoek/-/hoek-2.16.2.tgz"
                 },
                 "topo": {
-                  "version": "1.0.2",
+                  "version": "1.0.3",
                   "from": "topo@>=1.0.0 <2.0.0",
-                  "resolved": "https://registry.npmjs.org/topo/-/topo-1.0.2.tgz"
+                  "resolved": "https://registry.npmjs.org/topo/-/topo-1.0.3.tgz"
                 },
                 "isemail": {
-                  "version": "1.1.1",
+                  "version": "1.2.0",
                   "from": "isemail@>=1.0.0 <2.0.0",
-                  "resolved": "https://registry.npmjs.org/isemail/-/isemail-1.1.1.tgz"
+                  "resolved": "https://registry.npmjs.org/isemail/-/isemail-1.2.0.tgz"
                 },
                 "moment": {
-                  "version": "2.10.3",
+                  "version": "2.10.6",
                   "from": "moment@>=2.0.0 <3.0.0",
-                  "resolved": "https://registry.npmjs.org/moment/-/moment-2.10.3.tgz"
+                  "resolved": "https://registry.npmjs.org/moment/-/moment-2.10.6.tgz"
                 }
               }
             },
@@ -103,9 +103,9 @@
                   "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
                 },
                 "minimatch": {
-                  "version": "2.0.9",
+                  "version": "2.0.10",
                   "from": "minimatch@>=2.0.1 <3.0.0",
-                  "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-2.0.9.tgz",
+                  "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-2.0.10.tgz",
                   "dependencies": {
                     "brace-expansion": {
                       "version": "1.1.0",
@@ -170,9 +170,9 @@
               "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
             },
             "minimatch": {
-              "version": "2.0.9",
+              "version": "2.0.10",
               "from": "minimatch@>=2.0.1 <3.0.0",
-              "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-2.0.9.tgz",
+              "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-2.0.10.tgz",
               "dependencies": {
                 "brace-expansion": {
                   "version": "1.1.0",
@@ -208,9 +208,9 @@
           }
         },
         "lazy.js": {
-          "version": "0.4.0",
+          "version": "0.4.2",
           "from": "lazy.js@>=0.4.0 <0.5.0",
-          "resolved": "https://registry.npmjs.org/lazy.js/-/lazy.js-0.4.0.tgz"
+          "resolved": "https://registry.npmjs.org/lazy.js/-/lazy.js-0.4.2.tgz"
         },
         "manticore": {
           "version": "0.2.4",
@@ -305,9 +305,9 @@
       }
     },
     "typescript": {
-      "version": "1.5.3",
-      "from": "typescript@1.5.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-1.5.3.tgz"
+      "version": "1.6.2",
+      "from": "typescript@1.6.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-1.6.2.tgz"
     }
   }
 }
diff --git a/object-assign/object-assign-tests.ts b/object-assign/object-assign-tests.ts
new file mode 100644
index 0000000000..53dfd5e707
--- /dev/null
+++ b/object-assign/object-assign-tests.ts
@@ -0,0 +1,17 @@
+/// <reference path="object-assign.d.ts" />
+import objectAssign = require("object-assign");
+
+function assign1() {
+  var result = objectAssign({hello: "world"});
+  return result;
+}
+
+function assign2() {
+  var result = objectAssign({hello: "world"}, {hello: "worlds", second: "extra"});
+  return result;
+}
+
+function assign3() {
+  var result = objectAssign({hello: "world"}, {hello: "worlds", second: "extra"}, {hello: "stop", the: "spinning"});
+  return result;
+}
diff --git a/object-assign/object-assign.d.ts b/object-assign/object-assign.d.ts
new file mode 100644
index 0000000000..76789d0038
--- /dev/null
+++ b/object-assign/object-assign.d.ts
@@ -0,0 +1,9 @@
+// Type definitions for object-assign 4.0.1
+// Project: https://github.com/sindresorhus/object-assign
+// Definitions by: Christopher Brown <https://github.com/chbrown>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "object-assign" {
+  function objectAssign(target: any, ...sources: any[]): any;
+  export = objectAssign;
+}
diff --git a/oboe/oboe-tests.ts b/oboe/oboe-tests.ts
index f98def75e7..48939d4180 100644
--- a/oboe/oboe-tests.ts
+++ b/oboe/oboe-tests.ts
@@ -32,3 +32,18 @@ oboe('/content')
 			console.error('no such content');
 		}
 	});
+
+oboe('friends.json')
+	.node('friend', function (parsedJson) {
+		console.log('friend parsed', parsedJson);
+	});
+
+oboe('friends.json')
+	.node({
+		'friend': function (parsedJson) {
+			console.log('friend parsed', parsedJson);
+		},
+		'!': function (parsedJson) {
+			console.log('root parsed', parsedJson);
+		}
+	});
diff --git a/oboe/oboe.d.ts b/oboe/oboe.d.ts
index 6e6ed650bf..1f036ce8b1 100644
--- a/oboe/oboe.d.ts
+++ b/oboe/oboe.d.ts
@@ -5,61 +5,65 @@
 
 /// <reference path="../node/node.d.ts" />
 
-declare module "oboe" {
-	import stream = require('stream');
-
-	function oboe(url: string): oboe.Oboe;
-	function oboe(options: oboe.Options): oboe.Oboe;
-	function oboe(stream: stream.Readable) : oboe.Oboe;
-
-	module oboe {
-
-		var drop: {};
-
-		interface Oboe {
-			done(callback: (result: any) => void): Oboe;
-
-			fail(callback: (result: FailReason) => void): Oboe;
-
-			node(pattern: string, callback: CallbackSignature): Oboe;
-
-			on(event: string, pattern: string, callback: CallbackSignature): Oboe;
-			on(eventPattern: string, callback: CallbackSignature): Oboe;
-
-			path(pattern: string, callback: CallbackSignature): Oboe;
-			path(listeners: any): Oboe;
-
-			removeListener(eventPattern: string, callback: CallbackSignature): Oboe;
-			removeListener(event: string, pattern: string, callback: CallbackSignature): Oboe;
-
-			start(callback: (status: number, headers: Object) => void): Oboe;
-			
-			abort():void;
-
-			source: string;
-		}
-
-		interface CallbackSignature {
-            (node: any, pathOrHeaders: any, ancestors: Object[]): any;
-		}
-
-		interface Options {
-			url: string;
-			method?: string;
-			headers?: Object;
-			body?: any;
-			cached?: boolean;
-			withCredentials?: boolean;
-		}
-
-		interface FailReason {
-			thrown?: Error;
-			statusCode?: number;
-			body?: string;
-			jsonBody?: Object;
-		}
+declare module oboe {
+	interface OboeFunction extends Function {
+		drop: Object;
+		(url: string): Oboe;
+		(options: Options): Oboe;
+		(stream: NodeJS.ReadableStream): Oboe;
 	}
 
-	export = oboe;
+	interface Oboe {
+		done(callback: (result: any) => void): Oboe;
+
+		fail(callback: (result: FailReason) => void): Oboe;
+
+		node(pattern: string, callback: CallbackSignature): Oboe;
+		node(patterns: PatternMap): Oboe;
+
+		on(event: string, pattern: string, callback: CallbackSignature): Oboe;
+		on(eventPattern: string, callback: CallbackSignature): Oboe;
+
+		path(pattern: string, callback: CallbackSignature): Oboe;
+		path(listeners: any): Oboe;
+
+		removeListener(eventPattern: string, callback: CallbackSignature): Oboe;
+		removeListener(event: string, pattern: string, callback: CallbackSignature): Oboe;
+
+		start(callback: (status: number, headers: Object) => void): Oboe;
+
+		abort():void;
+
+		source: string;
+	}
+
+	interface CallbackSignature {
+          (node: any, pathOrHeaders: any, ancestors: Object[]): any;
+	}
+
+	interface Options {
+		url: string;
+		method?: string;
+		headers?: Object;
+		body?: any;
+		cached?: boolean;
+		withCredentials?: boolean;
+	}
+
+	interface FailReason {
+		thrown?: Error;
+		statusCode?: number;
+		body?: string;
+		jsonBody?: Object;
+	}
+
+	interface PatternMap {
+	  [pattern: string]: CallbackSignature
+	}
 }
 
+declare var oboe: oboe.OboeFunction;
+
+declare module "oboe" {
+	export = oboe;
+}
diff --git a/observe-js/observe-js-test.ts b/observe-js/observe-js-test.ts
new file mode 100644
index 0000000000..37ad0216c5
--- /dev/null
+++ b/observe-js/observe-js-test.ts
@@ -0,0 +1,111 @@
+/// <reference path="observe-js.d.ts" />
+
+module observejs {
+	
+	function Test_PathObserver() {
+		var obj = { foo: { bar: 'baz' } };
+		var defaultValue = 42;
+		var observer = new PathObserver(obj, 'foo.bar', defaultValue);
+		observer.open(function(newValue, oldValue) {
+		// respond to obj.foo.bar having changed value.
+		});
+	}
+	
+	
+	function Test_ArrayObserver() {
+		var arr = [0, 1, 2, 4];
+		var observer = new ArrayObserver(arr);
+		observer.open(function(splices) {
+		// respond to changes to the elements of arr.
+		splices.forEach(function(splice) {
+			splice.index; // the index position that the change occurred.
+			splice.removed; // an array of values representing the sequence of removed elements
+			splice.addedCount; // the number of elements which were inserted.
+		});
+		});
+	}
+	
+	function Test_ObejctObserver() {
+		var myObj = { id: 1, foo: 'bar' };
+		var observer = new ObjectObserver(myObj);
+		observer.open(function(added, removed, changed, getOldValueFn) {
+		// respond to changes to the obj.
+		Object.keys(added).forEach(function(property) {
+			property; // a property which has been been added to obj
+			added[property]; // its value
+		});
+		Object.keys(removed).forEach(function(property) {
+			property; // a property which has been been removed from obj
+			getOldValueFn(property); // its old value
+		});
+		Object.keys(changed).forEach(function(property) {
+			property; // a property on obj which has changed value.
+			changed[property]; // its value
+			getOldValueFn(property); // its old value
+		});
+		});
+	}
+	
+	function Test_CompounObserver() {
+		var obj = {
+			a: 1,
+			b: 2,
+		};
+		
+		var otherObj = { c: 3 };
+		
+		var observer = new CompoundObserver();
+		observer.addPath(obj, 'a');
+		observer.addObserver(new PathObserver(obj, 'b'));
+		observer.addPath(otherObj, 'c');
+		var logTemplate = 'The %sth value before & after:';
+		observer.open(function(newValues, oldValues) {
+		// Use for-in to iterate which values have changed.
+		for (var i in oldValues) {
+			console.log(logTemplate, i, oldValues[i], newValues[i]);
+		}
+		});
+	}
+	
+	function Test_ObserverTransform_1() {
+		var obj = { value: 10 };
+		var observer = new PathObserver(obj, 'value');
+		function getValue(value:any) { return value * 2 };
+		function setValue(value:any) { return value / 2 };
+		
+		var transform = new ObserverTransform(observer, getValue, setValue);
+		
+		// returns 20.
+		transform.open(function(newValue, oldValue) {
+		console.log('new: ' + newValue + ', old: ' + oldValue);
+		});
+		
+		obj.value = 20;
+		transform.deliver(); // 'new: 40, old: 20'
+		transform.setValue(4); // obj.value === 2;
+	}
+	
+	function Test_ObserverTransform_2() {
+		var obj = { a: 1, b: 2, c: 3 };
+		var observer = new CompoundObserver();
+		observer.addPath(obj, 'a');
+		observer.addPath(obj, 'b');
+		observer.addPath(obj, 'c');
+		var transform = new ObserverTransform(observer, function(values) {
+		var value = 0;
+		for (var i = 0; i < values.length; i++)
+			value += values[i]
+		return value;
+		});
+		
+		// returns 6.
+		transform.open(function(newValue, oldValue) {
+		console.log('new: ' + newValue + ', old: ' + oldValue);
+		});
+		
+		obj.a = 2;
+		obj.c = 10;
+		transform.deliver(); // 'new: 14, old: 6'
+	}
+
+}
\ No newline at end of file
diff --git a/observe-js/observe-js.d.ts b/observe-js/observe-js.d.ts
new file mode 100644
index 0000000000..abd2caa008
--- /dev/null
+++ b/observe-js/observe-js.d.ts
@@ -0,0 +1,250 @@
+// Type definitions for observe-js v0.5.5
+// Project: https://github.com/Polymer/observe-js
+// Definitions by: Oliver Herrmann <https://github.com/herrmanno/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module observejs {
+	
+	/*----------------------
+		Observable
+	----------------------*/
+		
+	interface Observable {
+		/**
+		 * Begins observation.
+		 * @param onChange the function that gets invoked if a change is detected
+		 * @param the target of observation
+		 */
+		open(onChange:(newValue:any, oldValue:any)=>any, receiver?:any):void
+
+		/**
+		 * Report any changes now (does nothing if there are no changes to report).
+		 */
+		deliver(): void
+		
+		/**
+		 * If there are changes to report, ignore them. Returns the current value of the observation.
+		 */
+		discardChanges():void
+		
+		/**
+		 * Ends observation. Frees resources and drops references to observed objects.
+		 */
+		close():void
+	}
+	
+	
+	/*----------------------
+		PathObserver
+	----------------------*/
+	
+	interface PathObserver_static {
+		/**
+		 * Constructor
+		 * @param receiver the target for observation
+		 * @param path specifies the paht to observe. If path === '' the receiver itself gets observed.
+		 * @param defaultValue the defaultValue
+		 */
+		new(receiver:any, path:string, defaultValue?:any): PathObserver_instance
+	}
+	
+	interface PathObserver_instance extends Observable {
+		/**
+		 * sets the observed value without notifying about the change.
+		 * @param value the value to set
+		 */
+		setValue(value:any): void
+	}
+	
+	/**
+	 * Observes a "value-at-a-path" from a given object: 
+	 */
+	var PathObserver: PathObserver_static
+	
+	
+	/*----------------------
+		ArrayObserver
+	----------------------*/
+	
+	interface splice {
+		
+		/**
+		 * the index position that the change occured
+		 */
+		index:number
+		
+		/**
+		 * an array of values representing the sequence of removed elements
+		 */
+		removed: Array<any>
+		
+		/**
+		 * the number of element which were inserted 
+		 */
+		addedCount:number
+	}
+	
+	interface ArrayObserver_static {
+		
+		/**
+		 * Constructor
+		 * @param receiver the target for observation
+		 */
+		new(receiver:Array<any>): ArrayObserver_instance
+		
+		/**
+		 * transforms a copy of an old state of an array into a copy of its current state.
+		 * @param previous array of old state
+		 * @param current array of current state
+		 * @param splices  splices to apply
+		 */
+		applySplices(previous:Array<any>, current:Array<any>, splices:Array<splice>):void
+	}
+	
+	interface ArrayObserver_instance extends Observable {
+		open(onChange:(splices:Array<splice>)=>any):void
+	}
+	
+	/**
+	 * ArrayObserver observes the index-positions of an Array and reports changes as the minimal set of "splices" which would have had the same effect.
+	 */
+	var ArrayObserver: ArrayObserver_static
+	
+	
+	/*----------------------
+		ObjectObserver
+	----------------------*/
+	
+	interface Properties {
+		[key:string]:any
+	}
+	
+	interface ObjectObserver_static {
+		
+		/**
+		 * Constructor
+		 * @param receiver the target for observation
+		 */
+		new(receiver:any): ObjectObserver_instance
+	}
+	
+	interface ObjectObserver_instance extends Observable {
+		open(onChange:(added:Properties, removed:Properties, changed:Properties, getOldValueFn:(property:string)=>any)=>any):void
+	}
+	
+	/**
+	 * Observes the set of own-properties of an object and their values
+	 */
+	var ObjectObserver: ObjectObserver_static
+	
+	
+	/*----------------------
+		CompounObserver
+	----------------------*/
+	
+	interface CompoundObserver_static {
+		
+		/**
+		 * Constructor
+		 */
+		new(): CompoundObserver_instance
+	}
+	
+	interface CompoundObserver_instance extends Observable {
+		open(onChange:(newValues:Array<any>, oldValue:Array<any>)=>any):void
+		
+		/**
+		 * Adds the receivers property at the specified path to the list of observables.
+		 * @param receiver the target for observation
+		 * @param path specifies the paht to observe. If path === '' the receiver itself gets observed.
+		 */
+		addPath(receiver:any, path:string):void
+		
+		/**
+		 * Adds an Observer to the list of observables.
+		 */
+		addObserver(observer:Observable):void
+	
+	}
+	
+	/**
+	 * CompoundObserver allows simultaneous observation of multiple paths and/or Observables.
+	 */
+	var CompoundObserver: CompoundObserver_static
+	
+	
+	
+	/*----------------------
+		ObserverTransform
+	----------------------*/
+	
+	interface ObserverTransform_static {
+		
+		/**
+		 * Constructor
+		 * @param observer the observer to transform
+		 * @param getValue function that proxys getting a value
+		 * @param setValue function that proxys setting a value
+		 */
+		new(observer:Observable, getValue:(value:any)=>any, setValue:(value:any)=>any): ObserverTransform_instance
+		
+		/**
+		 * Constructor
+		 * @param observer the observer to transform
+		 * @param valueFn function that gets invoked with all observed values. May return a single new value.
+		 */
+		new(observer:Observable, valueFn:(values:Array<any>)=>any): ObserverTransform_instance
+	}
+	
+	interface ObserverTransform_instance extends Observable {
+		/**
+		 * sets the observed value without notifying about the change.
+		 * @param value the value to set
+		 */
+		setValue(value:any): void
+	}
+	
+	/**
+	 * CompoundObserver allows simultaneous observation of multiple paths and/or Observables.
+	 */
+	var ObserverTransform: ObserverTransform_static
+	
+	
+	/*----------------------
+		Path
+	----------------------*/
+	
+	interface Path {
+		
+		/**
+		 * Returns the current value of the path from the provided object. If eval() is available,
+  		 * a compiled getter will be used for better performance. Like PathObserver above, undefined
+  		 * is returned unless you provide an overriding defaultValue.
+		 */
+		getValueFrom(object:any, defaultValue:any): any
+		
+		/**
+		 * Attempts to set the value of the path from the provided object. Returns true IFF the path
+  		 * was reachable and set.
+		 */
+		getValueFrom(object:any, newValue:any): any
+	}
+}
+
+declare module "observejs" {
+	var PathObserver: typeof observejs.PathObserver;
+	var ArrayObserver: typeof observejs.ArrayObserver;
+	var ObjectObserver: typeof observejs.ObjectObserver;
+	var CompoundObserver: typeof observejs.CompoundObserver;
+	var ObserverTransform: typeof observejs.ObserverTransform;
+	var Path: observejs.Path;
+	
+	export {
+		PathObserver,
+		ArrayObserver,
+		ObjectObserver,
+		CompoundObserver,
+		ObserverTransform,
+		Path
+	};
+}
\ No newline at end of file
diff --git a/openlayers/openlayers-tests.ts b/openlayers/openlayers-tests.ts
index 3effa928aa..0092737467 100644
--- a/openlayers/openlayers-tests.ts
+++ b/openlayers/openlayers-tests.ts
@@ -34,6 +34,7 @@ var geometry: ol.geom.Geometry;
 var loadingstrategy: ol.LoadingStrategy;
 var tilegrid: ol.tilegrid.TileGrid;
 var vector: ol.source.Vector;
+var projection: ol.proj.Projection;
 
 //
 // ol.Attribution
@@ -161,7 +162,9 @@ var tileLayer: ol.layer.Tile = new ol.layer.Tile({
 //
 // ol.proj
 //
-var projection: ol.proj.Projection;
+projection = new ol.proj.Projection({
+    code:stringValue,    
+});
 
 //
 // ol.Map 
@@ -174,6 +177,21 @@ var map: ol.Map = new ol.Map({
 });
 map.beforeRender(preRenderFunction);
 
+//
+// ol.source.ImageWMS
+//
+var imageWMS: ol.source.ImageWMS = new ol.source.ImageWMS({
+    serverType: stringValue,
+    url:stringValue
+});
+//
+// ol.source.TileWMS
+//
+var tileWMS: ol.source.TileWMS = new ol.source.TileWMS({
+    serverType: stringValue,
+    url:stringValue
+});
+
 //
 // ol.animation
 //
diff --git a/openlayers/openlayers.d.ts b/openlayers/openlayers.d.ts
index 9974ef9ebd..5aba19b54c 100644
--- a/openlayers/openlayers.d.ts
+++ b/openlayers/openlayers.d.ts
@@ -22,23 +22,23 @@ declare module olx {
     interface FrameState {
 
         /**
-         * 
+         *
          */
         pixelRatio: number;
 
         /**
-         * 
+         *
          */
         time: number;
 
         /**
-         * 
+         *
          */
         viewState: olx.ViewState;
     }
 
     interface FeatureOverlayOptions {
-        
+
         /**
          * Features
          */
@@ -88,6 +88,71 @@ declare module olx {
         targetSize?: number;
     }
 
+    interface BaseWMSOptions {
+
+        /** Attributions. */
+        attributions?: Array<ol.Attribution>;
+
+        /** WMS request parameters. At least a LAYERS param is required. STYLES is '' by default. VERSION is 1.3.0 by default. WIDTH, HEIGHT, BBOX and CRS (SRS for WMS version < 1.3.0) will be set dynamically. */
+        params?: any;
+
+        /** The crossOrigin attribute for loaded images. Note that you must provide a crossOrigin value if you are using the WebGL renderer or if you want to access pixel data with the Canvas renderer. See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail. */
+        crossOrigin?: string;
+
+        /** experimental Use the ol.Map#pixelRatio value when requesting the image from the remote server. Default is true. */
+        hidpi?: boolean;
+
+        /** experimental The type of the remote WMS server: mapserver, geoserver or qgis. Only needed if hidpi is true. Default is undefined. */
+        serverType?: ol.source.wms.ServerType;
+
+        /** WMS service URL. */
+        url?: string;
+
+        /** Logo. */
+        logo?: olx.LogoOptions;
+
+        /** experimental Projection. */
+        projection?: ol.proj.ProjectionLike;
+    }
+
+    interface ImageWMSOptions extends BaseWMSOptions {
+
+        /** experimental Optional function to load an image given a URL. */
+        imageLoadFunction?: ol.ImageLoadFunctionType;
+
+        /** Ratio. 1 means image requests are the size of the map viewport, 2 means twice the width and height of the map viewport, and so on. Must be 1 or higher. Default is 1.5. */
+        ratio?: number;
+
+        /** Resolutions. If specified, requests will be made for these resolutions only. */
+        resolutions?: Array<number>;
+    }
+
+    interface TileWMSOptions {
+
+        /** The size in pixels of the gutter around image tiles to ignore. By setting this property to a non-zero value, images will be requested that are wider and taller than the tile size by a value of 2 x gutter. Defaults to zero. Using a non-zero value allows artifacts of rendering at tile edges to be ignored. If you control the WMS service it is recommended to address "artifacts at tile edges" issues by properly configuring the WMS service. For example, MapServer has a tile_map_edge_buffer configuration parameter for this. See http://mapserver.org/output/tile_mode.html. */
+        gutter?: number;
+
+        /** Tile grid. Base this on the resolutions, tilesize and extent supported by the server. If this is not defined, a default grid will be used: if there is a projection extent, the grid will be based on that; if not, a grid based on a global extent with origin at 0,0 will be used. */
+        tileGrid?: ol.tilegrid.TileGrid;
+
+        /** experimental Maximum zoom. */
+        maxZoom?: number;
+
+        /** experimental Optional function to load a tile given a URL. */
+        tileLoadFunction?: ol.TileLoadFunctionType;
+
+        /** WMS service URL. */
+        url?: string;
+
+        /** WMS service urls. Use this instead of url when the WMS supports multiple urls for GetMap requests. */
+        urls?: Array<string>;
+
+        /** experimental The type of the remote WMS server. Currently only used when hidpi is true. Default is undefined. */
+        serverType?: ol.source.wms.ServerType;
+
+        /** experimental Whether to wrap the world horizontally. When set to false, only one world will be rendered. When true, tiles will be requested for one world only, but they will be wrapped horizontally to render multiple worlds. The default is true. */
+        wrapX?: boolean;
+    }
     /**
      * Object literal with config options for the map logo.
      */
@@ -101,6 +166,7 @@ declare module olx {
        * Image src for the logo
        */
       src: string;
+
     }
 
     interface MapOptions {
@@ -238,30 +304,69 @@ declare module olx {
     interface ViewState {
 
         /**
-         * 
+         *
          */
         center: ol.Coordinate;
 
         /**
-         * 
+         *
          */
         projection: ol.proj.Projection;
 
         /**
-         * 
+         *
          */
         resolution: number;
 
         /**
-         * 
+         *
          */
         rotation: number;
     }
 
+    interface Projection {
+        /**
+         * The SRS identifier code, e.g. EPSG:4326.
+         */
+        code: string;
+
+        /**
+        * Units. Required unless a proj4 projection is defined for code.
+        */
+        units?: ol.proj.Units;
+
+        /**
+        * The validity extent for the SRS.
+        */
+        extent?: Array<number>;
+
+        /**
+        * The axis orientation as specified in Proj4. The default is enu.
+        */
+        axisOrientation?: string;
+
+        /**
+        * Whether the projection is valid for the whole globe. Default is false.
+        */
+        global?: boolean;
+
+        /**
+        * experimental The world extent for the SRS.
+        */
+        worldExtent?: ol.Extent;
+
+        /**
+        *  experimental Function to determine resolution at a point. The function is called with
+        *  a {number} view resolution and an {ol.Coordinate} as arguments, and returns the {number}
+        *  resolution at the passed coordinate.
+        */
+        getPointResolution?: (resolution: number, coordinate: ol.Coordinate) => number;
+    }
+
     module animation {
 
         interface BounceOptions {
-            
+
             /**
              * The resolution to start the bounce from, typically map.getView().getResolution().
              */
@@ -284,7 +389,7 @@ declare module olx {
         }
 
         interface PanOptions {
-            
+
             /**
              * The resolution to start the bounce from, typically map.getView().getResolution().
              */
@@ -307,7 +412,7 @@ declare module olx {
         }
 
         interface RotateOptions {
-            
+
             /**
              * The rotation value (in radians) to begin rotating from, typically map.getView().getRotation(). If undefined then 0 is assumed.
              */
@@ -335,7 +440,7 @@ declare module olx {
         }
 
         interface ZoomOptions {
-            
+
             /**
              * The resolution to begin zooming from, typically map.getView().getResolution().
              */
@@ -383,14 +488,14 @@ declare module olx {
              */
             //TODO: Replace with olx.control.RotateOptions
             rotateOptions?: any;
-            
+
             /**
              * Zoom. Default is true
              */
             zoom?: boolean;
 
             /**
-             * 
+             *
              */
             //TODO: Replace with olx.control.ZoomOptions
             zoomOptions?: any;
@@ -729,7 +834,7 @@ declare module olx {
              * Tile sizes. The length of this array needs to match the length of the resolutions array.
              */
             tileSizes?: Array<number | ol.Size>;
-            
+
             /**
              * Number of tile columns that cover the grid's extent for each zoom level. Only required when used with a source that has wrapX set to true, and only when the grid's origin differs from the one of the projection's extent. The array length has to match the length of the resolutions array, i.e. each resolution will have a matching entry here.
              */
@@ -852,6 +957,10 @@ declare module olx {
  */
 declare module ol {
 
+    interface TileLoadFunctionType{ (image: ol.Image, url: string): void }
+
+    interface ImageLoadFunctionType{ (image: ol.Image, url: string): void }
+
     /**
      * An attribution for a layer source.
      */
@@ -862,13 +971,13 @@ declare module ol {
          */
         constructor(options: olx.AttributionOptions);
 
-        /** 
-         * Get the attribution markup. 
+        /**
+         * Get the attribution markup.
          * @returns The attribution HTML.
          */
         getHTML(): string;
     }
-    
+
     /**
      * An expanded version of standard JS Array, adding convenience methods for manipulation. Add and remove changes to the Collection trigger a Collection event. Note that this does not cover changes to the objects within the Collection; they trigger events on the appropriate object, not on the Collection as a whole.
      */
@@ -925,7 +1034,7 @@ declare module ol {
          */
         item(index: number): T;
 
-        /** 
+        /**
          * Remove the last element of the collection and return it. Return undefined if the collection is empty.
          * @returns Element
          */
@@ -952,7 +1061,7 @@ declare module ol {
          */
         removeAt(index: number): T;
 
-        /** 
+        /**
          * Set the element at the provided index.
          * @param index Index.
          * @param elem Element.
@@ -984,7 +1093,7 @@ declare module ol {
 
         /**
          * Rotation around the device z-axis (in radians).
-         * @returns The euler angle in radians of the device from the standard Z axis. 
+         * @returns The euler angle in radians of the device from the standard Z axis.
          */
         getAlpha(): number;
 
@@ -996,7 +1105,7 @@ declare module ol {
 
         /**
          * Rotation around the device y-axis (in radians).
-         * @returns The euler angle in radians of the device from the planar Y axis. 
+         * @returns The euler angle in radians of the device from the planar Y axis.
          */
         getGamma(): number;
 
@@ -1014,11 +1123,11 @@ declare module ol {
 
         /**
          * Enable or disable tracking of device orientation events.
-         * @param tracking The status of tracking changes to alpha, beta and gamma. If true, changes are tracked and reported immediately. 
+         * @param tracking The status of tracking changes to alpha, beta and gamma. If true, changes are tracked and reported immediately.
          */
         setTracking(tracking: boolean): void;
     }
-    
+
     /**
      * Events emitted by ol.interaction.DragBox instances are instances of this type.
      */
@@ -1145,7 +1254,7 @@ declare module ol {
 
         /**
          * Get the map associated with the overlay.
-         * @returns The map with which this feature overlay is associated. 
+         * @returns The map with which this feature overlay is associated.
          */
         getMap(): ol.Map;
 
@@ -1217,19 +1326,19 @@ declare module ol {
 
         /**
          * Get a geometry of the position accuracy.
-         * @returns A geometry of the position accuracy. 
+         * @returns A geometry of the position accuracy.
          */
         getAccuracyGeometry(): ol.geom.Geometry;
 
         /**
          * Get the altitude associated with the position.
-         * @returns The altitude of the position in meters above mean sea level. 
+         * @returns The altitude of the position in meters above mean sea level.
          */
         getAltitude(): number;
 
         /**
          * Get the altitude accuracy of the position.
-         * @returns The accuracy of the altitude measurement in meters. 
+         * @returns The accuracy of the altitude measurement in meters.
          */
         getAltitudeAccuracy(): number;
 
@@ -1247,7 +1356,7 @@ declare module ol {
 
         /**
          * Get the projection associated with the position.
-         * @returns The projection the position is reported in. 
+         * @returns The projection the position is reported in.
          */
         getProjection(): ol.proj.Projection;
 
@@ -1259,7 +1368,7 @@ declare module ol {
 
         /**
          * Determine if the device location is being tracked.
-         * @returns The device location is being tracked. 
+         * @returns The device location is being tracked.
          */
         getTracking(): boolean;
 
@@ -1298,33 +1407,33 @@ declare module ol {
          */
         constructor(options?: olx.GraticuleOptions);
 
-        /** 
-         * Get the map associated with this graticule. 
+        /**
+         * Get the map associated with this graticule.
          * @returns The map.
          */
         getMap(): Map;
 
-        /** 
-         * Get the list of meridians. Meridians are lines of equal longitude. 
+        /**
+         * Get the list of meridians. Meridians are lines of equal longitude.
          * @returns The meridians.
          */
         getMeridians(): Array<ol.geom.LineString>;
 
-        /** 
-         * Get the list of parallels. Pallels are lines of equal latitude. 
+        /**
+         * Get the list of parallels. Pallels are lines of equal latitude.
          * @returns The parallels.
          */
         getParallels(): Array<ol.geom.LineString>;
-    
-        /** 
-         * Set the map for this graticule.The graticule will be rendered on the provided map. 
+
+        /**
+         * Set the map for this graticule.The graticule will be rendered on the provided map.
          * @param map Map
          */
         setMap(map: Map): void;
     }
-    
+
     /**
-     * 
+     *
      */
     class Image extends ol.ImageBase {
 
@@ -1351,13 +1460,13 @@ declare module ol {
     }
 
     /**
-     * 
+     *
      */
     class ImageBase {
     }
 
     /**
-     * 
+     *
      */
     class ImageTile extends ol.Tile {
 
@@ -1446,7 +1555,7 @@ declare module ol {
          * @param ref Value to use as this when executing callback.
          * @param layerFilter Layer filter function. The filter function will receive one argument, the layer-candidate and it should return a boolean value. Only layers which are visible and for which this function returns true will be tested for features. By default, all visible layers will be tested. Feature overlays will always be tested.
          * @param ref2 Value to use as this when executing layerFilter.
-         * @returns Callback result, i.e. the return value of last callback execution, or the first truthy callback return value. 
+         * @returns Callback result, i.e. the return value of last callback execution, or the first truthy callback return value.
          */
         forEachFeatureAtPixel(pixel: ol.Pixel, callback: (feature: ol.Feature, layer: ol.layer.Layer) => any, ref?: any, layerFilter?: (layerCandidate: ol.layer.Layer) => boolean, ref2?: any): void;
 
@@ -1457,7 +1566,7 @@ declare module ol {
          * @param ref Value to use as this when executing callback.
          * @param layerFilter Layer filter function. The filter function will receive one argument, the layer-candidate and it should return a boolean value. Only layers which are visible and for which this function returns true will be tested for features. By default, all visible layers will be tested. Feature overlays will always be tested.
          * @param ref2 Value to use as this when executing layerFilter.
-         * @returns Callback result, i.e. the return value of last callback execution, or the first truthy callback return value. 
+         * @returns Callback result, i.e. the return value of last callback execution, or the first truthy callback return value.
          */
         forEachLayerAtPixel(pixel: ol.Pixel, callback: (layer: ol.layer.Layer) => any, ref?: any, layerFilter?: (layerCandidate: ol.layer.Layer) => boolean, ref2?: any): void;
 
@@ -1470,7 +1579,7 @@ declare module ol {
         /**
          * Get the coordinate for a given pixel. This returns a coordinate in the map view projection.
          * @param pixel Pixel position in the map viewport.
-         * @returns The coordinate for the pixel position. 
+         * @returns The coordinate for the pixel position.
          */
         getCoordinateFromPixel(pixel: ol.Pixel): ol.Coordinate;
 
@@ -1496,7 +1605,7 @@ declare module ol {
 
         /**
          * Get the layergroup associated with this map.
-         * @returns A layer group containing the layers in this map. 
+         * @returns A layer group containing the layers in this map.
          */
         getLayerGroup(): ol.layer.Group;
 
@@ -1521,13 +1630,13 @@ declare module ol {
 
         /**
          * Get the size of this map.
-         * @returns The size in pixels of the map in the DOM. 
+         * @returns The size in pixels of the map in the DOM.
          */
         getSize(): ol.Size;
 
         /**
          * Get the target in which this map is rendered. Note that this returns what is entered as an option or in setTarget: if that was an element, it returns an element; if a string, it returns that.
-         * @returns The Element or id of the Element that the map is rendered in. 
+         * @returns The Element or id of the Element that the map is rendered in.
          */
         getTarget(): Element | string;
 
@@ -1537,8 +1646,8 @@ declare module ol {
          */
         getTargetElement(): Element;
 
-        /** 
-         * Get the view associated with this map. A view manages properties such as center and resolution. 
+        /**
+         * Get the view associated with this map. A view manages properties such as center and resolution.
          * @returns The view that controls this map.
          */
         getView(): View;
@@ -1561,21 +1670,21 @@ declare module ol {
         /**
          * Remove the given control from the map.
          * @param Control.
-         * @returns The removed control (or undefined if the control was not found). 
+         * @returns The removed control (or undefined if the control was not found).
          */
         removeControl(control: ol.control.Control): ol.control.Control;
 
         /**
          * Remove the given interaction from the map.
          * @param interaction Interaction to remove.
-         * @returns The removed interaction (or undefined if the interaction was not found). 
+         * @returns The removed interaction (or undefined if the interaction was not found).
          */
         removeInteraction(interaction: ol.interaction.Interaction): ol.interaction.Interaction;
 
         /**
          * Removes the given layer from the map.
          * @param Layer.
-         * @returns The removed layer (or undefined if the layer was not found). 
+         * @returns The removed layer (or undefined if the layer was not found).
          */
         removeLayer(layer: ol.layer.Base): ol.layer.Base;
 
@@ -1620,18 +1729,18 @@ declare module ol {
          */
         setTarget(target: string): void;
 
-        /** 
-         * Set the view for this map. 
+        /**
+         * Set the view for this map.
          * @param view The view that controls this map.
          */
         setView(view: View): void;
 
-        /** 
-         * Force a recalculation of the map viewport size. This should be called when third-party code changes the size of the map viewport. 
+        /**
+         * Force a recalculation of the map viewport size. This should be called when third-party code changes the size of the map viewport.
          * */
         updateSize(): void;
     }
-   
+
     /**
      * Events emitted as map browser events are instances of this type. See ol.Map for which events trigger a map browser event.
      */
@@ -1646,7 +1755,7 @@ declare module ol {
          * Indicates if the map is currently being dragged. Only set for POINTERDRAG and POINTERMOVE events. Default is false.
          */
         dragging: boolean;
-        
+
         /**
          * The frame state at the time of the event
          */
@@ -1662,12 +1771,12 @@ declare module ol {
          */
         originalEvent: Event;
 
-        /** 
+        /**
          * The pixel of the original browser event.
          */
         pixel: Pixel;
 
-        
+
         // Methods
 
         /**
@@ -1715,13 +1824,13 @@ declare module ol {
          */
         get(key: string): any;
 
-        /** 
+        /**
          * Get a list of object property names.
          * @returns List of property names.
          */
         getKeys(): Array<string>;
 
-        /** 
+        /**
          * Get an object of all property names and values.
          * @returns Object.
          */
@@ -1732,14 +1841,14 @@ declare module ol {
          */
         getRevision(): number;
 
-        /** 
+        /**
          * Sets a value.
          * @param key Key name.
          * @param value Value.
          */
         set(key: string, value: any): void;
 
-        /** 
+        /**
          * Sets a collection of key-value pairs. Note that this changes any existing properties and adds new ones (it does not remove any existing properties).
          * @param Values.
          */
@@ -1910,7 +2019,7 @@ declare module ol {
          */
         setPositioning(positioning: ol.OverlayPositioning): void;
     }
-    
+
     /**
      * Events emitted by ol.interaction.Select instances are instances of this type.
      */
@@ -2089,7 +2198,7 @@ declare module ol {
          */
         setZoom(zoom: number): void;
     }
-    
+
     // NAMESPACES
 
     /**
@@ -2102,7 +2211,7 @@ declare module ol {
          * @param options Bounce options.
          */
         function bounce(options: olx.animation.BounceOptions): ol.PreRenderFunction;
-        
+
         /**
          * Generate an animated transition while updating the view center.
          * @param options Pan options.
@@ -2160,7 +2269,7 @@ declare module ol {
          * @returns Control.s
          */
         function defaults(options?: olx.control.DefaultsOptions): ol.Collection<ol.control.Control>;
-        
+
         /**
          * Units for the scale line. Supported values are 'degrees', 'imperial', 'nautical', 'metric', 'us'.
          */
@@ -2203,7 +2312,7 @@ declare module ol {
          * Add delta to coordinate. coordinate is modified in place and returned by the function.
          * @param coordinate Coordinate
          * @param delta Delta
-         * @returns The input coordinate adjusted by the given delta. 
+         * @returns The input coordinate adjusted by the given delta.
          */
         function add(coordinate: ol.Coordinate, delta: ol.Coordinate): ol.Coordinate;
 
@@ -2234,7 +2343,7 @@ declare module ol {
         /**
          * Format a geographic coordinate with the hemisphere, degrees, minutes, and seconds.
          * @param coordinate COordinate
-         * @returns Hemisphere, degrees, minutes and seconds. 
+         * @returns Hemisphere, degrees, minutes and seconds.
          */
         function toStringHDMS(coordinate?: ol.Coordinate): string;
 
@@ -2271,7 +2380,7 @@ declare module ol {
         * @param number Input between 0 and 1
         * @returns Output between 0 and 1
         */
-        function inAndOut (t: number): number;
+        function inAndOut(t: number): number;
 
         /**
         * Maintain a constant speed over time.
@@ -2341,7 +2450,7 @@ declare module ol {
          * @param extent Extent
          * @param x X coordinate
          * @param y Y coordinate
-         * @returns The x, y values are contained in the extent. 
+         * @returns The x, y values are contained in the extent.
          */
         function containsXY(extent: ol.Extent, x: number, y: number): boolean;
 
@@ -2478,7 +2587,7 @@ declare module ol {
          * Feature format for reading and writing data in the GeoJSON format.
          */
         class GeoJSON extends ol.format.JSONFeature {
-            
+
             /**
              * @constructor
              * @param Options
@@ -2492,7 +2601,7 @@ declare module ol {
              * @returns Feature
              */
             readFeature(source: Document | Node | JSON | string, options?: olx.format.ReadOptions): ol.Feature;
-    
+
             /**
              * Read all features from a GeoJSON source. Works with both Feature and FeatureCollection sources.
              * @param source Source
@@ -2624,7 +2733,7 @@ declare module ol {
     }
 
     module geom {
-        
+
         // Type definitions
         interface GeometryLayout extends String { }
         interface GeometryType extends String { }
@@ -2798,7 +2907,7 @@ declare module ol {
 
             /**
              * Return the minimum resolution of the layer.
-             * @returns The minimum resolution of the layer. 
+             * @returns The minimum resolution of the layer.
              */
             getMinResolution(): number;
 
@@ -2971,7 +3080,7 @@ declare module ol {
         class Layer extends ol.layer.Base {
 
             /**
-             * @constructor 
+             * @constructor
              * @param options Layer options
              */
             constructor(options?: olx.layer.LayerOptions);
@@ -2988,7 +3097,7 @@ declare module ol {
              */
             setSource(source: ol.source.Source): void;
         }
-        
+
         /**
          * For layer sources that provide pre-rendered, tiled images in grids that are organized by zoom levels for specific resolutions. Note that any property set in the options is set as a ol.Object property on the layer object; for example, setting title: 'My Title' in the options means that title is observable, and has get/set accessors.
          */
@@ -3193,7 +3302,8 @@ declare module ol {
          */
         function transformExtent(extent: Extent, source: ProjectionLike, destination: ProjectionLike): Extent;
 
-        interface Projection {
+        class Projection {
+            constructor(options: olx.Projection)
         }
     }
 
@@ -3238,6 +3348,7 @@ declare module ol {
         }
 
         class ImageWMS {
+            constructor(options: olx.ImageWMSOptions);
         }
 
         class MapQuest {
@@ -3278,6 +3389,7 @@ declare module ol {
         }
 
         class TileWMS {
+            constructor(options: olx.TileWMSOptions);
         }
 
         class Vector {
@@ -3514,7 +3626,7 @@ declare module ol {
              */
             getTileSize(z: number): number | ol.Size;
         }
-        
+
         /**
          * Set the grid pattern for sources accessing WMTS tiled-image servers.
          */
@@ -3540,7 +3652,7 @@ declare module ol {
              */
             getMatrixIds(): Array<string>;
         }
-        
+
         /**
          * Set the grid pattern for sources accessing Zoomify tiled-image servers.
          */
@@ -3572,7 +3684,7 @@ declare module ol {
              */
             constructor(canvas: HTMLCanvasElement, gl: WebGLRenderingContext);
 
-            /** 
+            /**
             Get the WebGL rendering context
              @returns The rendering context.
             */
@@ -3595,55 +3707,55 @@ declare module ol {
 
     // Type definitions
 
-    /** 
-     * A function returning the canvas element ({HTMLCanvasElement}) used by the source as an image. The arguments passed to the function are: ol.Extent the image extent, {number} the image resolution, {number} the device pixel ratio, ol.Size the image size, and ol.proj.Projection the image projection. The canvas returned by this function is cached by the source. The this keyword inside the function references the ol.source.ImageCanvas. 
+    /**
+     * A function returning the canvas element ({HTMLCanvasElement}) used by the source as an image. The arguments passed to the function are: ol.Extent the image extent, {number} the image resolution, {number} the device pixel ratio, ol.Size the image size, and ol.proj.Projection the image projection. The canvas returned by this function is cached by the source. The this keyword inside the function references the ol.source.ImageCanvas.
      */
     function CanvasFunctionType(extent: Extent, resolution: number, pixelRatio: number, size: Size, projection: proj.Projection): HTMLCanvasElement;
 
-    /** 
-     * A color represented as a short array [red, green, blue, alpha]. red, green, and blue should be integers in the range 0..255 inclusive. alpha should be a float in the range 0..1 inclusive. 
+    /**
+     * A color represented as a short array [red, green, blue, alpha]. red, green, and blue should be integers in the range 0..255 inclusive. alpha should be a float in the range 0..1 inclusive.
      */
     interface Color extends Array<number> { }
-    
+
     /**
-     * An array of numbers representing an xy coordinate. Example: [16, 48]. 
+     * An array of numbers representing an xy coordinate. Example: [16, 48].
      */
     interface Coordinate extends Array<number> { }
 
-    /** 
-     * An array of numbers representing an extent: [minx, miny, maxx, maxy]. 
+    /**
+     * An array of numbers representing an extent: [minx, miny, maxx, maxy].
      */
     interface Extent extends Array<number> { }
 
-    /** 
-     * Overlay position: 'bottom-left', 'bottom-center', 'bottom-right', 'center-left', 'center-center', 'center-right', 'top-left', 'top-center', 'top-right' 
+    /**
+     * Overlay position: 'bottom-left', 'bottom-center', 'bottom-right', 'center-left', 'center-center', 'center-right', 'top-left', 'top-center', 'top-right'
      */
     interface OverlayPositioning extends String { }
 
     /**
-     * An array with two elements, representing a pixel. The first element is the x-coordinate, the second the y-coordinate of the pixel. 
+     * An array with two elements, representing a pixel. The first element is the x-coordinate, the second the y-coordinate of the pixel.
      */
     interface Pixel extends Array<number> { }
 
-    /** 
-     * Available renderers: 'canvas', 'dom' or 'webgl'. 
+    /**
+     * Available renderers: 'canvas', 'dom' or 'webgl'.
      */
     interface RendererType extends String { }
-    
-    /** 
-     * An array of numbers representing a size: [width, height]. 
+
+    /**
+     * An array of numbers representing a size: [width, height].
      */
     interface Size extends Array<number> { }
 
-    /** 
-     * An array of three numbers representing the location of a tile in a tile grid. The order is z, x, and y. z is the zoom level. 
+    /**
+     * An array of three numbers representing the location of a tile in a tile grid. The order is z, x, and y. z is the zoom level.
      */
     interface TileCoord extends Array<number> { }
 
-    // Functions 
+    // Functions
 
-    /** 
-     * A function that takes a ol.Coordinate and transforms it into a {string}. 
+    /**
+     * A function that takes a ol.Coordinate and transforms it into a {string}.
      */
     interface CoordinateFormatType { (coordinate?: Coordinate): string; }
 
@@ -3671,4 +3783,4 @@ declare module ol {
      * A transform function accepts an array of input coordinate values, an optional output array, and an optional dimension (default should be 2). The function transforms the input coordinate values, populates the output array, and returns the output array.
      */
     interface TransformFunction { (input: Array<number>, output?: Array<number>, dimension?: number): Array<number> }
-}
\ No newline at end of file
+}
diff --git a/package.json b/package.json
index 2c5b834ed0..b92031a386 100644
--- a/package.json
+++ b/package.json
@@ -36,6 +36,6 @@
   },
   "devDependencies": {
     "definition-tester": "0.2.0",
-    "typescript": "1.5.3"
+    "typescript": "1.6.2"
   }
 }
diff --git a/papaparse/papaparse-tests.ts b/papaparse/papaparse-tests.ts
index 14cc40bb30..8ae3f91672 100644
--- a/papaparse/papaparse-tests.ts
+++ b/papaparse/papaparse-tests.ts
@@ -12,14 +12,14 @@ res.errors[0].code;
 Papa.parse("3,3,3", {
 	delimiter: ';',
 	comments: false,
-	
+
 	step: function(results, p) {
 		p.abort();
 		results.data.length;
 	}
 });
 
-var file = new File();
+var file = new File(null, null, null);
 
 Papa.parse(file, {
 	complete: function(a, b) {
@@ -52,4 +52,4 @@ Papa.LocalChunkSize;
 var parser = new Papa.Parser({})
 parser.getCharIndex();
 parser.abort();
-parser.parse("", 0, false);
\ No newline at end of file
+parser.parse("", 0, false);
diff --git a/passport-facebook/passport-facebook-tests.ts b/passport-facebook/passport-facebook-tests.ts
index b35770479f..8accf57c07 100644
--- a/passport-facebook/passport-facebook-tests.ts
+++ b/passport-facebook/passport-facebook-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./passport-facebook.d.ts" />
+
 /**
  * Created by jcabresos on 4/19/2014.
  */
@@ -22,4 +24,4 @@ passport.use(new facebook.Strategy({
              done(null, user);
          });
     })
-);
\ No newline at end of file
+);
diff --git a/passport-google-oauth/passport-google-oauth-tests.ts b/passport-google-oauth/passport-google-oauth-tests.ts
index 60fad97b41..ef7a4e9ef9 100644
--- a/passport-google-oauth/passport-google-oauth-tests.ts
+++ b/passport-google-oauth/passport-google-oauth-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./passport-google-oauth.d.ts" />
+
 /**
  * Created by jcabresos on 4/19/2014.
  */
diff --git a/passport-local/passport-local-tests.ts b/passport-local/passport-local-tests.ts
index 873dc609bc..68056db49b 100644
--- a/passport-local/passport-local-tests.ts
+++ b/passport-local/passport-local-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./passport-local.d.ts" />
+
 /**
  * Created by Maxime LUCE <https://github.com/SomaticIT>.
  */
diff --git a/passport-strategy/passport-strategy-tests.ts b/passport-strategy/passport-strategy-tests.ts
index e9c6fd604f..ad5a9a38d3 100644
--- a/passport-strategy/passport-strategy-tests.ts
+++ b/passport-strategy/passport-strategy-tests.ts
@@ -1,3 +1,4 @@
+/// <reference path="./passport-strategy.d.ts" />
 
 import express = require('express');
 import passport = require('passport-strategy');
diff --git a/passport-twitter/passport-twitter-tests.ts b/passport-twitter/passport-twitter-tests.ts
index ae644dfa2a..f7d539f16b 100644
--- a/passport-twitter/passport-twitter-tests.ts
+++ b/passport-twitter/passport-twitter-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./passport-twitter.d.ts" />
+
 /**
  * Created by jcabresos on 4/19/2014.
  */
diff --git a/phantom/phantom-tests.ts b/phantom/phantom-tests.ts
index bd12a5e6e1..d18168827d 100644
--- a/phantom/phantom-tests.ts
+++ b/phantom/phantom-tests.ts
@@ -117,7 +117,7 @@ phantom.create((ph) => {
       var finishedFunc = (result: any) => {
         ph.exit();
       };
-      page.evaluate(someFunc, finishedFunc, 'div', {wahtt: 111});
+      page.evaluate<string, {wahtt: number;}, void>(someFunc, finishedFunc, 'div', {wahtt: 111});
     });
   });
 
@@ -164,5 +164,3 @@ phantom.create((ph) => {
     });
   });
 });
-
-
diff --git a/photoswipe/photoswipe-tests.ts b/photoswipe/photoswipe-tests.ts
index ca136f3a2e..e4006d5c13 100644
--- a/photoswipe/photoswipe-tests.ts
+++ b/photoswipe/photoswipe-tests.ts
@@ -51,7 +51,8 @@ function test_defaultUI() {
             return el.tagName === 'A';
         },
         mainScrollEndFriction: 0.35,
-        panEndFriction: 0.35
+        panEndFriction: 0.35,
+        modal: true
     };
 
     var photoSwipe: PhotoSwipe<PhotoSwipeUI_Default.Options>;
diff --git a/photoswipe/photoswipe.d.ts b/photoswipe/photoswipe.d.ts
index 16ce87a68c..bf1cf701ba 100644
--- a/photoswipe/photoswipe.d.ts
+++ b/photoswipe/photoswipe.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for PhotoSwipe 4.0.7
+// Type definitions for PhotoSwipe 4.0.8
 // Project: http://photoswipe.com/
 // Definitions by: Xiaohan Zhang <https://github.com/hellochar>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -308,6 +308,13 @@ declare module PhotoSwipe {
          * }
          */
         isClickableElement?: (el: HTMLElement) => boolean;
+
+        /**
+         * Controls whether PhotoSwipe should expand to take up the entire viewport.
+         * If false, the PhotoSwipe element will take the size of the positioned parent of the template. Take a look at the FAQ for more
+         * information.
+         */
+        modal?: boolean;
     }
 
     interface UIFramework {
diff --git a/physijs/tests/jenga.ts b/physijs/tests/jenga.ts
index e2eeecc94e..77b9c6cd6a 100644
--- a/physijs/tests/jenga.ts
+++ b/physijs/tests/jenga.ts
@@ -85,7 +85,7 @@ initScene = function() {
 
     // Materials
     table_material = Physijs.createMaterial(
-        new THREE.MeshLambertMaterial({ map: THREE.ImageUtils.loadTexture( 'images/wood.jpg' ), ambient: 0xFFFFFF }),
+        new THREE.MeshLambertMaterial({ map: THREE.ImageUtils.loadTexture( 'images/wood.jpg' ) }),
         .9, // high friction
         .2 // low restitution
     );
@@ -93,7 +93,7 @@ initScene = function() {
     table_material.map.repeat.set( 5, 5 );
 
     block_material = Physijs.createMaterial(
-        new THREE.MeshLambertMaterial({ map: THREE.ImageUtils.loadTexture( 'images/plywood.jpg' ), ambient: 0xFFFFFF }),
+        new THREE.MeshLambertMaterial({ map: THREE.ImageUtils.loadTexture( 'images/plywood.jpg' ) }),
         .4, // medium friction
         .4 // medium restitution
     );
diff --git a/progress/progress-test.ts b/progress/progress-test.ts
new file mode 100644
index 0000000000..699c20b057
--- /dev/null
+++ b/progress/progress-test.ts
@@ -0,0 +1,32 @@
+/// <reference path="progress.d.ts"/>
+
+var ProgressBar = require('progress');
+
+
+/**
+ * Usage example from https://github.com/tj/node-progress
+ */
+var bar = new ProgressBar(':bar', { total: 10 });
+var timer = setInterval(function () {
+  bar.tick();
+  if (bar.complete) {
+    console.log('\ncomplete\n');
+    clearInterval(timer);
+  }
+}, 100);
+
+
+/**
+ * Custom token example from https://github.com/tj/node-progress
+ */
+var bar = new ProgressBar(':current: :token1 :token2', { total: 3 });
+
+bar.tick({
+  'token1': "Hello",
+  'token2': "World!\n"
+});
+
+bar.tick(2, {
+  'token1': "Goodbye",
+  'token2': "World!"
+});
diff --git a/progress/progress.d.ts b/progress/progress.d.ts
new file mode 100644
index 0000000000..2c7e683ec4
--- /dev/null
+++ b/progress/progress.d.ts
@@ -0,0 +1,121 @@
+// Type definitions for node-progress v1.1.8
+// Project: https://github.com/tj/node-progress
+// Definitions by: Sebastian Lenz <https://github.com/sebastian-lenz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts"/>
+
+
+declare module "progress"
+{
+    /**
+     * These are keys in the options object you can pass to the progress bar along with total as seen in the example above.
+     */
+    interface ProgressBarOptions
+    {
+        /**
+         * Total number of ticks to complete.
+         */
+        total:number;
+
+        /**
+         * The displayed width of the progress bar defaulting to total.
+         */
+        width?:number;
+
+        /**
+         * The output stream defaulting to stderr.
+         */
+        stream?:NodeJS.WritableStream;
+
+        /**
+         * Completion character defaulting to "=".
+         */
+        complete?:string;
+
+        /**
+         * Incomplete character defaulting to "-".
+         */
+        incomplete?:string;
+
+        /**
+         * Option to clear the bar on completion defaulting to false.
+         */
+        clear?:boolean;
+
+        /**
+         * Optional function to call when the progress bar completes.
+         */
+        callback?:Function;
+    }
+
+
+    /**
+     * Flexible ascii progress bar.
+     */
+    class ProgressBar
+    {
+        /**
+         * Initialize a `ProgressBar` with the given `fmt` string and `options` or
+         * `total`.
+         *
+         * Options:
+         *   - `total` total number of ticks to complete
+         *   - `width` the displayed width of the progress bar defaulting to total
+         *   - `stream` the output stream defaulting to stderr
+         *   - `complete` completion character defaulting to "="
+         *   - `incomplete` incomplete character defaulting to "-"
+         *   - `renderThrottle` minimum time between updates in milliseconds defaulting to 16
+         *   - `callback` optional function to call when the progress bar completes
+         *   - `clear` will clear the progress bar upon termination
+         *
+         * Tokens:
+         *   - `:bar` the progress bar itself
+         *   - `:current` current tick number
+         *   - `:total` total ticks
+         *   - `:elapsed` time elapsed in seconds
+         *   - `:percent` completion percentage
+         *   - `:eta` eta in seconds
+         */
+        constructor(format:string, total:number);
+        constructor(format:string, options:ProgressBarOptions);
+
+
+        /**
+         * "tick" the progress bar with optional `len` and optional `tokens`.
+         */
+        tick(tokens?:any):void;
+        tick(count?:number, tokens?:any):void;
+
+
+        /**
+         * Method to render the progress bar with optional `tokens` to place in the
+         * progress bar's `fmt` field.
+         */
+        render(tokens?:any):void;
+
+
+        /**
+         * "update" the progress bar to represent an exact percentage.
+         * The ratio (between 0 and 1) specified will be multiplied by `total` and
+         * floored, representing the closest available "tick." For example, if a
+         * progress bar has a length of 3 and `update(0.5)` is called, the progress
+         * will be set to 1.
+         *
+         * A ratio of 0.5 will attempt to set the progress to halfway.
+         *
+         * @param ratio The ratio (between 0 and 1 inclusive) to set the
+         *   overall completion to.
+         */
+        update(ratio:number, tokens?:any):void;
+
+
+        /**
+         * Terminates a progress bar.
+         */
+        terminate():void;
+    }
+
+
+    export = ProgressBar;
+}
diff --git a/project-oxford/project-oxford-tests.ts b/project-oxford/project-oxford-tests.ts
index 3d662d5040..896d407b8d 100644
--- a/project-oxford/project-oxford-tests.ts
+++ b/project-oxford/project-oxford-tests.ts
@@ -16,7 +16,7 @@ var billFaces = <string[]>[];
 var personGroupId = "uuid.v4()";
 var personGroupId2 = "uuid.v4()";
 var billPersonId: string;
- 
+
 describe('Project Oxford Face API Test', function () {
     afterEach(function() {
         // delay after each test to prevent throttling
@@ -82,7 +82,7 @@ describe('Project Oxford Face API Test', function () {
             });
         });
     });
-    
+
     describe('#similar()', function () {
         it('detects similar faces', function (done) {
             var detects = <any>[];
@@ -148,7 +148,7 @@ describe('Project Oxford Face API Test', function () {
             });
         });
     });
-    
+
     describe('#PersonGroup', function () {
         before(function(done) {
             this.timeout(5000);
@@ -199,7 +199,7 @@ describe('Project Oxford Face API Test', function () {
                 done();
             });
         });
-        
+
         it('updates a PersonGroup', function (done) {
             client.face.personGroup.update(personGroupId, 'po-node-test-group2', 'test-data2').then(function (response) {
                 assert.ok(true, "void response expected");;
@@ -364,7 +364,7 @@ describe('Project Oxford Vision API Test', function () {
     before(function() {
         // ensure the output directory exists
         if(!fs.existsSync('./test/output')){
-            fs.mkdirSync('./test/output', 0766);
+            fs.mkdirSync('./test/output', parseInt("0766", 8));
         }
     });
 
@@ -417,7 +417,7 @@ describe('Project Oxford Vision API Test', function () {
             done();
         });
     });
-    
+
     it('creates a thumbnail for a local image', function (done) {
         this.timeout(10000);
         client.vision.thumbnail({
@@ -449,7 +449,7 @@ describe('Project Oxford Vision API Test', function () {
             done();
         });
     });
-    
+
     it('runs OCR on a local image', function (done) {
         this.timeout(10000);
         client.vision.ocr({
@@ -477,4 +477,4 @@ describe('Project Oxford Vision API Test', function () {
             done();
         });
     });
-});
\ No newline at end of file
+});
diff --git a/promise-pool/promise-pool-tests.ts b/promise-pool/promise-pool-tests.ts
index 4f3bd40def..a9cc160bea 100644
--- a/promise-pool/promise-pool-tests.ts
+++ b/promise-pool/promise-pool-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./promise-pool.d.ts" />
+
 import Q = require('q');
 import promisePool = require('promise-pool');
 
@@ -44,4 +46,4 @@ function onProgress(progress: promisePool.IProgress) {
     progress.fulfilled == 0;
     progress.total == 0;
     progress.index == 0;
-}
\ No newline at end of file
+}
diff --git a/protobufjs/protobufjs-tests.ts b/protobufjs/protobufjs-tests.ts
index 8cf52b274b..f20efec3c5 100644
--- a/protobufjs/protobufjs-tests.ts
+++ b/protobufjs/protobufjs-tests.ts
@@ -15,51 +15,51 @@ function testProtoBufJs() {
     assert.ok("loadProto" in ProtoBuf, "ProtoBuf should contain property loadProto");
     assert.ok("loadProtoFile" in ProtoBuf, "ProtoBuf should contain property loadProtoFile");
     assert.ok("newBuilder" in ProtoBuf, "ProtoBuf should contain property newBuilder");
-    
+
     var jsonProto: ProtoBuf.ProtoBuilder = ProtoBuf.loadJson(readFileSync("test.json",
         {"encoding": "utf8"}));
     assertIsProtoBuilder(jsonProto, "loadJson");
-    
+
     var jsonFileProto: ProtoBuf.ProtoBuilder = ProtoBuf.loadJsonFile("test.json");
     assertIsProtoBuilder(jsonFileProto, "loadJsonFile");
-    
+
     ProtoBuf.loadJsonFile("test.json", (error: any, builder: ProtoBuf.ProtoBuilder) => {
         assertIsProtoBuilder(builder, "loadJsonFile callback");
       });
-      
+
     var proto: ProtoBuf.ProtoBuilder = ProtoBuf.loadProto(readFileSync("test.proto",
         {"encoding": "utf8"}));
     assertIsProtoBuilder(proto, "loadProto");
-    
+
     var protoFile: ProtoBuf.ProtoBuilder = ProtoBuf.loadProtoFile("test.proto");
     assertIsProtoBuilder(protoFile, "loadProtoFile");
-    
+
     ProtoBuf.loadProtoFile("test.proto", (error: any, builder: ProtoBuf.ProtoBuilder) => {
         assertIsProtoBuilder(builder, "loadProtoFile callback");
       });
-      
+
      var newBuilder: ProtoBuf.ProtoBuilder = ProtoBuf.newBuilder();
      assertIsProtoBuilder(newBuilder, "newBuilder");
-     
+
      assertIsNamespace(protoFile.ns, "protoFile.ns");
      assertIsNamespace(protoFile.ptr, "protoFile.ptr");
-     
+
      assertIsProtoBuf(protoFile.build(), "protoFile.build()");
      assertIsProtoBuf(protoFile.result, "protoFile.result");
-     
+
      assertIsProtoBuilder(protoFile.create(), "protoFile.create()");
      assertIsProtoBuilder(protoFile.define("js"), "protoFile.define()");
-     
+
      assertIsT(protoFile.lookup(), "protoFile.lookup()");
 }
 
 function testBuilderJs() {
     var Builder: ProtoBuf.Builder = ProtoBuf.Builder;
     assertIsBuilder(Builder, "Builder");
-    
+
     var newBuilder: ProtoBuf.ProtoBuilder = new ProtoBuf.Builder();
     assertIsProtoBuilder(newBuilder, "new Builder()");
-    
+
     var Message: ProtoBuf.Message = Builder.Message;
     var Service: ProtoBuf.Service = Builder.Service;
 }
@@ -104,13 +104,13 @@ function assertIsBuilder(b: ProtoBuf.Builder, name: string) {
 }
 
 function assertIsProtoBuf(pb: ProtoBuf.ProtoBuf, name: string) {
-    for (var package in pb) {
-        if (pb.hasOwnProperty(package)) {
-            for (var property in pb[package]) {
-                if (typeof pb[package][property] == typeof Object
-                      && pb[package].hasOwnProperty(property)) {
-                    assertIsMetaMessage(pb[package][property],
-                        name + "." + package + "." + property);
+    for (var pkg in pb) {
+        if (pb.hasOwnProperty(pkg)) {
+            for (var property in pb[pkg]) {
+                if (typeof pb[pkg][property] == typeof Object
+                      && pb[pkg].hasOwnProperty(property)) {
+                    assertIsMetaMessage(pb[pkg][property],
+                        name + "." + pkg + "." + property);
                 }
             }
         }
@@ -127,7 +127,7 @@ function assertIsMetaMessage(mm: ProtoBuf.MetaMessage, name: string) {
 function assertIsDotProto(dp: ProtoBuf.DotProto, name: string) {
     assert.ok("Parser" in dp, name + " should contain property Parser");
     assert.ok("Tokenizer" in dp, name + " should contain property Tokenizer");
-    
+
     assertIsParser(new dp.Parser(readFileSync("test.proto", {"encoding": "utf8"})),
         name + ".Parser");
     assertIsTokenizer(new dp.Tokenizer(readFileSync("test.proto", {"encoding": "utf8"})),
@@ -138,7 +138,7 @@ function assertIsParser(p: ProtoBuf.Parser, name: string) {
     assert.ok("tn" in p, name + " should contain property tn");
     assert.ok("parse" in p, name + " should contain property parse");
     assert.ok("toString" in p, name + " should contain property toString");
-    
+
     assertIsTokenizer(p.tn, name + ".tn");
     assertIsMetaProto(p.parse(), name + ".parse()");
 }
@@ -162,7 +162,7 @@ function assertIsMetaProto(mp: ProtoBuf.MetaProto, name: string) {
     assert.ok("imports" in mp, name + " should contain proeprty imports");
     assert.ok("options" in mp, name + " should contain proeprty options");
     assert.ok("services" in mp, name + " should contain proeprty services");
-    
+
     for (var message in mp.messages) {
         assertIsProtoMessage(mp.messages[message], name + ".messages." + message);
     }
@@ -178,7 +178,7 @@ function assertIsProtoEnum(pe: ProtoBuf.ProtoEnum, name: string) {
     assert.ok("name" in pe, name + " should contain property name");
     assert.ok("values" in pe, name + " should contain property values");
     assert.ok("options" in pe, name + " should contain property options");
-    
+
     assertIsProtoEnumValue(pe.values, name + ".values");
 }
 
@@ -202,7 +202,7 @@ function assertIsProtoMessage(pm: ProtoBuf.ProtoMessage, name: string) {
     assert.ok("messages" in pm, name + " should contain property messages");
     assert.ok("options" in pm, name + " should contain property options");
     assert.ok("oneofs" in pm, name + " should contain property oneofs");
-    
+
     for (var f in pm.fields) {
         assertIsProtoField(pm.fields[f], name + ".fields." + f);
     }
@@ -224,7 +224,7 @@ function assertIsProtoService(ps: ProtoBuf.ProtoService, name: string) {
     assert.ok("name" in ps, name + " should contain property name");
     assert.ok("rpc" in ps, name + " should contain property rpc");
     assert.ok("options" in ps, name + " should contain property options");
-    
+
     for (var rpc in ps.rpc) {
       assertIsProtoRpcService(ps.rpc[rpc], name + ".rpc." + rpc);
     }
@@ -237,14 +237,14 @@ function assertIsReflect(r: ProtoBuf.Reflect, name: string) {
     assert.ok("Enum" in r, name + " should contain property Enum");
     assert.ok("Extension" in r, name + " should contain property Extension");
     assert.ok("Service" in r, name + " should contain property Service");
-    
+
     assertIsT(new ProtoBuf.Reflect.T(), "new ProtoBuf.Reflect.T()");
     assertIsNamespace(new ProtoBuf.Reflect.Namespace(), "new ProtoBuf.Reflect.Namespace()");
     assertIsMessage(new ProtoBuf.Reflect.Message(), "new ProtoBuf.Reflect.Message()");
     assertIsEnum(new ProtoBuf.Reflect.Enum(), "new ProtoBuf.Reflect.Enum()");
     assertIsExtension(new ProtoBuf.Reflect.Extension(), "new ProtoBuf.Reflect.Extension()");
     assertIsService(new ProtoBuf.Reflect.Service(), "new ProtoBuf.Reflect.Service()");
-    
+
     assertIsValue(new ProtoBuf.Reflect.Enum.Value(), "new ProtoBuf.Reflect.Enum.Value()");
     assertIsOneOf(new ProtoBuf.Reflect.Message.OneOf(), "new ProtoBuf.Reflect.Message.OneOf()");
     assertIsMethod(new ProtoBuf.Reflect.Service.Method(), "new ProtoBuf.Reflect.Service.Method()");
@@ -255,7 +255,7 @@ function assertIsReflect(r: ProtoBuf.Reflect, name: string) {
 function assertIsT(t: ProtoBuf.ReflectT, name: string) {
     if (t != null && t != undefined) {
         assertIsTNoRecursion(t, name);
-    
+
         assertIsProtoBuilder(t.builder, name + ".builder");
         assertIsTNoRecursion(t.parent, name + ".parent");
     }
@@ -273,9 +273,9 @@ function assertIsTNoRecursion(t: ProtoBuf.ReflectT, name: string) {
 
 function assertIsNamespace(ns: ProtoBuf.ReflectNamespace, name: string) {
     assertIsNamespaceNoRecursion(ns, name);
-    
+
     assertIsT(ns, name);
-    
+
     for (var child in ns.children) {
         assertIsT(ns.children[child], name + ".children." + child);
     }
@@ -308,7 +308,7 @@ function assertIsMessage(m: ProtoBuf.ReflectMessage, name: string) {
         assert.ok("encode" in m, name + " should contain property encode");
         assert.ok("calculate" in m, name + " should contain property calculate");
         assert.ok("decode" in m, name + " should contain property decode");
-        
+
         assertIsNamespace(m, name);
     }
 }
@@ -316,22 +316,22 @@ function assertIsMessage(m: ProtoBuf.ReflectMessage, name: string) {
 function assertIsEnum(e: ProtoBuf.ReflectEnum, name: string) {
     assert.ok("object" in e, name + " should contain property object");
     assert.ok("build" in e, name + " should contain property build");
-    
+
     assertIsNamespace(e, name);
 }
 
 function assertIsExtension(e: ProtoBuf.ReflectExtension, name: string) {
     assert.ok("field" in e, name + " should contain property field");
-    
+
     assertIsT(e, name);
-    
+
     assertIsField(e.field, name + ".field");
 }
 
 function assertIsService(s: ProtoBuf.ReflectService, name: string) {
     assert.ok("clazz" in s, name + " should contain property clazz");
     assert.ok("build" in s, name + " should contain property build");
-    
+
     assertIsNamespace(s, name);
 }
 
@@ -355,9 +355,9 @@ function assertIsField(f: ProtoBuf.ReflectField, name: string) {
         assert.ok("calculate" in f, name + " should contain property calculate");
         assert.ok("calculateValue" in f, name + " should contain property calculateValue");
         assert.ok("decode" in f, name + " should contain property decode");
-        
+
         assertIsT(f, name);
-        
+
         assertIsT(f.resolvedType, name + ".resolvedType");
         assertIsOneOf(f.oneof, name + ".oneof");
     }
@@ -370,15 +370,15 @@ function assertIsWireTuple(wt: ProtoBuf.WireTuple, name: string) {
 
 function assertIsExtensionField(ef: ProtoBuf.ReflectExtensionField, name: string) {
     assert.ok("extension" in ef, name + " should contain property extension");
-    
+
     assertIsField(ef, name);
-    
+
     assertIsExtension(ef.extension, name + ".extension");
 }
 
 function assertIsOneOf(oo: ProtoBuf.ReflectOneOf, name: string) {
     assert.ok("fields" in oo, name + " should contain property fields");
-    
+
     for (var f in oo.fields) {
         assertIsField(oo.fields[f], name + ".fields." + f);
     }
@@ -387,7 +387,7 @@ function assertIsOneOf(oo: ProtoBuf.ReflectOneOf, name: string) {
 function assertIsValue(v: ProtoBuf.ReflectValue, name: string) {
     assert.ok("className" in v, name + " should contain property className");
     assert.ok("id" in v, name + " should contain property id");
-    
+
     assertIsT(v, name);
 }
 
@@ -395,7 +395,7 @@ function assertIsMethod(m: ProtoBuf.ReflectMethod, name: string) {
     assert.ok("className" in m, name + " should contain property className");
     assert.ok("options" in m, name + " should contain property options");
     assert.ok("buildOpt" in m, name + " should contain property buildOpt");
-    
+
     assertIsT(m, name);
 }
 
@@ -405,9 +405,9 @@ function assertIsRPCMethod(rpc: ProtoBuf.ReflectRPCMethod, name: string) {
     assert.ok("resolvedRequestType" in rpc, name + " should contain property resolvedRequestType");
     assert.ok("resolvedResponseType" in rpc,
         name + " should contain property resolvedResponseType");
-        
+
     assertIsMethod(rpc, name);
-        
+
     assertIsMessage(rpc.resolvedRequestType, name + ".resolvedRequestType");
     assertIsMessage(rpc.resolveResponseType, name + ".resolvedResponsetype");
 }
@@ -415,4 +415,4 @@ function assertIsRPCMethod(rpc: ProtoBuf.ReflectRPCMethod, name: string) {
 testProtoBufJs();
 testBuilderJs();
 testDotProtoJs();
-testReflectJs();
\ No newline at end of file
+testReflectJs();
diff --git a/q-retry/q-retry-tests.ts b/q-retry/q-retry-tests.ts
index e5d5dd8ca6..fc33d7ba97 100644
--- a/q-retry/q-retry-tests.ts
+++ b/q-retry/q-retry-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./q-retry.d.ts" />
+
 import Q = require('q-retry');
 
 Q
@@ -9,7 +11,7 @@ Q
         return 0;
     })
     .retry(num => {
-        num.toFixed;    
+        num.toFixed;
     })
     .retry(() => {
 
@@ -32,8 +34,8 @@ Q
         limit: 10,
         interval: 1000,
         maxInterval: 20000,
-        intervalMultiplier: 1.5    
+        intervalMultiplier: 1.5
     })
     .then(str => {
         str.charAt;
-    });
\ No newline at end of file
+    });
diff --git a/qs/qs-tests.ts b/qs/qs-tests.ts
new file mode 100644
index 0000000000..04be4f266b
--- /dev/null
+++ b/qs/qs-tests.ts
@@ -0,0 +1,9 @@
+/// <reference path="./qs.d.ts" />
+
+import qs = require('qs');
+
+qs.stringify({ a: 'b' });
+qs.stringify({ a: 'b', c: 'd' }, { delimiter: '&' });
+
+qs.parse('a=b');
+qs.parse('a=b&c=d', { delimiter: '&' });
diff --git a/qs/qs.d.ts b/qs/qs.d.ts
new file mode 100644
index 0000000000..5889fae499
--- /dev/null
+++ b/qs/qs.d.ts
@@ -0,0 +1,35 @@
+// Type definitions for qs
+// Project: https://github.com/hapijs/qs
+// Definitions by: Roman Korneev <https://github.com/RWander>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module QueryString {
+    interface IStringifyOptions {
+        delimiter?: string;
+        strictNullHandling?: boolean;
+        skipNulls?: boolean;
+        encode?: boolean;
+        filter?: any;
+        arrayFormat?: any;
+        indices?: string;
+    }
+
+    interface IParseOptions {
+        delimiter?: string;
+        depth?: number;
+        arrayLimit?: number;
+        parseArrays?: boolean;
+        allowDots?: boolean;
+        plainObjects?: boolean;
+        allowPrototypes?: boolean;
+        parameterLimit?: number;
+        strictNullHandling?: boolean;
+    }
+
+    function stringify(obj: any, options?: IStringifyOptions): string;
+    function parse(str: string, options?: IParseOptions): any;
+}
+
+declare module "qs" {
+	export = QueryString;
+}
diff --git a/rangy/rangy-tests.ts b/rangy/rangy-tests.ts
new file mode 100644
index 0000000000..b0c6c1cc27
--- /dev/null
+++ b/rangy/rangy-tests.ts
@@ -0,0 +1,95 @@
+/// <reference path="rangy.d.ts" />
+
+declare function assertAny(a:any):any;
+declare function assertBoolean(b:boolean):any;
+declare function assertString(s:string):any;
+declare function assertRangyRange(r:RangyRange):any;
+declare function getRangyRange():RangyRange;
+
+function testRangyStatic() {
+    rangy.addInitListener((rangy:RangyStatic) => {
+    });
+
+    rangy.createMissingNativeApi();
+    rangy.shim();
+
+    let nativeRange:Range|TextRange = rangy.createNativeRange(document);
+    nativeRange = rangy.createNativeRange(window);
+    nativeRange = rangy.createNativeRange(new HTMLIFrameElement);
+    nativeRange = rangy.createNativeRange();
+
+    let rangyRange:RangyRange = rangy.createRange(document);
+    rangyRange = rangy.createRange(window);
+    rangyRange = rangy.createRange(new HTMLIFrameElement);
+    rangyRange = rangy.createRange();
+
+    rangyRange = rangy.createRangyRange(document);
+    rangyRange = rangy.createRangyRange(window);
+    rangyRange = rangy.createRangyRange(new HTMLIFrameElement);
+    rangyRange = rangy.createRangyRange();
+
+    let nativeSelection:Selection = rangy.getNativeSelection(window);
+    nativeSelection = rangy.getNativeSelection();
+
+    let rangySelection:RangySelection = rangy.getSelection();
+
+    let initialized:boolean = rangy.initialized;
+    let supported:boolean = rangy.supported;
+}
+
+function testRangyRange() {
+    let rangyRange:RangyRange = rangy.createRange();
+
+    assertBoolean(rangyRange.canSurroundContents());
+    rangyRange.collapseAfter(new Node);
+    rangyRange.collapseBefore(new Node);
+    rangyRange.collapseToPoint(new Node, 23);
+    assertAny(rangyRange.compareNode(new Node));
+    assertBoolean(rangyRange.containsNode(new Node, true));
+    assertBoolean(rangyRange.containsNodeContents(new Node));
+    assertBoolean(rangyRange.containsNodeText(new Node));
+    assertBoolean(rangyRange.containsNodeText(new Node));
+    assertBoolean(rangyRange.containsRange(rangyRange));
+    assertBoolean(rangyRange.equals(rangyRange));
+    let bookmark:{start:number, end:number} = rangyRange.getBookmark();
+    bookmark = rangyRange.getBookmark(new Node);
+    let doc:Document = rangyRange.getDocument();
+    let nodes:Node[] = rangyRange.getNodes();
+    nodes = rangyRange.getNodes([new Node]);
+    nodes = rangyRange.getNodes([new Node], (node:Node) => true);
+    assertString(rangyRange.inspect());
+    assertRangyRange(rangyRange.intersection(rangyRange));
+    assertBoolean(rangyRange.intersectsOrTouchesRange(rangyRange));
+    assertBoolean(rangyRange.intersectsRange(rangyRange));
+    assertBoolean(rangyRange.isValid());
+    rangyRange.moveToBookmark({});
+    rangyRange.normalizeBoundaries();
+    rangyRange.refresh();
+    rangyRange.select();
+    rangyRange.setStartAndEnd(new Node, 23);
+    rangyRange.setStartAndEnd(new Node, 23, 42);
+    rangyRange.setStartAndEnd(new Node, 23, new Node, 42);
+    rangyRange.splitBoundaries();
+    assertString(rangyRange.toHtml());
+    assertRangyRange(rangyRange.union(rangyRange));
+}
+
+function testSelection() {
+    let selection:RangySelection = rangy.getSelection();
+
+    selection.detach();
+    let ranges:RangyRange[] = selection.getAllRanges();
+    selection.getBookmark(new Node);
+    let nativeTextRange:TextRange = selection.getNativeTextRange();
+    assertString(selection.inspect());
+    assertBoolean(selection.isBackwards());
+    selection.moveToBookmark({});
+    var nativeSelection:Selection = selection.nativeSelection;
+    selection.refresh();
+    selection.refresh(true);
+    selection.restoreRanges({});
+    var object:Object = selection.saveRanges();
+    selection.setRanges(ranges);
+    selection.setSingleRange(getRangyRange());
+    assertString(selection.toHtml());
+}
diff --git a/rangy/rangy.d.ts b/rangy/rangy.d.ts
new file mode 100644
index 0000000000..16ce2a5a3d
--- /dev/null
+++ b/rangy/rangy.d.ts
@@ -0,0 +1,66 @@
+// Type definitions for Rangy
+// Project: https://github.com/timdown/rangy
+// Definitions by: Rudolph Gottesheim <http://www.midnight-design.at/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface RangyRange extends Range {
+    setStartAndEnd(startNode:Node, startOffset:number, endNode?:Node, endOffset?:number):any;
+    setStartAndEnd(startNode:Node, startOffset:number, endOffset:number):any;
+    canSurroundContents():boolean;
+    isValid():boolean;
+    toHtml():string;
+    compareNode(node:Node):any;
+    intersectsOrTouchesRange(range:RangyRange):boolean;
+    intersectsRange(range:RangyRange):boolean;
+    intersection(range:RangyRange):RangyRange;
+    union(range:RangyRange):RangyRange;
+    containsNode(node:Node, partial:boolean):boolean;
+    containsNodeContents(node:Node):boolean;
+    containsNodeText(node:Node):boolean;
+    containsRange(range:RangyRange):boolean;
+    splitBoundaries():any;
+    normalizeBoundaries():any;
+    collapseToPoint(node:Node, offset:number):any;
+    collapseBefore(node:Node):any;
+    collapseAfter(node:Node):any;
+    getNodes(nodeTypes?:any[], filter?:(node:Node) => boolean):Node[];
+    getBookmark(containerNode?:Node):{start:number, end:number};
+    moveToBookmark(bookmark:Object):any;
+    getDocument():Document;
+    inspect():string;
+    equals(range:RangyRange):boolean;
+    refresh():any;
+    select():any;
+}
+
+interface RangySelection extends Selection {
+    nativeSelection:Selection;
+    isBackwards():boolean;
+    refresh(checkForChanges?:boolean):any;
+    toHtml():string;
+    getAllRanges():RangyRange[];
+    getNativeTextRange():TextRange;
+    setSingleRange(range:RangyRange):any;
+    setRanges(ranges:RangyRange[]):any;
+    getBookmark(containerNode:Node):any;
+    moveToBookmark(bookmark:Object):any;
+    saveRanges():Object;
+    restoreRanges(saved:Object):any;
+    detach():any;
+    inspect():string;
+}
+
+interface RangyStatic {
+    createNativeRange(doc?:Document|Window|HTMLIFrameElement):TextRange|Range;
+    createRange(doc?:Document|Window|HTMLIFrameElement):RangyRange;
+    createRangyRange(doc?:Document|Window|HTMLIFrameElement):RangyRange;
+    getNativeSelection(win?:Window):Selection;
+    getSelection():RangySelection;
+    addInitListener(listener:(rangy:RangyStatic) => void):any;
+    shim():any;
+    createMissingNativeApi():any;
+    initialized:boolean;
+    supported:boolean;
+}
+
+declare var rangy:RangyStatic;
diff --git a/react-router/react-router.d.ts b/react-router/react-router.d.ts
index f43f56484a..4cebcfab36 100644
--- a/react-router/react-router.d.ts
+++ b/react-router/react-router.d.ts
@@ -4,7 +4,6 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 ///<reference path='../react/react.d.ts' />
-///<reference path='../react/react-addons.d.ts' />
 
 declare module ReactRouter {
     import React = __React;
@@ -114,13 +113,12 @@ declare module ReactRouter {
     // Components
     // ----------------------------------------------------------------------
     // Link
-    interface LinkProp {
+    interface LinkProp extends React.HTMLAttributes {
         activeClassName?: string;
         activeStyle?: {};
         to: string;
         params?: {};
         query?: {};
-        onClick?: Function;
     }
     interface Link extends React.ReactElement<LinkProp>, Navigation, State {
         handleClick(event: any): void;
diff --git a/react/README.md b/react/README.md
index 1f4cb7f036..b7ff4b55e6 100644
--- a/react/README.md
+++ b/react/README.md
@@ -1,11 +1,5 @@
 # React v0.13.3 Type Definitions
 
 This folder contains the following `.d.ts` files:
-* `react.d.ts` declares the external module `"react"`
-* `react-addons.d.ts` declares the external module `"react/addons"`
-* `react-global.d.ts` declares the internal module `React` in the global namespace
-* `react-addons-global.d.ts` extends the global `React` module with `addons`
-
-Interfaces are duplicated between these files; please take care to keep them in sync when making changes.
-See [#3615](https://github.com/borisyankov/DefinitelyTyped/pull/3615) for relevant discussion.
-
+* `react.d.ts` declares the module `"react"` and `"react/addons"`
+* `react-global.d.ts` declares the global namespace `React` (only include this if you are actually using the global `React`)
diff --git a/react/react-addons-global.d.ts b/react/react-addons-global.d.ts
deleted file mode 100644
index 508ae05225..0000000000
--- a/react/react-addons-global.d.ts
+++ /dev/null
@@ -1,278 +0,0 @@
-// Type definitions for ReactWithAddons v0.13.1 (internal module)
-// Project: http://facebook.github.io/react/
-// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-/// <reference path="react-global.d.ts" />
-
-declare module React {
-    //
-    // React.addons
-    // ----------------------------------------------------------------------
-
-    export module addons {
-        export var CSSTransitionGroup: CSSTransitionGroup;
-        export var TransitionGroup: TransitionGroup;
-
-        export var LinkedStateMixin: LinkedStateMixin;
-        export var PureRenderMixin: PureRenderMixin;
-
-        export function batchedUpdates<A, B>(
-            callback: (a: A, b: B) => any, a: A, b: B): void;
-        export function batchedUpdates<A>(callback: (a: A) => any, a: A): void;
-        export function batchedUpdates(callback: () => any): void;
-
-        // deprecated: use petehunt/react-classset or JedWatson/classnames
-        export function classSet(cx: { [key: string]: boolean }): string;
-        export function classSet(...classList: string[]): string;
-
-        export function cloneWithProps<P>(
-            element: DOMElement<P>, props: P): DOMElement<P>;
-        export function cloneWithProps<P>(
-            element: ClassicElement<P>, props: P): ClassicElement<P>;
-        export function cloneWithProps<P>(
-            element: ReactElement<P>, props: P): ReactElement<P>;
-
-        export function createFragment(
-            object: { [key: string]: ReactNode }): ReactFragment;
-
-        export function update(value: any[], spec: UpdateArraySpec): any[];
-        export function update(value: {}, spec: UpdateSpec): any;
-
-        // Development tools
-        export import Perf = ReactPerf;
-        export import TestUtils = ReactTestUtils;
-    }
-
-    //
-    // React.addons (Transitions)
-    // ----------------------------------------------------------------------
-
-    interface TransitionGroupProps {
-        component?: ReactType;
-        childFactory?: (child: ReactElement<any>) => ReactElement<any>;
-    }
-
-    interface CSSTransitionGroupProps extends TransitionGroupProps {
-        transitionName: string;
-        transitionAppear?: boolean;
-        transitionEnter?: boolean;
-        transitionLeave?: boolean;
-    }
-
-    type CSSTransitionGroup = ComponentClass<CSSTransitionGroupProps>;
-    type TransitionGroup = ComponentClass<TransitionGroupProps>;
-
-    //
-    // React.addons (Mixins)
-    // ----------------------------------------------------------------------
-
-    interface ReactLink<T> {
-        value: T;
-        requestChange(newValue: T): void;
-    }
-
-    interface LinkedStateMixin extends Mixin<any, any> {
-        linkState<T>(key: string): ReactLink<T>;
-    }
-
-    interface PureRenderMixin extends Mixin<any, any> {
-    }
-
-    //
-    // Reat.addons.update
-    // ----------------------------------------------------------------------
-
-    interface UpdateSpec {
-        $set?: any;
-        $merge?: {};
-        $apply?(value: any): any;
-        // [key: string]: UpdateSpec;
-    }
-
-    interface UpdateArraySpec extends UpdateSpec {
-        $push?: any[];
-        $unshift?: any[];
-        $splice?: any[][];
-    }
-
-    //
-    // React.addons.Perf
-    // ----------------------------------------------------------------------
-
-    interface ComponentPerfContext {
-        current: string;
-        owner: string;
-    }
-
-    interface NumericPerfContext {
-        [key: string]: number;
-    }
-
-    interface Measurements {
-        exclusive: NumericPerfContext;
-        inclusive: NumericPerfContext;
-        render: NumericPerfContext;
-        counts: NumericPerfContext;
-        writes: NumericPerfContext;
-        displayNames: {
-            [key: string]: ComponentPerfContext;
-        };
-        totalTime: number;
-    }
-
-    module ReactPerf {
-        export function start(): void;
-        export function stop(): void;
-        export function printInclusive(measurements: Measurements[]): void;
-        export function printExclusive(measurements: Measurements[]): void;
-        export function printWasted(measurements: Measurements[]): void;
-        export function printDOM(measurements: Measurements[]): void;
-        export function getLastMeasurements(): Measurements[];
-    }
-
-    //
-    // React.addons.TestUtils
-    // ----------------------------------------------------------------------
-
-    interface MockedComponentClass {
-        new(): any;
-    }
-
-    module ReactTestUtils {
-        export import Simulate = ReactSimulate;
-
-        export function renderIntoDocument<P>(
-            element: ReactElement<P>): Component<P, any>;
-        export function renderIntoDocument<C extends Component<any, any>>(
-            element: ReactElement<any>): C;
-
-        export function mockComponent(
-            mocked: MockedComponentClass, mockTagName?: string): typeof ReactTestUtils;
-
-        export function isElementOfType(
-            element: ReactElement<any>, type: ReactType): boolean;
-        export function isTextComponent(instance: Component<any, any>): boolean;
-        export function isDOMComponent(instance: Component<any, any>): boolean;
-        export function isCompositeComponent(instance: Component<any, any>): boolean;
-        export function isCompositeComponentWithType(
-            instance: Component<any, any>,
-            type: ComponentClass<any>): boolean;
-
-        export function findAllInRenderedTree(
-            tree: Component<any, any>,
-            fn: (i: Component<any, any>) => boolean): Component<any, any>;
-
-        export function scryRenderedDOMComponentsWithClass(
-            tree: Component<any, any>,
-            className: string): DOMComponent<any>[];
-        export function findRenderedDOMComponentWithClass(
-            tree: Component<any, any>,
-            className: string): DOMComponent<any>;
-
-        export function scryRenderedDOMComponentsWithTag(
-            tree: Component<any, any>,
-            tagName: string): DOMComponent<any>[];
-        export function findRenderedDOMComponentWithTag(
-            tree: Component<any, any>,
-            tagName: string): DOMComponent<any>;
-
-        export function scryRenderedComponentsWithType<P>(
-            tree: Component<any, any>,
-            type: ComponentClass<P>): Component<P, {}>[];
-        export function scryRenderedComponentsWithType<C extends Component<any, any>>(
-            tree: Component<any, any>,
-            type: ComponentClass<any>): C[];
-
-        export function findRenderedComponentWithType<P>(
-            tree: Component<any, any>,
-            type: ComponentClass<P>): Component<P, {}>;
-        export function findRenderedComponentWithType<C extends Component<any, any>>(
-            tree: Component<any, any>,
-            type: ComponentClass<any>): C;
-
-        export function createRenderer(): ShallowRenderer;
-    }
-
-    interface SyntheticEventData {
-        altKey?: boolean;
-        button?: number;
-        buttons?: number;
-        clientX?: number;
-        clientY?: number;
-        changedTouches?: TouchList;
-        charCode?: boolean;
-        clipboardData?: DataTransfer;
-        ctrlKey?: boolean;
-        deltaMode?: number;
-        deltaX?: number;
-        deltaY?: number;
-        deltaZ?: number;
-        detail?: number;
-        getModifierState?(key: string): boolean;
-        key?: string;
-        keyCode?: number;
-        locale?: string;
-        location?: number;
-        metaKey?: boolean;
-        pageX?: number;
-        pageY?: number;
-        relatedTarget?: EventTarget;
-        repeat?: boolean;
-        screenX?: number;
-        screenY?: number;
-        shiftKey?: boolean;
-        targetTouches?: TouchList;
-        touches?: TouchList;
-        view?: AbstractView;
-        which?: number;
-    }
-
-    interface EventSimulator {
-        (element: Element, eventData?: SyntheticEventData): void;
-        (component: Component<any, any>, eventData?: SyntheticEventData): void;
-    }
-
-    module ReactSimulate {
-        export var blur: EventSimulator;
-        export var change: EventSimulator;
-        export var click: EventSimulator;
-        export var cut: EventSimulator;
-        export var doubleClick: EventSimulator;
-        export var drag: EventSimulator;
-        export var dragEnd: EventSimulator;
-        export var dragEnter: EventSimulator;
-        export var dragExit: EventSimulator;
-        export var dragLeave: EventSimulator;
-        export var dragOver: EventSimulator;
-        export var dragStart: EventSimulator;
-        export var drop: EventSimulator;
-        export var focus: EventSimulator;
-        export var input: EventSimulator;
-        export var keyDown: EventSimulator;
-        export var keyPress: EventSimulator;
-        export var keyUp: EventSimulator;
-        export var mouseDown: EventSimulator;
-        export var mouseEnter: EventSimulator;
-        export var mouseLeave: EventSimulator;
-        export var mouseMove: EventSimulator;
-        export var mouseOut: EventSimulator;
-        export var mouseOver: EventSimulator;
-        export var mouseUp: EventSimulator;
-        export var paste: EventSimulator;
-        export var scroll: EventSimulator;
-        export var submit: EventSimulator;
-        export var touchCancel: EventSimulator;
-        export var touchEnd: EventSimulator;
-        export var touchMove: EventSimulator;
-        export var touchStart: EventSimulator;
-        export var wheel: EventSimulator;
-    }
-
-    class ShallowRenderer {
-        getRenderOutput<E extends ReactElement<any>>(): E;
-        getRenderOutput(): ReactElement<any>;
-        render(element: ReactElement<any>, context?: any): void;
-        unmount(): void;
-    }
-}
-
diff --git a/react/react-addons-tests.ts b/react/react-addons-tests.ts
index 6976d9959d..245cb78d8d 100644
--- a/react/react-addons-tests.ts
+++ b/react/react-addons-tests.ts
@@ -1,4 +1,4 @@
-/// <reference path="react-addons.d.ts" />
+/// <reference path="react.d.ts" />
 import React = require("react/addons");
 
 import TestUtils = React.addons.TestUtils;
@@ -57,9 +57,10 @@ var ClassicComponent: React.ClassicComponentClass<Props> =
                 seconds: this.props.foo
             };
         },
-        reset: () => {
-            this.replaceState(this.getInitialState());
-        },
+        // NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
+        // reset: () => {
+        //     this.replaceState(this.getInitialState());
+        // },
         render: () => {
             return React.DOM.div(null,
                 React.DOM.input({
@@ -71,32 +72,32 @@ var ClassicComponent: React.ClassicComponentClass<Props> =
 
 class ModernComponent extends React.Component<Props, State>
     implements React.ChildContextProvider<ChildContext> {
-    
+
     static propTypes: React.ValidationMap<Props> = {
         foo: React.PropTypes.number
     }
-    
+
     static contextTypes: React.ValidationMap<Context> = {
         someValue: React.PropTypes.string
     }
-    
+
     static childContextTypes: React.ValidationMap<ChildContext> = {
         someOtherValue: React.PropTypes.string
     }
-    
+
     context: Context;
-    
+
     getChildContext() {
         return {
             someOtherValue: 'foo'
         }
     }
-    
+
     state = {
         inputValue: this.context.someValue,
         seconds: this.props.foo
     }
-    
+
     reset() {
         this.setState({
             inputValue: this.context.someValue,
@@ -105,7 +106,7 @@ class ModernComponent extends React.Component<Props, State>
     }
 
     private _input: React.HTMLComponent;
-    
+
     render() {
         return React.DOM.div(null,
             React.DOM.input({
@@ -206,7 +207,7 @@ myComponent.reset();
 // --------------------------------------------------------------------------
 
 var children: any[] = ["Hello world", [null], React.DOM.span(null)];
-var divStyle = { // CSSProperties
+var divStyle: React.CSSProperties = { // CSSProperties
     flex: "1 1 main-size",
     backgroundImage: "url('hello.png')"
 };
diff --git a/react/react-addons.d.ts b/react/react-addons.d.ts
deleted file mode 100644
index 822f370b8e..0000000000
--- a/react/react-addons.d.ts
+++ /dev/null
@@ -1,1054 +0,0 @@
-// Type definitions for ReactWithAddons v0.13.1 (external module)
-// Project: http://facebook.github.io/react/
-// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-declare module "react/addons" {
-    //
-    // React Elements
-    // ----------------------------------------------------------------------
-
-    type ReactType = ComponentClass<any> | string;
-
-    interface ReactElement<P> {
-        type: string | ComponentClass<P>;
-        props: P;
-        key: string | number;
-        ref: string | ((component: Component<P, any>) => any);
-    }
-
-    interface ClassicElement<P> extends ReactElement<P> {
-        type: string | ClassicComponentClass<P>;
-        ref: string | ((component: ClassicComponent<P, any>) => any);
-    }
-
-    interface DOMElement<P> extends ClassicElement<P> {
-        type: string;
-        ref: string | ((component: DOMComponent<P>) => any);
-    }
-
-    type HTMLElement = DOMElement<HTMLAttributes>;
-    type SVGElement = DOMElement<SVGAttributes>;
-
-    //
-    // Factories
-    // ----------------------------------------------------------------------
-
-    interface Factory<P> {
-        (props?: P, ...children: ReactNode[]): ReactElement<P>;
-    }
-
-    interface ClassicFactory<P> extends Factory<P> {
-        (props?: P, ...children: ReactNode[]): ClassicElement<P>;
-    }
-
-    interface DOMFactory<P> extends ClassicFactory<P> {
-        (props?: P, ...children: ReactNode[]): DOMElement<P>;
-    }
-
-    type HTMLFactory = DOMFactory<HTMLAttributes>;
-    type SVGFactory = DOMFactory<SVGAttributes>;
-
-    //
-    // React Nodes
-    // http://facebook.github.io/react/docs/glossary.html
-    // ----------------------------------------------------------------------
-
-    type ReactText = string | number;
-    type ReactChild = ReactElement<any> | ReactText;
-
-    // Should be Array<ReactNode> but type aliases cannot be recursive
-    type ReactFragment = {} | Array<ReactChild | any[] | boolean>;
-    type ReactNode = ReactChild | ReactFragment | boolean;
-
-    //
-    // Top Level API
-    // ----------------------------------------------------------------------
-
-    function createClass<P, S>(spec: ComponentSpec<P, S>): ClassicComponentClass<P>;
-
-    function createFactory<P>(type: string): DOMFactory<P>;
-    function createFactory<P>(type: ClassicComponentClass<P> | string): ClassicFactory<P>;
-    function createFactory<P>(type: ComponentClass<P>): Factory<P>;
-
-    function createElement<P>(
-        type: string,
-        props?: P,
-        ...children: ReactNode[]): DOMElement<P>;
-    function createElement<P>(
-        type: ClassicComponentClass<P> | string,
-        props?: P,
-        ...children: ReactNode[]): ClassicElement<P>;
-    function createElement<P>(
-        type: ComponentClass<P>,
-        props?: P,
-        ...children: ReactNode[]): ReactElement<P>;
-
-    function cloneElement<P>(
-        element: DOMElement<P>,
-        props?: P,
-        ...children: ReactNode[]): DOMElement<P>;
-    function cloneElement<P>(
-        element: ClassicElement<P>,
-        props?: P,
-        ...children: ReactNode[]): ClassicElement<P>;
-    function cloneElement<P>(
-        element: ReactElement<P>,
-        props?: P,
-        ...children: ReactNode[]): ReactElement<P>;
-
-    function render<P>(
-        element: DOMElement<P>,
-        container: Element,
-        callback?: () => any): DOMComponent<P>;
-    function render<P, S>(
-        element: ClassicElement<P>,
-        container: Element,
-        callback?: () => any): ClassicComponent<P, S>;
-    function render<P, S>(
-        element: ReactElement<P>,
-        container: Element,
-        callback?: () => any): Component<P, S>;
-
-    function unmountComponentAtNode(container: Element): boolean;
-    function renderToString(element: ReactElement<any>): string;
-    function renderToStaticMarkup(element: ReactElement<any>): string;
-    function isValidElement(object: {}): boolean;
-    function initializeTouchEvents(shouldUseTouch: boolean): void;
-
-    function findDOMNode<TElement extends Element>(
-        componentOrElement: Component<any, any> | Element): TElement;
-    function findDOMNode(
-        componentOrElement: Component<any, any> | Element): Element;
-
-    var DOM: ReactDOM;
-    var PropTypes: ReactPropTypes;
-    var Children: ReactChildren;
-
-    //
-    // Component API
-    // ----------------------------------------------------------------------
-
-    // Base component for plain JS classes
-    class Component<P, S> implements ComponentLifecycle<P, S> {
-        constructor(props?: P, context?: any);
-        setState(f: (prevState: S, props: P) => S, callback?: () => any): void;
-        setState(state: S, callback?: () => any): void;
-        forceUpdate(): void;
-        props: P;
-        state: S;
-        context: {};
-        refs: {
-            [key: string]: Component<any, any>
-        };
-    }
-
-    interface ClassicComponent<P, S> extends Component<P, S> {
-        replaceState(nextState: S, callback?: () => any): void;
-        getDOMNode<TElement extends Element>(): TElement;
-        getDOMNode(): Element;
-        isMounted(): boolean;
-        getInitialState?(): S;
-        setProps(nextProps: P, callback?: () => any): void;
-        replaceProps(nextProps: P, callback?: () => any): void;
-    }
-
-    interface DOMComponent<P> extends ClassicComponent<P, any> {
-        tagName: string;
-    }
-
-    type HTMLComponent = DOMComponent<HTMLAttributes>;
-    type SVGComponent = DOMComponent<SVGAttributes>;
-
-    interface ChildContextProvider<CC> {
-        getChildContext(): CC;
-    }
-
-    //
-    // Class Interfaces
-    // ----------------------------------------------------------------------
-
-    interface ComponentClass<P> {
-        new(props?: P, context?: any): Component<P, any>;
-        propTypes?: ValidationMap<P>;
-        contextTypes?: ValidationMap<any>;
-        childContextTypes?: ValidationMap<any>;
-        defaultProps?: P;
-    }
-
-    interface ClassicComponentClass<P> extends ComponentClass<P> {
-        new(props?: P, context?: any): ClassicComponent<P, any>;
-        getDefaultProps?(): P;
-        displayName?: string;
-    }
-
-    //
-    // Component Specs and Lifecycle
-    // ----------------------------------------------------------------------
-
-    interface ComponentLifecycle<P, S> {
-        componentWillMount?(): void;
-        componentDidMount?(): void;
-        componentWillReceiveProps?(nextProps: P, nextContext: any): void;
-        shouldComponentUpdate?(nextProps: P, nextState: S, nextContext: any): boolean;
-        componentWillUpdate?(nextProps: P, nextState: S, nextContext: any): void;
-        componentDidUpdate?(prevProps: P, prevState: S, prevContext: any): void;
-        componentWillUnmount?(): void;
-    }
-
-    interface Mixin<P, S> extends ComponentLifecycle<P, S> {
-        mixins?: Mixin<P, S>;
-        statics?: {
-            [key: string]: any;
-        };
-
-        displayName?: string;
-        propTypes?: ValidationMap<any>;
-        contextTypes?: ValidationMap<any>;
-        childContextTypes?: ValidationMap<any>
-
-        getDefaultProps?(): P;
-        getInitialState?(): S;
-    }
-
-    interface ComponentSpec<P, S> extends Mixin<P, S> {
-        render(): ReactElement<any>;
-    }
-
-    //
-    // Event System
-    // ----------------------------------------------------------------------
-
-    interface SyntheticEvent {
-        bubbles: boolean;
-        cancelable: boolean;
-        currentTarget: EventTarget;
-        defaultPrevented: boolean;
-        eventPhase: number;
-        isTrusted: boolean;
-        nativeEvent: Event;
-        preventDefault(): void;
-        stopPropagation(): void;
-        target: EventTarget;
-        timeStamp: Date;
-        type: string;
-    }
-
-    interface DragEvent extends SyntheticEvent {
-        dataTransfer: DataTransfer;
-    }
-
-    interface ClipboardEvent extends SyntheticEvent {
-        clipboardData: DataTransfer;
-    }
-
-    interface KeyboardEvent extends SyntheticEvent {
-        altKey: boolean;
-        charCode: number;
-        ctrlKey: boolean;
-        getModifierState(key: string): boolean;
-        key: string;
-        keyCode: number;
-        locale: string;
-        location: number;
-        metaKey: boolean;
-        repeat: boolean;
-        shiftKey: boolean;
-        which: number;
-    }
-
-    interface FocusEvent extends SyntheticEvent {
-        relatedTarget: EventTarget;
-    }
-
-    interface FormEvent extends SyntheticEvent {
-    }
-
-    interface MouseEvent extends SyntheticEvent {
-        altKey: boolean;
-        button: number;
-        buttons: number;
-        clientX: number;
-        clientY: number;
-        ctrlKey: boolean;
-        getModifierState(key: string): boolean;
-        metaKey: boolean;
-        pageX: number;
-        pageY: number;
-        relatedTarget: EventTarget;
-        screenX: number;
-        screenY: number;
-        shiftKey: boolean;
-    }
-
-    interface TouchEvent extends SyntheticEvent {
-        altKey: boolean;
-        changedTouches: TouchList;
-        ctrlKey: boolean;
-        getModifierState(key: string): boolean;
-        metaKey: boolean;
-        shiftKey: boolean;
-        targetTouches: TouchList;
-        touches: TouchList;
-    }
-
-    interface UIEvent extends SyntheticEvent {
-        detail: number;
-        view: AbstractView;
-    }
-
-    interface WheelEvent extends SyntheticEvent {
-        deltaMode: number;
-        deltaX: number;
-        deltaY: number;
-        deltaZ: number;
-    }
-
-    //
-    // Event Handler Types
-    // ----------------------------------------------------------------------
-
-    interface EventHandler<E extends SyntheticEvent> {
-        (event: E): void;
-    }
-
-    interface DragEventHandler extends EventHandler<DragEvent> {}
-    interface ClipboardEventHandler extends EventHandler<ClipboardEvent> {}
-    interface KeyboardEventHandler extends EventHandler<KeyboardEvent> {}
-    interface FocusEventHandler extends EventHandler<FocusEvent> {}
-    interface FormEventHandler extends EventHandler<FormEvent> {}
-    interface MouseEventHandler extends EventHandler<MouseEvent> {}
-    interface TouchEventHandler extends EventHandler<TouchEvent> {}
-    interface UIEventHandler extends EventHandler<UIEvent> {}
-    interface WheelEventHandler extends EventHandler<WheelEvent> {}
-
-    //
-    // Props / DOM Attributes
-    // ----------------------------------------------------------------------
-
-    interface Props<T> {
-        children?: ReactNode;
-        key?: string | number;
-        ref?: string | ((component: T) => any);
-    }
-
-    interface DOMAttributes extends Props<DOMComponent<any>> {
-        onCopy?: ClipboardEventHandler;
-        onCut?: ClipboardEventHandler;
-        onPaste?: ClipboardEventHandler;
-        onKeyDown?: KeyboardEventHandler;
-        onKeyPress?: KeyboardEventHandler;
-        onKeyUp?: KeyboardEventHandler;
-        onFocus?: FocusEventHandler;
-        onBlur?: FocusEventHandler;
-        onChange?: FormEventHandler;
-        onInput?: FormEventHandler;
-        onSubmit?: FormEventHandler;
-        onClick?: MouseEventHandler;
-        onDoubleClick?: MouseEventHandler;
-        onDrag?: DragEventHandler;
-        onDragEnd?: DragEventHandler;
-        onDragEnter?: DragEventHandler;
-        onDragExit?: DragEventHandler;
-        onDragLeave?: DragEventHandler;
-        onDragOver?: DragEventHandler;
-        onDragStart?: DragEventHandler;
-        onDrop?: DragEventHandler;
-        onMouseDown?: MouseEventHandler;
-        onMouseEnter?: MouseEventHandler;
-        onMouseLeave?: MouseEventHandler;
-        onMouseMove?: MouseEventHandler;
-        onMouseOut?: MouseEventHandler;
-        onMouseOver?: MouseEventHandler;
-        onMouseUp?: MouseEventHandler;
-        onTouchCancel?: TouchEventHandler;
-        onTouchEnd?: TouchEventHandler;
-        onTouchMove?: TouchEventHandler;
-        onTouchStart?: TouchEventHandler;
-        onScroll?: UIEventHandler;
-        onWheel?: WheelEventHandler;
-
-        dangerouslySetInnerHTML?: {
-            __html: string;
-        };
-    }
-
-    // This interface is not complete. Only properties accepting
-    // unitless numbers are listed here (see CSSProperty.js in React)
-    interface CSSProperties {
-        boxFlex?: number;
-        boxFlexGroup?: number;
-        columnCount?: number;
-        flex?: number | string;
-        flexGrow?: number;
-        flexShrink?: number;
-        fontWeight?: number | string;
-        lineClamp?: number;
-        lineHeight?: number | string;
-        opacity?: number;
-        order?: number;
-        orphans?: number;
-        widows?: number;
-        zIndex?: number;
-        zoom?: number;
-
-        // SVG-related properties
-        fillOpacity?: number;
-        strokeOpacity?: number;
-        strokeWidth?: number;
-    }
-
-    interface HTMLAttributes extends DOMAttributes {
-        ref?: string | ((component: HTMLComponent) => void);
-
-        accept?: string;
-        acceptCharset?: string;
-        accessKey?: string;
-        action?: string;
-        allowFullScreen?: boolean;
-        allowTransparency?: boolean;
-        alt?: string;
-        async?: boolean;
-        autoComplete?: boolean;
-        autoFocus?: boolean;
-        autoPlay?: boolean;
-        cellPadding?: number | string;
-        cellSpacing?: number | string;
-        charSet?: string;
-        checked?: boolean;
-        classID?: string;
-        className?: string;
-        cols?: number;
-        colSpan?: number;
-        content?: string;
-        contentEditable?: boolean;
-        contextMenu?: string;
-        controls?: any;
-        coords?: string;
-        crossOrigin?: string;
-        data?: string;
-        dateTime?: string;
-        defaultChecked?: boolean;
-        defaultValue?: string;
-        defer?: boolean;
-        dir?: string;
-        disabled?: boolean;
-        download?: any;
-        draggable?: boolean;
-        encType?: string;
-        form?: string;
-        formAction?: string;
-        formEncType?: string;
-        formMethod?: string;
-        formNoValidate?: boolean;
-        formTarget?: string;
-        frameBorder?: number | string;
-        headers?: string;
-        height?: number | string;
-        hidden?: boolean;
-        high?: number;
-        href?: string;
-        hrefLang?: string;
-        htmlFor?: string;
-        httpEquiv?: string;
-        icon?: string;
-        id?: string;
-        label?: string;
-        lang?: string;
-        list?: string;
-        loop?: boolean;
-        low?: number;
-        manifest?: string;
-        marginHeight?: number;
-        marginWidth?: number;
-        max?: number | string;
-        maxLength?: number;
-        media?: string;
-        mediaGroup?: string;
-        method?: string;
-        min?: number | string;
-        multiple?: boolean;
-        muted?: boolean;
-        name?: string;
-        noValidate?: boolean;
-        open?: boolean;
-        optimum?: number;
-        pattern?: string;
-        placeholder?: string;
-        poster?: string;
-        preload?: string;
-        radioGroup?: string;
-        readOnly?: boolean;
-        rel?: string;
-        required?: boolean;
-        role?: string;
-        rows?: number;
-        rowSpan?: number;
-        sandbox?: string;
-        scope?: string;
-        scoped?: boolean;
-        scrolling?: string;
-        seamless?: boolean;
-        selected?: boolean;
-        shape?: string;
-        size?: number;
-        sizes?: string;
-        span?: number;
-        spellCheck?: boolean;
-        src?: string;
-        srcDoc?: string;
-        srcSet?: string;
-        start?: number;
-        step?: number | string;
-        style?: CSSProperties;
-        tabIndex?: number;
-        target?: string;
-        title?: string;
-        type?: string;
-        useMap?: string;
-        value?: string;
-        width?: number | string;
-        wmode?: string;
-
-        // Non-standard Attributes
-        autoCapitalize?: boolean;
-        autoCorrect?: boolean;
-        property?: string;
-        itemProp?: string;
-        itemScope?: boolean;
-        itemType?: string;
-        unselectable?: boolean;
-    }
-
-    interface SVGAttributes extends DOMAttributes {
-        ref?: string | ((component: SVGComponent) => void);
-
-        cx?: number | string;
-        cy?: number | string;
-        d?: string;
-        dx?: number | string;
-        dy?: number | string;
-        fill?: string;
-        fillOpacity?: number | string;
-        fontFamily?: string;
-        fontSize?: number | string;
-        fx?: number | string;
-        fy?: number | string;
-        gradientTransform?: string;
-        gradientUnits?: string;
-        height?: number | string;
-        markerEnd?: string;
-        markerMid?: string;
-        markerStart?: string;
-        offset?: number | string;
-        opacity?: number | string;
-        patternContentUnits?: string;
-        patternUnits?: string;
-        points?: string;
-        preserveAspectRatio?: string;
-        r?: number | string;
-        rx?: number | string;
-        ry?: number | string;
-        spreadMethod?: string;
-        stopColor?: string;
-        stopOpacity?: number | string;
-        stroke?: string;
-        strokeDasharray?: string;
-        strokeLinecap?: string;
-        strokeOpacity?: number | string;
-        strokeWidth?: number | string;
-        textAnchor?: string;
-        transform?: string;
-        version?: string;
-        viewBox?: string;
-        width?: number | string;
-        x1?: number | string;
-        x2?: number | string;
-        x?: number | string;
-        y1?: number | string;
-        y2?: number | string
-        y?: number | string;
-    }
-
-    //
-    // React.DOM
-    // ----------------------------------------------------------------------
-
-    interface ReactDOM {
-        // HTML
-        a: HTMLFactory;
-        abbr: HTMLFactory;
-        address: HTMLFactory;
-        area: HTMLFactory;
-        article: HTMLFactory;
-        aside: HTMLFactory;
-        audio: HTMLFactory;
-        b: HTMLFactory;
-        base: HTMLFactory;
-        bdi: HTMLFactory;
-        bdo: HTMLFactory;
-        big: HTMLFactory;
-        blockquote: HTMLFactory;
-        body: HTMLFactory;
-        br: HTMLFactory;
-        button: HTMLFactory;
-        canvas: HTMLFactory;
-        caption: HTMLFactory;
-        cite: HTMLFactory;
-        code: HTMLFactory;
-        col: HTMLFactory;
-        colgroup: HTMLFactory;
-        data: HTMLFactory;
-        datalist: HTMLFactory;
-        dd: HTMLFactory;
-        del: HTMLFactory;
-        details: HTMLFactory;
-        dfn: HTMLFactory;
-        dialog: HTMLFactory;
-        div: HTMLFactory;
-        dl: HTMLFactory;
-        dt: HTMLFactory;
-        em: HTMLFactory;
-        embed: HTMLFactory;
-        fieldset: HTMLFactory;
-        figcaption: HTMLFactory;
-        figure: HTMLFactory;
-        footer: HTMLFactory;
-        form: HTMLFactory;
-        h1: HTMLFactory;
-        h2: HTMLFactory;
-        h3: HTMLFactory;
-        h4: HTMLFactory;
-        h5: HTMLFactory;
-        h6: HTMLFactory;
-        head: HTMLFactory;
-        header: HTMLFactory;
-        hr: HTMLFactory;
-        html: HTMLFactory;
-        i: HTMLFactory;
-        iframe: HTMLFactory;
-        img: HTMLFactory;
-        input: HTMLFactory;
-        ins: HTMLFactory;
-        kbd: HTMLFactory;
-        keygen: HTMLFactory;
-        label: HTMLFactory;
-        legend: HTMLFactory;
-        li: HTMLFactory;
-        link: HTMLFactory;
-        main: HTMLFactory;
-        map: HTMLFactory;
-        mark: HTMLFactory;
-        menu: HTMLFactory;
-        menuitem: HTMLFactory;
-        meta: HTMLFactory;
-        meter: HTMLFactory;
-        nav: HTMLFactory;
-        noscript: HTMLFactory;
-        object: HTMLFactory;
-        ol: HTMLFactory;
-        optgroup: HTMLFactory;
-        option: HTMLFactory;
-        output: HTMLFactory;
-        p: HTMLFactory;
-        param: HTMLFactory;
-        picture: HTMLFactory;
-        pre: HTMLFactory;
-        progress: HTMLFactory;
-        q: HTMLFactory;
-        rp: HTMLFactory;
-        rt: HTMLFactory;
-        ruby: HTMLFactory;
-        s: HTMLFactory;
-        samp: HTMLFactory;
-        script: HTMLFactory;
-        section: HTMLFactory;
-        select: HTMLFactory;
-        small: HTMLFactory;
-        source: HTMLFactory;
-        span: HTMLFactory;
-        strong: HTMLFactory;
-        style: HTMLFactory;
-        sub: HTMLFactory;
-        summary: HTMLFactory;
-        sup: HTMLFactory;
-        table: HTMLFactory;
-        tbody: HTMLFactory;
-        td: HTMLFactory;
-        textarea: HTMLFactory;
-        tfoot: HTMLFactory;
-        th: HTMLFactory;
-        thead: HTMLFactory;
-        time: HTMLFactory;
-        title: HTMLFactory;
-        tr: HTMLFactory;
-        track: HTMLFactory;
-        u: HTMLFactory;
-        ul: HTMLFactory;
-        "var": HTMLFactory;
-        video: HTMLFactory;
-        wbr: HTMLFactory;
-
-        // SVG
-        circle: SVGFactory;
-        defs: SVGFactory;
-        ellipse: SVGFactory;
-        g: SVGFactory;
-        line: SVGFactory;
-        linearGradient: SVGFactory;
-        mask: SVGFactory;
-        path: SVGFactory;
-        pattern: SVGFactory;
-        polygon: SVGFactory;
-        polyline: SVGFactory;
-        radialGradient: SVGFactory;
-        rect: SVGFactory;
-        stop: SVGFactory;
-        svg: SVGFactory;
-        text: SVGFactory;
-        tspan: SVGFactory;
-    }
-
-    //
-    // React.PropTypes
-    // ----------------------------------------------------------------------
-
-    interface Validator<T> {
-        (object: T, key: string, componentName: string): Error;
-    }
-
-    interface Requireable<T> extends Validator<T> {
-        isRequired: Validator<T>;
-    }
-
-    interface ValidationMap<T> {
-        [key: string]: Validator<T>;
-    }
-
-    interface ReactPropTypes {
-        any: Requireable<any>;
-        array: Requireable<any>;
-        bool: Requireable<any>;
-        func: Requireable<any>;
-        number: Requireable<any>;
-        object: Requireable<any>;
-        string: Requireable<any>;
-        node: Requireable<any>;
-        element: Requireable<any>;
-        instanceOf(expectedClass: {}): Requireable<any>;
-        oneOf(types: any[]): Requireable<any>;
-        oneOfType(types: Validator<any>[]): Requireable<any>;
-        arrayOf(type: Validator<any>): Requireable<any>;
-        objectOf(type: Validator<any>): Requireable<any>;
-        shape(type: ValidationMap<any>): Requireable<any>;
-    }
-
-    //
-    // React.Children
-    // ----------------------------------------------------------------------
-
-    interface ReactChildren {
-        map<T>(children: ReactNode, fn: (child: ReactChild, index: number) => T): { [key:string]: T };
-        forEach(children: ReactNode, fn: (child: ReactChild, index: number) => any): void;
-        count(children: ReactNode): number;
-        only(children: ReactNode): ReactChild;
-    }
-
-    //
-    // React.addons
-    // ----------------------------------------------------------------------
-
-    export module addons {
-        export var CSSTransitionGroup: CSSTransitionGroup;
-        export var TransitionGroup: TransitionGroup;
-
-        export var LinkedStateMixin: LinkedStateMixin;
-        export var PureRenderMixin: PureRenderMixin;
-
-        export function batchedUpdates<A, B>(
-            callback: (a: A, b: B) => any, a: A, b: B): void;
-        export function batchedUpdates<A>(callback: (a: A) => any, a: A): void;
-        export function batchedUpdates(callback: () => any): void;
-
-        // deprecated: use petehunt/react-classset or JedWatson/classnames
-        export function classSet(cx: { [key: string]: boolean }): string;
-        export function classSet(...classList: string[]): string;
-
-        export function cloneWithProps<P>(
-            element: DOMElement<P>, props: P): DOMElement<P>;
-        export function cloneWithProps<P>(
-            element: ClassicElement<P>, props: P): ClassicElement<P>;
-        export function cloneWithProps<P>(
-            element: ReactElement<P>, props: P): ReactElement<P>;
-
-        export function createFragment(
-            object: { [key: string]: ReactNode }): ReactFragment;
-
-        export function update(value: any[], spec: UpdateArraySpec): any[];
-        export function update(value: {}, spec: UpdateSpec): any;
-
-        // Development tools
-        export import Perf = ReactPerf;
-        export import TestUtils = ReactTestUtils;
-    }
-
-    //
-    // React.addons (Transitions)
-    // ----------------------------------------------------------------------
-
-    interface TransitionGroupProps {
-        component?: ReactType;
-        childFactory?: (child: ReactElement<any>) => ReactElement<any>;
-    }
-
-    interface CSSTransitionGroupProps extends TransitionGroupProps {
-        transitionName: string;
-        transitionAppear?: boolean;
-        transitionEnter?: boolean;
-        transitionLeave?: boolean;
-    }
-
-    type CSSTransitionGroup = ComponentClass<CSSTransitionGroupProps>;
-    type TransitionGroup = ComponentClass<TransitionGroupProps>;
-
-    //
-    // React.addons (Mixins)
-    // ----------------------------------------------------------------------
-
-    interface ReactLink<T> {
-        value: T;
-        requestChange(newValue: T): void;
-    }
-
-    interface LinkedStateMixin extends Mixin<any, any> {
-        linkState<T>(key: string): ReactLink<T>;
-    }
-
-    interface PureRenderMixin extends Mixin<any, any> {
-    }
-
-    //
-    // Reat.addons.update
-    // ----------------------------------------------------------------------
-
-    interface UpdateSpec {
-        $set?: any;
-        $merge?: {};
-        $apply?(value: any): any;
-        // [key: string]: UpdateSpec;
-    }
-
-    interface UpdateArraySpec extends UpdateSpec {
-        $push?: any[];
-        $unshift?: any[];
-        $splice?: any[][];
-    }
-
-    //
-    // React.addons.Perf
-    // ----------------------------------------------------------------------
-
-    interface ComponentPerfContext {
-        current: string;
-        owner: string;
-    }
-
-    interface NumericPerfContext {
-        [key: string]: number;
-    }
-
-    interface Measurements {
-        exclusive: NumericPerfContext;
-        inclusive: NumericPerfContext;
-        render: NumericPerfContext;
-        counts: NumericPerfContext;
-        writes: NumericPerfContext;
-        displayNames: {
-            [key: string]: ComponentPerfContext;
-        };
-        totalTime: number;
-    }
-
-    module ReactPerf {
-        export function start(): void;
-        export function stop(): void;
-        export function printInclusive(measurements: Measurements[]): void;
-        export function printExclusive(measurements: Measurements[]): void;
-        export function printWasted(measurements: Measurements[]): void;
-        export function printDOM(measurements: Measurements[]): void;
-        export function getLastMeasurements(): Measurements[];
-    }
-
-    //
-    // React.addons.TestUtils
-    // ----------------------------------------------------------------------
-
-    interface MockedComponentClass {
-        new(): any;
-    }
-
-    module ReactTestUtils {
-        export import Simulate = ReactSimulate;
-
-        export function renderIntoDocument<P>(
-            element: ReactElement<P>): Component<P, any>;
-        export function renderIntoDocument<C extends Component<any, any>>(
-            element: ReactElement<any>): C;
-
-        export function mockComponent(
-            mocked: MockedComponentClass, mockTagName?: string): typeof ReactTestUtils;
-
-        export function isElementOfType(
-            element: ReactElement<any>, type: ReactType): boolean;
-        export function isTextComponent(instance: Component<any, any>): boolean;
-        export function isDOMComponent(instance: Component<any, any>): boolean;
-        export function isCompositeComponent(instance: Component<any, any>): boolean;
-        export function isCompositeComponentWithType(
-            instance: Component<any, any>,
-            type: ComponentClass<any>): boolean;
-
-        export function findAllInRenderedTree(
-            tree: Component<any, any>,
-            fn: (i: Component<any, any>) => boolean): Component<any, any>;
-
-        export function scryRenderedDOMComponentsWithClass(
-            tree: Component<any, any>,
-            className: string): DOMComponent<any>[];
-        export function findRenderedDOMComponentWithClass(
-            tree: Component<any, any>,
-            className: string): DOMComponent<any>;
-
-        export function scryRenderedDOMComponentsWithTag(
-            tree: Component<any, any>,
-            tagName: string): DOMComponent<any>[];
-        export function findRenderedDOMComponentWithTag(
-            tree: Component<any, any>,
-            tagName: string): DOMComponent<any>;
-
-        export function scryRenderedComponentsWithType<P>(
-            tree: Component<any, any>,
-            type: ComponentClass<P>): Component<P, {}>[];
-        export function scryRenderedComponentsWithType<C extends Component<any, any>>(
-            tree: Component<any, any>,
-            type: ComponentClass<any>): C[];
-
-        export function findRenderedComponentWithType<P>(
-            tree: Component<any, any>,
-            type: ComponentClass<P>): Component<P, {}>;
-        export function findRenderedComponentWithType<C extends Component<any, any>>(
-            tree: Component<any, any>,
-            type: ComponentClass<any>): C;
-
-        export function createRenderer(): ShallowRenderer;
-    }
-
-    interface SyntheticEventData {
-        altKey?: boolean;
-        button?: number;
-        buttons?: number;
-        clientX?: number;
-        clientY?: number;
-        changedTouches?: TouchList;
-        charCode?: boolean;
-        clipboardData?: DataTransfer;
-        ctrlKey?: boolean;
-        deltaMode?: number;
-        deltaX?: number;
-        deltaY?: number;
-        deltaZ?: number;
-        detail?: number;
-        getModifierState?(key: string): boolean;
-        key?: string;
-        keyCode?: number;
-        locale?: string;
-        location?: number;
-        metaKey?: boolean;
-        pageX?: number;
-        pageY?: number;
-        relatedTarget?: EventTarget;
-        repeat?: boolean;
-        screenX?: number;
-        screenY?: number;
-        shiftKey?: boolean;
-        targetTouches?: TouchList;
-        touches?: TouchList;
-        view?: AbstractView;
-        which?: number;
-    }
-
-    interface EventSimulator {
-        (element: Element, eventData?: SyntheticEventData): void;
-        (component: Component<any, any>, eventData?: SyntheticEventData): void;
-    }
-
-    module ReactSimulate {
-        export var blur: EventSimulator;
-        export var change: EventSimulator;
-        export var click: EventSimulator;
-        export var cut: EventSimulator;
-        export var doubleClick: EventSimulator;
-        export var drag: EventSimulator;
-        export var dragEnd: EventSimulator;
-        export var dragEnter: EventSimulator;
-        export var dragExit: EventSimulator;
-        export var dragLeave: EventSimulator;
-        export var dragOver: EventSimulator;
-        export var dragStart: EventSimulator;
-        export var drop: EventSimulator;
-        export var focus: EventSimulator;
-        export var input: EventSimulator;
-        export var keyDown: EventSimulator;
-        export var keyPress: EventSimulator;
-        export var keyUp: EventSimulator;
-        export var mouseDown: EventSimulator;
-        export var mouseEnter: EventSimulator;
-        export var mouseLeave: EventSimulator;
-        export var mouseMove: EventSimulator;
-        export var mouseOut: EventSimulator;
-        export var mouseOver: EventSimulator;
-        export var mouseUp: EventSimulator;
-        export var paste: EventSimulator;
-        export var scroll: EventSimulator;
-        export var submit: EventSimulator;
-        export var touchCancel: EventSimulator;
-        export var touchEnd: EventSimulator;
-        export var touchMove: EventSimulator;
-        export var touchStart: EventSimulator;
-        export var wheel: EventSimulator;
-    }
-
-    class ShallowRenderer {
-        getRenderOutput<E extends ReactElement<any>>(): E;
-        getRenderOutput(): ReactElement<any>;
-        render(element: ReactElement<any>, context?: any): void;
-        unmount(): void;
-    }
-
-    //
-    // Browser Interfaces
-    // https://github.com/nikeee/2048-typescript/blob/master/2048/js/touch.d.ts
-    // ----------------------------------------------------------------------
-
-    interface AbstractView {
-        styleMedia: StyleMedia;
-        document: Document;
-    }
-
-    interface Touch {
-        identifier: number;
-        target: EventTarget;
-        screenX: number;
-        screenY: number;
-        clientX: number;
-        clientY: number;
-        pageX: number;
-        pageY: number;
-    }
-
-    interface TouchList {
-        [index: number]: Touch;
-        length: number;
-        item(index: number): Touch;
-        identifiedTouch(identifier: number): Touch;
-    }
-}
diff --git a/react/react-global-tests.ts b/react/react-global-tests.ts
new file mode 100644
index 0000000000..a3f4a14849
--- /dev/null
+++ b/react/react-global-tests.ts
@@ -0,0 +1,367 @@
+/// <reference path="react-global.d.ts" />
+
+interface Props extends React.Props<MyComponent> {
+    hello: string;
+    world?: string;
+    foo: number;
+    bar: boolean;
+}
+
+interface State {
+    inputValue?: string;
+    seconds?: number;
+}
+
+interface Context {
+    someValue?: string;
+}
+
+interface ChildContext {
+    someOtherValue: string;
+}
+
+interface MyComponent extends React.Component<Props, State> {
+    reset(): void;
+}
+
+var props: Props = {
+    key: 42,
+    ref: "myComponent42",
+    hello: "world",
+    foo: 42,
+    bar: true
+};
+
+var container: Element;
+
+//
+// Top-Level API
+// --------------------------------------------------------------------------
+
+var ClassicComponent: React.ClassicComponentClass<Props> =
+    React.createClass<Props, State>({
+        getDefaultProps() {
+            return <Props>{
+                hello: undefined,
+                world: "peace",
+                foo: undefined,
+                bar: undefined,
+            };
+        },
+        getInitialState() {
+            return {
+                inputValue: this.context.someValue,
+                seconds: this.props.foo
+            };
+        },
+        reset() {
+            this.replaceState(this.getInitialState());
+        },
+        render() {
+            return React.DOM.div(null,
+                React.DOM.input({
+                    ref: input => this._input = input,
+                    value: this.state.inputValue
+                }));
+        }
+    });
+
+class ModernComponent extends React.Component<Props, State>
+    implements React.ChildContextProvider<ChildContext> {
+    
+    static propTypes: React.ValidationMap<Props> = {
+        foo: React.PropTypes.number
+    }
+    
+    static contextTypes: React.ValidationMap<Context> = {
+        someValue: React.PropTypes.string
+    }
+    
+    static childContextTypes: React.ValidationMap<ChildContext> = {
+        someOtherValue: React.PropTypes.string
+    }
+    
+    context: Context;
+    
+    getChildContext() {
+        return {
+            someOtherValue: 'foo'
+        }
+    }
+    
+    state = {
+        inputValue: this.context.someValue,
+        seconds: this.props.foo
+    }
+    
+    reset() {
+        this.setState({
+            inputValue: this.context.someValue,
+            seconds: this.props.foo
+        });
+    }
+
+    private _input: React.HTMLComponent;
+    
+    render() {
+        return React.DOM.div(null,
+            React.DOM.input({
+                ref: input => this._input = input,
+                value: this.state.inputValue
+            }));
+    }
+}
+
+// React.createFactory
+var factory: React.Factory<Props> =
+    React.createFactory(ModernComponent);
+var factoryElement: React.ReactElement<Props> =
+    factory(props);
+
+var classicFactory: React.ClassicFactory<Props> =
+    React.createFactory(ClassicComponent);
+var classicFactoryElement: React.ClassicElement<Props> =
+    classicFactory(props);
+
+var domFactory: React.DOMFactory<any> =
+    React.createFactory("foo");
+var domFactoryElement: React.DOMElement<any> =
+    domFactory();
+
+// React.createElement
+var element: React.ReactElement<Props> =
+    React.createElement(ModernComponent, props);
+var classicElement: React.ClassicElement<Props> =
+    React.createElement(ClassicComponent, props);
+var domElement: React.HTMLElement =
+    React.createElement("div");
+
+// React.cloneElement
+var clonedElement: React.ReactElement<Props> =
+    React.cloneElement(element, props);
+var clonedClassicElement: React.ClassicElement<Props> =
+    React.cloneElement(classicElement, props);
+var clonedDOMElement: React.HTMLElement =
+    React.cloneElement(domElement);
+
+// React.render
+var component: React.Component<Props, any> =
+    React.render(element, container);
+var classicComponent: React.ClassicComponent<Props, any> =
+    React.render(classicElement, container);
+var domComponent: React.DOMComponent<any> =
+    React.render(domElement, container);
+
+// Other Top-Level API
+var unmounted: boolean = React.unmountComponentAtNode(container);
+var str: string = React.renderToString(element);
+var markup: string = React.renderToStaticMarkup(element);
+var notValid: boolean = React.isValidElement(props); // false
+var isValid = React.isValidElement(element); // true
+React.initializeTouchEvents(true);
+var domNode: Element = React.findDOMNode(component);
+domNode = React.findDOMNode(domNode);
+
+//
+// React Elements
+// --------------------------------------------------------------------------
+
+var type = element.type;
+var elementProps: Props = element.props;
+var key = element.key;
+
+//
+// React Components
+// --------------------------------------------------------------------------
+
+var displayName: string = ClassicComponent.displayName;
+var defaultProps: Props = ClassicComponent.getDefaultProps();
+var propTypes: React.ValidationMap<Props> = ClassicComponent.propTypes;
+
+//
+// Component API
+// --------------------------------------------------------------------------
+
+// modern
+var componentState: State = component.state;
+component.setState({ inputValue: "!!!" });
+component.forceUpdate();
+
+// classic
+var htmlElement: Element = classicComponent.getDOMNode();
+var divElement: HTMLDivElement = classicComponent.getDOMNode<HTMLDivElement>();
+var isMounted: boolean = classicComponent.isMounted();
+classicComponent.setProps(elementProps);
+classicComponent.replaceProps(props);
+classicComponent.replaceState({ inputValue: "???", seconds: 60 });
+
+var myComponent = <MyComponent>component;
+myComponent.reset();
+
+//
+// Attributes
+// --------------------------------------------------------------------------
+
+var children: any[] = ["Hello world", [null], React.DOM.span(null)];
+var divStyle: React.CSSProperties = { // CSSProperties
+    flex: "1 1 main-size",
+    backgroundImage: "url('hello.png')"
+};
+var htmlAttr: React.HTMLAttributes = {
+    key: 36,
+    ref: "htmlComponent",
+    children: children,
+    className: "test-attr",
+    style: divStyle,
+    onClick: (event: React.MouseEvent) => {
+        event.preventDefault();
+        event.stopPropagation();
+    },
+    dangerouslySetInnerHTML: {
+        __html: "<strong>STRONG</strong>"
+    }
+};
+React.DOM.div(htmlAttr);
+React.DOM.span(htmlAttr);
+React.DOM.input(htmlAttr);
+
+React.DOM.svg({ viewBox: "0 0 48 48" },
+    React.DOM.rect({
+      x: 22,
+      y: 10,
+      width: 4,
+      height: 28
+    }),
+    React.DOM.rect({
+      x: 10,
+      y: 22,
+      width: 28,
+      height: 4
+    }));
+
+
+//
+// React.PropTypes
+// --------------------------------------------------------------------------
+
+var PropTypesSpecification: React.ComponentSpec<any, any> = {
+    propTypes: {
+        optionalArray: React.PropTypes.array,
+        optionalBool: React.PropTypes.bool,
+        optionalFunc: React.PropTypes.func,
+        optionalNumber: React.PropTypes.number,
+        optionalObject: React.PropTypes.object,
+        optionalString: React.PropTypes.string,
+        optionalNode: React.PropTypes.node,
+        optionalElement: React.PropTypes.element,
+        optionalMessage: React.PropTypes.instanceOf(Date),
+        optionalEnum: React.PropTypes.oneOf(["News", "Photos"]),
+        optionalUnion: React.PropTypes.oneOfType([
+            React.PropTypes.string,
+            React.PropTypes.number,
+            React.PropTypes.instanceOf(Date)
+        ]),
+        optionalArrayOf: React.PropTypes.arrayOf(React.PropTypes.number),
+        optionalObjectOf: React.PropTypes.objectOf(React.PropTypes.number),
+        optionalObjectWithShape: React.PropTypes.shape({
+            color: React.PropTypes.string,
+            fontSize: React.PropTypes.number
+        }),
+        requiredFunc: React.PropTypes.func.isRequired,
+        requiredAny: React.PropTypes.any.isRequired,
+        customProp: function(props: any, propName: string, componentName: string) {
+            if (!/matchme/.test(props[propName])) {
+                return new Error("Validation failed!");
+            }
+            return null;
+        }
+    },
+    render: (): React.ReactElement<any> => {
+        return null;
+    }
+};
+
+//
+// ContextTypes
+// --------------------------------------------------------------------------
+
+var ContextTypesSpecification: React.ComponentSpec<any, any> = {
+    contextTypes: {
+        optionalArray: React.PropTypes.array,
+        optionalBool: React.PropTypes.bool,
+        optionalFunc: React.PropTypes.func,
+        optionalNumber: React.PropTypes.number,
+        optionalObject: React.PropTypes.object,
+        optionalString: React.PropTypes.string,
+        optionalNode: React.PropTypes.node,
+        optionalElement: React.PropTypes.element,
+        optionalMessage: React.PropTypes.instanceOf(Date),
+        optionalEnum: React.PropTypes.oneOf(["News", "Photos"]),
+        optionalUnion: React.PropTypes.oneOfType([
+            React.PropTypes.string,
+            React.PropTypes.number,
+            React.PropTypes.instanceOf(Date)
+        ]),
+        optionalArrayOf: React.PropTypes.arrayOf(React.PropTypes.number),
+        optionalObjectOf: React.PropTypes.objectOf(React.PropTypes.number),
+        optionalObjectWithShape: React.PropTypes.shape({
+            color: React.PropTypes.string,
+            fontSize: React.PropTypes.number
+        }),
+        requiredFunc: React.PropTypes.func.isRequired,
+        requiredAny: React.PropTypes.any.isRequired,
+        customProp: function(props: any, propName: string, componentName: string) {
+            if (!/matchme/.test(props[propName])) {
+                return new Error("Validation failed!");
+            }
+            return null;
+        }
+    },
+    render: (): React.ReactElement<any> => {
+        return null;
+    }
+};
+
+//
+// React.Children
+// --------------------------------------------------------------------------
+
+var childMap: { [key: string]: number } =
+    React.Children.map<number>(children, (child) => { return 42; });
+React.Children.forEach(children, (child) => {});
+var nChildren: number = React.Children.count(children);
+var onlyChild = React.Children.only([null, [[["Hallo"], true]], false]);
+
+//
+// Example from http://facebook.github.io/react/
+// --------------------------------------------------------------------------
+
+interface TimerState {
+    secondsElapsed: number;
+}
+class Timer extends React.Component<{}, TimerState> {
+    state = {
+        secondsElapsed: 0
+    }
+    private _interval: number;
+    tick() {
+        this.setState((prevState, props) => ({
+            secondsElapsed: prevState.secondsElapsed + 1
+        }));
+    }
+    componentDidMount() {
+        this._interval = setInterval(() => this.tick(), 1000);
+    }
+    componentWillUnmount() {
+        clearInterval(this._interval);
+    }
+    render() {
+        return React.DOM.div(
+            null,
+            "Seconds Elapsed: ",
+            this.state.secondsElapsed
+        );
+    }
+}
+React.render(React.createElement(Timer), container);
+
diff --git a/react/react-global.d.ts b/react/react-global.d.ts
index df8aaf421c..99fba1e3de 100644
--- a/react/react-global.d.ts
+++ b/react/react-global.d.ts
@@ -1,941 +1,280 @@
-// Type definitions for React v0.13.1 (internal module)
+// Type definitions for React v0.13.3 (namespace)
 // Project: http://facebook.github.io/react/
 // Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-declare module React {
+/// <reference path="react.d.ts" />
+
+import React = __React;
+
+declare namespace __React {
     //
-    // React Elements
+    // React.addons
     // ----------------------------------------------------------------------
 
-    type ReactType = ComponentClass<any> | string;
+    export module addons {
+        export var CSSTransitionGroup: CSSTransitionGroup;
+        export var TransitionGroup: TransitionGroup;
 
-    interface ReactElement<P> {
-        type: string | ComponentClass<P>;
-        props: P;
-        key: string | number;
-        ref: string | ((component: Component<P, any>) => any);
+        export var LinkedStateMixin: LinkedStateMixin;
+        export var PureRenderMixin: PureRenderMixin;
+
+        export function batchedUpdates<A, B>(
+            callback: (a: A, b: B) => any, a: A, b: B): void;
+        export function batchedUpdates<A>(callback: (a: A) => any, a: A): void;
+        export function batchedUpdates(callback: () => any): void;
+
+        // deprecated: use petehunt/react-classset or JedWatson/classnames
+        export function classSet(cx: { [key: string]: boolean }): string;
+        export function classSet(...classList: string[]): string;
+
+        export function cloneWithProps<P>(
+            element: DOMElement<P>, props: P): DOMElement<P>;
+        export function cloneWithProps<P>(
+            element: ClassicElement<P>, props: P): ClassicElement<P>;
+        export function cloneWithProps<P>(
+            element: ReactElement<P>, props: P): ReactElement<P>;
+
+        export function createFragment(
+            object: { [key: string]: ReactNode }): ReactFragment;
+
+        export function update(value: any[], spec: UpdateArraySpec): any[];
+        export function update(value: {}, spec: UpdateSpec): any;
+
+        // Development tools
+        export import Perf = ReactPerf;
+        export import TestUtils = ReactTestUtils;
     }
 
-    interface ClassicElement<P> extends ReactElement<P> {
-        type: string | ClassicComponentClass<P>;
-        ref: string | ((component: ClassicComponent<P, any>) => any);
-    }
-
-    interface DOMElement<P> extends ClassicElement<P> {
-        type: string;
-        ref: string | ((component: DOMComponent<P>) => any);
-    }
-
-    type HTMLElement = DOMElement<HTMLAttributes>;
-    type SVGElement = DOMElement<SVGAttributes>;
-
     //
-    // Factories
+    // React.addons (Transitions)
     // ----------------------------------------------------------------------
 
-    interface Factory<P> {
-        (props?: P, ...children: ReactNode[]): ReactElement<P>;
+    interface TransitionGroupProps {
+        component?: ReactType;
+        childFactory?: (child: ReactElement<any>) => ReactElement<any>;
     }
 
-    interface ClassicFactory<P> extends Factory<P> {
-        (props?: P, ...children: ReactNode[]): ClassicElement<P>;
+    interface CSSTransitionGroupProps extends TransitionGroupProps {
+        transitionName: string;
+        transitionAppear?: boolean;
+        transitionEnter?: boolean;
+        transitionLeave?: boolean;
     }
 
-    interface DOMFactory<P> extends ClassicFactory<P> {
-        (props?: P, ...children: ReactNode[]): DOMElement<P>;
+    type CSSTransitionGroup = ComponentClass<CSSTransitionGroupProps>;
+    type TransitionGroup = ComponentClass<TransitionGroupProps>;
+
+    //
+    // React.addons (Mixins)
+    // ----------------------------------------------------------------------
+
+    interface ReactLink<T> {
+        value: T;
+        requestChange(newValue: T): void;
     }
 
-    type HTMLFactory = DOMFactory<HTMLAttributes>;
-    type SVGFactory = DOMFactory<SVGAttributes>;
-    type SVGElementFactory = DOMFactory<SVGElementAttributes>;
+    interface LinkedStateMixin extends Mixin<any, any> {
+        linkState<T>(key: string): ReactLink<T>;
+    }
+
+    interface PureRenderMixin extends Mixin<any, any> {
+    }
 
     //
-    // React Nodes
-    // http://facebook.github.io/react/docs/glossary.html
+    // Reat.addons.update
     // ----------------------------------------------------------------------
 
-    type ReactText = string | number;
-    type ReactChild = ReactElement<any> | ReactText;
+    interface UpdateSpec {
+        $set?: any;
+        $merge?: {};
+        $apply?(value: any): any;
+        // [key: string]: UpdateSpec;
+    }
 
-    // Should be Array<ReactNode> but type aliases cannot be recursive
-    type ReactFragment = {} | Array<ReactChild | any[] | boolean>;
-    type ReactNode = ReactChild | ReactFragment | boolean;
+    interface UpdateArraySpec extends UpdateSpec {
+        $push?: any[];
+        $unshift?: any[];
+        $splice?: any[][];
+    }
 
     //
-    // Top Level API
+    // React.addons.Perf
     // ----------------------------------------------------------------------
 
-    function createClass<P, S>(spec: ComponentSpec<P, S>): ClassicComponentClass<P>;
+    interface ComponentPerfContext {
+        current: string;
+        owner: string;
+    }
 
-    function createFactory<P>(type: string): DOMFactory<P>;
-    function createFactory<P>(type: ClassicComponentClass<P> | string): ClassicFactory<P>;
-    function createFactory<P>(type: ComponentClass<P>): Factory<P>;
+    interface NumericPerfContext {
+        [key: string]: number;
+    }
 
-    function createElement<P>(
-        type: string,
-        props?: P,
-        ...children: ReactNode[]): DOMElement<P>;
-    function createElement<P>(
-        type: ClassicComponentClass<P> | string,
-        props?: P,
-        ...children: ReactNode[]): ClassicElement<P>;
-    function createElement<P>(
-        type: ComponentClass<P>,
-        props?: P,
-        ...children: ReactNode[]): ReactElement<P>;
-
-    function cloneElement<P>(
-        element: DOMElement<P>,
-        props?: P,
-        ...children: ReactNode[]): DOMElement<P>;
-    function cloneElement<P>(
-        element: ClassicElement<P>,
-        props?: P,
-        ...children: ReactNode[]): ClassicElement<P>;
-    function cloneElement<P>(
-        element: ReactElement<P>,
-        props?: P,
-        ...children: ReactNode[]): ReactElement<P>;
-
-    function render<P>(
-        element: DOMElement<P>,
-        container: Element,
-        callback?: () => any): DOMComponent<P>;
-    function render<P, S>(
-        element: ClassicElement<P>,
-        container: Element,
-        callback?: () => any): ClassicComponent<P, S>;
-    function render<P, S>(
-        element: ReactElement<P>,
-        container: Element,
-        callback?: () => any): Component<P, S>;
-
-    function unmountComponentAtNode(container: Element): boolean;
-    function renderToString(element: ReactElement<any>): string;
-    function renderToStaticMarkup(element: ReactElement<any>): string;
-    function isValidElement(object: {}): boolean;
-    function initializeTouchEvents(shouldUseTouch: boolean): void;
-
-    function findDOMNode<TElement extends Element>(
-        componentOrElement: Component<any, any> | Element): TElement;
-    function findDOMNode(
-        componentOrElement: Component<any, any> | Element): Element;
-
-    var DOM: ReactDOM;
-    var PropTypes: ReactPropTypes;
-    var Children: ReactChildren;
-
-    //
-    // Component API
-    // ----------------------------------------------------------------------
-
-    // Base component for plain JS classes
-    class Component<P, S> implements ComponentLifecycle<P, S> {
-        constructor(props?: P, context?: any);
-        setState(f: (prevState: S, props: P) => S, callback?: () => any): void;
-        setState(state: S, callback?: () => any): void;
-        forceUpdate(): void;
-        render(): JSX.Element;
-        props: P;
-        state: S;
-        context: {};
-        refs: {
-            [key: string]: Component<any, any>
+    interface Measurements {
+        exclusive: NumericPerfContext;
+        inclusive: NumericPerfContext;
+        render: NumericPerfContext;
+        counts: NumericPerfContext;
+        writes: NumericPerfContext;
+        displayNames: {
+            [key: string]: ComponentPerfContext;
         };
+        totalTime: number;
     }
 
-    interface ClassicComponent<P, S> extends Component<P, S> {
-        replaceState(nextState: S, callback?: () => any): void;
-        getDOMNode<TElement extends Element>(): TElement;
-        getDOMNode(): Element;
-        isMounted(): boolean;
-        getInitialState?(): S;
-        setProps(nextProps: P, callback?: () => any): void;
-        replaceProps(nextProps: P, callback?: () => any): void;
-    }
-
-    interface DOMComponent<P> extends ClassicComponent<P, any> {
-        tagName: string;
-    }
-
-    type HTMLComponent = DOMComponent<HTMLAttributes>;
-    type SVGComponent = DOMComponent<SVGAttributes>;
-
-    interface ChildContextProvider<CC> {
-        getChildContext(): CC;
+    module ReactPerf {
+        export function start(): void;
+        export function stop(): void;
+        export function printInclusive(measurements: Measurements[]): void;
+        export function printExclusive(measurements: Measurements[]): void;
+        export function printWasted(measurements: Measurements[]): void;
+        export function printDOM(measurements: Measurements[]): void;
+        export function getLastMeasurements(): Measurements[];
     }
 
     //
-    // Class Interfaces
+    // React.addons.TestUtils
     // ----------------------------------------------------------------------
 
-    interface ComponentClass<P> {
-        new(props?: P, context?: any): Component<P, any>;
-        propTypes?: ValidationMap<P>;
-        contextTypes?: ValidationMap<any>;
-        childContextTypes?: ValidationMap<any>;
-        defaultProps?: P;
+    interface MockedComponentClass {
+        new(): any;
     }
 
-    interface ClassicComponentClass<P> extends ComponentClass<P> {
-        new(props?: P, context?: any): ClassicComponent<P, any>;
-        getDefaultProps?(): P;
-        displayName?: string;
+    module ReactTestUtils {
+        export import Simulate = ReactSimulate;
+
+        export function renderIntoDocument<P>(
+            element: ReactElement<P>): Component<P, any>;
+        export function renderIntoDocument<C extends Component<any, any>>(
+            element: ReactElement<any>): C;
+
+        export function mockComponent(
+            mocked: MockedComponentClass, mockTagName?: string): typeof ReactTestUtils;
+
+        export function isElementOfType(
+            element: ReactElement<any>, type: ReactType): boolean;
+        export function isTextComponent(instance: Component<any, any>): boolean;
+        export function isDOMComponent(instance: Component<any, any>): boolean;
+        export function isCompositeComponent(instance: Component<any, any>): boolean;
+        export function isCompositeComponentWithType(
+            instance: Component<any, any>,
+            type: ComponentClass<any>): boolean;
+
+        export function findAllInRenderedTree(
+            tree: Component<any, any>,
+            fn: (i: Component<any, any>) => boolean): Component<any, any>;
+
+        export function scryRenderedDOMComponentsWithClass(
+            tree: Component<any, any>,
+            className: string): DOMComponent<any>[];
+        export function findRenderedDOMComponentWithClass(
+            tree: Component<any, any>,
+            className: string): DOMComponent<any>;
+
+        export function scryRenderedDOMComponentsWithTag(
+            tree: Component<any, any>,
+            tagName: string): DOMComponent<any>[];
+        export function findRenderedDOMComponentWithTag(
+            tree: Component<any, any>,
+            tagName: string): DOMComponent<any>;
+
+        export function scryRenderedComponentsWithType<P>(
+            tree: Component<any, any>,
+            type: ComponentClass<P>): Component<P, {}>[];
+        export function scryRenderedComponentsWithType<C extends Component<any, any>>(
+            tree: Component<any, any>,
+            type: ComponentClass<any>): C[];
+
+        export function findRenderedComponentWithType<P>(
+            tree: Component<any, any>,
+            type: ComponentClass<P>): Component<P, {}>;
+        export function findRenderedComponentWithType<C extends Component<any, any>>(
+            tree: Component<any, any>,
+            type: ComponentClass<any>): C;
+
+        export function createRenderer(): ShallowRenderer;
     }
 
-    //
-    // Component Specs and Lifecycle
-    // ----------------------------------------------------------------------
-
-    interface ComponentLifecycle<P, S> {
-        componentWillMount?(): void;
-        componentDidMount?(): void;
-        componentWillReceiveProps?(nextProps: P, nextContext: any): void;
-        shouldComponentUpdate?(nextProps: P, nextState: S, nextContext: any): boolean;
-        componentWillUpdate?(nextProps: P, nextState: S, nextContext: any): void;
-        componentDidUpdate?(prevProps: P, prevState: S, prevContext: any): void;
-        componentWillUnmount?(): void;
+    interface SyntheticEventData {
+        altKey?: boolean;
+        button?: number;
+        buttons?: number;
+        clientX?: number;
+        clientY?: number;
+        changedTouches?: TouchList;
+        charCode?: boolean;
+        clipboardData?: DataTransfer;
+        ctrlKey?: boolean;
+        deltaMode?: number;
+        deltaX?: number;
+        deltaY?: number;
+        deltaZ?: number;
+        detail?: number;
+        getModifierState?(key: string): boolean;
+        key?: string;
+        keyCode?: number;
+        locale?: string;
+        location?: number;
+        metaKey?: boolean;
+        pageX?: number;
+        pageY?: number;
+        relatedTarget?: EventTarget;
+        repeat?: boolean;
+        screenX?: number;
+        screenY?: number;
+        shiftKey?: boolean;
+        targetTouches?: TouchList;
+        touches?: TouchList;
+        view?: AbstractView;
+        which?: number;
     }
 
-    interface Mixin<P, S> extends ComponentLifecycle<P, S> {
-        mixins?: Mixin<P, S>;
-        statics?: {
-            [key: string]: any;
-        };
-
-        displayName?: string;
-        propTypes?: ValidationMap<any>;
-        contextTypes?: ValidationMap<any>;
-        childContextTypes?: ValidationMap<any>
-
-        getDefaultProps?(): P;
-        getInitialState?(): S;
+    interface EventSimulator {
+        (element: Element, eventData?: SyntheticEventData): void;
+        (component: Component<any, any>, eventData?: SyntheticEventData): void;
     }
 
-    interface ComponentSpec<P, S> extends Mixin<P, S> {
-        render(): ReactElement<any>;
-
-        [propertyName: string]: any;
+    module ReactSimulate {
+        export var blur: EventSimulator;
+        export var change: EventSimulator;
+        export var click: EventSimulator;
+        export var cut: EventSimulator;
+        export var doubleClick: EventSimulator;
+        export var drag: EventSimulator;
+        export var dragEnd: EventSimulator;
+        export var dragEnter: EventSimulator;
+        export var dragExit: EventSimulator;
+        export var dragLeave: EventSimulator;
+        export var dragOver: EventSimulator;
+        export var dragStart: EventSimulator;
+        export var drop: EventSimulator;
+        export var focus: EventSimulator;
+        export var input: EventSimulator;
+        export var keyDown: EventSimulator;
+        export var keyPress: EventSimulator;
+        export var keyUp: EventSimulator;
+        export var mouseDown: EventSimulator;
+        export var mouseEnter: EventSimulator;
+        export var mouseLeave: EventSimulator;
+        export var mouseMove: EventSimulator;
+        export var mouseOut: EventSimulator;
+        export var mouseOver: EventSimulator;
+        export var mouseUp: EventSimulator;
+        export var paste: EventSimulator;
+        export var scroll: EventSimulator;
+        export var submit: EventSimulator;
+        export var touchCancel: EventSimulator;
+        export var touchEnd: EventSimulator;
+        export var touchMove: EventSimulator;
+        export var touchStart: EventSimulator;
+        export var wheel: EventSimulator;
     }
 
-    //
-    // Event System
-    // ----------------------------------------------------------------------
-
-    interface SyntheticEvent {
-        bubbles: boolean;
-        cancelable: boolean;
-        currentTarget: EventTarget;
-        defaultPrevented: boolean;
-        eventPhase: number;
-        isTrusted: boolean;
-        nativeEvent: Event;
-        preventDefault(): void;
-        stopPropagation(): void;
-        target: EventTarget;
-        timeStamp: Date;
-        type: string;
-    }
-
-    interface DragEvent extends SyntheticEvent {
-        dataTransfer: DataTransfer;
-    }
-
-    interface ClipboardEvent extends SyntheticEvent {
-        clipboardData: DataTransfer;
-    }
-
-    interface KeyboardEvent extends SyntheticEvent {
-        altKey: boolean;
-        charCode: number;
-        ctrlKey: boolean;
-        getModifierState(key: string): boolean;
-        key: string;
-        keyCode: number;
-        locale: string;
-        location: number;
-        metaKey: boolean;
-        repeat: boolean;
-        shiftKey: boolean;
-        which: number;
-    }
-
-    interface FocusEvent extends SyntheticEvent {
-        relatedTarget: EventTarget;
-    }
-
-    interface FormEvent extends SyntheticEvent {
-    }
-
-    interface MouseEvent extends SyntheticEvent {
-        altKey: boolean;
-        button: number;
-        buttons: number;
-        clientX: number;
-        clientY: number;
-        ctrlKey: boolean;
-        getModifierState(key: string): boolean;
-        metaKey: boolean;
-        pageX: number;
-        pageY: number;
-        relatedTarget: EventTarget;
-        screenX: number;
-        screenY: number;
-        shiftKey: boolean;
-    }
-
-    interface TouchEvent extends SyntheticEvent {
-        altKey: boolean;
-        changedTouches: TouchList;
-        ctrlKey: boolean;
-        getModifierState(key: string): boolean;
-        metaKey: boolean;
-        shiftKey: boolean;
-        targetTouches: TouchList;
-        touches: TouchList;
-    }
-
-    interface UIEvent extends SyntheticEvent {
-        detail: number;
-        view: AbstractView;
-    }
-
-    interface WheelEvent extends SyntheticEvent {
-        deltaMode: number;
-        deltaX: number;
-        deltaY: number;
-        deltaZ: number;
-    }
-
-    //
-    // Event Handler Types
-    // ----------------------------------------------------------------------
-
-    interface EventHandler<E extends SyntheticEvent> {
-        (event: E): void;
-    }
-
-    interface DragEventHandler extends EventHandler<DragEvent> {}
-    interface ClipboardEventHandler extends EventHandler<ClipboardEvent> {}
-    interface KeyboardEventHandler extends EventHandler<KeyboardEvent> {}
-    interface FocusEventHandler extends EventHandler<FocusEvent> {}
-    interface FormEventHandler extends EventHandler<FormEvent> {}
-    interface MouseEventHandler extends EventHandler<MouseEvent> {}
-    interface TouchEventHandler extends EventHandler<TouchEvent> {}
-    interface UIEventHandler extends EventHandler<UIEvent> {}
-    interface WheelEventHandler extends EventHandler<WheelEvent> {}
-
-    //
-    // Props / DOM Attributes
-    // ----------------------------------------------------------------------
-
-    interface Props<T> {
-        children?: ReactNode;
-        key?: string | number;
-        ref?: string | ((component: T) => any);
-    }
-
-    interface DOMAttributes extends Props<DOMComponent<any>> {
-        onCopy?: ClipboardEventHandler;
-        onCut?: ClipboardEventHandler;
-        onPaste?: ClipboardEventHandler;
-        onKeyDown?: KeyboardEventHandler;
-        onKeyPress?: KeyboardEventHandler;
-        onKeyUp?: KeyboardEventHandler;
-        onFocus?: FocusEventHandler;
-        onBlur?: FocusEventHandler;
-        onChange?: FormEventHandler;
-        onInput?: FormEventHandler;
-        onSubmit?: FormEventHandler;
-        onClick?: MouseEventHandler;
-        onDoubleClick?: MouseEventHandler;
-        onDrag?: DragEventHandler;
-        onDragEnd?: DragEventHandler;
-        onDragEnter?: DragEventHandler;
-        onDragExit?: DragEventHandler;
-        onDragLeave?: DragEventHandler;
-        onDragOver?: DragEventHandler;
-        onDragStart?: DragEventHandler;
-        onDrop?: DragEventHandler;
-        onMouseDown?: MouseEventHandler;
-        onMouseEnter?: MouseEventHandler;
-        onMouseLeave?: MouseEventHandler;
-        onMouseMove?: MouseEventHandler;
-        onMouseOut?: MouseEventHandler;
-        onMouseOver?: MouseEventHandler;
-        onMouseUp?: MouseEventHandler;
-        onTouchCancel?: TouchEventHandler;
-        onTouchEnd?: TouchEventHandler;
-        onTouchMove?: TouchEventHandler;
-        onTouchStart?: TouchEventHandler;
-        onScroll?: UIEventHandler;
-        onWheel?: WheelEventHandler;
-
-        dangerouslySetInnerHTML?: {
-            __html: string;
-        };
-    }
-
-    // This interface is not complete. Only properties accepting
-    // unitless numbers are listed here (see CSSProperty.js in React)
-    interface CSSProperties {
-        boxFlex?: number;
-        boxFlexGroup?: number;
-        columnCount?: number;
-        flex?: number | string;
-        flexGrow?: number;
-        flexShrink?: number;
-        fontWeight?: number | string;
-        lineClamp?: number;
-        lineHeight?: number | string;
-        opacity?: number;
-        order?: number;
-        orphans?: number;
-        widows?: number;
-        zIndex?: number;
-        zoom?: number;
-
-        fontSize?: number | string;
-
-        // SVG-related properties
-        fillOpacity?: number;
-        strokeOpacity?: number;
-        strokeWidth?: number;
-
-        [propertyName: string]: string | number | boolean;
-    }
-
-    interface HTMLAttributes extends DOMAttributes {
-        ref?: string | ((component: HTMLComponent) => void);
-
-        accept?: string;
-        acceptCharset?: string;
-        accessKey?: string;
-        action?: string;
-        allowFullScreen?: boolean;
-        allowTransparency?: boolean;
-        alt?: string;
-        async?: boolean;
-        autoComplete?: boolean;
-        autoFocus?: boolean;
-        autoPlay?: boolean;
-        cellPadding?: number | string;
-        cellSpacing?: number | string;
-        charSet?: string;
-        checked?: boolean;
-        classID?: string;
-        className?: string;
-        cols?: number;
-        colSpan?: number;
-        content?: string;
-        contentEditable?: boolean;
-        contextMenu?: string;
-        controls?: any;
-        coords?: string;
-        crossOrigin?: string;
-        data?: string;
-        dateTime?: string;
-        defaultChecked?: boolean;
-        defaultValue?: string;
-        defer?: boolean;
-        dir?: string;
-        disabled?: boolean;
-        download?: any;
-        draggable?: boolean;
-        encType?: string;
-        form?: string;
-        formAction?: string;
-        formEncType?: string;
-        formMethod?: string;
-        formNoValidate?: boolean;
-        formTarget?: string;
-        frameBorder?: number | string;
-        headers?: string;
-        height?: number | string;
-        hidden?: boolean;
-        high?: number;
-        href?: string;
-        hrefLang?: string;
-        htmlFor?: string;
-        httpEquiv?: string;
-        icon?: string;
-        id?: string;
-        label?: string;
-        lang?: string;
-        list?: string;
-        loop?: boolean;
-        low?: number;
-        manifest?: string;
-        marginHeight?: number;
-        marginWidth?: number;
-        max?: number | string;
-        maxLength?: number;
-        media?: string;
-        mediaGroup?: string;
-        method?: string;
-        min?: number | string;
-        multiple?: boolean;
-        muted?: boolean;
-        name?: string;
-        noValidate?: boolean;
-        open?: boolean;
-        optimum?: number;
-        pattern?: string;
-        placeholder?: string;
-        poster?: string;
-        preload?: string;
-        radioGroup?: string;
-        readOnly?: boolean;
-        rel?: string;
-        required?: boolean;
-        role?: string;
-        rows?: number;
-        rowSpan?: number;
-        sandbox?: string;
-        scope?: string;
-        scoped?: boolean;
-        scrolling?: string;
-        seamless?: boolean;
-        selected?: boolean;
-        shape?: string;
-        size?: number;
-        sizes?: string;
-        span?: number;
-        spellCheck?: boolean;
-        src?: string;
-        srcDoc?: string;
-        srcSet?: string;
-        start?: number;
-        step?: number | string;
-        style?: CSSProperties;
-        tabIndex?: number;
-        target?: string;
-        title?: string;
-        type?: string;
-        useMap?: string;
-        value?: string;
-        width?: number | string;
-        wmode?: string;
-
-        // Non-standard Attributes
-        autoCapitalize?: boolean;
-        autoCorrect?: boolean;
-        property?: string;
-        itemProp?: string;
-        itemScope?: boolean;
-        itemType?: string;
-        unselectable?: boolean;
-    }
-
-    interface SVGElementAttributes extends HTMLAttributes {
-        viewBox?: string;
-        preserveAspectRatio?: string;
-    }
-
-    interface SVGAttributes extends DOMAttributes {
-        ref?: string | ((component: SVGComponent) => void);
-
-        cx?: number | string;
-        cy?: number | string;
-        d?: string;
-        dx?: number | string;
-        dy?: number | string;
-        fill?: string;
-        fillOpacity?: number | string;
-        fontFamily?: string;
-        fontSize?: number | string;
-        fx?: number | string;
-        fy?: number | string;
-        gradientTransform?: string;
-        gradientUnits?: string;
-        height?: number | string;
-        markerEnd?: string;
-        markerMid?: string;
-        markerStart?: string;
-        offset?: number | string;
-        opacity?: number | string;
-        patternContentUnits?: string;
-        patternUnits?: string;
-        points?: string;
-        preserveAspectRatio?: string;
-        r?: number | string;
-        rx?: number | string;
-        ry?: number | string;
-        spreadMethod?: string;
-        stopColor?: string;
-        stopOpacity?: number | string;
-        stroke?: string;
-        strokeDasharray?: string;
-        strokeLinecap?: string;
-        strokeOpacity?: number | string;
-        strokeWidth?: number | string;
-        textAnchor?: string;
-        transform?: string;
-        version?: string;
-        viewBox?: string;
-        width?: number | string;
-        x1?: number | string;
-        x2?: number | string;
-        x?: number | string;
-        y1?: number | string;
-        y2?: number | string
-        y?: number | string;
-    }
-
-    //
-    // React.DOM
-    // ----------------------------------------------------------------------
-
-    interface ReactDOM {
-        // HTML
-        a: HTMLFactory;
-        abbr: HTMLFactory;
-        address: HTMLFactory;
-        area: HTMLFactory;
-        article: HTMLFactory;
-        aside: HTMLFactory;
-        audio: HTMLFactory;
-        b: HTMLFactory;
-        base: HTMLFactory;
-        bdi: HTMLFactory;
-        bdo: HTMLFactory;
-        big: HTMLFactory;
-        blockquote: HTMLFactory;
-        body: HTMLFactory;
-        br: HTMLFactory;
-        button: HTMLFactory;
-        canvas: HTMLFactory;
-        caption: HTMLFactory;
-        cite: HTMLFactory;
-        code: HTMLFactory;
-        col: HTMLFactory;
-        colgroup: HTMLFactory;
-        data: HTMLFactory;
-        datalist: HTMLFactory;
-        dd: HTMLFactory;
-        del: HTMLFactory;
-        details: HTMLFactory;
-        dfn: HTMLFactory;
-        dialog: HTMLFactory;
-        div: HTMLFactory;
-        dl: HTMLFactory;
-        dt: HTMLFactory;
-        em: HTMLFactory;
-        embed: HTMLFactory;
-        fieldset: HTMLFactory;
-        figcaption: HTMLFactory;
-        figure: HTMLFactory;
-        footer: HTMLFactory;
-        form: HTMLFactory;
-        h1: HTMLFactory;
-        h2: HTMLFactory;
-        h3: HTMLFactory;
-        h4: HTMLFactory;
-        h5: HTMLFactory;
-        h6: HTMLFactory;
-        head: HTMLFactory;
-        header: HTMLFactory;
-        hr: HTMLFactory;
-        html: HTMLFactory;
-        i: HTMLFactory;
-        iframe: HTMLFactory;
-        img: HTMLFactory;
-        input: HTMLFactory;
-        ins: HTMLFactory;
-        kbd: HTMLFactory;
-        keygen: HTMLFactory;
-        label: HTMLFactory;
-        legend: HTMLFactory;
-        li: HTMLFactory;
-        link: HTMLFactory;
-        main: HTMLFactory;
-        map: HTMLFactory;
-        mark: HTMLFactory;
-        menu: HTMLFactory;
-        menuitem: HTMLFactory;
-        meta: HTMLFactory;
-        meter: HTMLFactory;
-        nav: HTMLFactory;
-        noscript: HTMLFactory;
-        object: HTMLFactory;
-        ol: HTMLFactory;
-        optgroup: HTMLFactory;
-        option: HTMLFactory;
-        output: HTMLFactory;
-        p: HTMLFactory;
-        param: HTMLFactory;
-        picture: HTMLFactory;
-        pre: HTMLFactory;
-        progress: HTMLFactory;
-        q: HTMLFactory;
-        rp: HTMLFactory;
-        rt: HTMLFactory;
-        ruby: HTMLFactory;
-        s: HTMLFactory;
-        samp: HTMLFactory;
-        script: HTMLFactory;
-        section: HTMLFactory;
-        select: HTMLFactory;
-        small: HTMLFactory;
-        source: HTMLFactory;
-        span: HTMLFactory;
-        strong: HTMLFactory;
-        style: HTMLFactory;
-        sub: HTMLFactory;
-        summary: HTMLFactory;
-        sup: HTMLFactory;
-        table: HTMLFactory;
-        tbody: HTMLFactory;
-        td: HTMLFactory;
-        textarea: HTMLFactory;
-        tfoot: HTMLFactory;
-        th: HTMLFactory;
-        thead: HTMLFactory;
-        time: HTMLFactory;
-        title: HTMLFactory;
-        tr: HTMLFactory;
-        track: HTMLFactory;
-        u: HTMLFactory;
-        ul: HTMLFactory;
-        "var": HTMLFactory;
-        video: HTMLFactory;
-        wbr: HTMLFactory;
-
-        // SVG
-        svg: SVGElementFactory;
-        circle: SVGFactory;
-        defs: SVGFactory;
-        ellipse: SVGFactory;
-        g: SVGFactory;
-        line: SVGFactory;
-        linearGradient: SVGFactory;
-        mask: SVGFactory;
-        path: SVGFactory;
-        pattern: SVGFactory;
-        polygon: SVGFactory;
-        polyline: SVGFactory;
-        radialGradient: SVGFactory;
-        rect: SVGFactory;
-        stop: SVGFactory;
-        text: SVGFactory;
-        tspan: SVGFactory;
-    }
-
-    //
-    // React.PropTypes
-    // ----------------------------------------------------------------------
-
-    interface Validator<T> {
-        (object: T, key: string, componentName: string): Error;
-    }
-
-    interface Requireable<T> extends Validator<T> {
-        isRequired: Validator<T>;
-    }
-
-    interface ValidationMap<T> {
-        [key: string]: Validator<T>;
-    }
-
-    interface ReactPropTypes {
-        any: Requireable<any>;
-        array: Requireable<any>;
-        bool: Requireable<any>;
-        func: Requireable<any>;
-        number: Requireable<any>;
-        object: Requireable<any>;
-        string: Requireable<any>;
-        node: Requireable<any>;
-        element: Requireable<any>;
-        instanceOf(expectedClass: {}): Requireable<any>;
-        oneOf(types: any[]): Requireable<any>;
-        oneOfType(types: Validator<any>[]): Requireable<any>;
-        arrayOf(type: Validator<any>): Requireable<any>;
-        objectOf(type: Validator<any>): Requireable<any>;
-        shape(type: ValidationMap<any>): Requireable<any>;
-    }
-
-    //
-    // React.Children
-    // ----------------------------------------------------------------------
-
-    interface ReactChildren {
-        map<T>(children: ReactNode, fn: (child: ReactChild, index: number) => T): { [key:string]: T };
-        forEach(children: ReactNode, fn: (child: ReactChild, index: number) => any): void;
-        count(children: ReactNode): number;
-        only(children: ReactNode): ReactChild;
-    }
-
-    //
-    // Browser Interfaces
-    // https://github.com/nikeee/2048-typescript/blob/master/2048/js/touch.d.ts
-    // ----------------------------------------------------------------------
-
-    interface AbstractView {
-        styleMedia: StyleMedia;
-        document: Document;
-    }
-
-    interface Touch {
-        identifier: number;
-        target: EventTarget;
-        screenX: number;
-        screenY: number;
-        clientX: number;
-        clientY: number;
-        pageX: number;
-        pageY: number;
-    }
-
-    interface TouchList {
-        [index: number]: Touch;
-        length: number;
-        item(index: number): Touch;
-        identifiedTouch(identifier: number): Touch;
-    }
-}
-
-declare module JSX {
-    interface Element extends React.ReactElement<any> { }
-    interface ElementClass extends React.Component<any, any> {
-        render(): JSX.Element;
-    }
-    interface ElementAttributesProperty { props: {}; }
-
-    interface IntrinsicElements {
-        // HTML
-        a: React.HTMLAttributes;
-        abbr: React.HTMLAttributes;
-        address: React.HTMLAttributes;
-        area: React.HTMLAttributes;
-        article: React.HTMLAttributes;
-        aside: React.HTMLAttributes;
-        audio: React.HTMLAttributes;
-        b: React.HTMLAttributes;
-        base: React.HTMLAttributes;
-        bdi: React.HTMLAttributes;
-        bdo: React.HTMLAttributes;
-        big: React.HTMLAttributes;
-        blockquote: React.HTMLAttributes;
-        body: React.HTMLAttributes;
-        br: React.HTMLAttributes;
-        button: React.HTMLAttributes;
-        canvas: React.HTMLAttributes;
-        caption: React.HTMLAttributes;
-        cite: React.HTMLAttributes;
-        code: React.HTMLAttributes;
-        col: React.HTMLAttributes;
-        colgroup: React.HTMLAttributes;
-        data: React.HTMLAttributes;
-        datalist: React.HTMLAttributes;
-        dd: React.HTMLAttributes;
-        del: React.HTMLAttributes;
-        details: React.HTMLAttributes;
-        dfn: React.HTMLAttributes;
-        dialog: React.HTMLAttributes;
-        div: React.HTMLAttributes;
-        dl: React.HTMLAttributes;
-        dt: React.HTMLAttributes;
-        em: React.HTMLAttributes;
-        embed: React.HTMLAttributes;
-        fieldset: React.HTMLAttributes;
-        figcaption: React.HTMLAttributes;
-        figure: React.HTMLAttributes;
-        footer: React.HTMLAttributes;
-        form: React.HTMLAttributes;
-        h1: React.HTMLAttributes;
-        h2: React.HTMLAttributes;
-        h3: React.HTMLAttributes;
-        h4: React.HTMLAttributes;
-        h5: React.HTMLAttributes;
-        h6: React.HTMLAttributes;
-        head: React.HTMLAttributes;
-        header: React.HTMLAttributes;
-        hr: React.HTMLAttributes;
-        html: React.HTMLAttributes;
-        i: React.HTMLAttributes;
-        iframe: React.HTMLAttributes;
-        img: React.HTMLAttributes;
-        input: React.HTMLAttributes;
-        ins: React.HTMLAttributes;
-        kbd: React.HTMLAttributes;
-        keygen: React.HTMLAttributes;
-        label: React.HTMLAttributes;
-        legend: React.HTMLAttributes;
-        li: React.HTMLAttributes;
-        link: React.HTMLAttributes;
-        main: React.HTMLAttributes;
-        map: React.HTMLAttributes;
-        mark: React.HTMLAttributes;
-        menu: React.HTMLAttributes;
-        menuitem: React.HTMLAttributes;
-        meta: React.HTMLAttributes;
-        meter: React.HTMLAttributes;
-        nav: React.HTMLAttributes;
-        noscript: React.HTMLAttributes;
-        object: React.HTMLAttributes;
-        ol: React.HTMLAttributes;
-        optgroup: React.HTMLAttributes;
-        option: React.HTMLAttributes;
-        output: React.HTMLAttributes;
-        p: React.HTMLAttributes;
-        param: React.HTMLAttributes;
-        picture: React.HTMLAttributes;
-        pre: React.HTMLAttributes;
-        progress: React.HTMLAttributes;
-        q: React.HTMLAttributes;
-        rp: React.HTMLAttributes;
-        rt: React.HTMLAttributes;
-        ruby: React.HTMLAttributes;
-        s: React.HTMLAttributes;
-        samp: React.HTMLAttributes;
-        script: React.HTMLAttributes;
-        section: React.HTMLAttributes;
-        select: React.HTMLAttributes;
-        small: React.HTMLAttributes;
-        source: React.HTMLAttributes;
-        span: React.HTMLAttributes;
-        strong: React.HTMLAttributes;
-        style: React.HTMLAttributes;
-        sub: React.HTMLAttributes;
-        summary: React.HTMLAttributes;
-        sup: React.HTMLAttributes;
-        table: React.HTMLAttributes;
-        tbody: React.HTMLAttributes;
-        td: React.HTMLAttributes;
-        textarea: React.HTMLAttributes;
-        tfoot: React.HTMLAttributes;
-        th: React.HTMLAttributes;
-        thead: React.HTMLAttributes;
-        time: React.HTMLAttributes;
-        title: React.HTMLAttributes;
-        tr: React.HTMLAttributes;
-        track: React.HTMLAttributes;
-        u: React.HTMLAttributes;
-        ul: React.HTMLAttributes;
-        "var": React.HTMLAttributes;
-        video: React.HTMLAttributes;
-        wbr: React.HTMLAttributes;
-
-        // SVG
-        svg: React.SVGElementAttributes;
-
-        circle: React.SVGAttributes;
-        defs: React.SVGAttributes;
-        ellipse: React.SVGAttributes;
-        g: React.SVGAttributes;
-        line: React.SVGAttributes;
-        linearGradient: React.SVGAttributes;
-        mask: React.SVGAttributes;
-        path: React.SVGAttributes;
-        pattern: React.SVGAttributes;
-        polygon: React.SVGAttributes;
-        polyline: React.SVGAttributes;
-        radialGradient: React.SVGAttributes;
-        rect: React.SVGAttributes;
-        stop: React.SVGAttributes;
-        text: React.SVGAttributes;
-        tspan: React.SVGAttributes;
+    class ShallowRenderer {
+        getRenderOutput<E extends ReactElement<any>>(): E;
+        getRenderOutput(): ReactElement<any>;
+        render(element: ReactElement<any>, context?: any): void;
+        unmount(): void;
     }
 }
diff --git a/react/react.d.ts b/react/react.d.ts
index a124e7b50d..54d13d5eb2 100644
--- a/react/react.d.ts
+++ b/react/react.d.ts
@@ -1,9 +1,9 @@
-// Type definitions for React v0.13.1 (external module)
+// Type definitions for React v0.13.3
 // Project: http://facebook.github.io/react/
 // Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-declare module __React {
+declare namespace __React {
     //
     // React Elements
     // ----------------------------------------------------------------------
@@ -135,7 +135,7 @@ declare module __React {
         constructor(props?: P, context?: any);
         setState(f: (prevState: S, props: P) => S, callback?: () => any): void;
         setState(state: S, callback?: () => any): void;
-        forceUpdate(): void;
+        forceUpdate(callBack?: () => any): void;
         render(): JSX.Element;
         props: P;
         state: S;
@@ -403,7 +403,7 @@ declare module __React {
         strokeOpacity?: number;
         strokeWidth?: number;
 
-        [propertyName: string]: string | number | boolean;
+        [propertyName: string]: any;
     }
 
     interface HTMLAttributes extends DOMAttributes {
@@ -800,7 +800,1070 @@ declare module "react" {
     export = __React;
 }
 
-declare module JSX {
+declare module "react/addons" {
+    //
+    // React Elements
+    // ----------------------------------------------------------------------
+
+    type ReactType = ComponentClass<any> | string;
+
+    interface ReactElement<P> {
+        type: string | ComponentClass<P>;
+        props: P;
+        key: string | number;
+        ref: string | ((component: Component<P, any>) => any);
+    }
+
+    interface ClassicElement<P> extends ReactElement<P> {
+        type: string | ClassicComponentClass<P>;
+        ref: string | ((component: ClassicComponent<P, any>) => any);
+    }
+
+    interface DOMElement<P> extends ClassicElement<P> {
+        type: string;
+        ref: string | ((component: DOMComponent<P>) => any);
+    }
+
+    type HTMLElement = DOMElement<HTMLAttributes>;
+    type SVGElement = DOMElement<SVGAttributes>;
+
+    //
+    // Factories
+    // ----------------------------------------------------------------------
+
+    interface Factory<P> {
+        (props?: P, ...children: ReactNode[]): ReactElement<P>;
+    }
+
+    interface ClassicFactory<P> extends Factory<P> {
+        (props?: P, ...children: ReactNode[]): ClassicElement<P>;
+    }
+
+    interface DOMFactory<P> extends ClassicFactory<P> {
+        (props?: P, ...children: ReactNode[]): DOMElement<P>;
+    }
+
+    type HTMLFactory = DOMFactory<HTMLAttributes>;
+    type SVGFactory = DOMFactory<SVGAttributes>;
+    type SVGElementFactory = DOMFactory<SVGElementAttributes>;
+
+    //
+    // React Nodes
+    // http://facebook.github.io/react/docs/glossary.html
+    // ----------------------------------------------------------------------
+
+    type ReactText = string | number;
+    type ReactChild = ReactElement<any> | ReactText;
+
+    // Should be Array<ReactNode> but type aliases cannot be recursive
+    type ReactFragment = {} | Array<ReactChild | any[] | boolean>;
+    type ReactNode = ReactChild | ReactFragment | boolean;
+
+    //
+    // Top Level API
+    // ----------------------------------------------------------------------
+
+    function createClass<P, S>(spec: ComponentSpec<P, S>): ClassicComponentClass<P>;
+
+    function createFactory<P>(type: string): DOMFactory<P>;
+    function createFactory<P>(type: ClassicComponentClass<P> | string): ClassicFactory<P>;
+    function createFactory<P>(type: ComponentClass<P>): Factory<P>;
+
+    function createElement<P>(
+        type: string,
+        props?: P,
+        ...children: ReactNode[]): DOMElement<P>;
+    function createElement<P>(
+        type: ClassicComponentClass<P> | string,
+        props?: P,
+        ...children: ReactNode[]): ClassicElement<P>;
+    function createElement<P>(
+        type: ComponentClass<P>,
+        props?: P,
+        ...children: ReactNode[]): ReactElement<P>;
+
+    function cloneElement<P>(
+        element: DOMElement<P>,
+        props?: P,
+        ...children: ReactNode[]): DOMElement<P>;
+    function cloneElement<P>(
+        element: ClassicElement<P>,
+        props?: P,
+        ...children: ReactNode[]): ClassicElement<P>;
+    function cloneElement<P>(
+        element: ReactElement<P>,
+        props?: P,
+        ...children: ReactNode[]): ReactElement<P>;
+
+    function render<P>(
+        element: DOMElement<P>,
+        container: Element,
+        callback?: () => any): DOMComponent<P>;
+    function render<P, S>(
+        element: ClassicElement<P>,
+        container: Element,
+        callback?: () => any): ClassicComponent<P, S>;
+    function render<P, S>(
+        element: ReactElement<P>,
+        container: Element,
+        callback?: () => any): Component<P, S>;
+
+    function unmountComponentAtNode(container: Element): boolean;
+    function renderToString(element: ReactElement<any>): string;
+    function renderToStaticMarkup(element: ReactElement<any>): string;
+    function isValidElement(object: {}): boolean;
+    function initializeTouchEvents(shouldUseTouch: boolean): void;
+
+    function findDOMNode<TElement extends Element>(
+        componentOrElement: Component<any, any> | Element): TElement;
+    function findDOMNode(
+        componentOrElement: Component<any, any> | Element): Element;
+
+    var DOM: ReactDOM;
+    var PropTypes: ReactPropTypes;
+    var Children: ReactChildren;
+
+    //
+    // Component API
+    // ----------------------------------------------------------------------
+
+    // Base component for plain JS classes
+    class Component<P, S> implements ComponentLifecycle<P, S> {
+        constructor(props?: P, context?: any);
+        setState(f: (prevState: S, props: P) => S, callback?: () => any): void;
+        setState(state: S, callback?: () => any): void;
+        forceUpdate(callBack?: () => any): void;
+        render(): JSX.Element;
+        props: P;
+        state: S;
+        context: {};
+        refs: {
+            [key: string]: Component<any, any>
+        };
+    }
+
+    interface ClassicComponent<P, S> extends Component<P, S> {
+        replaceState(nextState: S, callback?: () => any): void;
+        getDOMNode<TElement extends Element>(): TElement;
+        getDOMNode(): Element;
+        isMounted(): boolean;
+        getInitialState?(): S;
+        setProps(nextProps: P, callback?: () => any): void;
+        replaceProps(nextProps: P, callback?: () => any): void;
+    }
+
+    interface DOMComponent<P> extends ClassicComponent<P, any> {
+        tagName: string;
+    }
+
+    type HTMLComponent = DOMComponent<HTMLAttributes>;
+    type SVGComponent = DOMComponent<SVGAttributes>;
+
+    interface ChildContextProvider<CC> {
+        getChildContext(): CC;
+    }
+
+    //
+    // Class Interfaces
+    // ----------------------------------------------------------------------
+
+    interface ComponentClass<P> {
+        new(props?: P, context?: any): Component<P, any>;
+        propTypes?: ValidationMap<P>;
+        contextTypes?: ValidationMap<any>;
+        childContextTypes?: ValidationMap<any>;
+        defaultProps?: P;
+    }
+
+    interface ClassicComponentClass<P> extends ComponentClass<P> {
+        new(props?: P, context?: any): ClassicComponent<P, any>;
+        getDefaultProps?(): P;
+        displayName?: string;
+    }
+
+    //
+    // Component Specs and Lifecycle
+    // ----------------------------------------------------------------------
+
+    interface ComponentLifecycle<P, S> {
+        componentWillMount?(): void;
+        componentDidMount?(): void;
+        componentWillReceiveProps?(nextProps: P, nextContext: any): void;
+        shouldComponentUpdate?(nextProps: P, nextState: S, nextContext: any): boolean;
+        componentWillUpdate?(nextProps: P, nextState: S, nextContext: any): void;
+        componentDidUpdate?(prevProps: P, prevState: S, prevContext: any): void;
+        componentWillUnmount?(): void;
+    }
+
+    interface Mixin<P, S> extends ComponentLifecycle<P, S> {
+        mixins?: Mixin<P, S>;
+        statics?: {
+            [key: string]: any;
+        };
+
+        displayName?: string;
+        propTypes?: ValidationMap<any>;
+        contextTypes?: ValidationMap<any>;
+        childContextTypes?: ValidationMap<any>
+
+        getDefaultProps?(): P;
+        getInitialState?(): S;
+    }
+
+    interface ComponentSpec<P, S> extends Mixin<P, S> {
+        render(): ReactElement<any>;
+
+        [propertyName: string]: any;
+    }
+
+    //
+    // Event System
+    // ----------------------------------------------------------------------
+
+    interface SyntheticEvent {
+        bubbles: boolean;
+        cancelable: boolean;
+        currentTarget: EventTarget;
+        defaultPrevented: boolean;
+        eventPhase: number;
+        isTrusted: boolean;
+        nativeEvent: Event;
+        preventDefault(): void;
+        stopPropagation(): void;
+        target: EventTarget;
+        timeStamp: Date;
+        type: string;
+    }
+
+    interface DragEvent extends SyntheticEvent {
+        dataTransfer: DataTransfer;
+    }
+
+    interface ClipboardEvent extends SyntheticEvent {
+        clipboardData: DataTransfer;
+    }
+
+    interface KeyboardEvent extends SyntheticEvent {
+        altKey: boolean;
+        charCode: number;
+        ctrlKey: boolean;
+        getModifierState(key: string): boolean;
+        key: string;
+        keyCode: number;
+        locale: string;
+        location: number;
+        metaKey: boolean;
+        repeat: boolean;
+        shiftKey: boolean;
+        which: number;
+    }
+
+    interface FocusEvent extends SyntheticEvent {
+        relatedTarget: EventTarget;
+    }
+
+    interface FormEvent extends SyntheticEvent {
+    }
+
+    interface MouseEvent extends SyntheticEvent {
+        altKey: boolean;
+        button: number;
+        buttons: number;
+        clientX: number;
+        clientY: number;
+        ctrlKey: boolean;
+        getModifierState(key: string): boolean;
+        metaKey: boolean;
+        pageX: number;
+        pageY: number;
+        relatedTarget: EventTarget;
+        screenX: number;
+        screenY: number;
+        shiftKey: boolean;
+    }
+
+    interface TouchEvent extends SyntheticEvent {
+        altKey: boolean;
+        changedTouches: TouchList;
+        ctrlKey: boolean;
+        getModifierState(key: string): boolean;
+        metaKey: boolean;
+        shiftKey: boolean;
+        targetTouches: TouchList;
+        touches: TouchList;
+    }
+
+    interface UIEvent extends SyntheticEvent {
+        detail: number;
+        view: AbstractView;
+    }
+
+    interface WheelEvent extends SyntheticEvent {
+        deltaMode: number;
+        deltaX: number;
+        deltaY: number;
+        deltaZ: number;
+    }
+
+    //
+    // Event Handler Types
+    // ----------------------------------------------------------------------
+
+    interface EventHandler<E extends SyntheticEvent> {
+        (event: E): void;
+    }
+
+    interface DragEventHandler extends EventHandler<DragEvent> {}
+    interface ClipboardEventHandler extends EventHandler<ClipboardEvent> {}
+    interface KeyboardEventHandler extends EventHandler<KeyboardEvent> {}
+    interface FocusEventHandler extends EventHandler<FocusEvent> {}
+    interface FormEventHandler extends EventHandler<FormEvent> {}
+    interface MouseEventHandler extends EventHandler<MouseEvent> {}
+    interface TouchEventHandler extends EventHandler<TouchEvent> {}
+    interface UIEventHandler extends EventHandler<UIEvent> {}
+    interface WheelEventHandler extends EventHandler<WheelEvent> {}
+
+    //
+    // Props / DOM Attributes
+    // ----------------------------------------------------------------------
+
+    interface Props<T> {
+        children?: ReactNode;
+        key?: string | number;
+        ref?: string | ((component: T) => any);
+    }
+
+    interface DOMAttributes extends Props<DOMComponent<any>> {
+        onCopy?: ClipboardEventHandler;
+        onCut?: ClipboardEventHandler;
+        onPaste?: ClipboardEventHandler;
+        onKeyDown?: KeyboardEventHandler;
+        onKeyPress?: KeyboardEventHandler;
+        onKeyUp?: KeyboardEventHandler;
+        onFocus?: FocusEventHandler;
+        onBlur?: FocusEventHandler;
+        onChange?: FormEventHandler;
+        onInput?: FormEventHandler;
+        onSubmit?: FormEventHandler;
+        onClick?: MouseEventHandler;
+        onDoubleClick?: MouseEventHandler;
+        onDrag?: DragEventHandler;
+        onDragEnd?: DragEventHandler;
+        onDragEnter?: DragEventHandler;
+        onDragExit?: DragEventHandler;
+        onDragLeave?: DragEventHandler;
+        onDragOver?: DragEventHandler;
+        onDragStart?: DragEventHandler;
+        onDrop?: DragEventHandler;
+        onMouseDown?: MouseEventHandler;
+        onMouseEnter?: MouseEventHandler;
+        onMouseLeave?: MouseEventHandler;
+        onMouseMove?: MouseEventHandler;
+        onMouseOut?: MouseEventHandler;
+        onMouseOver?: MouseEventHandler;
+        onMouseUp?: MouseEventHandler;
+        onTouchCancel?: TouchEventHandler;
+        onTouchEnd?: TouchEventHandler;
+        onTouchMove?: TouchEventHandler;
+        onTouchStart?: TouchEventHandler;
+        onScroll?: UIEventHandler;
+        onWheel?: WheelEventHandler;
+
+        dangerouslySetInnerHTML?: {
+            __html: string;
+        };
+    }
+
+    // This interface is not complete. Only properties accepting
+    // unitless numbers are listed here (see CSSProperty.js in React)
+    interface CSSProperties {
+        boxFlex?: number;
+        boxFlexGroup?: number;
+        columnCount?: number;
+        flex?: number | string;
+        flexGrow?: number;
+        flexShrink?: number;
+        fontWeight?: number | string;
+        lineClamp?: number;
+        lineHeight?: number | string;
+        opacity?: number;
+        order?: number;
+        orphans?: number;
+        widows?: number;
+        zIndex?: number;
+        zoom?: number;
+
+        fontSize?: number | string;
+
+        // SVG-related properties
+        fillOpacity?: number;
+        strokeOpacity?: number;
+        strokeWidth?: number;
+
+        [propertyName: string]: any;
+    }
+
+    interface HTMLAttributes extends DOMAttributes {
+        ref?: string | ((component: HTMLComponent) => void);
+
+        accept?: string;
+        acceptCharset?: string;
+        accessKey?: string;
+        action?: string;
+        allowFullScreen?: boolean;
+        allowTransparency?: boolean;
+        alt?: string;
+        async?: boolean;
+        autoComplete?: boolean;
+        autoFocus?: boolean;
+        autoPlay?: boolean;
+        cellPadding?: number | string;
+        cellSpacing?: number | string;
+        charSet?: string;
+        checked?: boolean;
+        classID?: string;
+        className?: string;
+        cols?: number;
+        colSpan?: number;
+        content?: string;
+        contentEditable?: boolean;
+        contextMenu?: string;
+        controls?: any;
+        coords?: string;
+        crossOrigin?: string;
+        data?: string;
+        dateTime?: string;
+        defaultChecked?: boolean;
+        defaultValue?: string;
+        defer?: boolean;
+        dir?: string;
+        disabled?: boolean;
+        download?: any;
+        draggable?: boolean;
+        encType?: string;
+        form?: string;
+        formAction?: string;
+        formEncType?: string;
+        formMethod?: string;
+        formNoValidate?: boolean;
+        formTarget?: string;
+        frameBorder?: number | string;
+        headers?: string;
+        height?: number | string;
+        hidden?: boolean;
+        high?: number;
+        href?: string;
+        hrefLang?: string;
+        htmlFor?: string;
+        httpEquiv?: string;
+        icon?: string;
+        id?: string;
+        label?: string;
+        lang?: string;
+        list?: string;
+        loop?: boolean;
+        low?: number;
+        manifest?: string;
+        marginHeight?: number;
+        marginWidth?: number;
+        max?: number | string;
+        maxLength?: number;
+        media?: string;
+        mediaGroup?: string;
+        method?: string;
+        min?: number | string;
+        multiple?: boolean;
+        muted?: boolean;
+        name?: string;
+        noValidate?: boolean;
+        open?: boolean;
+        optimum?: number;
+        pattern?: string;
+        placeholder?: string;
+        poster?: string;
+        preload?: string;
+        radioGroup?: string;
+        readOnly?: boolean;
+        rel?: string;
+        required?: boolean;
+        role?: string;
+        rows?: number;
+        rowSpan?: number;
+        sandbox?: string;
+        scope?: string;
+        scoped?: boolean;
+        scrolling?: string;
+        seamless?: boolean;
+        selected?: boolean;
+        shape?: string;
+        size?: number;
+        sizes?: string;
+        span?: number;
+        spellCheck?: boolean;
+        src?: string;
+        srcDoc?: string;
+        srcSet?: string;
+        start?: number;
+        step?: number | string;
+        style?: CSSProperties;
+        tabIndex?: number;
+        target?: string;
+        title?: string;
+        type?: string;
+        useMap?: string;
+        value?: string;
+        width?: number | string;
+        wmode?: string;
+
+        // Non-standard Attributes
+        autoCapitalize?: boolean;
+        autoCorrect?: boolean;
+        property?: string;
+        itemProp?: string;
+        itemScope?: boolean;
+        itemType?: string;
+        unselectable?: boolean;
+    }
+
+    interface SVGElementAttributes extends HTMLAttributes {
+        viewBox?: string;
+        preserveAspectRatio?: string;
+    }
+
+    interface SVGAttributes extends DOMAttributes {
+        ref?: string | ((component: SVGComponent) => void);
+
+        cx?: number | string;
+        cy?: number | string;
+        d?: string;
+        dx?: number | string;
+        dy?: number | string;
+        fill?: string;
+        fillOpacity?: number | string;
+        fontFamily?: string;
+        fontSize?: number | string;
+        fx?: number | string;
+        fy?: number | string;
+        gradientTransform?: string;
+        gradientUnits?: string;
+        height?: number | string;
+        markerEnd?: string;
+        markerMid?: string;
+        markerStart?: string;
+        offset?: number | string;
+        opacity?: number | string;
+        patternContentUnits?: string;
+        patternUnits?: string;
+        points?: string;
+        preserveAspectRatio?: string;
+        r?: number | string;
+        rx?: number | string;
+        ry?: number | string;
+        spreadMethod?: string;
+        stopColor?: string;
+        stopOpacity?: number | string;
+        stroke?: string;
+        strokeDasharray?: string;
+        strokeLinecap?: string;
+        strokeOpacity?: number | string;
+        strokeWidth?: number | string;
+        textAnchor?: string;
+        transform?: string;
+        version?: string;
+        viewBox?: string;
+        width?: number | string;
+        x1?: number | string;
+        x2?: number | string;
+        x?: number | string;
+        y1?: number | string;
+        y2?: number | string
+        y?: number | string;
+    }
+
+    //
+    // React.DOM
+    // ----------------------------------------------------------------------
+
+    interface ReactDOM {
+        // HTML
+        a: HTMLFactory;
+        abbr: HTMLFactory;
+        address: HTMLFactory;
+        area: HTMLFactory;
+        article: HTMLFactory;
+        aside: HTMLFactory;
+        audio: HTMLFactory;
+        b: HTMLFactory;
+        base: HTMLFactory;
+        bdi: HTMLFactory;
+        bdo: HTMLFactory;
+        big: HTMLFactory;
+        blockquote: HTMLFactory;
+        body: HTMLFactory;
+        br: HTMLFactory;
+        button: HTMLFactory;
+        canvas: HTMLFactory;
+        caption: HTMLFactory;
+        cite: HTMLFactory;
+        code: HTMLFactory;
+        col: HTMLFactory;
+        colgroup: HTMLFactory;
+        data: HTMLFactory;
+        datalist: HTMLFactory;
+        dd: HTMLFactory;
+        del: HTMLFactory;
+        details: HTMLFactory;
+        dfn: HTMLFactory;
+        dialog: HTMLFactory;
+        div: HTMLFactory;
+        dl: HTMLFactory;
+        dt: HTMLFactory;
+        em: HTMLFactory;
+        embed: HTMLFactory;
+        fieldset: HTMLFactory;
+        figcaption: HTMLFactory;
+        figure: HTMLFactory;
+        footer: HTMLFactory;
+        form: HTMLFactory;
+        h1: HTMLFactory;
+        h2: HTMLFactory;
+        h3: HTMLFactory;
+        h4: HTMLFactory;
+        h5: HTMLFactory;
+        h6: HTMLFactory;
+        head: HTMLFactory;
+        header: HTMLFactory;
+        hr: HTMLFactory;
+        html: HTMLFactory;
+        i: HTMLFactory;
+        iframe: HTMLFactory;
+        img: HTMLFactory;
+        input: HTMLFactory;
+        ins: HTMLFactory;
+        kbd: HTMLFactory;
+        keygen: HTMLFactory;
+        label: HTMLFactory;
+        legend: HTMLFactory;
+        li: HTMLFactory;
+        link: HTMLFactory;
+        main: HTMLFactory;
+        map: HTMLFactory;
+        mark: HTMLFactory;
+        menu: HTMLFactory;
+        menuitem: HTMLFactory;
+        meta: HTMLFactory;
+        meter: HTMLFactory;
+        nav: HTMLFactory;
+        noscript: HTMLFactory;
+        object: HTMLFactory;
+        ol: HTMLFactory;
+        optgroup: HTMLFactory;
+        option: HTMLFactory;
+        output: HTMLFactory;
+        p: HTMLFactory;
+        param: HTMLFactory;
+        picture: HTMLFactory;
+        pre: HTMLFactory;
+        progress: HTMLFactory;
+        q: HTMLFactory;
+        rp: HTMLFactory;
+        rt: HTMLFactory;
+        ruby: HTMLFactory;
+        s: HTMLFactory;
+        samp: HTMLFactory;
+        script: HTMLFactory;
+        section: HTMLFactory;
+        select: HTMLFactory;
+        small: HTMLFactory;
+        source: HTMLFactory;
+        span: HTMLFactory;
+        strong: HTMLFactory;
+        style: HTMLFactory;
+        sub: HTMLFactory;
+        summary: HTMLFactory;
+        sup: HTMLFactory;
+        table: HTMLFactory;
+        tbody: HTMLFactory;
+        td: HTMLFactory;
+        textarea: HTMLFactory;
+        tfoot: HTMLFactory;
+        th: HTMLFactory;
+        thead: HTMLFactory;
+        time: HTMLFactory;
+        title: HTMLFactory;
+        tr: HTMLFactory;
+        track: HTMLFactory;
+        u: HTMLFactory;
+        ul: HTMLFactory;
+        "var": HTMLFactory;
+        video: HTMLFactory;
+        wbr: HTMLFactory;
+
+        // SVG
+        svg: SVGElementFactory;
+        circle: SVGFactory;
+        defs: SVGFactory;
+        ellipse: SVGFactory;
+        g: SVGFactory;
+        line: SVGFactory;
+        linearGradient: SVGFactory;
+        mask: SVGFactory;
+        path: SVGFactory;
+        pattern: SVGFactory;
+        polygon: SVGFactory;
+        polyline: SVGFactory;
+        radialGradient: SVGFactory;
+        rect: SVGFactory;
+        stop: SVGFactory;
+        text: SVGFactory;
+        tspan: SVGFactory;
+    }
+
+    //
+    // React.PropTypes
+    // ----------------------------------------------------------------------
+
+    interface Validator<T> {
+        (object: T, key: string, componentName: string): Error;
+    }
+
+    interface Requireable<T> extends Validator<T> {
+        isRequired: Validator<T>;
+    }
+
+    interface ValidationMap<T> {
+        [key: string]: Validator<T>;
+    }
+
+    interface ReactPropTypes {
+        any: Requireable<any>;
+        array: Requireable<any>;
+        bool: Requireable<any>;
+        func: Requireable<any>;
+        number: Requireable<any>;
+        object: Requireable<any>;
+        string: Requireable<any>;
+        node: Requireable<any>;
+        element: Requireable<any>;
+        instanceOf(expectedClass: {}): Requireable<any>;
+        oneOf(types: any[]): Requireable<any>;
+        oneOfType(types: Validator<any>[]): Requireable<any>;
+        arrayOf(type: Validator<any>): Requireable<any>;
+        objectOf(type: Validator<any>): Requireable<any>;
+        shape(type: ValidationMap<any>): Requireable<any>;
+    }
+
+    //
+    // React.Children
+    // ----------------------------------------------------------------------
+
+    interface ReactChildren {
+        map<T>(children: ReactNode, fn: (child: ReactChild, index: number) => T): { [key:string]: T };
+        forEach(children: ReactNode, fn: (child: ReactChild, index: number) => any): void;
+        count(children: ReactNode): number;
+        only(children: ReactNode): ReactChild;
+    }
+
+    //
+    // Browser Interfaces
+    // https://github.com/nikeee/2048-typescript/blob/master/2048/js/touch.d.ts
+    // ----------------------------------------------------------------------
+
+    interface AbstractView {
+        styleMedia: StyleMedia;
+        document: Document;
+    }
+
+    interface Touch {
+        identifier: number;
+        target: EventTarget;
+        screenX: number;
+        screenY: number;
+        clientX: number;
+        clientY: number;
+        pageX: number;
+        pageY: number;
+    }
+
+    interface TouchList {
+        [index: number]: Touch;
+        length: number;
+        item(index: number): Touch;
+        identifiedTouch(identifier: number): Touch;
+    }
+    
+    //
+    // React.addons
+    // ----------------------------------------------------------------------
+
+    export module addons {
+        export var CSSTransitionGroup: CSSTransitionGroup;
+        export var TransitionGroup: TransitionGroup;
+
+        export var LinkedStateMixin: LinkedStateMixin;
+        export var PureRenderMixin: PureRenderMixin;
+
+        export function batchedUpdates<A, B>(
+            callback: (a: A, b: B) => any, a: A, b: B): void;
+        export function batchedUpdates<A>(callback: (a: A) => any, a: A): void;
+        export function batchedUpdates(callback: () => any): void;
+
+        // deprecated: use petehunt/react-classset or JedWatson/classnames
+        export function classSet(cx: { [key: string]: boolean }): string;
+        export function classSet(...classList: string[]): string;
+
+        export function cloneWithProps<P>(
+            element: DOMElement<P>, props: P): DOMElement<P>;
+        export function cloneWithProps<P>(
+            element: ClassicElement<P>, props: P): ClassicElement<P>;
+        export function cloneWithProps<P>(
+            element: ReactElement<P>, props: P): ReactElement<P>;
+
+        export function createFragment(
+            object: { [key: string]: ReactNode }): ReactFragment;
+
+        export function update(value: any[], spec: UpdateArraySpec): any[];
+        export function update(value: {}, spec: UpdateSpec): any;
+
+        // Development tools
+        export import Perf = ReactPerf;
+        export import TestUtils = ReactTestUtils;
+    }
+
+    //
+    // React.addons (Transitions)
+    // ----------------------------------------------------------------------
+
+    interface TransitionGroupProps {
+        component?: ReactType;
+        childFactory?: (child: ReactElement<any>) => ReactElement<any>;
+    }
+
+    interface CSSTransitionGroupProps extends TransitionGroupProps {
+        transitionName: string;
+        transitionAppear?: boolean;
+        transitionEnter?: boolean;
+        transitionLeave?: boolean;
+    }
+
+    type CSSTransitionGroup = ComponentClass<CSSTransitionGroupProps>;
+    type TransitionGroup = ComponentClass<TransitionGroupProps>;
+
+    //
+    // React.addons (Mixins)
+    // ----------------------------------------------------------------------
+
+    interface ReactLink<T> {
+        value: T;
+        requestChange(newValue: T): void;
+    }
+
+    interface LinkedStateMixin extends Mixin<any, any> {
+        linkState<T>(key: string): ReactLink<T>;
+    }
+
+    interface PureRenderMixin extends Mixin<any, any> {
+    }
+
+    //
+    // Reat.addons.update
+    // ----------------------------------------------------------------------
+
+    interface UpdateSpec {
+        $set?: any;
+        $merge?: {};
+        $apply?(value: any): any;
+        // [key: string]: UpdateSpec;
+    }
+
+    interface UpdateArraySpec extends UpdateSpec {
+        $push?: any[];
+        $unshift?: any[];
+        $splice?: any[][];
+    }
+
+    //
+    // React.addons.Perf
+    // ----------------------------------------------------------------------
+
+    interface ComponentPerfContext {
+        current: string;
+        owner: string;
+    }
+
+    interface NumericPerfContext {
+        [key: string]: number;
+    }
+
+    interface Measurements {
+        exclusive: NumericPerfContext;
+        inclusive: NumericPerfContext;
+        render: NumericPerfContext;
+        counts: NumericPerfContext;
+        writes: NumericPerfContext;
+        displayNames: {
+            [key: string]: ComponentPerfContext;
+        };
+        totalTime: number;
+    }
+
+    module ReactPerf {
+        export function start(): void;
+        export function stop(): void;
+        export function printInclusive(measurements: Measurements[]): void;
+        export function printExclusive(measurements: Measurements[]): void;
+        export function printWasted(measurements: Measurements[]): void;
+        export function printDOM(measurements: Measurements[]): void;
+        export function getLastMeasurements(): Measurements[];
+    }
+
+    //
+    // React.addons.TestUtils
+    // ----------------------------------------------------------------------
+
+    interface MockedComponentClass {
+        new(): any;
+    }
+
+    module ReactTestUtils {
+        export import Simulate = ReactSimulate;
+
+        export function renderIntoDocument<P>(
+            element: ReactElement<P>): Component<P, any>;
+        export function renderIntoDocument<C extends Component<any, any>>(
+            element: ReactElement<any>): C;
+
+        export function mockComponent(
+            mocked: MockedComponentClass, mockTagName?: string): typeof ReactTestUtils;
+
+        export function isElementOfType(
+            element: ReactElement<any>, type: ReactType): boolean;
+        export function isTextComponent(instance: Component<any, any>): boolean;
+        export function isDOMComponent(instance: Component<any, any>): boolean;
+        export function isCompositeComponent(instance: Component<any, any>): boolean;
+        export function isCompositeComponentWithType(
+            instance: Component<any, any>,
+            type: ComponentClass<any>): boolean;
+
+        export function findAllInRenderedTree(
+            tree: Component<any, any>,
+            fn: (i: Component<any, any>) => boolean): Component<any, any>;
+
+        export function scryRenderedDOMComponentsWithClass(
+            tree: Component<any, any>,
+            className: string): DOMComponent<any>[];
+        export function findRenderedDOMComponentWithClass(
+            tree: Component<any, any>,
+            className: string): DOMComponent<any>;
+
+        export function scryRenderedDOMComponentsWithTag(
+            tree: Component<any, any>,
+            tagName: string): DOMComponent<any>[];
+        export function findRenderedDOMComponentWithTag(
+            tree: Component<any, any>,
+            tagName: string): DOMComponent<any>;
+
+        export function scryRenderedComponentsWithType<P>(
+            tree: Component<any, any>,
+            type: ComponentClass<P>): Component<P, {}>[];
+        export function scryRenderedComponentsWithType<C extends Component<any, any>>(
+            tree: Component<any, any>,
+            type: ComponentClass<any>): C[];
+
+        export function findRenderedComponentWithType<P>(
+            tree: Component<any, any>,
+            type: ComponentClass<P>): Component<P, {}>;
+        export function findRenderedComponentWithType<C extends Component<any, any>>(
+            tree: Component<any, any>,
+            type: ComponentClass<any>): C;
+
+        export function createRenderer(): ShallowRenderer;
+    }
+
+    interface SyntheticEventData {
+        altKey?: boolean;
+        button?: number;
+        buttons?: number;
+        clientX?: number;
+        clientY?: number;
+        changedTouches?: TouchList;
+        charCode?: boolean;
+        clipboardData?: DataTransfer;
+        ctrlKey?: boolean;
+        deltaMode?: number;
+        deltaX?: number;
+        deltaY?: number;
+        deltaZ?: number;
+        detail?: number;
+        getModifierState?(key: string): boolean;
+        key?: string;
+        keyCode?: number;
+        locale?: string;
+        location?: number;
+        metaKey?: boolean;
+        pageX?: number;
+        pageY?: number;
+        relatedTarget?: EventTarget;
+        repeat?: boolean;
+        screenX?: number;
+        screenY?: number;
+        shiftKey?: boolean;
+        targetTouches?: TouchList;
+        touches?: TouchList;
+        view?: AbstractView;
+        which?: number;
+    }
+
+    interface EventSimulator {
+        (element: Element, eventData?: SyntheticEventData): void;
+        (component: Component<any, any>, eventData?: SyntheticEventData): void;
+    }
+
+    module ReactSimulate {
+        export var blur: EventSimulator;
+        export var change: EventSimulator;
+        export var click: EventSimulator;
+        export var cut: EventSimulator;
+        export var doubleClick: EventSimulator;
+        export var drag: EventSimulator;
+        export var dragEnd: EventSimulator;
+        export var dragEnter: EventSimulator;
+        export var dragExit: EventSimulator;
+        export var dragLeave: EventSimulator;
+        export var dragOver: EventSimulator;
+        export var dragStart: EventSimulator;
+        export var drop: EventSimulator;
+        export var focus: EventSimulator;
+        export var input: EventSimulator;
+        export var keyDown: EventSimulator;
+        export var keyPress: EventSimulator;
+        export var keyUp: EventSimulator;
+        export var mouseDown: EventSimulator;
+        export var mouseEnter: EventSimulator;
+        export var mouseLeave: EventSimulator;
+        export var mouseMove: EventSimulator;
+        export var mouseOut: EventSimulator;
+        export var mouseOver: EventSimulator;
+        export var mouseUp: EventSimulator;
+        export var paste: EventSimulator;
+        export var scroll: EventSimulator;
+        export var submit: EventSimulator;
+        export var touchCancel: EventSimulator;
+        export var touchEnd: EventSimulator;
+        export var touchMove: EventSimulator;
+        export var touchStart: EventSimulator;
+        export var wheel: EventSimulator;
+    }
+
+    class ShallowRenderer {
+        getRenderOutput<E extends ReactElement<any>>(): E;
+        getRenderOutput(): ReactElement<any>;
+        render(element: ReactElement<any>, context?: any): void;
+        unmount(): void;
+    }
+}
+
+declare namespace JSX {
     import React = __React;
 
     interface Element extends React.ReactElement<any> { }
diff --git a/redis/redis-tests.ts b/redis/redis-tests.ts
index 9c7003541f..5acb02465e 100644
--- a/redis/redis-tests.ts
+++ b/redis/redis-tests.ts
@@ -4,6 +4,7 @@ import redis = require('redis');
 
 var value: any;
 var valueArr: any[];
+var commandArr: any[][];
 var num: number;
 var str: string;
 var bool: boolean;
@@ -40,6 +41,7 @@ client.end();
 // Connection (http://redis.io/commands#connection)
 client.auth(str, resCallback);
 client.ping(numCallback);
+client.unref();
 
 // Strings (http://redis.io/commands#strings)
 client.append(str, str, numCallback);
@@ -49,9 +51,7 @@ client.set(str, str, strCallback);
 client.get(str, strCallback);
 client.exists(str, numCallback);
 
-client.publish(str, value);
-client.subscribe(str);
-
+// Event handlers
 client.on(str, messageHandler);
 client.once(str, messageHandler);
 
@@ -62,5 +62,31 @@ client.get(args);
 client.get(args, resCallback);
 client.set(args);
 client.set(args, resCallback);
+client.mset(args, resCallback);
 
 client.incr(str, resCallback);
+
+// Friendlier hash commands
+client.hgetall(str, resCallback);
+client.hmset(str, value, resCallback);
+client.hmset(str, str, str, str, str, resCallback);
+
+// Publish / Subscribe
+client.publish(str, value);
+client.subscribe(str);
+
+// Multi
+client.multi()
+    .scard(str)
+    .smembers(str)
+    .keys('*', resCallback)
+    .dbsize()
+    .exec(resCallback);
+
+client.multi(commandArr).exec();
+
+// Monitor mode
+client.monitor(resCallback);
+
+// Send command
+client.send_command(str, args, resCallback);
\ No newline at end of file
diff --git a/redis/redis.d.ts b/redis/redis.d.ts
index 8e9c978567..79caa6aa3a 100644
--- a/redis/redis.d.ts
+++ b/redis/redis.d.ts
@@ -1,6 +1,6 @@
-// Type definitions for redis
+// Type definitions for redis 0.12.1
 // Project: https://github.com/mranney/node_redis
-// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>, Peter Harris <https://github.com/CodeAnimal>
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>, Peter Harris <https://github.com/CodeAnimal>, TANAKA Koichi <https://github.com/MugeSo>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 // Imported from: https://github.com/soywiz/typescript-node-definitions/redis.d.ts
@@ -8,347 +8,619 @@
 /// <reference path="../node/node.d.ts" />
 
 declare module "redis" {
-  export function createClient(port_arg: number, host_arg?: string, options?: ClientOpts): RedisClient;
-  export function createClient(unix_socket: string, options?: ClientOpts): RedisClient;
-  export function createClient(options?: ClientOpts): RedisClient;
-	export function print(err: Error, reply: any): void;
-	export var debug_mode: boolean;
+    export function createClient(port_arg:number, host_arg?:string, options?:ClientOpts):RedisClient;
+    export function createClient(unix_socket:string, options?:ClientOpts):RedisClient;
+    export function createClient(options?:ClientOpts):RedisClient;
 
-	interface MessageHandler {
-		(channel: string, message: any): void;
-	}
+    export function print(err:Error, reply:any):void;
 
-  interface CommandT<R> { //This is a placeholder to be used eventually, to not have to define each command twice, or four times if all caps versions are to be implemented.
-    (args: any[], callback?: ResCallbackT<R>): void;
-    (...args: any[]): void;
-  }
+    export var debug_mode:boolean;
 
-  interface ResCallbackT<R> {
-    (err: Error, res: R): void;
-  }
+    export interface MessageHandler<M> {
+        (channel:string, message:M): void;
+    }
 
-	interface ServerInfo {
-		redis_version: string;
-		versions: number[];
-	}
+    export interface CommandT<R> { //This is a placeholder to be used eventually, to not have to define each command twice, or four times if all caps versions are to be implemented.
+        (args:any[], callback?:ResCallbackT<R>): void;
+        (...args:any[]): void;
+    }
 
-	interface ClientOpts {
-		parser?: string;
-		return_buffers?: boolean;
-		detect_buffers?: boolean;
-		socket_nodelay?: boolean;
-		no_ready_check?: boolean;
-		enable_offline_queue?: boolean;
-		retry_max_delay?: number;
-		connect_timeout?: number;
-		max_attempts?: number;
-		auth_pass?: string;
-	}
+    export interface ResCallbackT<R> {
+        (err:Error, res:R): void;
+    }
 
-	interface RedisClient extends NodeJS.EventEmitter {
-    // event: connect
-    // event: error
-    // event: message
-    // event: pmessage
-    // event: subscribe
-    // event: psubscribe
-    // event: unsubscribe
-    // event: punsubscribe
+    export interface ServerInfo {
+        redis_version: string;
+        versions: number[];
+    }
 
-    connected: boolean;
-    retry_delay: number;
-    retry_backoff: number;
-    command_queue: any[];
-    offline_queue: any[];
-    server_info: ServerInfo;
+    export interface ClientOpts {
+        parser?: string;
+        return_buffers?: boolean;
+        detect_buffers?: boolean;
+        socket_nodelay?: boolean;
+        socket_keepalive?: boolean;
+        no_ready_check?: boolean;
+        enable_offline_queue?: boolean;
+        retry_max_delay?: number;
+        connect_timeout?: number;
+        max_attempts?: number;
+        auth_pass?: string;
+        family?: string;
+        command_queue_high_water?: number;
+        command_queue_low_water?: number;
+    }
 
-    end(): void;
+    export interface RedisClient extends NodeJS.EventEmitter {
+        // event: connect
+        // event: error
+        // event: message
+        // event: pmessage
+        // event: subscribe
+        // event: psubscribe
+        // event: unsubscribe
+        // event: punsubscribe
 
-    // Connection (http://redis.io/commands#connection)
-    auth(password: string, callback?: ResCallbackT<any>): void;
-    ping(callback?: ResCallbackT<number>): void;
+        connected: boolean;
+        retry_delay: number;
+        retry_backoff: number;
+        command_queue: any[];
+        offline_queue: any[];
+        server_info: ServerInfo;
 
-    // Strings (http://redis.io/commands#strings)
-    append(key: string, value: string, callback?: ResCallbackT<number>): void;
-    bitcount(key: string, callback?: ResCallbackT<number>): void;
-    bitcount(key: string, start: number, end: number, callback?: ResCallbackT<number>): void;
-    set(key: string, value: string, callback?: ResCallbackT<string>): void;
-    get(key: string, callback?: ResCallbackT<string>): void;
-    exists(key: string, value: string, callback?: ResCallbackT<number>): void;
+        end(): void;
+        unref(): void;
 
-    publish(channel: string, value: any): void;
-    subscribe(channel: string): void;
+        // Low level command execution
+        send_command(command:string, ...args:any[]): boolean;
 
-    /*
-    commands = set_union([
-      "get", "set", "setnx", "setex", "append", "strlen", "del", "exists", "setbit", "getbit", "setrange", "getrange", "substr",
-      "incr", "decr", "mget", "rpush", "lpush", "rpushx", "lpushx", "linsert", "rpop", "lpop", "brpop", "brpoplpush", "blpop", "llen", "lindex",
-      "lset", "lrange", "ltrim", "lrem", "rpoplpush", "sadd", "srem", "smove", "sismember", "scard", "spop", "srandmember", "sinter", "sinterstore",
-      "sunion", "sunionstore", "sdiff", "sdiffstore", "smembers", "zadd", "zincrby", "zrem", "zremrangebyscore", "zremrangebyrank", "zunionstore",
-      "zinterstore", "zrange", "zrangebyscore", "zrevrangebyscore", "zcount", "zrevrange", "zcard", "zscore", "zrank", "zrevrank", "hset", "hsetnx",
-      "hget", "hmset", "hmget", "hincrby", "hdel", "hlen", "hkeys", "hvals", "hgetall", "hexists", "incrby", "decrby", "getset", "mset", "msetnx",
-      "randomkey", "select", "move", "rename", "renamenx", "expire", "expireat", "keys", "dbsize", "auth", "ping", "echo", "save", "bgsave",
-      "bgrewriteaof", "shutdown", "lastsave", "type", "multi", "exec", "discard", "sync", "flushdb", "flushall", "sort", "info", "monitor", "ttl",
-      "persist", "slaveof", "debug", "config", "subscribe", "unsubscribe", "psubscribe", "punsubscribe", "publish", "watch", "unwatch", "cluster",
-      "restore", "migrate", "dump", "object", "client", "eval", "evalsha"], require("./lib/commands"));
-    */
+        // Connection (http://redis.io/commands#connection)
+        auth(password:string, callback?:ResCallbackT<any>): boolean;
+        ping(callback?:ResCallbackT<number>): boolean;
 
-    get(args: any[], callback?: ResCallbackT<string>): void;
-    get(...args: any[]): void;
-    set(args: any[], callback?: ResCallbackT<string>): void;
-    set(...args: any[]): void;
-    setnx(args: any[], callback?: ResCallbackT<any>): void;
-    setnx(...args: any[]): void;
-    setex(args: any[], callback?: ResCallbackT<any>): void;
-    setex(...args: any[]): void;
-    append(args: any[], callback?: ResCallbackT<any>): void;
-    append(...args: any[]): void;
-    strlen(args: any[], callback?: ResCallbackT<any>): void;
-    strlen(...args: any[]): void;
-    del(args: any[], callback?: ResCallbackT<any>): void;
-    del(...args: any[]): void;
-    exists(args: any[], callback?: ResCallbackT<any>): void;
-    exists(...args: any[]): void;
-    setbit(args: any[], callback?: ResCallbackT<any>): void;
-    setbit(...args: any[]): void;
-    getbit(args: any[], callback?: ResCallbackT<any>): void;
-    getbit(...args: any[]): void;
-    setrange(args: any[], callback?: ResCallbackT<any>): void;
-    setrange(...args: any[]): void;
-    getrange(args: any[], callback?: ResCallbackT<any>): void;
-    getrange(...args: any[]): void;
-    substr(args: any[], callback?: ResCallbackT<any>): void;
-    substr(...args: any[]): void;
-    incr(args: any[], callback?: ResCallbackT<any>): void;
-    incr(...args: any[]): void;
-    decr(args: any[], callback?: ResCallbackT<any>): void;
-    decr(...args: any[]): void;
-    mget(args: any[], callback?: ResCallbackT<any>): void;
-    mget(...args: any[]): void;
-    rpush(...args: any[]): void;
-    lpush(args: any[], callback?: ResCallbackT<any>): void;
-    lpush(...args: any[]): void;
-    rpushx(args: any[], callback?: ResCallbackT<any>): void;
-    rpushx(...args: any[]): void;
-    lpushx(args: any[], callback?: ResCallbackT<any>): void;
-    lpushx(...args: any[]): void;
-    linsert(args: any[], callback?: ResCallbackT<any>): void;
-    linsert(...args: any[]): void;
-    rpop(args: any[], callback?: ResCallbackT<any>): void;
-    rpop(...args: any[]): void;
-    lpop(args: any[], callback?: ResCallbackT<any>): void;
-    lpop(...args: any[]): void;
-    brpop(args: any[], callback?: ResCallbackT<any>): void;
-    brpop(...args: any[]): void;
-    brpoplpush(args: any[], callback?: ResCallbackT<any>): void;
-    brpoplpush(...args: any[]): void;
-    blpop(args: any[], callback?: ResCallbackT<any>): void;
-    blpop(...args: any[]): void;
-    llen(args: any[], callback?: ResCallbackT<any>): void;
-    llen(...args: any[]): void;
-    lindex(args: any[], callback?: ResCallbackT<any>): void;
-    lindex(...args: any[]): void;
-    lset(args: any[], callback?: ResCallbackT<any>): void;
-    lset(...args: any[]): void;
-    lrange(args: any[], callback?: ResCallbackT<any>): void;
-    lrange(...args: any[]): void;
-    ltrim(args: any[], callback?: ResCallbackT<any>): void;
-    ltrim(...args: any[]): void;
-    lrem(args: any[], callback?: ResCallbackT<any>): void;
-    lrem(...args: any[]): void;
-    rpoplpush(args: any[], callback?: ResCallbackT<any>): void;
-    rpoplpush(...args: any[]): void;
-    sadd(args: any[], callback?: ResCallbackT<any>): void;
-    sadd(...args: any[]): void;
-    srem(args: any[], callback?: ResCallbackT<any>): void;
-    srem(...args: any[]): void;
-    smove(args: any[], callback?: ResCallbackT<any>): void;
-    smove(...args: any[]): void;
-    sismember(args: any[], callback?: ResCallbackT<any>): void;
-    sismember(...args: any[]): void;
-    scard(args: any[], callback?: ResCallbackT<any>): void;
-    scard(...args: any[]): void;
-    spop(args: any[], callback?: ResCallbackT<any>): void;
-    spop(...args: any[]): void;
-    srandmember(args: any[], callback?: ResCallbackT<any>): void;
-    srandmember(...args: any[]): void;
-    sinter(args: any[], callback?: ResCallbackT<any>): void;
-    sinter(...args: any[]): void;
-    sinterstore(args: any[], callback?: ResCallbackT<any>): void;
-    sinterstore(...args: any[]): void;
-    sunion(args: any[], callback?: ResCallbackT<any>): void;
-    sunion(...args: any[]): void;
-    sunionstore(args: any[], callback?: ResCallbackT<any>): void;
-    sunionstore(...args: any[]): void;
-    sdiff(args: any[], callback?: ResCallbackT<any>): void;
-    sdiff(...args: any[]): void;
-    sdiffstore(args: any[], callback?: ResCallbackT<any>): void;
-    sdiffstore(...args: any[]): void;
-    smembers(args: any[], callback?: ResCallbackT<any>): void;
-    smembers(...args: any[]): void;
-    zadd(args: any[], callback?: ResCallbackT<any>): void;
-    zadd(...args: any[]): void;
-    zincrby(args: any[], callback?: ResCallbackT<any>): void;
-    zincrby(...args: any[]): void;
-    zrem(args: any[], callback?: ResCallbackT<any>): void;
-    zrem(...args: any[]): void;
-    zremrangebyscore(args: any[], callback?: ResCallbackT<any>): void;
-    zremrangebyscore(...args: any[]): void;
-    zremrangebyrank(args: any[], callback?: ResCallbackT<any>): void;
-    zremrangebyrank(...args: any[]): void;
-    zunionstore(args: any[], callback?: ResCallbackT<any>): void;
-    zunionstore(...args: any[]): void;
-    zinterstore(args: any[], callback?: ResCallbackT<any>): void;
-    zinterstore(...args: any[]): void;
-    zrange(args: any[], callback?: ResCallbackT<any>): void;
-    zrange(...args: any[]): void;
-    zrangebyscore(args: any[], callback?: ResCallbackT<any>): void;
-    zrangebyscore(...args: any[]): void;
-    zrevrangebyscore(args: any[], callback?: ResCallbackT<any>): void;
-    zrevrangebyscore(...args: any[]): void;
-    zcount(args: any[], callback?: ResCallbackT<any>): void;
-    zcount(...args: any[]): void;
-    zrevrange(args: any[], callback?: ResCallbackT<any>): void;
-    zrevrange(...args: any[]): void;
-    zcard(args: any[], callback?: ResCallbackT<any>): void;
-    zcard(...args: any[]): void;
-    zscore(args: any[], callback?: ResCallbackT<any>): void;
-    zscore(...args: any[]): void;
-    zrank(args: any[], callback?: ResCallbackT<any>): void;
-    zrank(...args: any[]): void;
-    zrevrank(args: any[], callback?: ResCallbackT<any>): void;
-    zrevrank(...args: any[]): void;
-    hset(args: any[], callback?: ResCallbackT<any>): void;
-    hset(...args: any[]): void;
-    hsetnx(args: any[], callback?: ResCallbackT<any>): void;
-    hsetnx(...args: any[]): void;
-    hget(args: any[], callback?: ResCallbackT<any>): void;
-    hget(...args: any[]): void;
-    hmset(args: any[], callback?: ResCallbackT<any>): void;
-    hmset(key: string, hash: any, callback?: ResCallbackT<any>): void;
-    hmset(...args: any[]): void;
-    hmget(args: any[], callback?: ResCallbackT<any>): void;
-    hmget(...args: any[]): void;
-    hincrby(args: any[], callback?: ResCallbackT<any>): void;
-    hincrby(...args: any[]): void;
-    hdel(args: any[], callback?: ResCallbackT<any>): void;
-    hdel(...args: any[]): void;
-    hlen(args: any[], callback?: ResCallbackT<any>): void;
-    hlen(...args: any[]): void;
-    hkeys(args: any[], callback?: ResCallbackT<any>): void;
-    hkeys(...args: any[]): void;
-    hvals(args: any[], callback?: ResCallbackT<any>): void;
-    hvals(...args: any[]): void;
-    hgetall(args: any[], callback?: ResCallbackT<any>): void;
-    hgetall(...args: any[]): void;
-    hgetall(key: string, callback?: ResCallbackT<any>): void;
-    hexists(args: any[], callback?: ResCallbackT<any>): void;
-    hexists(...args: any[]): void;
-    incrby(args: any[], callback?: ResCallbackT<any>): void;
-    incrby(...args: any[]): void;
-    decrby(args: any[], callback?: ResCallbackT<any>): void;
-    decrby(...args: any[]): void;
-    getset(args: any[], callback?: ResCallbackT<any>): void;
-    getset(...args: any[]): void;
-    mset(args: any[], callback?: ResCallbackT<any>): void;
-    mset(...args: any[]): void;
-    msetnx(args: any[], callback?: ResCallbackT<any>): void;
-    msetnx(...args: any[]): void;
-    randomkey(args: any[], callback?: ResCallbackT<any>): void;
-    randomkey(...args: any[]): void;
-    select(args: any[], callback?: ResCallbackT<any>): void;
-    select(...args: any[]): void;
-    move(args: any[], callback?: ResCallbackT<any>): void;
-    move(...args: any[]): void;
-    rename(args: any[], callback?: ResCallbackT<any>): void;
-    rename(...args: any[]): void;
-    renamenx(args: any[], callback?: ResCallbackT<any>): void;
-    renamenx(...args: any[]): void;
-    expire(args: any[], callback?: ResCallbackT<any>): void;
-    expire(...args: any[]): void;
-    expireat(args: any[], callback?: ResCallbackT<any>): void;
-    expireat(...args: any[]): void;
-    keys(args: any[], callback?: ResCallbackT<any>): void;
-    keys(...args: any[]): void;
-    dbsize(args: any[], callback?: ResCallbackT<any>): void;
-    dbsize(...args: any[]): void;
-    auth(args: any[], callback?: ResCallbackT<any>): void;
-    auth(...args: any[]): void;
-    ping(args: any[], callback?: ResCallbackT<any>): void;
-    ping(...args: any[]): void;
-    echo(args: any[], callback?: ResCallbackT<any>): void;
-    echo(...args: any[]): void;
-    save(args: any[], callback?: ResCallbackT<any>): void;
-    save(...args: any[]): void;
-    bgsave(args: any[], callback?: ResCallbackT<any>): void;
-    bgsave(...args: any[]): void;
-    bgrewriteaof(args: any[], callback?: ResCallbackT<any>): void;
-    bgrewriteaof(...args: any[]): void;
-    shutdown(args: any[], callback?: ResCallbackT<any>): void;
-    shutdown(...args: any[]): void;
-    lastsave(args: any[], callback?: ResCallbackT<any>): void;
-    lastsave(...args: any[]): void;
-    type(args: any[], callback?: ResCallbackT<any>): void;
-    type(...args: any[]): void;
-    multi(args: any[], callback?: ResCallbackT<any>): void;
-    multi(...args: any[]): void;
-    exec(args: any[], callback?: ResCallbackT<any>): void;
-    exec(...args: any[]): void;
-    discard(args: any[], callback?: ResCallbackT<any>): void;
-    discard(...args: any[]): void;
-    sync(args: any[], callback?: ResCallbackT<any>): void;
-    sync(...args: any[]): void;
-    flushdb(args: any[], callback?: ResCallbackT<any>): void;
-    flushdb(...args: any[]): void;
-    flushall(args: any[], callback?: ResCallbackT<any>): void;
-    flushall(...args: any[]): void;
-    sort(args: any[], callback?: ResCallbackT<any>): void;
-    sort(...args: any[]): void;
-    info(args: any[], callback?: ResCallbackT<any>): void;
-    info(...args: any[]): void;
-    monitor(args: any[], callback?: ResCallbackT<any>): void;
-    monitor(...args: any[]): void;
-    ttl(args: any[], callback?: ResCallbackT<any>): void;
-    ttl(...args: any[]): void;
-    persist(args: any[], callback?: ResCallbackT<any>): void;
-    persist(...args: any[]): void;
-    slaveof(args: any[], callback?: ResCallbackT<any>): void;
-    slaveof(...args: any[]): void;
-    debug(args: any[], callback?: ResCallbackT<any>): void;
-    debug(...args: any[]): void;
-    config(args: any[], callback?: ResCallbackT<any>): void;
-    config(...args: any[]): void;
-    subscribe(args: any[], callback?: ResCallbackT<any>): void;
-    subscribe(...args: any[]): void;
-    unsubscribe(args: any[], callback?: ResCallbackT<any>): void;
-    unsubscribe(...args: any[]): void;
-    psubscribe(args: any[], callback?: ResCallbackT<any>): void;
-    psubscribe(...args: any[]): void;
-    punsubscribe(args: any[], callback?: ResCallbackT<any>): void;
-    punsubscribe(...args: any[]): void;
-    publish(args: any[], callback?: ResCallbackT<any>): void;
-    publish(...args: any[]): void;
-    watch(args: any[], callback?: ResCallbackT<any>): void;
-    watch(...args: any[]): void;
-    unwatch(args: any[], callback?: ResCallbackT<any>): void;
-    unwatch(...args: any[]): void;
-    cluster(args: any[], callback?: ResCallbackT<any>): void;
-    cluster(...args: any[]): void;
-    restore(args: any[], callback?: ResCallbackT<any>): void;
-    restore(...args: any[]): void;
-    migrate(args: any[], callback?: ResCallbackT<any>): void;
-    migrate(...args: any[]): void;
-    dump(args: any[], callback?: ResCallbackT<any>): void;
-    dump(...args: any[]): void;
-    object(args: any[], callback?: ResCallbackT<any>): void;
-    object(...args: any[]): void;
-    client(args: any[], callback?: ResCallbackT<any>): void;
-    client(...args: any[]): void;
-    eval(args: any[], callback?: ResCallbackT<any>): void;
-    eval(...args: any[]): void;
-    evalsha(args: any[], callback?: ResCallbackT<any>): void;
-    evalsha(...args: any[]): void;
-    quit(args: any[], callback?: ResCallbackT<any>): void;
-    quit(...args: any[]): void;
-	}
+        // Strings (http://redis.io/commands#strings)
+        append(key:string, value:string, callback?:ResCallbackT<number>): boolean;
+        bitcount(key:string, callback?:ResCallbackT<number>): boolean;
+        bitcount(key:string, start:number, end:number, callback?:ResCallbackT<number>): boolean;
+        set(key:string, value:string, callback?:ResCallbackT<string>): boolean;
+        get(key:string, callback?:ResCallbackT<string>): boolean;
+        exists(key:string, value:string, callback?:ResCallbackT<number>): boolean;
+
+        publish(channel:string, value:any): boolean;
+        subscribe(channel:string): boolean;
+
+        /*
+         commands = set_union([
+         "get", "set", "setnx", "setex", "append", "strlen", "del", "exists", "setbit", "getbit", "setrange", "getrange", "substr",
+         "incr", "decr", "mget", "rpush", "lpush", "rpushx", "lpushx", "linsert", "rpop", "lpop", "brpop", "brpoplpush", "blpop", "llen", "lindex",
+         "lset", "lrange", "ltrim", "lrem", "rpoplpush", "sadd", "srem", "smove", "sismember", "scard", "spop", "srandmember", "sinter", "sinterstore",
+         "sunion", "sunionstore", "sdiff", "sdiffstore", "smembers", "zadd", "zincrby", "zrem", "zremrangebyscore", "zremrangebyrank", "zunionstore",
+         "zinterstore", "zrange", "zrangebyscore", "zrevrangebyscore", "zcount", "zrevrange", "zcard", "zscore", "zrank", "zrevrank", "hset", "hsetnx",
+         "hget", "hmset", "hmget", "hincrby", "hdel", "hlen", "hkeys", "hvals", "hgetall", "hexists", "incrby", "decrby", "getset", "mset", "msetnx",
+         "randomkey", "select", "move", "rename", "renamenx", "expire", "expireat", "keys", "dbsize", "auth", "ping", "echo", "save", "bgsave",
+         "bgrewriteaof", "shutdown", "lastsave", "type", "multi", "exec", "discard", "sync", "flushdb", "flushall", "sort", "info", "monitor", "ttl",
+         "persist", "slaveof", "debug", "config", "subscribe", "unsubscribe", "psubscribe", "punsubscribe", "publish", "watch", "unwatch", "cluster",
+         "restore", "migrate", "dump", "object", "client", "eval", "evalsha"], require("./lib/commands"));
+         */
+
+        get(args:any[], callback?:ResCallbackT<string>): boolean;
+        get(...args:any[]): boolean;
+        set(args:any[], callback?:ResCallbackT<string>): boolean;
+        set(...args:any[]): boolean;
+        setnx(args:any[], callback?:ResCallbackT<any>): boolean;
+        setnx(...args:any[]): boolean;
+        setex(args:any[], callback?:ResCallbackT<any>): boolean;
+        setex(...args:any[]): boolean;
+        append(args:any[], callback?:ResCallbackT<any>): boolean;
+        append(...args:any[]): boolean;
+        strlen(args:any[], callback?:ResCallbackT<any>): boolean;
+        strlen(...args:any[]): boolean;
+        del(args:any[], callback?:ResCallbackT<any>): boolean;
+        del(...args:any[]): boolean;
+        exists(args:any[], callback?:ResCallbackT<any>): boolean;
+        exists(...args:any[]): boolean;
+        setbit(args:any[], callback?:ResCallbackT<any>): boolean;
+        setbit(...args:any[]): boolean;
+        getbit(args:any[], callback?:ResCallbackT<any>): boolean;
+        getbit(...args:any[]): boolean;
+        setrange(args:any[], callback?:ResCallbackT<any>): boolean;
+        setrange(...args:any[]): boolean;
+        getrange(args:any[], callback?:ResCallbackT<any>): boolean;
+        getrange(...args:any[]): boolean;
+        substr(args:any[], callback?:ResCallbackT<any>): boolean;
+        substr(...args:any[]): boolean;
+        incr(args:any[], callback?:ResCallbackT<any>): boolean;
+        incr(...args:any[]): boolean;
+        decr(args:any[], callback?:ResCallbackT<any>): boolean;
+        decr(...args:any[]): boolean;
+        mget(args:any[], callback?:ResCallbackT<any>): boolean;
+        mget(...args:any[]): boolean;
+        rpush(...args:any[]): boolean;
+        lpush(args:any[], callback?:ResCallbackT<any>): boolean;
+        lpush(...args:any[]): boolean;
+        rpushx(args:any[], callback?:ResCallbackT<any>): boolean;
+        rpushx(...args:any[]): boolean;
+        lpushx(args:any[], callback?:ResCallbackT<any>): boolean;
+        lpushx(...args:any[]): boolean;
+        linsert(args:any[], callback?:ResCallbackT<any>): boolean;
+        linsert(...args:any[]): boolean;
+        rpop(args:any[], callback?:ResCallbackT<any>): boolean;
+        rpop(...args:any[]): boolean;
+        lpop(args:any[], callback?:ResCallbackT<any>): boolean;
+        lpop(...args:any[]): boolean;
+        brpop(args:any[], callback?:ResCallbackT<any>): boolean;
+        brpop(...args:any[]): boolean;
+        brpoplpush(args:any[], callback?:ResCallbackT<any>): boolean;
+        brpoplpush(...args:any[]): boolean;
+        blpop(args:any[], callback?:ResCallbackT<any>): boolean;
+        blpop(...args:any[]): boolean;
+        llen(args:any[], callback?:ResCallbackT<any>): boolean;
+        llen(...args:any[]): boolean;
+        lindex(args:any[], callback?:ResCallbackT<any>): boolean;
+        lindex(...args:any[]): boolean;
+        lset(args:any[], callback?:ResCallbackT<any>): boolean;
+        lset(...args:any[]): boolean;
+        lrange(args:any[], callback?:ResCallbackT<any>): boolean;
+        lrange(...args:any[]): boolean;
+        ltrim(args:any[], callback?:ResCallbackT<any>): boolean;
+        ltrim(...args:any[]): boolean;
+        lrem(args:any[], callback?:ResCallbackT<any>): boolean;
+        lrem(...args:any[]): boolean;
+        rpoplpush(args:any[], callback?:ResCallbackT<any>): boolean;
+        rpoplpush(...args:any[]): boolean;
+        sadd(args:any[], callback?:ResCallbackT<any>): boolean;
+        sadd(...args:any[]): boolean;
+        srem(args:any[], callback?:ResCallbackT<any>): boolean;
+        srem(...args:any[]): boolean;
+        smove(args:any[], callback?:ResCallbackT<any>): boolean;
+        smove(...args:any[]): boolean;
+        sismember(args:any[], callback?:ResCallbackT<any>): boolean;
+        sismember(...args:any[]): boolean;
+        scard(args:any[], callback?:ResCallbackT<any>): boolean;
+        scard(...args:any[]): boolean;
+        spop(args:any[], callback?:ResCallbackT<any>): boolean;
+        spop(...args:any[]): boolean;
+        srandmember(args:any[], callback?:ResCallbackT<any>): boolean;
+        srandmember(...args:any[]): boolean;
+        sinter(args:any[], callback?:ResCallbackT<any>): boolean;
+        sinter(...args:any[]): boolean;
+        sinterstore(args:any[], callback?:ResCallbackT<any>): boolean;
+        sinterstore(...args:any[]): boolean;
+        sunion(args:any[], callback?:ResCallbackT<any>): boolean;
+        sunion(...args:any[]): boolean;
+        sunionstore(args:any[], callback?:ResCallbackT<any>): boolean;
+        sunionstore(...args:any[]): boolean;
+        sdiff(args:any[], callback?:ResCallbackT<any>): boolean;
+        sdiff(...args:any[]): boolean;
+        sdiffstore(args:any[], callback?:ResCallbackT<any>): boolean;
+        sdiffstore(...args:any[]): boolean;
+        smembers(args:any[], callback?:ResCallbackT<any>): boolean;
+        smembers(...args:any[]): boolean;
+        zadd(args:any[], callback?:ResCallbackT<any>): boolean;
+        zadd(...args:any[]): boolean;
+        zincrby(args:any[], callback?:ResCallbackT<any>): boolean;
+        zincrby(...args:any[]): boolean;
+        zrem(args:any[], callback?:ResCallbackT<any>): boolean;
+        zrem(...args:any[]): boolean;
+        zremrangebyscore(args:any[], callback?:ResCallbackT<any>): boolean;
+        zremrangebyscore(...args:any[]): boolean;
+        zremrangebyrank(args:any[], callback?:ResCallbackT<any>): boolean;
+        zremrangebyrank(...args:any[]): boolean;
+        zunionstore(args:any[], callback?:ResCallbackT<any>): boolean;
+        zunionstore(...args:any[]): boolean;
+        zinterstore(args:any[], callback?:ResCallbackT<any>): boolean;
+        zinterstore(...args:any[]): boolean;
+        zrange(args:any[], callback?:ResCallbackT<any>): boolean;
+        zrange(...args:any[]): boolean;
+        zrangebyscore(args:any[], callback?:ResCallbackT<any>): boolean;
+        zrangebyscore(...args:any[]): boolean;
+        zrevrangebyscore(args:any[], callback?:ResCallbackT<any>): boolean;
+        zrevrangebyscore(...args:any[]): boolean;
+        zcount(args:any[], callback?:ResCallbackT<any>): boolean;
+        zcount(...args:any[]): boolean;
+        zrevrange(args:any[], callback?:ResCallbackT<any>): boolean;
+        zrevrange(...args:any[]): boolean;
+        zcard(args:any[], callback?:ResCallbackT<any>): boolean;
+        zcard(...args:any[]): boolean;
+        zscore(args:any[], callback?:ResCallbackT<any>): boolean;
+        zscore(...args:any[]): boolean;
+        zrank(args:any[], callback?:ResCallbackT<any>): boolean;
+        zrank(...args:any[]): boolean;
+        zrevrank(args:any[], callback?:ResCallbackT<any>): boolean;
+        zrevrank(...args:any[]): boolean;
+        hset(args:any[], callback?:ResCallbackT<any>): boolean;
+        hset(...args:any[]): boolean;
+        hsetnx(args:any[], callback?:ResCallbackT<any>): boolean;
+        hsetnx(...args:any[]): boolean;
+        hget(args:any[], callback?:ResCallbackT<any>): boolean;
+        hget(...args:any[]): boolean;
+        hmset(args:any[], callback?:ResCallbackT<any>): boolean;
+        hmset(key:string, hash:any, callback?:ResCallbackT<any>): boolean;
+        hmset(...args:any[]): boolean;
+        hmget(args:any[], callback?:ResCallbackT<any>): boolean;
+        hmget(...args:any[]): boolean;
+        hincrby(args:any[], callback?:ResCallbackT<any>): boolean;
+        hincrby(...args:any[]): boolean;
+        hdel(args:any[], callback?:ResCallbackT<any>): boolean;
+        hdel(...args:any[]): boolean;
+        hlen(args:any[], callback?:ResCallbackT<any>): boolean;
+        hlen(...args:any[]): boolean;
+        hkeys(args:any[], callback?:ResCallbackT<any>): boolean;
+        hkeys(...args:any[]): boolean;
+        hvals(args:any[], callback?:ResCallbackT<any>): boolean;
+        hvals(...args:any[]): boolean;
+        hgetall(args:any[], callback?:ResCallbackT<any>): boolean;
+        hgetall(...args:any[]): boolean;
+        hgetall(key:string, callback?:ResCallbackT<any>): boolean;
+        hexists(args:any[], callback?:ResCallbackT<any>): boolean;
+        hexists(...args:any[]): boolean;
+        incrby(args:any[], callback?:ResCallbackT<any>): boolean;
+        incrby(...args:any[]): boolean;
+        decrby(args:any[], callback?:ResCallbackT<any>): boolean;
+        decrby(...args:any[]): boolean;
+        getset(args:any[], callback?:ResCallbackT<any>): boolean;
+        getset(...args:any[]): boolean;
+        mset(args:any[], callback?:ResCallbackT<any>): boolean;
+        mset(...args:any[]): boolean;
+        msetnx(args:any[], callback?:ResCallbackT<any>): boolean;
+        msetnx(...args:any[]): boolean;
+        randomkey(args:any[], callback?:ResCallbackT<any>): boolean;
+        randomkey(...args:any[]): boolean;
+        select(args:any[], callback?:ResCallbackT<any>): void;
+        select(...args:any[]): void;
+        move(args:any[], callback?:ResCallbackT<any>): boolean;
+        move(...args:any[]): boolean;
+        rename(args:any[], callback?:ResCallbackT<any>): boolean;
+        rename(...args:any[]): boolean;
+        renamenx(args:any[], callback?:ResCallbackT<any>): boolean;
+        renamenx(...args:any[]): boolean;
+        expire(args:any[], callback?:ResCallbackT<any>): boolean;
+        expire(...args:any[]): boolean;
+        expireat(args:any[], callback?:ResCallbackT<any>): boolean;
+        expireat(...args:any[]): boolean;
+        keys(args:any[], callback?:ResCallbackT<any>): boolean;
+        keys(...args:any[]): boolean;
+        dbsize(args:any[], callback?:ResCallbackT<any>): boolean;
+        dbsize(...args:any[]): boolean;
+        auth(args:any[], callback?:ResCallbackT<any>): void;
+        auth(...args:any[]): void;
+        ping(args:any[], callback?:ResCallbackT<any>): boolean;
+        ping(...args:any[]): boolean;
+        echo(args:any[], callback?:ResCallbackT<any>): boolean;
+        echo(...args:any[]): boolean;
+        save(args:any[], callback?:ResCallbackT<any>): boolean;
+        save(...args:any[]): boolean;
+        bgsave(args:any[], callback?:ResCallbackT<any>): boolean;
+        bgsave(...args:any[]): boolean;
+        bgrewriteaof(args:any[], callback?:ResCallbackT<any>): boolean;
+        bgrewriteaof(...args:any[]): boolean;
+        shutdown(args:any[], callback?:ResCallbackT<any>): boolean;
+        shutdown(...args:any[]): boolean;
+        lastsave(args:any[], callback?:ResCallbackT<any>): boolean;
+        lastsave(...args:any[]): boolean;
+        type(args:any[], callback?:ResCallbackT<any>): boolean;
+        type(...args:any[]): boolean;
+        multi(args:any[], callback?:ResCallbackT<any>): Multi;
+        multi(...args:any[]): Multi;
+        exec(args:any[], callback?:ResCallbackT<any>): boolean;
+        exec(...args:any[]): boolean;
+        discard(args:any[], callback?:ResCallbackT<any>): boolean;
+        discard(...args:any[]): boolean;
+        sync(args:any[], callback?:ResCallbackT<any>): boolean;
+        sync(...args:any[]): boolean;
+        flushdb(args:any[], callback?:ResCallbackT<any>): boolean;
+        flushdb(...args:any[]): boolean;
+        flushall(args:any[], callback?:ResCallbackT<any>): boolean;
+        flushall(...args:any[]): boolean;
+        sort(args:any[], callback?:ResCallbackT<any>): boolean;
+        sort(...args:any[]): boolean;
+        info(args:any[], callback?:ResCallbackT<any>): boolean;
+        info(...args:any[]): boolean;
+        monitor(args:any[], callback?:ResCallbackT<any>): boolean;
+        monitor(...args:any[]): boolean;
+        ttl(args:any[], callback?:ResCallbackT<any>): boolean;
+        ttl(...args:any[]): boolean;
+        persist(args:any[], callback?:ResCallbackT<any>): boolean;
+        persist(...args:any[]): boolean;
+        slaveof(args:any[], callback?:ResCallbackT<any>): boolean;
+        slaveof(...args:any[]): boolean;
+        debug(args:any[], callback?:ResCallbackT<any>): boolean;
+        debug(...args:any[]): boolean;
+        config(args:any[], callback?:ResCallbackT<any>): boolean;
+        config(...args:any[]): boolean;
+        subscribe(args:any[], callback?:ResCallbackT<any>): boolean;
+        subscribe(...args:any[]): boolean;
+        unsubscribe(args:any[], callback?:ResCallbackT<any>): boolean;
+        unsubscribe(...args:any[]): boolean;
+        psubscribe(args:any[], callback?:ResCallbackT<any>): boolean;
+        psubscribe(...args:any[]): boolean;
+        punsubscribe(args:any[], callback?:ResCallbackT<any>): boolean;
+        punsubscribe(...args:any[]): boolean;
+        publish(args:any[], callback?:ResCallbackT<any>): boolean;
+        publish(...args:any[]): boolean;
+        watch(args:any[], callback?:ResCallbackT<any>): boolean;
+        watch(...args:any[]): boolean;
+        unwatch(args:any[], callback?:ResCallbackT<any>): boolean;
+        unwatch(...args:any[]): boolean;
+        cluster(args:any[], callback?:ResCallbackT<any>): boolean;
+        cluster(...args:any[]): boolean;
+        restore(args:any[], callback?:ResCallbackT<any>): boolean;
+        restore(...args:any[]): boolean;
+        migrate(args:any[], callback?:ResCallbackT<any>): boolean;
+        migrate(...args:any[]): boolean;
+        dump(args:any[], callback?:ResCallbackT<any>): boolean;
+        dump(...args:any[]): boolean;
+        object(args:any[], callback?:ResCallbackT<any>): boolean;
+        object(...args:any[]): boolean;
+        client(args:any[], callback?:ResCallbackT<any>): boolean;
+        client(...args:any[]): boolean;
+        eval(args:any[], callback?:ResCallbackT<any>): boolean;
+        eval(...args:any[]): boolean;
+        evalsha(args:any[], callback?:ResCallbackT<any>): boolean;
+        evalsha(...args:any[]): boolean;
+        quit(args:any[], callback?:ResCallbackT<any>): boolean;
+        quit(...args:any[]): boolean;
+    }
+
+    export interface Multi {
+        exec(callback?:ResCallbackT<any[]>): boolean;
+
+        get(args:any[], callback?:ResCallbackT<string>): Multi;
+        get(...args:any[]): Multi;
+        set(args:any[], callback?:ResCallbackT<string>): Multi;
+        set(...args:any[]): Multi;
+        setnx(args:any[], callback?:ResCallbackT<any>): Multi;
+        setnx(...args:any[]): Multi;
+        setex(args:any[], callback?:ResCallbackT<any>): Multi;
+        setex(...args:any[]): Multi;
+        append(args:any[], callback?:ResCallbackT<any>): Multi;
+        append(...args:any[]): Multi;
+        strlen(args:any[], callback?:ResCallbackT<any>): Multi;
+        strlen(...args:any[]): Multi;
+        del(args:any[], callback?:ResCallbackT<any>): Multi;
+        del(...args:any[]): Multi;
+        exists(args:any[], callback?:ResCallbackT<any>): Multi;
+        exists(...args:any[]): Multi;
+        setbit(args:any[], callback?:ResCallbackT<any>): Multi;
+        setbit(...args:any[]): Multi;
+        getbit(args:any[], callback?:ResCallbackT<any>): Multi;
+        getbit(...args:any[]): Multi;
+        setrange(args:any[], callback?:ResCallbackT<any>): Multi;
+        setrange(...args:any[]): Multi;
+        getrange(args:any[], callback?:ResCallbackT<any>): Multi;
+        getrange(...args:any[]): Multi;
+        substr(args:any[], callback?:ResCallbackT<any>): Multi;
+        substr(...args:any[]): Multi;
+        incr(args:any[], callback?:ResCallbackT<any>): Multi;
+        incr(...args:any[]): Multi;
+        decr(args:any[], callback?:ResCallbackT<any>): Multi;
+        decr(...args:any[]): Multi;
+        mget(args:any[], callback?:ResCallbackT<any>): Multi;
+        mget(...args:any[]): Multi;
+        rpush(...args:any[]): Multi;
+        lpush(args:any[], callback?:ResCallbackT<any>): Multi;
+        lpush(...args:any[]): Multi;
+        rpushx(args:any[], callback?:ResCallbackT<any>): Multi;
+        rpushx(...args:any[]): Multi;
+        lpushx(args:any[], callback?:ResCallbackT<any>): Multi;
+        lpushx(...args:any[]): Multi;
+        linsert(args:any[], callback?:ResCallbackT<any>): Multi;
+        linsert(...args:any[]): Multi;
+        rpop(args:any[], callback?:ResCallbackT<any>): Multi;
+        rpop(...args:any[]): Multi;
+        lpop(args:any[], callback?:ResCallbackT<any>): Multi;
+        lpop(...args:any[]): Multi;
+        brpop(args:any[], callback?:ResCallbackT<any>): Multi;
+        brpop(...args:any[]): Multi;
+        brpoplpush(args:any[], callback?:ResCallbackT<any>): Multi;
+        brpoplpush(...args:any[]): Multi;
+        blpop(args:any[], callback?:ResCallbackT<any>): Multi;
+        blpop(...args:any[]): Multi;
+        llen(args:any[], callback?:ResCallbackT<any>): Multi;
+        llen(...args:any[]): Multi;
+        lindex(args:any[], callback?:ResCallbackT<any>): Multi;
+        lindex(...args:any[]): Multi;
+        lset(args:any[], callback?:ResCallbackT<any>): Multi;
+        lset(...args:any[]): Multi;
+        lrange(args:any[], callback?:ResCallbackT<any>): Multi;
+        lrange(...args:any[]): Multi;
+        ltrim(args:any[], callback?:ResCallbackT<any>): Multi;
+        ltrim(...args:any[]): Multi;
+        lrem(args:any[], callback?:ResCallbackT<any>): Multi;
+        lrem(...args:any[]): Multi;
+        rpoplpush(args:any[], callback?:ResCallbackT<any>): Multi;
+        rpoplpush(...args:any[]): Multi;
+        sadd(args:any[], callback?:ResCallbackT<any>): Multi;
+        sadd(...args:any[]): Multi;
+        srem(args:any[], callback?:ResCallbackT<any>): Multi;
+        srem(...args:any[]): Multi;
+        smove(args:any[], callback?:ResCallbackT<any>): Multi;
+        smove(...args:any[]): Multi;
+        sismember(args:any[], callback?:ResCallbackT<any>): Multi;
+        sismember(...args:any[]): Multi;
+        scard(args:any[], callback?:ResCallbackT<any>): Multi;
+        scard(...args:any[]): Multi;
+        spop(args:any[], callback?:ResCallbackT<any>): Multi;
+        spop(...args:any[]): Multi;
+        srandmember(args:any[], callback?:ResCallbackT<any>): Multi;
+        srandmember(...args:any[]): Multi;
+        sinter(args:any[], callback?:ResCallbackT<any>): Multi;
+        sinter(...args:any[]): Multi;
+        sinterstore(args:any[], callback?:ResCallbackT<any>): Multi;
+        sinterstore(...args:any[]): Multi;
+        sunion(args:any[], callback?:ResCallbackT<any>): Multi;
+        sunion(...args:any[]): Multi;
+        sunionstore(args:any[], callback?:ResCallbackT<any>): Multi;
+        sunionstore(...args:any[]): Multi;
+        sdiff(args:any[], callback?:ResCallbackT<any>): Multi;
+        sdiff(...args:any[]): Multi;
+        sdiffstore(args:any[], callback?:ResCallbackT<any>): Multi;
+        sdiffstore(...args:any[]): Multi;
+        smembers(args:any[], callback?:ResCallbackT<any>): Multi;
+        smembers(...args:any[]): Multi;
+        zadd(args:any[], callback?:ResCallbackT<any>): Multi;
+        zadd(...args:any[]): Multi;
+        zincrby(args:any[], callback?:ResCallbackT<any>): Multi;
+        zincrby(...args:any[]): Multi;
+        zrem(args:any[], callback?:ResCallbackT<any>): Multi;
+        zrem(...args:any[]): Multi;
+        zremrangebyscore(args:any[], callback?:ResCallbackT<any>): Multi;
+        zremrangebyscore(...args:any[]): Multi;
+        zremrangebyrank(args:any[], callback?:ResCallbackT<any>): Multi;
+        zremrangebyrank(...args:any[]): Multi;
+        zunionstore(args:any[], callback?:ResCallbackT<any>): Multi;
+        zunionstore(...args:any[]): Multi;
+        zinterstore(args:any[], callback?:ResCallbackT<any>): Multi;
+        zinterstore(...args:any[]): Multi;
+        zrange(args:any[], callback?:ResCallbackT<any>): Multi;
+        zrange(...args:any[]): Multi;
+        zrangebyscore(args:any[], callback?:ResCallbackT<any>): Multi;
+        zrangebyscore(...args:any[]): Multi;
+        zrevrangebyscore(args:any[], callback?:ResCallbackT<any>): Multi;
+        zrevrangebyscore(...args:any[]): Multi;
+        zcount(args:any[], callback?:ResCallbackT<any>): Multi;
+        zcount(...args:any[]): Multi;
+        zrevrange(args:any[], callback?:ResCallbackT<any>): Multi;
+        zrevrange(...args:any[]): Multi;
+        zcard(args:any[], callback?:ResCallbackT<any>): Multi;
+        zcard(...args:any[]): Multi;
+        zscore(args:any[], callback?:ResCallbackT<any>): Multi;
+        zscore(...args:any[]): Multi;
+        zrank(args:any[], callback?:ResCallbackT<any>): Multi;
+        zrank(...args:any[]): Multi;
+        zrevrank(args:any[], callback?:ResCallbackT<any>): Multi;
+        zrevrank(...args:any[]): Multi;
+        hset(args:any[], callback?:ResCallbackT<any>): Multi;
+        hset(...args:any[]): Multi;
+        hsetnx(args:any[], callback?:ResCallbackT<any>): Multi;
+        hsetnx(...args:any[]): Multi;
+        hget(args:any[], callback?:ResCallbackT<any>): Multi;
+        hget(...args:any[]): Multi;
+        hmset(args:any[], callback?:ResCallbackT<any>): Multi;
+        hmset(key:string, hash:any, callback?:ResCallbackT<any>): Multi;
+        hmset(...args:any[]): Multi;
+        hmget(args:any[], callback?:ResCallbackT<any>): Multi;
+        hmget(...args:any[]): Multi;
+        hincrby(args:any[], callback?:ResCallbackT<any>): Multi;
+        hincrby(...args:any[]): Multi;
+        hdel(args:any[], callback?:ResCallbackT<any>): Multi;
+        hdel(...args:any[]): Multi;
+        hlen(args:any[], callback?:ResCallbackT<any>): Multi;
+        hlen(...args:any[]): Multi;
+        hkeys(args:any[], callback?:ResCallbackT<any>): Multi;
+        hkeys(...args:any[]): Multi;
+        hvals(args:any[], callback?:ResCallbackT<any>): Multi;
+        hvals(...args:any[]): Multi;
+        hgetall(args:any[], callback?:ResCallbackT<any>): Multi;
+        hgetall(...args:any[]): Multi;
+        hgetall(key:string, callback?:ResCallbackT<any>): Multi;
+        hexists(args:any[], callback?:ResCallbackT<any>): Multi;
+        hexists(...args:any[]): Multi;
+        incrby(args:any[], callback?:ResCallbackT<any>): Multi;
+        incrby(...args:any[]): Multi;
+        decrby(args:any[], callback?:ResCallbackT<any>): Multi;
+        decrby(...args:any[]): Multi;
+        getset(args:any[], callback?:ResCallbackT<any>): Multi;
+        getset(...args:any[]): Multi;
+        mset(args:any[], callback?:ResCallbackT<any>): Multi;
+        mset(...args:any[]): Multi;
+        msetnx(args:any[], callback?:ResCallbackT<any>): Multi;
+        msetnx(...args:any[]): Multi;
+        randomkey(args:any[], callback?:ResCallbackT<any>): Multi;
+        randomkey(...args:any[]): Multi;
+        select(args:any[], callback?:ResCallbackT<any>): void;
+        select(...args:any[]): Multi;
+        move(args:any[], callback?:ResCallbackT<any>): Multi;
+        move(...args:any[]): Multi;
+        rename(args:any[], callback?:ResCallbackT<any>): Multi;
+        rename(...args:any[]): Multi;
+        renamenx(args:any[], callback?:ResCallbackT<any>): Multi;
+        renamenx(...args:any[]): Multi;
+        expire(args:any[], callback?:ResCallbackT<any>): Multi;
+        expire(...args:any[]): Multi;
+        expireat(args:any[], callback?:ResCallbackT<any>): Multi;
+        expireat(...args:any[]): Multi;
+        keys(args:any[], callback?:ResCallbackT<any>): Multi;
+        keys(...args:any[]): Multi;
+        dbsize(args:any[], callback?:ResCallbackT<any>): Multi;
+        dbsize(...args:any[]): Multi;
+        auth(args:any[], callback?:ResCallbackT<any>): void;
+        auth(...args:any[]): void;
+        ping(args:any[], callback?:ResCallbackT<any>): Multi;
+        ping(...args:any[]): Multi;
+        echo(args:any[], callback?:ResCallbackT<any>): Multi;
+        echo(...args:any[]): Multi;
+        save(args:any[], callback?:ResCallbackT<any>): Multi;
+        save(...args:any[]): Multi;
+        bgsave(args:any[], callback?:ResCallbackT<any>): Multi;
+        bgsave(...args:any[]): Multi;
+        bgrewriteaof(args:any[], callback?:ResCallbackT<any>): Multi;
+        bgrewriteaof(...args:any[]): Multi;
+        shutdown(args:any[], callback?:ResCallbackT<any>): Multi;
+        shutdown(...args:any[]): Multi;
+        lastsave(args:any[], callback?:ResCallbackT<any>): Multi;
+        lastsave(...args:any[]): Multi;
+        type(args:any[], callback?:ResCallbackT<any>): Multi;
+        type(...args:any[]): Multi;
+        multi(args:any[], callback?:ResCallbackT<any>): Multi;
+        multi(...args:any[]): Multi;
+        exec(args:any[], callback?:ResCallbackT<any>): Multi;
+        exec(...args:any[]): Multi;
+        discard(args:any[], callback?:ResCallbackT<any>): Multi;
+        discard(...args:any[]): Multi;
+        sync(args:any[], callback?:ResCallbackT<any>): Multi;
+        sync(...args:any[]): Multi;
+        flushdb(args:any[], callback?:ResCallbackT<any>): Multi;
+        flushdb(...args:any[]): Multi;
+        flushall(args:any[], callback?:ResCallbackT<any>): Multi;
+        flushall(...args:any[]): Multi;
+        sort(args:any[], callback?:ResCallbackT<any>): Multi;
+        sort(...args:any[]): Multi;
+        info(args:any[], callback?:ResCallbackT<any>): Multi;
+        info(...args:any[]): Multi;
+        monitor(args:any[], callback?:ResCallbackT<any>): Multi;
+        monitor(...args:any[]): Multi;
+        ttl(args:any[], callback?:ResCallbackT<any>): Multi;
+        ttl(...args:any[]): Multi;
+        persist(args:any[], callback?:ResCallbackT<any>): Multi;
+        persist(...args:any[]): Multi;
+        slaveof(args:any[], callback?:ResCallbackT<any>): Multi;
+        slaveof(...args:any[]): Multi;
+        debug(args:any[], callback?:ResCallbackT<any>): Multi;
+        debug(...args:any[]): Multi;
+        config(args:any[], callback?:ResCallbackT<any>): Multi;
+        config(...args:any[]): Multi;
+        subscribe(args:any[], callback?:ResCallbackT<any>): Multi;
+        subscribe(...args:any[]): Multi;
+        unsubscribe(args:any[], callback?:ResCallbackT<any>): Multi;
+        unsubscribe(...args:any[]): Multi;
+        psubscribe(args:any[], callback?:ResCallbackT<any>): Multi;
+        psubscribe(...args:any[]): Multi;
+        punsubscribe(args:any[], callback?:ResCallbackT<any>): Multi;
+        punsubscribe(...args:any[]): Multi;
+        publish(args:any[], callback?:ResCallbackT<any>): Multi;
+        publish(...args:any[]): Multi;
+        watch(args:any[], callback?:ResCallbackT<any>): Multi;
+        watch(...args:any[]): Multi;
+        unwatch(args:any[], callback?:ResCallbackT<any>): Multi;
+        unwatch(...args:any[]): Multi;
+        cluster(args:any[], callback?:ResCallbackT<any>): Multi;
+        cluster(...args:any[]): Multi;
+        restore(args:any[], callback?:ResCallbackT<any>): Multi;
+        restore(...args:any[]): Multi;
+        migrate(args:any[], callback?:ResCallbackT<any>): Multi;
+        migrate(...args:any[]): Multi;
+        dump(args:any[], callback?:ResCallbackT<any>): Multi;
+        dump(...args:any[]): Multi;
+        object(args:any[], callback?:ResCallbackT<any>): Multi;
+        object(...args:any[]): Multi;
+        client(args:any[], callback?:ResCallbackT<any>): Multi;
+        client(...args:any[]): Multi;
+        eval(args:any[], callback?:ResCallbackT<any>): Multi;
+        eval(...args:any[]): Multi;
+        evalsha(args:any[], callback?:ResCallbackT<any>): Multi;
+        evalsha(...args:any[]): Multi;
+        quit(args:any[], callback?:ResCallbackT<any>): Multi;
+        quit(...args:any[]): Multi;
+    }
 }
diff --git a/redlock/redlock-test.ts b/redlock/redlock-test.ts
new file mode 100644
index 0000000000..70a9341a75
--- /dev/null
+++ b/redlock/redlock-test.ts
@@ -0,0 +1,103 @@
+/// <reference path="./redlock.d.ts" />
+
+import Redlock = require('redlock');
+
+import NodeifyCallback = RedlockTypes.NodeifyCallback;
+import Lock = RedlockTypes.Lock;
+import RedlockOptions = RedlockTypes.RedlockOptions;
+
+module RedlockTest {
+	// constructor
+	{
+		let redlock: Redlock;
+		let client: any;
+		let options: RedlockOptions;
+		redlock = new Redlock([client]);
+		redlock = new Redlock([client], options);
+	}
+
+	// acquire, lock
+	{
+		let redlock: Redlock;
+		let resource: string;
+		let ttl: number;
+		let callback: NodeifyCallback<Lock>;
+		let result: Promise<Lock>;
+		result = redlock.acquire(resource, ttl);
+		result = redlock.acquire(resource, ttl, callback);
+		result = redlock.lock(resource, ttl);
+		result = redlock.lock(resource, ttl, callback);
+	}
+
+	// disposer
+	{
+		let redlock: Redlock;
+		let resource: string;
+		let ttl: number;
+		let result: any;
+		result = redlock.acquire(resource, ttl);
+	}
+
+	// release, unlock
+	{
+		let redlock: Redlock;
+		let lock: Lock;
+		let callback: NodeifyCallback<void>;
+		let result: Promise<void>;
+		result = redlock.release(lock);
+		result = redlock.release(lock, callback);
+		result = redlock.unlock(lock);
+		result = redlock.unlock(lock, callback);
+	}
+
+	// extend
+	{
+		let redlock: Redlock;
+		let lock: Lock;
+		let ttl: number;
+		let callback: NodeifyCallback<Lock>;
+		let result: Promise<Lock>;
+		result = redlock.extend(lock, ttl);
+		result = redlock.extend(lock, ttl, callback);
+	}
+
+	// _lock
+	{
+		let redlock: Redlock;
+		let resource: string;
+		let value: string;
+		let ttl: number;
+		let callback: NodeifyCallback<Lock>;
+		let result: Promise<Lock>;
+		result = redlock._lock(resource, value, ttl);
+		result = redlock._lock(resource, value, ttl, callback);
+	}
+
+	// _random
+	{
+		let redlock: Redlock;
+		let result: string;
+		result = redlock._random();
+	}
+}
+
+module LockTest {
+	// unlock
+	{
+		let lock: Lock;
+		let callback: NodeifyCallback<void>;
+		let result: Promise<void>;
+		result = lock.unlock();
+		result = lock.unlock(callback);
+	}
+
+	// extend
+	{
+		let lock: Lock;
+		let ttl: number;
+		let callback: NodeifyCallback<Lock>;
+		let result: Promise<Lock>;
+		result = lock.extend(ttl);
+		result = lock.extend(ttl, callback);
+	}
+}
diff --git a/redlock/redlock.d.ts b/redlock/redlock.d.ts
new file mode 100644
index 0000000000..07760e1020
--- /dev/null
+++ b/redlock/redlock.d.ts
@@ -0,0 +1,62 @@
+// Type definitions for Redlock
+// Project: https://github.com/mike-marcacci/node-redlock
+// Definitions by: Ilya Mochalov <https://github.com/chrootsu>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../bluebird/bluebird.d.ts" />
+
+declare module RedlockTypes {
+	interface LockError extends Error {}
+
+	interface NodeifyCallback<T> {
+		(err: any, value?: T): void;
+	}
+
+	interface Lock {
+		redlock: Redlock;
+		resource: string;
+		value: any;
+		expiration: number;
+
+		unlock(callback?: NodeifyCallback<void>): Promise<void>;
+
+		extend(ttl: number, callback?: NodeifyCallback<Lock>): Promise<Lock>;
+	}
+
+	interface RedlockOptions {
+		driftFactor?: number;
+		retryCount?: number;
+		retryDelay?: number;
+	}
+
+	class Redlock {
+		LockError: LockError;
+
+		driftFactor: number;
+		retryCount: number;
+		retryDelay: number;
+
+		servers: any[]; // array of redis.RedisClient
+
+		constructor(clients: any[], options?: RedlockOptions);
+
+		acquire(resource: string, ttl: number, callback?: NodeifyCallback<Lock>): Promise<Lock>;
+		lock(resource: string, ttl: number, callback?: NodeifyCallback<Lock>): Promise<Lock>;
+
+		disposer(resource: string, ttl: number): any; // return bluebird.Disposer
+
+		release(lock: Lock, callback?: NodeifyCallback<void>): Promise<void>;
+		unlock(lock: Lock, callback?: NodeifyCallback<void>): Promise<void>;
+
+		extend(lock: Lock, ttl: number, callback?: NodeifyCallback<Lock>): Promise<Lock>;
+
+		_lock(resource: string, value: string, ttl: number, callback?: NodeifyCallback<Lock>): Promise<Lock>;
+
+		_random(): string;
+	}
+}
+
+declare module "redlock" {
+	import Redlock = RedlockTypes.Redlock;
+	export = Redlock;
+}
diff --git a/redux-actions/redux-actions-tests.ts b/redux-actions/redux-actions-tests.ts
new file mode 100644
index 0000000000..30dd00a970
--- /dev/null
+++ b/redux-actions/redux-actions-tests.ts
@@ -0,0 +1,56 @@
+/// <reference path="./redux-actions.d.ts" />
+
+const minimalAction: ReduxActions.Action = { type: 'INCREMENT' };
+const richerAction: ReduxActions.Action = {
+    type: 'INCREMENT',
+    payload: 2,
+    error: false,
+    meta: {
+        remote: true
+    }
+};
+
+const incrementAction: (...args: any[]) => ReduxActions.Action = ReduxActions.createAction<number>(
+    'INCREMENT',
+    (amount: number) => amount
+);
+const action: ReduxActions.Action = incrementAction(42);
+
+const incrementByAction: (...args: any[]) => ReduxActions.Action = ReduxActions.createAction<number>(
+    'INCREMENT_BY',
+    (amount: number) => amount,
+    amount => ({ remote: true })
+);
+
+let state: number;
+
+const actionHandler = ReduxActions.handleAction<number>(
+    'INCREMENT',
+    (state: number, action: ReduxActions.Action) => state + 1
+);
+state = actionHandler(0, { type: 'INCREMENT' });
+
+const actionHandlerWithReduceMap = ReduxActions.handleAction<number>(
+    'INCREMENT_BY', {
+        next(state: number, action: ReduxActions.Action) {
+            return state + action.payload;
+        },
+        throw(state: number) { return state }
+    }
+);
+state = actionHandlerWithReduceMap(0, { type: 'INCREMENT' });
+
+const actionsHandler = ReduxActions.handleActions<number>({
+    'INCREMENT': (state: number, action: ReduxActions.Action) => state + 1,
+    'DECREMENT': (state: number, action: ReduxActions.Action) => state - 1
+});
+state = actionsHandler(0, { type: 'INCREMENT' });
+
+const actionsHandlerWithInitialState = ReduxActions.handleActions<number>({
+    'INCREMENT': (state: number, action: ReduxActions.Action) => state + 1,
+    'DECREMENT': (state: number, action: ReduxActions.Action) => state - 1
+}, 0);
+state = actionsHandlerWithInitialState(0, { type: 'INCREMENT' });
+
+
+
diff --git a/redux-actions/redux-actions.d.ts b/redux-actions/redux-actions.d.ts
new file mode 100644
index 0000000000..522f184625
--- /dev/null
+++ b/redux-actions/redux-actions.d.ts
@@ -0,0 +1,34 @@
+// Type definitions for redux-actions v0.8.0
+// Project: https://github.com/acdlite/redux-actions
+// Definitions by: Jack Hsu <https://github.com/jaysoo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+declare module ReduxActions {
+    // FSA-compliant action.
+    // See: https://github.com/acdlite/flux-standard-action
+    type Action = {
+        type: string
+        payload?: any
+        error?: boolean
+        meta?: any
+    };
+
+    type PayloadCreator<T> = (...args: any[]) => T;
+    type MetaCreator = (...args: any[]) => any;
+
+    type Reducer<T> = (state: T, action: Action) => T;
+
+    type ReducerMap<T> = {
+        [actionType: string]: Reducer<T>
+    };
+
+    export function createAction<T>(actionType: string, payloadCreator?: PayloadCreator<T>, metaCreator?: MetaCreator): (...args: any[]) => Action;
+
+    export function handleAction<T>(actionType: string, reducer: Reducer<T> | ReducerMap<T>): Reducer<T>;
+
+    export function handleActions<T>(reducerMap: ReducerMap<T>, initialState?: T): Reducer<T>;
+}
+
+declare module 'redux-actions' {
+    export = ReduxActions;
+}
+
diff --git a/requirejs/require.d.ts b/requirejs/require.d.ts
index 58fb4f6f12..5ca4b476a7 100644
--- a/requirejs/require.d.ts
+++ b/requirejs/require.d.ts
@@ -166,8 +166,8 @@ interface RequireConfig {
 
 	/**
 	* Extra query string arguments appended to URLs that RequireJS
-	* uses to fetch resources.  Most useful to cachce bust when
-	* the browser or server is not configured correcty.
+	* uses to fetch resources.  Most useful to cache bust when
+	* the browser or server is not configured correctly.
 	*
 	* @example
 	* urlArgs: "bust= + (new Date()).getTime()
diff --git a/rest/rest-tests.ts b/rest/rest-tests.ts
index 6d267c7926..cedc11b003 100644
--- a/rest/rest-tests.ts
+++ b/rest/rest-tests.ts
@@ -117,24 +117,24 @@ var promiseOrResponse = interceptor({
 });
 
 client = rest
-    .wrap(defaultRequest)
-    .wrap(hateoas)
-    .wrap(location)
-    .wrap(mime)
-    .wrap(pathPrefix)
-    .wrap(basicAuth)
-    .wrap(oAuth)
-    .wrap(csrf)
-    .wrap(errorCode)
-    .wrap(retry)
-    .wrap(timeout)
-    .wrap(jsonp)
-    .wrap(xdomain)
-    .wrap(xhr)
-    .wrap(noop)
-    .wrap(fail)
-    .wrap(knownConfig, { prop: 'value' })
-    .wrap(transformedConfig, { prop: 'value' });
+    .wrap<any>(defaultRequest)
+    .wrap<any>(hateoas)
+    .wrap<any>(location)
+    .wrap<any>(mime)
+    .wrap<any>(pathPrefix)
+    .wrap<any>(basicAuth)
+    .wrap<any>(oAuth)
+    .wrap<any>(csrf)
+    .wrap<any>(errorCode)
+    .wrap<any>(retry)
+    .wrap<any>(timeout)
+    .wrap<any>(jsonp)
+    .wrap<any>(xdomain)
+    .wrap<any>(xhr)
+    .wrap<any>(noop)
+    .wrap<any>(fail)
+    .wrap<any>(knownConfig, { prop: 'value' })
+    .wrap<any>(transformedConfig, { prop: 'value' });
 
 import xhrClient = require('rest/client/xhr');
 import nodeClient = require('rest/client/node');
diff --git a/riotcontrol/riotcontrol-tests.ts b/riotcontrol/riotcontrol-tests.ts
new file mode 100644
index 0000000000..b3eee8b2e0
--- /dev/null
+++ b/riotcontrol/riotcontrol-tests.ts
@@ -0,0 +1,41 @@
+/// <reference path="./riotcontrol.d.ts" />
+
+import riotcontrol = require('riotcontrol');
+
+{
+	let store: RiotControl.Store;
+	let result: void;
+	result = riotcontrol.addStore(store);
+}
+
+{
+	let events: string;
+	let fn: Function;
+	let result: void;
+	result = riotcontrol.on(events, fn);
+}
+
+{
+	let name: string;
+	let fn: Function;
+	let result: void;
+	result = riotcontrol.one(name, fn);
+}
+
+{
+	let events: string;
+	let fn: Function;
+	let result: void;
+	result = riotcontrol.off(events);
+	result = riotcontrol.off(events, fn);
+}
+
+{
+	let name: string;
+	let arg: any;
+	let result: void;
+	result = riotcontrol.trigger(name);
+	result = riotcontrol.trigger(name, arg);
+	result = riotcontrol.trigger(name, arg, arg);
+	result = riotcontrol.trigger(name, arg, arg, arg);
+}
diff --git a/riotcontrol/riotcontrol.d.ts b/riotcontrol/riotcontrol.d.ts
new file mode 100644
index 0000000000..0fcafcf28b
--- /dev/null
+++ b/riotcontrol/riotcontrol.d.ts
@@ -0,0 +1,26 @@
+// Type definitions for RiotControl
+// Project: https://github.com/jimsparkman/RiotControl
+// Definitions by: Ilya Mochalov <https://github.com/chrootsu>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module RiotControl {
+	interface Store {
+		on(events: string, fn: Function): Store;
+		one(name: string, fn: Function): Store;
+		off(events: string, fn?: Function): Store;
+		trigger(name: string, ...args: any[]): Store;
+	}
+
+	var _stores: Store[];
+
+	function addStore(store: Store): void;
+
+	function on(events: string, fn: Function): void;
+	function one(name: string, fn: Function): void;
+	function off(events: string, fn?: Function): void;
+	function trigger(name: string, ...args: any[]): void;
+}
+
+declare module "riotcontrol" {
+	export = RiotControl;
+}
diff --git a/rsmq-worker/rsmq-worker-tests.ts b/rsmq-worker/rsmq-worker-tests.ts
index fa635e4152..d5d974bd06 100644
--- a/rsmq-worker/rsmq-worker-tests.ts
+++ b/rsmq-worker/rsmq-worker-tests.ts
@@ -1,3 +1,4 @@
+/// <reference path="./rsmq-worker.d.ts" />
 
 import RSMQWorker = require('rsmq-worker');
 
@@ -20,4 +21,3 @@ worker.send('message2', 1, (e: Error, id:string) => {
 worker.send('message3', () => {});
 
 worker.stop();
-
diff --git a/seedrandom/seedrandom-tests.ts b/seedrandom/seedrandom-tests.ts
index 1f913a406b..69a11622fa 100644
--- a/seedrandom/seedrandom-tests.ts
+++ b/seedrandom/seedrandom-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./seedrandom.d.ts" />
+
 import seedrandom = require("seedrandom");
 
 var rng = seedrandom("hello.");
diff --git a/selectize/selectize-tests.ts b/selectize/selectize-tests.ts
index b5ea65829d..caf0b06e3b 100644
--- a/selectize/selectize-tests.ts
+++ b/selectize/selectize-tests.ts
@@ -212,7 +212,7 @@ interface Link {
 }
 
 $('#select-links').selectize({
-    theme: 'links',
+    // NOTE ( https://github.com/borisyankov/DefinitelyTyped/pull/5590 ) theme: 'links',
     maxItems: null,
     valueField: 'id',
     searchField: 'title',
@@ -418,4 +418,3 @@ $("#select-car").selectize({
     plugins: ['optgroup_columns'],
     openOnFocus: false
 });
-
diff --git a/sequelize/sequelize-tests.ts b/sequelize/sequelize-tests.ts
index 2651453d6e..ae6fd7af4c 100644
--- a/sequelize/sequelize-tests.ts
+++ b/sequelize/sequelize-tests.ts
@@ -587,7 +587,9 @@ User.findOne( { where : { name : 'worker' }, include : [User] } );
 User.findOne( { where : { name : 'Boris' }, include : [User, { model : User, as : 'Photos' }] } );
 User.findOne( { where : { username : 'someone' }, include : [User] } );
 User.findOne( { where : { username : 'barfooz' }, raw : true } );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 User.findOne( { updatedAt : { ne : null } } );
+ */
 User.find( { where : { intVal : { gt : 5 } } } );
 User.find( { where : { intVal : { lte : 5 } } } );
 
@@ -639,7 +641,9 @@ User.findOrInitialize( { where : { username : 'foo' }, defaults : { foo : 'asd'
 
 User.findOrCreate( { where : { a : 'b' }, defaults : { json : { a : { b : 'c' }, d : [1, 2, 3] } } } );
 User.findOrCreate( { where : { a : 'b' }, defaults : { json : 'a', data : 'b' } } );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 User.findOrCreate( { where : { a : 'b' }, transaction : t, lock : t.LOCK.UPDATE } );
+ */
 User.findOrCreate( { where : { a : 'b' }, logging : function(  ) { } } );
 User.findOrCreate( { where : { username : 'Username' }, defaults : { data : 'some data' }, transaction : t } );
 User.findOrCreate( { where : { objectId : 'asdasdasd' }, defaults : { username : 'gottlieb' } } );
@@ -719,24 +723,32 @@ queryInterface.dropAllTables();
 queryInterface.showAllTables( { logging : function() { } } );
 queryInterface.createTable( 'table', { name : Sequelize.STRING }, { logging : function() { } } );
 queryInterface.createTable( 'skipme', { name : Sequelize.STRING } );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 queryInterface.dropAllTables( { skip : ['skipme'] } );
+ */
 queryInterface.dropTable( 'Group', { logging : function() { } } );
 queryInterface.addIndex( 'Group', ['username', 'isAdmin'], { logging : function() { } } );
 queryInterface.showIndex( 'Group', { logging : function() { } } );
 queryInterface.removeIndex( 'Group', ['username', 'isAdmin'], { logging : function() { } } );
 queryInterface.showIndex( 'Group' );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 queryInterface.createTable( 'table', { name : { type : Sequelize.STRING } }, { schema : 'schema' } );
+ */
 queryInterface.addIndex( { schema : 'a', tableName : 'c' }, ['d', 'e'], { logging : function() {} }, 'schema_table' );
 queryInterface.showIndex( { schema : 'schema', tableName : 'table' }, { logging : function() {} } );
 queryInterface.addIndex( 'Group', ['from'] );
 queryInterface.describeTable( '_Users', { logging : function() {} } );
 queryInterface.createTable( 's', { table_id : { type : Sequelize.INTEGER, primaryKey : true, autoIncrement : true } } );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 queryInterface.insert( null, 'TableWithPK', {}, { raw : true, returning : true, plain : true } );
+ */
 queryInterface.createTable( 'SomeTable', { someEnum : Sequelize.ENUM( 'value1', 'value2', 'value3' ) } );
 queryInterface.createTable( 'SomeTable', { someEnum : { type : Sequelize.ENUM, values : ['b1', 'b2', 'b3'] } } );
 queryInterface.createTable( 't', { someEnum : { type : Sequelize.ENUM, values : ['c1', 'c2', 'c3'], field : 'd' } } );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 queryInterface.createTable( 'User', { name : { type : Sequelize.STRING } }, { schema : 'hero' } );
 queryInterface.rawSelect( 'User', { schema : 'hero', logging : function() {} }, 'name' );
+ */
 queryInterface.renameColumn( '_Users', 'username', 'pseudo', { logging : function() {} } );
 queryInterface.renameColumn( { schema : 'archive', tableName : 'Users' }, 'username', 'pseudo' );
 queryInterface.renameColumn( '_Users', 'username', 'pseudo' );
@@ -918,6 +930,7 @@ s.define( 'UserWithUniqueUsername', {
     username : { type : Sequelize.STRING, unique : { name : 'user_and_email', msg : 'User and email must be unique' } },
     email : { type : Sequelize.STRING, unique : 'user_and_email' }
 } );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 s.define( 'UserWithUniqueUsername', {
     user_id : { type : Sequelize.INTEGER },
     email : { type : Sequelize.STRING }
@@ -931,7 +944,7 @@ s.define( 'UserWithUniqueUsername', {
             fields : ['user_id', { attribute : 'email', collate : 'en_US', order : 'DESC', length : 5 }]
         }]
 } );
-
+ */
 s.define( 'TaskBuild', {
     title : { type : Sequelize.STRING, defaultValue : 'a task!' },
     foo : { type : Sequelize.INTEGER, defaultValue : 2 },
@@ -1239,49 +1252,3 @@ s.transaction( function() {
 s.transaction( { isolationLevel : 'SERIALIZABLE' }, function( t ) { return Promise.resolve(); } );
 s.transaction( { isolationLevel : s.Transaction.ISOLATION_LEVELS.SERIALIZABLE }, (t) => Promise.resolve() );
 s.transaction( { isolationLevel : s.Transaction.ISOLATION_LEVELS.READ_COMMITTED }, (t) => Promise.resolve() );
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/sequelize/sequelize.d.ts b/sequelize/sequelize.d.ts
index 41e8410aec..ba465db5e7 100644
--- a/sequelize/sequelize.d.ts
+++ b/sequelize/sequelize.d.ts
@@ -2034,6 +2034,7 @@ declare module "sequelize" {
              */
             logging? : boolean | Function;
 
+            transaction?: Transaction;
         }
 
         /**
@@ -2085,6 +2086,9 @@ declare module "sequelize" {
              */
             logging? : boolean | Function;
 
+            silent? : boolean;
+
+            returning? : boolean;
         }
 
         /**
@@ -4878,4 +4882,3 @@ declare module "sequelize" {
     export = sequelize;
 
 }
-
diff --git a/serve-favicon/serve-favicon.d.ts b/serve-favicon/serve-favicon.d.ts
index bb19c2f69a..19bbb261e6 100644
--- a/serve-favicon/serve-favicon.d.ts
+++ b/serve-favicon/serve-favicon.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for serve-favicon 2.1.6
+// Type definitions for serve-favicon 2.2.0
 // Project: https://github.com/expressjs/serve-favicon
 // Definitions by: Uros Smolnik <https://github.com/urossmolnik/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -24,6 +24,8 @@ declare module "serve-favicon" {
         */
         maxAge?: number;
     }): express.RequestHandler;
+    
+    namespace serveFavicon{}
 
     export = serveFavicon;
 }
\ No newline at end of file
diff --git a/should-promised/should-promised-tests.ts b/should-promised/should-promised-tests.ts
index 03167e663f..50ea0b59a0 100644
--- a/should-promised/should-promised-tests.ts
+++ b/should-promised/should-promised-tests.ts
@@ -7,9 +7,9 @@ var promise: Promise<number> = new Promise<number>(function (resolve, reject) {}
 promise.should.be.Promise;
 (10).should.not.be.a.Promise;
 
-promise.should.be.fulfilled;
+promise.should.be.fulfilled();
 
-promise.should.be.rejected;
+promise.should.be.rejected();
 
 promise.should.be.rejectedWith(Error);
 promise.should.be.rejectedWith('boom');
diff --git a/should-promised/should-promised.d.ts b/should-promised/should-promised.d.ts
index c6c95ba989..f7e2a97f57 100644
--- a/should-promised/should-promised.d.ts
+++ b/should-promised/should-promised.d.ts
@@ -5,8 +5,8 @@
 
 interface ShouldAssertion {
     Promise: ShouldAssertion;
-    fulfilled: ShouldAssertion;
-    rejected: ShouldAssertion;
+    fulfilled(): ShouldAssertion;
+    rejected(): ShouldAssertion;
     rejectedWith(message: (string | Function | RegExp), properties?: Object): ShouldAssertion;
     rejectedWith(message: Object): ShouldAssertion;
     finally: ShouldAssertion;
diff --git a/simplebar/simplebar-tests.ts b/simplebar/simplebar-tests.ts
new file mode 100755
index 0000000000..abf906a089
--- /dev/null
+++ b/simplebar/simplebar-tests.ts
@@ -0,0 +1,5 @@
+/// <reference path="simplebar.d.ts"/>
+/// <reference path="../jquery/jquery.d.ts"/>
+
+var simplebar = $.fn.simplebar.noConflict();
+$.fn.simplebar = simplebar;
diff --git a/simplebar/simplebar.d.ts b/simplebar/simplebar.d.ts
new file mode 100755
index 0000000000..bab795e1ae
--- /dev/null
+++ b/simplebar/simplebar.d.ts
@@ -0,0 +1,37 @@
+// Type definitions for simplebar.js 1.1.7
+// Project: https://github.com/Grsmto/simplebar
+// Definitions by: Gregor Woiwode <https://github.com/gregonnet>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface SimplebarOptions {
+    autoHide?: boolean;
+    wrapContent?: boolean;
+}
+
+interface JQuery {
+    /**
+    * Enables simplebar on calling element.
+    */
+    simplebar: {
+        /**
+        * Define if scrollbar should be faded out automatically
+        *
+        * @param indicator if scrollbar should be faded out automatically.
+        */
+        (options?: SimplebarOptions): JQuery;
+    };
+}
+
+interface JQueryStatic {
+    /**
+    * Enables simplebar on calling element.
+    */
+    simplebar: {
+        /**
+        * Define if scrollbar should be faded out automatically
+        *
+        * @param indicator if scrollbar should be faded out automatically.
+        */
+        (options?: SimplebarOptions): JQuery;
+    };
+}
diff --git a/slickgrid/SlickGrid.d.ts b/slickgrid/SlickGrid.d.ts
index 54686df9f2..ae3a910239 100644
--- a/slickgrid/SlickGrid.d.ts
+++ b/slickgrid/SlickGrid.d.ts
@@ -507,11 +507,11 @@ declare module Slick {
 		getEditor<T>(column: Column<T>): Editors.Editor<T>;
 	}
 
-	export interface FormatterFactory<T extends Slick.SlickData> {
+	export interface FormatterFactory<T extends SlickData> {
 		getFormatter(column: Column<T>): Formatter<any>;
 	}
 
-	export interface GridOptions<T extends Slick.SlickData> {
+	export interface GridOptions<T extends SlickData> {
 
 		/**
 		* Makes cell editors load asynchronously after a small delay. This greatly increases keyboard navigation speed.
@@ -729,23 +729,8 @@ declare module Slick {
 		* @param options Additional options.  See Grid Options for a list of options that can be included.
 		**/
 		constructor(
-			container: string,
-			data: T[],
-			columns: Column<T>[],
-			options: GridOptions<T>);
-		constructor(
-			container: HTMLElement,
-			data: T[],
-			columns: Column<T>[],
-			options: GridOptions<T>);
-		constructor(
-			container: string,
-			data: DataProvider<T>,
-			columns: Column<T>[],
-			options: GridOptions<T>);
-		constructor(
-			container: HTMLElement,
-			data: DataProvider<T>,
+			container: string|HTMLElement|JQuery,
+			data: T[]|DataProvider<T>,
 			columns: Column<T>[],
 			options: GridOptions<T>);
 
@@ -878,7 +863,7 @@ declare module Slick {
 		* todo: no docs or comments available
 		* @return
 		**/
-		public getSortColumns(): Column<T>[];
+		public getSortColumns(): { columnId: string; sortAsc: boolean }[];
 
 		/**
 		* Updates an existing column definition and a corresponding header DOM element with the new title and tooltip.
@@ -1121,39 +1106,39 @@ declare module Slick {
 
 		// #region Events
 
-		public onScroll: Slick.Event<OnScrollEventData>;
-		public onSort: Slick.Event<OnSortEventData<T>>;
-		public onHeaderMouseEnter: Slick.Event<OnHeaderMouseEventData<T>>;
-		public onHeaderMouseLeave: Slick.Event<OnHeaderMouseEventData<T>>;
-		public onHeaderContextMenu: Slick.Event<OnHeaderContextMenuEventData<T>>;
-		public onHeaderClick: Slick.Event<OnHeaderClickEventData<T>>;
-		public onHeaderCellRendered: Slick.Event<OnHeaderCellRenderedEventData<T>>;
-		public onBeforeHeaderCellDestroy: Slick.Event<OnBeforeHeaderCellDestroyEventData<T>>;
-		public onHeaderRowCellRendered: Slick.Event<OnHeaderRowCellRenderedEventData<T>>;
-		public onBeforeHeaderRowCellDestroy: Slick.Event<OnBeforeHeaderRowCellDestroyEventData<T>>;
-		public onMouseEnter: Slick.Event<OnMouseEnterEventData>;
-		public onMouseLeave: Slick.Event<OnMouseLeaveEventData>;
-		public onClick: Slick.Event<OnClickEventData>;
-		public onDblClick: Slick.Event<OnDblClickEventData>;
-		public onContextMenu: Slick.Event<OnContextMenuEventData>;
-		public onKeyDown: Slick.Event<OnKeyDownEventData>;
-		public onAddNewRow: Slick.Event<OnAddNewRowEventData<T>>;
-		public onValidationError: Slick.Event<OnValidationErrorEventData<T>>;
-		public onColumnsReordered: Slick.Event<OnColumnsReorderedEventData>;
-		public onColumnsResized: Slick.Event<OnColumnsResizedEventData>;
-		public onCellChange: Slick.Event<OnCellChangeEventData<T>>;
-		public onBeforeEditCell: Slick.Event<OnBeforeEditCellEventData<T>>;
-		public onBeforeCellEditorDestroy: Slick.Event<OnBeforeCellEditorDestroyEventData<T>>;
-		public onBeforeDestroy: Slick.Event<OnBeforeDestroyEventData>;
-		public onActiveCellChanged: Slick.Event<OnActiveCellChangedEventData>;
-		public onActiveCellPositionChanged: Slick.Event<OnActiveCellPositionChangedEventData>;
-		public onDragInit: Slick.Event<OnDragInitEventData>;
-		public onDragStart: Slick.Event<OnDragStartEventData>;
-		public onDrag: Slick.Event<OnDragEventData>;
-		public onDragEnd: Slick.Event<OnDragEndEventData>;
-		public onSelectedRowsChanged: Slick.Event<OnSelectedRowsChangedEventData>;
-		public onCellCssStylesChanged: Slick.Event<OnCellCssStylesChangedEventData>;
-		public onViewportChanged: Slick.Event<OnViewportChangedEventData>;
+		public onScroll: Slick.Event<OnScrollEventArgs<T>>;
+		public onSort: Slick.Event<OnSortEventArgs<T>>;
+		public onHeaderMouseEnter: Slick.Event<OnHeaderMouseEventArgs<T>>;
+		public onHeaderMouseLeave: Slick.Event<OnHeaderMouseEventArgs<T>>;
+		public onHeaderContextMenu: Slick.Event<OnHeaderContextMenuEventArgs<T>>;
+		public onHeaderClick: Slick.Event<OnHeaderClickEventArgs<T>>;
+		public onHeaderCellRendered: Slick.Event<OnHeaderCellRenderedEventArgs<T>>;
+		public onBeforeHeaderCellDestroy: Slick.Event<OnBeforeHeaderCellDestroyEventArgs<T>>;
+		public onHeaderRowCellRendered: Slick.Event<OnHeaderRowCellRenderedEventArgs<T>>;
+		public onBeforeHeaderRowCellDestroy: Slick.Event<OnBeforeHeaderRowCellDestroyEventArgs<T>>;
+		public onMouseEnter: Slick.Event<OnMouseEnterEventArgs<T>>;
+		public onMouseLeave: Slick.Event<OnMouseLeaveEventArgs<T>>;
+		public onClick: Slick.Event<OnClickEventArgs<T>>;
+		public onDblClick: Slick.Event<OnDblClickEventArgs<T>>;
+		public onContextMenu: Slick.Event<OnContextMenuEventArgs<T>>;
+		public onKeyDown: Slick.Event<OnKeyDownEventArgs<T>>;
+		public onAddNewRow: Slick.Event<OnAddNewRowEventArgs<T>>;
+		public onValidationError: Slick.Event<OnValidationErrorEventArgs<T>>;
+		public onColumnsReordered: Slick.Event<OnColumnsReorderedEventArgs<T>>;
+		public onColumnsResized: Slick.Event<OnColumnsResizedEventArgs<T>>;
+		public onCellChange: Slick.Event<OnCellChangeEventArgs<T>>;
+		public onBeforeEditCell: Slick.Event<OnBeforeEditCellEventArgs<T>>;
+		public onBeforeCellEditorDestroy: Slick.Event<OnBeforeCellEditorDestroyEventArgs<T>>;
+		public onBeforeDestroy: Slick.Event<OnBeforeDestroyEventArgs<T>>;
+		public onActiveCellChanged: Slick.Event<OnActiveCellChangedEventArgs<T>>;
+		public onActiveCellPositionChanged: Slick.Event<OnActiveCellPositionChangedEventArgs<T>>;
+		public onDragInit: Slick.Event<OnDragInitEventArgs<T>>;
+		public onDragStart: Slick.Event<OnDragStartEventArgs<T>>;
+		public onDrag: Slick.Event<OnDragEventArgs<T>>;
+		public onDragEnd: Slick.Event<OnDragEndEventArgs<T>>;
+		public onSelectedRowsChanged: Slick.Event<OnSelectedRowsChangedEventArgs<T>>;
+		public onCellCssStylesChanged: Slick.Event<OnCellCssStylesChangedEventArgs<T>>;
+		public onViewportChanged: Slick.Event<OnViewportChangedEventArgs<T>>;
 		// #endregion Events
 
 		// #region Plugins
@@ -1169,6 +1154,7 @@ declare module Slick {
 		public invalidate(): void;
 		public invalidateRow(row: number): void;
 		public invalidateRows(rows: number[]): void;
+		public invalidateAllRows(): void;
 		public updateCell(row: number, cell: number): void;
 		public updateRow(row: number): void;
 		public getViewport(viewportTop?: number, viewportLeft?: number): Viewport;
@@ -1191,74 +1177,78 @@ declare module Slick {
 		// #endregion Editors
 	}
 
-	export interface OnCellCssStylesChangedEventData {
+	export interface GridEventArgs<T extends SlickData> {
+		grid: Grid<T>;
+	}
+
+	export interface OnCellCssStylesChangedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		key: string;
 		hash: CellCssStylesHash;
 	}
 
-	export interface OnSelectedRowsChangedEventData {
+	export interface OnSelectedRowsChangedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		rows: number[];
 	}
 
-	export interface OnDragEndEventData {
+	export interface OnDragEndEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		// todo: need to understand $canvas drag event parameter's 'dd' object
 		// the documentation is not enlightening
 	}
 
-	export interface OnDragEventData {
+	export interface OnDragEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		// todo: need to understand $canvas drag event parameter's 'dd' object
 		// the documentation is not enlightening
 	}
 
-	export interface OnDragStartEventData {
+	export interface OnDragStartEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		// todo: need to understand $canvas drag event parameter's 'dd' object
 		// the documentation is not enlightening
 	}
 
-	export interface OnDragInitEventData {
+	export interface OnDragInitEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		// todo: need to understand $canvas drag event parameter's 'dd' object
 		// the documentation is not enlightening
 	}
 
-	export interface OnActiveCellPositionChangedEventData {
+	export interface OnActiveCellPositionChangedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnActiveCellChangedEventData {
+	export interface OnActiveCellChangedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		row: number;
 		cell: number;
 	}
 
-	export interface OnBeforeDestroyEventData {
+	export interface OnBeforeDestroyEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnBeforeCellEditorDestroyEventData<T extends Slick.SlickData> {
+	export interface OnBeforeCellEditorDestroyEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		editor: Editors.Editor<T>;
 	}
 
-	export interface OnBeforeEditCellEventData<T extends SlickData> {
+	export interface OnBeforeEditCellEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		row: number;
 		cell: number;
 		item: T;
 		column: Column<T>;
 	}
 
-	export interface OnCellChangeEventData<T extends SlickData> {
+	export interface OnCellChangeEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		row: number;
 		cell: number;
 		item: T;
 	}
 
-	export interface OnColumnsResizedEventData {
+	export interface OnColumnsResizedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnColumnsReorderedEventData {
+	export interface OnColumnsReorderedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnValidationErrorEventData<T extends SlickData> {
+	export interface OnValidationErrorEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		editor: Editors.Editor<T>;
 		cellNode: HTMLElement;
 		validationResults: ValidateResults;
@@ -1267,92 +1257,91 @@ declare module Slick {
 		column: Column<T>;
 	}
 
-	export interface OnAddNewRowEventData<T extends SlickData> {
+	export interface OnAddNewRowEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		item: T;
 		column: Column<T>;
 	}
 
-	export interface OnKeyDownEventData {
+	export interface OnKeyDownEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		row: number;
 		cell: number;
 	}
 
-	export interface OnContextMenuEventData {
+	export interface OnContextMenuEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnDblClickEventData {
+	export interface OnDblClickEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		row: number;
 		cell: number;
 	}
 
-	export interface OnClickEventData {
+	export interface OnClickEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		row: number;
 		cell: number;
 	}
 
-	export interface OnMouseLeaveEventData {
+	export interface OnMouseLeaveEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnMouseEnterEventData {
+	export interface OnMouseEnterEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnBeforeHeaderRowCellDestroyEventData<T extends SlickData> {
+	export interface OnBeforeHeaderRowCellDestroyEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		node: HTMLElement; // todo: might be JQuery instance
 		column: Column<T>;
 	}
 
-	export interface OnHeaderRowCellRenderedEventData<T extends SlickData> {
+	export interface OnHeaderRowCellRenderedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		node: HTMLElement; // todo: might be JQuery instance
 		column: Column<T>;
 	}
 
-	export interface OnBeforeHeaderCellDestroyEventData<T extends SlickData> {
+	export interface OnBeforeHeaderCellDestroyEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		node: HTMLElement; // todo: might be JQuery instance
 		column: Column<T>;
 	}
 
-	export interface OnHeaderCellRenderedEventData<T extends SlickData> {
+	export interface OnHeaderCellRenderedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		node: HTMLElement;	// todo: might be JQuery instance
 		column: Column<T>;
 	}
 
-	export interface OnHeaderClickEventData<T extends SlickData> {
+	export interface OnHeaderClickEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		column: Column<T>;
 	}
 
-	export interface OnHeaderContextMenuEventData<T extends SlickData> {
+	export interface OnHeaderContextMenuEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		column: Column<T>;
 	}
 
-	export interface OnHeaderMouseEventData<T extends SlickData> {
+	export interface OnHeaderMouseEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		column: Column<T>;
 	}
 
-	// todo: merge with existing column definition
-	export interface Column<T extends SlickData> {
-		sortCol?: Column<T>;
-		sortAsc?: boolean;
-	}
-
-	export interface OnSortEventData<T extends SlickData> {
+	export interface OnSortEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		multiColumnSort: boolean;
-		sortCol?: Column<T>;
-		sortCols: Column<T>[];
-		sortAsc?: boolean;
+		sortCol?: SortColumn<T>;
+		sortCols?: SortColumn<T>[];
+		sortAsc: boolean;
 	}
 
-	export interface OnScrollEventData {
+	export interface OnScrollEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		scrollLeft: number;
 		scrollTop: number;
 	}
 
-	export interface OnViewportChangedEventData {
+	export interface OnViewportChangedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
+	export interface SortColumn<T extends SlickData> {
+		sortCol: Column<T>;
+		sortAsc: boolean;
+	}
+
 	export interface Cell {
 		row: number;
 		cell: number;
@@ -1463,7 +1452,7 @@ declare module Slick {
 		}
 	}
 
-	export interface Formatter<T extends Slick.SlickData> {
+	export interface Formatter<T extends SlickData> {
         (row: number, cell: number, value: any, columnDef: Column<T>, dataContext: SlickData): string;
 	}
 
@@ -1541,9 +1530,9 @@ declare module Slick {
 			public expandGroup(...varArgs: string[]): void;
 			public getGroups(): Group<T, any>[];
 			public getIdxById(id: string): number;
-			public getRowById(): T;
+			public getRowById(id: string): number;
 			public getItemById(id: any): T;
-			public getItemByIdx(): T;
+			public getItemByIdx(idx: number): T;
 			public mapRowsToIds(rowArray: T[]): string[];
 			public setRefreshHints(hints: RefreshHints): void;
 			public setFilterArgs(args: any): void;
@@ -1557,7 +1546,7 @@ declare module Slick {
 
 			public getLength(): number;
 			public getItem(index: number): T;
-			public getItemMetadata(index?: number): void;
+			public getItemMetadata(index?: number): TotalsRowMetadata<T>;
 
 			public onRowCountChanged: Slick.Event<OnRowCountChangedEventData>;
 			public onRowsChanged: Slick.Event<OnRowsChangedEventData>;
@@ -1707,7 +1696,7 @@ declare module Slick {
 
 	export class Plugin<T extends Slick.SlickData> {
 
-		constructor(options: PluginOptions);
+		constructor(options?: PluginOptions);
 		public init(grid: Grid<T>): void;
 		public destroy(): void;
 	}
diff --git a/slickgrid/slick.headerbuttons.d.ts b/slickgrid/slick.headerbuttons.d.ts
index 613203f438..df7e6bb257 100644
--- a/slickgrid/slick.headerbuttons.d.ts
+++ b/slickgrid/slick.headerbuttons.d.ts
@@ -24,7 +24,7 @@ declare module Slick {
         tooltip?: string;
     }
 
-    export interface OnCommandEventData<T extends SlickData> {
+    export interface OnCommandEventArgs<T extends SlickData> {
         grid: Grid<T>;
         column: Column<T>;
         command: string;
@@ -35,7 +35,7 @@ declare module Slick {
 
         export class HeaderButtons<T extends SlickData> extends Plugin<T> {
             constructor();
-            public onCommand: Event<OnCommandEventData<T>>;
+            public onCommand: Event<OnCommandEventArgs<T>>;
         }
     }
 }
diff --git a/socket.io-client/legacy/socket.io-client-0.9-commonjs-tests.ts b/socket.io-client/legacy/socket.io-client-0.9-commonjs-tests.ts
deleted file mode 100644
index beb8f0fad5..0000000000
--- a/socket.io-client/legacy/socket.io-client-0.9-commonjs-tests.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import io = require('socket.io-client-0.9');
-
-var socket = io.connect('http://localhost:80');
-
-socket.on('connect', function () {
-    console.log('Connected!');
-    socket.emit('event', 'some test data', function () {
-        console.log('Sent some data.');
-    });
-});
diff --git a/socket.io-client/legacy/socket.io-client-0.9-tests.ts b/socket.io-client/legacy/socket.io-client-0.9-tests.ts
deleted file mode 100644
index 7178306281..0000000000
--- a/socket.io-client/legacy/socket.io-client-0.9-tests.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-/// <reference path="socket.io-client-0.9.d.ts"/>
-
-var socket = io.connect('http://localhost:80');
-
-socket.on('connect', function () {
-    console.log('Connected!');
-    socket.emit('event', 'some test data', function () {
-        console.log('Sent some data.');
-    });
-});
diff --git a/socket.io-client/legacy/socket.io-client-0.9.d.ts b/socket.io-client/legacy/socket.io-client-0.9.d.ts
deleted file mode 100644
index 0b3626e420..0000000000
--- a/socket.io-client/legacy/socket.io-client-0.9.d.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-// Type definitions for socket.io nodejs client
-// Project: http://socket.io/
-// Definitions by: Maido Kaara <https://github.com/v3rm0n>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-declare module "socket.io-client-0.9" {
-  export = io;
-}
-
-declare var io: SocketIOStatic;
-
-interface SocketIOStatic {
-    connect(host: string, details?: any): SocketIOClient.Socket;
-}
-
-declare module SocketIOClient {
-    interface EventEmitter {
-        emit(name: string, ...data: any[]): any;
-        on(ns: string, fn: Function): EventEmitter;
-        addListener(ns: string, fn: Function): EventEmitter;
-        removeListener(ns: string, fn: Function): EventEmitter;
-        removeAllListeners(ns: string): EventEmitter;
-        once(ns: string, fn: Function): EventEmitter;
-        listeners(ns: string): Function[];
-    }
-
-    interface SocketNamespace extends EventEmitter {
-        of(name: string): SocketNamespace;
-        send(data: any, fn: Function): SocketNamespace;
-        emit(name: string): SocketNamespace;
-    }
-
-    interface Socket extends EventEmitter {
-        of(name: string): SocketNamespace;
-        connect(fn: Function): Socket;
-        packet(data: any): Socket;
-        flushBuffer(): void;
-        disconnect(): Socket;
-    }
-}
diff --git a/socket.io-client/legacy/socket.io-client-1.2.0-tests.ts b/socket.io-client/legacy/socket.io-client-1.2.0-tests.ts
deleted file mode 100644
index 3ad8db95f6..0000000000
--- a/socket.io-client/legacy/socket.io-client-1.2.0-tests.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-/// <reference path="socket.io-client-1.2.0.d.ts"/>
-
-function testUsingWithNodeHTTPServer() {
-    var socket = io('http://localhost');
-    socket.on('news', function (data: any) {
-        console.log(data);
-        socket.emit('my other event', { my: 'data' });
-    });
-}
-
-function testUsingWithExpress() {
-    var socket = io.connect('http://localhost');
-    socket.on('news', function (data: any) {
-        console.log(data);
-        socket.emit('my other event', { my: 'data' });
-    });
-}
-
-function testUsingWithTheExpressFramework() {
-    var socket = io.connect('http://localhost');
-    socket.on('news', function (data: any) {
-        console.log(data);
-        socket.emit('my other event', { my: 'data' });
-    });
-}
-
-function testRestrictingYourselfToANamespace() {
-    var chat = io.connect('http://localhost/chat')
-        , news = io.connect('http://localhost/news');
-
-    chat.on('connect', function () {
-        chat.emit('hi!');
-    });
-
-    news.on('news', function () {
-        news.emit('woot');
-    });
-}
-
-function testSendingAndGettingData() {
-    var socket = io();
-    socket.on('connect', function () {
-        socket.emit('ferret', 'tobi', function (data: any) {
-            console.log(data);
-        });
-    });
-}
-
-function testUsingItJustAsACrossBrowserWebSocket() {
-    var socket = io('http://localhost/');
-    socket.on('connect', function () {
-        socket.emit('hi');
-
-        socket.on('message', function (msg: any) {
-        });
-    });
-}
diff --git a/socket.io-client/legacy/socket.io-client-1.2.0.d.ts b/socket.io-client/legacy/socket.io-client-1.2.0.d.ts
deleted file mode 100644
index c5d7837641..0000000000
--- a/socket.io-client/legacy/socket.io-client-1.2.0.d.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-// Type definitions for socket.io-client 1.2.0
-// Project: http://socket.io/
-// Definitions by: PROGRE <https://github.com/progre/>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-declare var io: SocketIOClientStatic;
-
-declare module 'socket.io-client' {
-    export = io;
-}
-
-interface SocketIOClientStatic {
-    (host: string, details?: any): SocketIOClient.Socket;
-    (details?: any): SocketIOClient.Socket;
-    connect(host: string, details?: any): SocketIOClient.Socket;
-    connect(details?: any): SocketIOClient.Socket;
-    protocol: number;
-    Socket: { new (...args: any[]): SocketIOClient.Socket };
-    Manager: SocketIOClient.ManagerStatic;
-}
-
-declare module SocketIOClient {
-    interface Socket {
-        on(event: string, fn: Function): Socket;
-        once(event: string, fn: Function): Socket;
-        off(event?: string, fn?: Function): Socket;
-        emit(event: string, ...args: any[]): Socket;
-        listeners(event: string): Function[];
-        hasListeners(event: string): boolean;
-        connected: boolean;
-    }
-
-    interface ManagerStatic {
-        (url: string, opts: any): SocketIOClient.Manager;
-        new (url: string, opts: any): SocketIOClient.Manager;
-    }
-
-    interface Manager {
-        reconnection(v: boolean): Manager;
-        reconnectionAttempts(v: boolean): Manager;
-        reconnectionDelay(v: boolean): Manager;
-        reconnectionDelayMax(v: boolean): Manager;
-        timeout(v: boolean): Manager;
-    }
-}
diff --git a/socket.io.users/socket.io.users-tests.ts b/socket.io.users/socket.io.users-tests.ts
new file mode 100644
index 0000000000..54a0472628
--- /dev/null
+++ b/socket.io.users/socket.io.users-tests.ts
@@ -0,0 +1,58 @@
+/// <reference path="../socket.io/socket.io.d.ts"/>
+/// <reference path="socket.io.users.d.ts" />
+/// <reference path="../node/node.d.ts" />
+/// <reference path="../express/express.d.ts" />
+var express = require('express');
+var app = express();
+var httpServer = require('http').createServer(app);
+var io = require('socket.io')(httpServer);
+import ioUsers = require("socket.io.users");
+
+
+
+ioUsers.Session(app, {
+  "secret": "socket.io.users secret test",
+  "resave": true,
+  "saveUninitialized": true
+});
+
+io.use(ioUsers.Middleware());
+
+var users = ioUsers.Users.of("/");
+
+
+var userDisconnected = (user: ioUsers.User) => {
+  console.log(user.get("username") + " has disconnected from all web browser windows or/and tabs");
+}
+
+var setUsername = (user: ioUsers.User, data: any) => {
+  console.log(user.ip + ' is for first time visiting our site. He/she wants ' + data.username + ' for username');
+  user.set("username", data.username);
+}
+
+var joinRoom = (user: ioUsers.User, roomToJoin: string) => {
+  console.log(user.get("username") + ' joined to ' + roomToJoin);
+}
+
+var leaveRoom = (user: ioUsers.User, roomToJoin: string) => {
+  console.log(user.get("username") + ' joined to ' + roomToJoin);
+}
+
+var sendMessage = (user: ioUsers.User, data: any) => {
+  console.log(user.get("username") + 'send ' + data.content + ' to room: ' + data.room);
+}
+
+users.on('disconnected', userDisconnected);
+users.on('set username', setUsername);
+users.on('join room', joinRoom); //notify other = user joined room or (GLOBAL) room created.
+users.on('leave room', leaveRoom); //notify other = user left room or (GLOBAL) room removed.
+users.on("send message", sendMessage); //notify other = receive message.
+
+httpServer.on('uncaughtException', function(err: any) {
+  console.log(err);
+})
+
+var httpPort = 80;
+httpServer.listen(httpPort, function() {
+  console.log("Server is running on " + httpPort);
+});
diff --git a/socket.io.users/socket.io.users.d.ts b/socket.io.users/socket.io.users.d.ts
new file mode 100644
index 0000000000..f7ee9b2d8e
--- /dev/null
+++ b/socket.io.users/socket.io.users.d.ts
@@ -0,0 +1,79 @@
+// Type definitions for socket.io.users
+// Project: https://github.com/nodets/socket.io.users
+// Definitions by: Makis Maropoulos <https://github.com/kataras>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+/// <reference path="../express/express.d.ts" />
+/// <reference path="../express-session/express-session.d.ts" />
+/// <reference path="../socket.io/socket.io.d.ts" />
+
+declare module "socket.io.users" {
+	import { EventEmitter } from 'events';
+	import { Application } from "express";
+	import { SessionOptions } from "express-session";
+
+	var CONNECTION_EVENTS: string[];
+	var Middleware: () => (socket: SocketIO.Socket, next: () => any) => void;
+	var Session: (app: Application, options?: SessionOptions) => void;
+
+	type SocketUserList = {
+		[namespace: string]: Users;
+	};
+
+	class Namespaces {
+		private static socketUsersList: any;
+		static attach(namespace: string, socketUsersObj: Users): void;
+		static get(namespace: string): Users;
+	}
+
+	class User {
+		id: string | number;
+		socket: SocketIO.Socket;
+		sockets: SocketIO.Socket[];
+		rooms: string[];
+		ip: string;
+		remoteAddresses: string[];
+		store: any;
+		attach(socket: SocketIO.Socket): void;
+		detachSocket(socket: SocketIO.Socket): void;
+		detach(): void;
+		join(room: string): boolean;
+		leave(room: string): void;
+		leaveAll(): void;
+		/** same as in, checks if this user is inside a room */
+		belong(room: string): boolean;
+		/** same as belong, checks if this user is inside a room  */
+		in(room: string): boolean;
+		set(key: string, value: any, callback?: () => void): void;
+		get: (key: string) => any;
+		toString(): string;
+		emit(...args: any[]): void;
+		to(room: string): SocketIO.Socket;
+	}
+
+
+	class Users extends EventEmitter {
+		namespace: string;
+		users: User[];
+		constructor(namespace?: string);
+		static of(namespace?: string): Users;
+		takeId: (request: any) => string | number;
+		create(socket: SocketIO.Socket): User;
+		getById(id: string | number): User;
+		get(socket: SocketIO.Socket): User;
+		list(): User[];
+		size(): number;
+		push(_user: User): void;
+		add(socket: SocketIO.Socket): User;
+		indexOf(user: User): number;
+		remove(user: User): void;
+		room(room: string): User[];
+		in(room: string): User[];
+		from(room: string): User[];
+		update(user: User): void;
+		emitAll(...args: any[]): void;
+		registerSocketEvents(currentUser: User): void;
+	}
+
+}
diff --git a/socket.io/legacy/socket.io-0.9-tests.ts b/socket.io/legacy/socket.io-0.9-tests.ts
deleted file mode 100644
index 0d7e12bb6d..0000000000
--- a/socket.io/legacy/socket.io-0.9-tests.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import io = require('socket.io-0.9');
-
-var socketManager = io.listen(80);
-
-socketManager.sockets.on('connection', socket => {
-	socket.emit('news', { hello: 'world' });
-	socket.on('my other event', data => {
-		console.log(data);
-	});
-});
-
-// Storing data Associated to a client. 
-// Server side sample 
-io.listen(80).sockets.on('connection', function (socket) {
-    socket.on('set nickname', function (name) {
-        socket.set('nickname', name, function () { socket.emit('ready'); });
-    });
-
-    socket.on('msg', function () {
-        socket.get('nickname', function (err, name) {
-            console.log('Chat message by ', name);
-        });
-    });
-});
\ No newline at end of file
diff --git a/socket.io/legacy/socket.io-0.9.d.ts b/socket.io/legacy/socket.io-0.9.d.ts
deleted file mode 100644
index 5ead4abde5..0000000000
--- a/socket.io/legacy/socket.io-0.9.d.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-// Type definitions for socket.io
-// Project: http://socket.io/
-// Definitions by: William Orr <https://github.com/worr>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-
-///<reference path='../../node/node.d.ts' />
-
-declare module "socket.io-0.9" {
-	import http = require('http');
-
-	export function listen(server: http.Server, options: any, fn: Function): SocketManager;
-	export function listen(server: http.Server, fn?: Function): SocketManager;
-	export function listen(port: Number): SocketManager;
-
-
-  interface Socket {
-    id: string;
-    json:any;
-    log: any;
-    volatile: any;
-    broadcast: any;
-    handshake: any;
-    in(room: string): Socket;
-    to(room: string): Socket;
-    join(name: string, fn: Function): Socket;
-    leave(name: string, fn: Function): Socket;
-    set(key: string, value: any, fn: Function): Socket;
-    get(key: string, fn: Function): Socket;
-    has(key: string, fn: Function): Socket;
-    del(key: string, fn: Function): Socket;
-    disconnect(): Socket;
-    send(data: any, fn: Function): Socket;
-    emit(ev: any, ...data:any[]): Socket;
-    on(ns: string, fn: Function): Socket;
-  }
-
-  interface SocketNamespace {
-    clients(room: string): Socket[];
-    log: any;
-    store: any;
-    json: any;
-    volatile: any;
-    in(room: string): SocketNamespace;
-    on(evt: string, fn: (socket: Socket) => void): SocketNamespace;
-    to(room: string): SocketNamespace;
-    except(id: any): SocketNamespace;
-    send(data: any): any;
-    emit(ev: any, ...data:any[]): Socket;
-    socket(sid: any, readable: boolean): Socket;
-    authorization(fn: Function): SocketNamespace;
-  }
-
-  interface SocketManager {
-    get(key: any): any;
-    set(key: any, value: any): SocketManager;
-    enable(key: any): SocketManager;
-    disable(key: any): SocketManager;
-    enabled(key: any): boolean;
-    disabled(key: any): boolean;
-    configure(env: string, fn: Function): SocketManager;
-    configure(fn: Function): SocketManager;
-    of(nsp: string): SocketNamespace;
-    on(ns: string, fn: Function): SocketManager;
-    sockets: SocketNamespace;
-  }
-
-
-}
-
diff --git a/socket.io/legacy/socket.io-1.2.0-tests.ts b/socket.io/legacy/socket.io-1.2.0-tests.ts
deleted file mode 100644
index c2664f9cd7..0000000000
--- a/socket.io/legacy/socket.io-1.2.0-tests.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-/// <reference path="socket.io-1.2.0.d.ts"/>
-
-import socketIO = require('socket.io-1.2.0');
-
-function testUsingWithNodeHTTPServer() {
-    var app = require('http').createServer(handler);
-    var io = socketIO(app);
-    var fs = require('fs');
-
-    app.listen(80);
-
-    function handler(req: any, res: any) {
-        fs.readFile(__dirname + '/index.html',
-            function (err: any, data: any) {
-                if (err) {
-                    res.writeHead(500);
-                    return res.end('Error loading index.html');
-                }
-
-                res.writeHead(200);
-                res.end(data);
-            });
-    }
-
-    io.on('connection', function (socket) {
-        socket.emit('news', { hello: 'world' });
-        socket.on('my other event', function (data: any) {
-            console.log(data);
-        });
-    });
-}
-
-function testUsingWithExpress() {
-    var app = require('express')();
-    var server = require('http').Server(app);
-    var io = socketIO(server);
-
-    server.listen(80);
-
-    app.get('/', function (req: any, res: any) {
-        res.sendfile(__dirname + '/index.html');
-    });
-
-    io.on('connection', function (socket) {
-        socket.emit('news', { hello: 'world' });
-        socket.on('my other event', function (data: any) {
-            console.log(data);
-        });
-    });
-}
-
-function testUsingWithTheExpressFramework() {
-    var app = require('express').createServer();
-    var io = socketIO(app);
-
-    app.listen(80);
-
-    app.get('/', function (req: any, res: any) {
-        res.sendfile(__dirname + '/index.html');
-    });
-
-    io.on('connection', function (socket) {
-        socket.emit('news', { hello: 'world' });
-        socket.on('my other event', function (data: any) {
-            console.log(data);
-        });
-    });
-}
-
-function testSendingAndReceivingEvents() {
-    var io = socketIO(80);
-
-    io.on('connection', function (socket) {
-        io.emit('this', { will: 'be received by everyone' });
-
-        socket.on('private message', function (from: any, msg: any) {
-            console.log('I received a private message by ', from, ' saying ', msg);
-        });
-
-        socket.on('disconnect', function () {
-            io.sockets.emit('user disconnected');
-        });
-    });
-}
-
-function testRestrictingYourselfToANamespace() {
-    var io = socketIO.listen(80);
-    var chat = io
-        .of('/chat')
-        .on('connection', function (socket) {
-            socket.emit('a message', {
-                that: 'only'
-                , '/chat': 'will get'
-            });
-            chat.emit('a message', {
-                everyone: 'in'
-                , '/chat': 'will get'
-            });
-        });
-
-    var news = io
-        .of('/news')
-        .on('connection', function (socket) {
-            socket.emit('item', { news: 'item' });
-        });
-}
-
-function testSendingVolatileMessages() {
-    var io = socketIO.listen(80);
-
-    io.sockets.on('connection', function (socket) {
-        var tweets = setInterval(function () {
-            socket.volatile.emit('bieber tweet', {});
-        }, 100);
-
-        socket.on('disconnect', function () {
-            clearInterval(tweets);
-        });
-    });
-}
-
-function testSendingAndGettingData() {
-    var io = socketIO.listen(80);
-
-    io.sockets.on('connection', function (socket) {
-        socket.on('ferret', function (name: any, fn: any) {
-            fn('woot');
-        });
-    });
-}
-
-function testBroadcastingMessages() {
-    var io = socketIO.listen(80);
-
-    io.sockets.on('connection', function (socket) {
-        socket.broadcast.emit('user connected');
-    });
-}
-
-function testUsingItJustAsACrossBrowserWebSocket() {
-    var io = socketIO.listen(80);
-
-    io.sockets.on('connection', function (socket) {
-        socket.on('message', function () { });
-        socket.on('disconnect', function () { });
-    });
-}
diff --git a/socket.io/legacy/socket.io-1.2.0.d.ts b/socket.io/legacy/socket.io-1.2.0.d.ts
deleted file mode 100644
index 01b5e08365..0000000000
--- a/socket.io/legacy/socket.io-1.2.0.d.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-// Type definitions for socket.io 1.2.0
-// Project: http://socket.io/
-// Definitions by: PROGRE <https://github.com/progre/>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-///<reference path='../../node/node.d.ts' />
-
-declare module 'socket.io-1.2.0' {
-    var server: SocketIOStatic;
-
-    export = server;
-}
-
-interface SocketIOStatic {
-    (): SocketIO.Server;
-    (srv: any, opts?: any): SocketIO.Server;
-    (port: number, opts?: any): SocketIO.Server;
-    (opts: any): SocketIO.Server;
-
-    listen: SocketIOStatic;
-}
-
-declare module SocketIO {
-    interface Server {
-        serveClient(v: boolean): Server;
-        path(v: string): Server;
-        adapter(v: any): Server;
-        origins(v: string): Server;
-        sockets: Namespace;
-        attach(srv: any, opts?: any): Server;
-        attach(port: number, opts?: any): Server;
-        listen(srv: any, opts?: any): Server;
-        listen(port: number, opts?: any): Server;
-        bind(srv: any): Server;
-        onconnection(socket: any): Server;
-        of(nsp: string): Namespace;
-        emit(name: string, ...args: any[]): Socket;
-        use(fn: Function): Namespace;
-
-        on(event: 'connection', listener: (socket: Socket) => void): Namespace;
-        on(event: 'connect', listener: (socket: Socket) => void): Namespace;
-        on(event: string, listener: Function): Namespace;
-    }
-
-    interface Namespace extends NodeJS.EventEmitter {
-        name: string;
-        connected: { [id: string]: Socket };
-        use(fn: Function): Namespace;
-        in(room: string): Namespace;
-
-        on(event: 'connection', listener: (socket: Socket) => void): Namespace;
-        on(event: 'connect', listener: (socket: Socket) => void): Namespace;
-        on(event: string, listener: Function): Namespace;
-    }
-
-    interface Socket {
-        rooms: string[];
-        client: Client;
-        conn: any;
-        request: any;
-        id: string;
-        handshake: {
-            headers: any;
-            time: string;
-            address: any;
-            xdomain: boolean;
-            secure: boolean;
-            issued: number;
-            url: string;
-            query: any;
-        };
-
-        emit(name: string, ...args: any[]): Socket;
-        join(name: string, fn?: Function): Socket;
-        leave(name: string, fn?: Function): Socket;
-        to(room: string): Socket;
-        in(room: string): Socket;
-        send(...args: any[]): Socket;
-        write(...args: any[]): Socket;
-
-        on(event: string, listener: Function): Socket;
-        once(event: string, listener: Function): Socket;
-        removeListener(event: string, listener: Function): Socket;
-        removeAllListeners(event: string): Socket;
-        broadcast: Socket;
-        volatile: Socket;
-        connected: boolean;
-        disconnect(close?: boolean): Socket;
-    }
-
-    interface Client {
-        conn: any;
-        request: any;
-        id: string;
-    }
-}
diff --git a/source-map/source-map-tests.ts b/source-map/source-map-tests.ts
index f7ad78e853..3ec6b666d6 100644
--- a/source-map/source-map-tests.ts
+++ b/source-map/source-map-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./source-map.d.ts" />
+
 import SourceMap = require('source-map');
 
 function testSourceMapConsumer() {
@@ -162,4 +164,4 @@ function testSourceNode() {
         result = node.toStringWithSourceMap();
         result = node.toStringWithSourceMap(sos);
     }
-}
\ No newline at end of file
+}
diff --git a/stack-trace/stack-trace-tests.ts b/stack-trace/stack-trace-tests.ts
index a0b2f8d55f..c18f637519 100644
--- a/stack-trace/stack-trace-tests.ts
+++ b/stack-trace/stack-trace-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./stack-trace.d.ts" />
+
 import stackTrace = require('stack-trace');
 
 var currentStackTrace = stackTrace.get();
diff --git a/stampit/stampit-1.2.0.d.ts b/stampit/stampit-1.2.0.d.ts
deleted file mode 100644
index 8d46e74778..0000000000
--- a/stampit/stampit-1.2.0.d.ts
+++ /dev/null
@@ -1,155 +0,0 @@
-// Type definitions for stampit
-// Project: https://github.com/ericelliott/stampit
-// Definitions by: Vasyl Boroviak <https://github.com/koresar>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-declare var stampit: stampit.Stampit;
-
-declare module stampit {
-    interface Stampit {
-        /**
-         * Return a factory (akaStamp) function that will produce new objects using the
-         * prototypes that are passed in or composed.
-         * @param methods A map of method names and bodies for delegation.
-         * @param state A map of property names and values to clone for each new object.
-         * @param enclose A closure (function) used to create private data and privileged methods.
-         * */
-        (methods?:{}, state?:{}, enclose?:{(...encloseArgs:any[]): void}[]):stampit.Stamp;
-
-        /**
-         * Take two or more Stamps and combine them to produce a new Stamp.
-         * Combining overrides properties with last-in priority.
-         * @param stamps Stamps produced by stampit.
-         * @return A new Stamp made of all the given.
-         */
-        compose(...stamps:Stamp[]): Stamp;
-
-        /**
-         * Take a destination object followed by one or more source objects,
-         * and copy the source object properties to the destination object,
-         * with last in priority overrides.
-         * @param destination An object to copy properties to.
-         * @param source Objects to copy properties from.
-         * @return The destination object.
-         */
-        mixIn(destination:any, ...source:any[]): any;
-
-        /**
-         * Alias for mixIn.
-         * Take a destination object followed by one or more source objects,
-         * and copy the source object properties to the destination object,
-         * with last in priority overrides.
-         * @param destination An object to copy properties to.
-         * @param source Objects to copy properties from.
-         * @return The destination object.
-         */
-        extend(destination:any, ...source:any[]): any;
-
-        /**
-         * Check if an object is a Stamp.
-         * @param obj An object to check.
-         * @return true if the object is a Stamp; otherwise - false.
-         */
-        isStamp(obj:any): boolean;
-
-        /**
-         * Take an old-fashioned JS constructor and return a Stamp
-         * that you can freely compose with other Stamps.
-         * @param Constructor Old-fashioned constructor function.
-         * @return A new Stamp based on the given constructor.
-         */
-        convertConstructor(Constructor:any): Stamp;
-    }
-
-    /**
-     * A factory function that will produce new objects using the
-     * prototypes that are passed in or composed.
-     */
-    export interface Stamp {
-        /**
-         * Just like calling stamp() invokes the stamp and returns a new object instance.
-         * @param state Properties you wish to set on the new objects.
-         * @param encloseArgs The remaining arguments are passed to all .enclose() functions.
-         * WARNING Avoid using two different .enclose() functions that expect different arguments.
-         * .enclose() functions that take arguments should not be considered safe to compose
-         * with other .enclose() functions that also take arguments. Taking arguments with
-         * an .enclose() function is an anti-pattern that should be avoided, when possible.
-         * @return A new object composed of the Stamps and prototypes provided.
-         */
-        (state?:{}, ...encloseArgs:any[]): any;
-
-        /**
-         * Just like calling stamp(), stamp.create() invokes the stamp and returns a new instance.
-         * @param state Properties you wish to set on the new objects.
-         * @param encloseArgs The remaining arguments are passed to all .enclose() functions.
-         * WARNING Avoid using two different .enclose() functions that expect different arguments.
-         * .enclose() functions that take arguments should not be considered safe to compose
-         * with other .enclose() functions that also take arguments. Taking arguments with
-         * an .enclose() function is an anti-pattern that should be avoided, when possible.
-         * @return A new object composed of the Stamps and prototypes provided.
-         */
-        create(state?:{}, ...encloseArgs:any[]): any;
-
-        /**
-         * An object map containing the fixed prototypes.
-         */
-        fixed: Fixed;
-
-        /**
-         * Add methods to the methods prototype. Chainable.
-         * @param methods Object(s) containing map of method names and bodies for delegation.
-         * @return Self.
-         */
-        methods(...methods:{}[]): Stamp;
-
-        /**
-         * Take n objects and add them to the state prototype. Changes `this` object. Chainable.
-         * @param states Object(s) containing map of property names and values to clone for each new object.
-         * @return Self.
-         */
-        state(...states:{}[]): Stamp;
-
-        /**
-         * Take n functions, an array of functions, or n objects and add the functions to the enclose prototype.
-         * Functions passed into .enclose() are called any time an object is instantiated.
-         * That happens when the stamp function is invoked, or when the .create() method is called.
-         * Changes `this` object. Chainable.
-         * @param functions Closures (functions) used to create private data and privileged methods.
-         * @return Self.
-         */
-        enclose(...functions:{(...encloseArgs:any[]): void}[]): Stamp;
-
-        /**
-         * Take n functions, an array of functions, or n objects and add the functions to the enclose prototype.
-         * Functions passed into .enclose() are called any time an object is instantiated.
-         * That happens when the stamp function is invoked, or when the .create() method is called.
-         * Changes `this` object. Chainable.
-         * @param methods Function properties of these objects will be treated as closure functions.
-         * @return Self.
-         */
-        enclose(...methods:{}[]): Stamp;
-
-        /**
-         * Take one or more Stamps and
-         * combine them with `this` to produce and return a new Stamp.
-         * Combining overrides properties with last-in priority.
-         * NOT chainable.
-         * @param stamps Stampit factories, aka Stamps.
-         * @return A new Stamp composed from arguments and `this`.
-         */
-        compose(...stamps:Stamp[]): Stamp;
-    }
-
-    /**
-     * An object map containing the fixed prototypes.
-     */
-    interface Fixed {
-        methods: {};
-        state: {};
-        enclose: {(...encloseArgs:any[]): void}[];
-    }
-}
-
-declare module "stampit" {
-    export = stampit;
-}
\ No newline at end of file
diff --git a/stampit/stampit-tests-1.2.0.ts b/stampit/stampit-tests-1.2.0.ts
deleted file mode 100644
index ce404651a1..0000000000
--- a/stampit/stampit-tests-1.2.0.ts
+++ /dev/null
@@ -1,168 +0,0 @@
-/// <reference path="stampit-1.2.0.d.ts" />
-
-var a = stampit().enclose(() => {
-    var a = 'a';
-    this.getA = () => {
-        return a;
-    };
-});
-a(); // Object -- so far so good.
-a().getA(); // "a"
-
-
-var b = stampit().enclose(function () {
-    var a = 'b';
-    this.getB = function () {
-        return a;
-    };
-});
-
-
-var c = stampit.compose(a, b);
-var foo = c(); // we won't throw this one away...
-foo.getA(); // "a"
-foo.getB(); // "b"
-
-
-// Some more privileged methods, with some private data.
-// Use stampit.mixIn() to make this feel declarative:
-var availability = stampit().enclose(function () {
-    var isOpen = false; // private
-
-    return stampit.mixIn(this, {
-        open: function open() {
-            isOpen = true;
-            return this;
-        },
-        close: function close() {
-            isOpen = false;
-            return this;
-        },
-        isOpen: function isOpenMethod() {
-            return isOpen;
-        }
-    });
-});
-// Hre's a mixin with public methods, and some state:
-var membership = stampit({
-        members: {},
-        add: function (member: any) {
-            this.members[member.name] = member;
-            return this;
-        },
-        getMember: function (name: any) {
-            return this.members[name];
-        }
-    },
-    {
-        members: {}
-    });
-// Let's set some defaults:
-var defaults = stampit().state({
-    name: 'The Saloon',
-    specials: 'Whisky, Gin, Tequila'
-});
-
-// Classical inheritance has nothing on this. No parent/child coupling. No deep inheritance hierarchies.
-// Just good, clean code reusability.
-var bar = stampit.compose(defaults, availability, membership);
-// Note that you can override state on instantiation:
-var myBar = bar({name: 'Moe\'s'});
-// Silly, but proves that everything is as it should be.
-myBar.add({name: 'Homer' }).open().getMember('Homer');
-
-
-
-var myStamp = stampit().methods({
-    foo: function () {
-        return 'foo';
-    },
-    methodOverride: function () {
-        return false;
-    }
-}).methods({
-    bar: function () {
-        return 'bar'
-    },
-    methodOverride: function () {
-        return true;
-    }
-});
-
-myStamp.state({
-    foo: {bar: 'bar'},
-    stateOverride: false
-}).state({
-    bar: 'bar',
-    stateOverride: true
-});
-
-myStamp.enclose(function () {
-    var secret = 'foo';
-
-    this.getSecret = function () {
-        return secret;
-    };
-}).enclose(function () {
-    this.a = true;
-}).enclose({
-    bar: function bar() {
-        this.b = true;
-    }
-}, {
-    baz: function baz() {
-        this.c = true;
-    }
-});
-
-var obj = myStamp.create();
-obj.getSecret && obj.a && obj.b && obj.c; // true
-
-var newStamp = stampit(null, { defaultNum: 1 }).compose(myStamp);
-
-
-
-var obj1 = stampit().methods({
-    a: function () { return 'a'; }
-}, {
-    b: function () { return 'b'; }
-}).create();
-
-var obj2 = stampit().state({
-    a: 'a'
-}, {
-    b: 'b'
-}).create();
-
-var obj = defaults.compose(newStamp, membership, availability).create();
-
-
-
-// The old constructor / class thing...
-var Constructor = function Constructor() {
-    this.thing = 'initialized';
-};
-Constructor.prototype.foo = function foo() { return 'foo'; };
-
-// The conversion
-var oldskool = stampit.convertConstructor(Constructor);
-
-// A new stamp to compose with...
-var newskool = stampit().methods({
-    bar: function bar() { return 'bar'; }
-    // your methods here...
-}).enclose(function () {
-    this.baz = 'baz';
-});
-
-// Now you can compose those old constructors just like you could
-// with any other stamp...
-var myThing = stampit.compose(oldskool, newskool);
-
-var t = myThing();
-
-t.thing; // 'initialized',
-
-t.foo(); // 'foo',
-
-t.bar(); // 'bar'
diff --git a/stampit/stampit-tests.ts b/stampit/stampit-tests.ts
index f813482d8f..07d3fe8585 100644
--- a/stampit/stampit-tests.ts
+++ b/stampit/stampit-tests.ts
@@ -1,5 +1,6 @@
 /// <reference path="stampit.d.ts" />
-import stampit = require('./stampit.d');
+
+import stampit = require('stampit');
 
 var a = stampit().init((options) => {
     var a = options.args[0];
diff --git a/stampit/stampit.d.ts b/stampit/stampit.d.ts
index e56035c4fa..5b03237f2d 100644
--- a/stampit/stampit.d.ts
+++ b/stampit/stampit.d.ts
@@ -294,4 +294,6 @@ declare module stampit {
     export function convertConstructor(Constructor:any): Stamp;
 }
 
-export = stampit;
+declare module "stampit" {
+    export = stampit;
+}
diff --git a/string/string-tests.ts b/string/string-tests.ts
new file mode 100644
index 0000000000..22fca046d3
--- /dev/null
+++ b/string/string-tests.ts
@@ -0,0 +1,286 @@
+/// <reference path="string.d.ts" />
+
+import S = require('string');
+
+S('hello').s //"hello"
+S(['a,b']).s //"a,b"
+S({hi: 'jp'}).s //"[object Object]""
+
+S('<a>foo</a>').between('<a>', '</a>').s // => 'foo'
+S('<a>foo</a></a>').between('<a>', '</a>').s // => 'foo'
+S('<a><a>foo</a></a>').between('<a>', '</a>').s // => '<a>foo'
+S('<a>foo').between('<a>', '</a>').s // => ''
+S('Some strings } are very {weird}, dont you think?').between('{', '}').s // => 'weird'
+S('This is a test string').between('test').s // => ' string'
+S('This is a test string').between('', 'test').s // => 'This is a '
+
+S('data_rate').camelize().s; //'dataRate'
+S('background-color').camelize().s; //'backgroundColor'
+S('-moz-something').camelize().s; //'MozSomething'
+S('_car_speed_').camelize().s; //'CarSpeed'
+S('yes_we_can').camelize().s; //'yesWeCan'
+
+S('jon').capitalize().s; //'Jon'
+S('JP').capitalize().s; //'Jp'
+
+S('foobar').chompLeft('foo').s; //'bar'
+S('foobar').chompLeft('bar').s; //'foobar'
+
+S('foobar').chompRight('bar').s; //'foo'
+S('foobar').chompRight('foo').s; //'foobar'
+
+var str = S('  String   \t libraries are   \n\n\t fun\n!  ').collapseWhitespace().s; //'String libraries are fun !'
+
+S('JavaScript is one of the best languages!').contains('one'); //true
+
+S('JP likes to program. JP does not play in the NBA.').count("JP")// 2
+S('Does not exist.').count("Flying Spaghetti Monster") //0
+S('Does not exist.').count("Bigfoot") //0
+S('JavaScript is fun, therefore Node.js is fun').count("fun") //2
+S('funfunfun').count("fun") //3
+
+S('dataRate').dasherize().s; //'data-rate'
+S('CarSpeed').dasherize().s; //'-car-speed'
+S('yesWeCan').dasherize().s; //'yes-we-can'
+S('backgroundColor').dasherize().s; //'background-color'
+
+S('Ken Thompson &amp; Dennis Ritchie').decodeHTMLEntities().s; //'Ken Thompson & Dennis Ritchie'
+S('3 &lt; 4').decodeHTMLEntities().s; //'3 < 4'
+
+S("hello jon").endsWith('jon'); //true
+
+S('<div>hi</div>').escapeHTML().s; //&lt;div&gt;hi&lt;/div&gt;
+
+S('subdir').ensureLeft('/').s; //'/subdir'
+S('/subdir').ensureLeft('/').s; //'/subdir'
+
+S('dir').ensureRight('/').s; //'dir/'
+S('dir/').ensureRight('/').s; //'dir/'
+
+S('the_humanize_string_method').humanize().s  //'The humanize string method'
+S('ThehumanizeStringMethod').humanize().s //'Thehumanize string method'
+S('the humanize string method').humanize().s  //'The humanize string method'
+S('the humanize_id string method_id').humanize().s //'The humanize id string method'
+S('the  humanize string method  ').humanize().s //'The humanize string method'
+S('   capitalize dash-CamelCase_underscore trim  ').humanize().s //'Capitalize dash camel case underscore trim'
+
+S('JavaScript is one of the best languages!').include('one'); //true
+
+S("afaf").isAlpha(); //true
+S('fdafaf3').isAlpha(); //false
+S('dfdf--dfd').isAlpha(); //false
+
+S("afaf35353afaf").isAlphaNumeric(); //true
+S("FFFF99fff").isAlphaNumeric(); //true
+S("99").isAlphaNumeric(); //true
+S("afff").isAlphaNumeric(); //true
+S("Infinity").isAlphaNumeric(); //true
+S("-Infinity").isAlphaNumeric(); //false
+S("-33").isAlphaNumeric(); //false
+S("aaff..").isAlphaNumeric(); //false
+
+S(' ').isEmpty(); //true
+S('\t\t\t    ').isEmpty(); //true
+S('\n\n ').isEmpty(); //true
+S('helo').isEmpty(); //false
+S(null).isEmpty(); //true
+S(undefined).isEmpty(); //true
+
+S('a').isLower(); //true
+S('z').isLower(); //true
+S('B').isLower(); //false
+S('hijp').isLower(); //true
+S('hi jp').isLower(); //false
+S('HelLO').isLower(); //false
+
+S("3").isNumeric(); //true
+S("34.22").isNumeric(); //false
+S("-22.33").isNumeric(); //false
+S("NaN").isNumeric(); //false
+S("Infinity").isNumeric(); //false
+S("-Infinity").isNumeric(); //false
+S("JP").isNumeric(); //false
+S("-5").isNumeric(); //false
+S("000992424242").isNumeric(); //true
+
+S('a').isUpper() //false
+S('z').isUpper()  //false
+S('B').isUpper() //true
+S('HIJP').isUpper() //true
+S('HI JP').isUpper() //false
+S('HelLO').isUpper() //true
+S('crème brûlée').latinise().s // 'creme brulee'
+
+S('My name is JP').left(2).s; //'My'
+S('Hi').left(0).s; //''
+S('My name is JP').left(-2).s; //'JP', same as right(2)
+
+var stuff = "My name is JP\nJavaScript is my fav language\r\nWhat is your fav language?"
+var lines = S(stuff).lines()
+console.dir(lines) 
+/*
+[ 'My name is JP',
+  'JavaScript is my fav language',
+  'What is your fav language?' ]
+*/
+
+S('hello').pad(5).s //'hello'
+S('hello').pad(10).s //'   hello  '
+S('hey').pad(7).s //'  hey  '
+S('hey').pad(5).s //' hey '
+S('hey').pad(4).s //' hey'
+S('hey').pad(7, '-').s//'--hey--'
+
+S('hello').padLeft(5).s //'hello'
+S('hello').padLeft(10).s //'     hello'
+S('hello').padLeft(7).s //'  hello'
+S('hello').padLeft(6).s //' hello'
+S('hello').padLeft(10, '.').s //'.....hello'
+
+S('hello').padRight(5).s //'hello'
+S('hello').padRight(10).s //'hello     '
+S('hello').padRight(7).s //'hello  '
+S('hello').padRight(6).s //'hello '
+S('hello').padRight(10, '.').s //'hello.....'
+
+S("'a','b','c'").parseCSV(',', "'") //['a', 'b', 'c'])
+S('"a","b","c"').parseCSV() // ['a', 'b', 'c'])
+S('a,b,c').parseCSV(',', null)  //['a', 'b', 'c'])
+S("'a,','b','c'").parseCSV(',', "'") //['a,', 'b', 'c'])
+S('"a","b",4,"c"').parseCSV(',', null) //['"a"', '"b"', '4', '"c"'])
+S('"a","b","4","c"').parseCSV() //['a', 'b', '4', 'c'])
+S('"a","b",       "4","c"').parseCSV() //['a', 'b', '4', 'c'])
+S('"a","b",       4,"c"').parseCSV(",", null) //[ '"a"', '"b"', '       4', '"c"' ])
+S('"a","b\\"","d","c"').parseCSV() //['a', 'b"', 'd', 'c'])
+S('"a","b\\"","d","c"').parseCSV() //['a', 'b"', 'd', 'c'])
+S('"a\na","b","c"\n"a", """b\nb", "a"').parseCSV(',', '"', '"', '\n'); // [ [ 'a\na', 'b', 'c' ], [ 'a', '"b\nb', 'a' ] ]
+
+S(' ').repeat(5).s; //'     '
+S('*').repeat(3).s; //'***'
+
+S(' does IT work? ').replaceAll(' ', '_').s; //'_does_IT_work?_'
+S('Yes it does!').replaceAll(' ', '').s; //'Yesitdoes!'
+
+S(' 1 2 3--__--4 5 6-7__8__9--0').strip(' ', '_', '-').s; //'1234567890'
+S('can words also be stripped out?').strip('words', 'also', 'be').s; //'can    stripped out?'
+
+S('I AM CRAZY').right(2).s; //'ZY'
+S('Does it work?  ').right(4).s; //'k?  '
+S('Hi').right(0).s; //''
+S('My name is JP').right(-2).s; //'My', same as left(2)
+
+S('my name is JP.').capitalize().s; //My name is JP.
+var a = "Hello " + S('joe!'); //a = "Hello joe!"
+S("Hello").toString() === S("Hello").s; //true
+
+var myString = S('War');
+myString.setValue('Peace').s; // 'Peace'
+
+S('Global Thermonuclear Warfare').slugify().s // 'global-thermonuclear-warfare'
+S('Crème brûlée').slugify().s // 'creme-brulee'
+
+S("JP is a software engineer").startsWith("JP"); //true
+S('wants to change the world').startsWith("politicians"); //false
+
+S('My, st[ring] *full* of %punct)').stripPunctuation().s; //My string full of punct
+
+S('<p>just <b>some</b> text</p>').stripTags().s //'just some text'
+S('<p>just <b>some</b> text</p>').stripTags('p').s //'just <b>some</b> text'
+
+var str = "Hello {{name}}! How are you doing during the year of {{date-year}}?"
+var values = {name: 'JP', 'date-year': 2013}
+console.log(S(str).template(values).s) //'Hello JP! How are you doing during the year of 2013?'
+
+str = "Hello #{name}! How are you doing during the year of #{date-year}?"
+console.log(S(str).template(values, '#{', '}').s) //'Hello JP! How are you doing during the year of 2013?'
+
+S.TMPL_OPEN = '{'
+S.TMPL_CLOSE = '}'
+str = "Hello {name}! How are you doing during the year of {date-year}?"
+console.log(S(str).template(values).s) //'Hello JP! How are you doing during the year of 2013?'
+
+S(' ').times(5).s //'     '
+S('*').times(3).s //'***'
+
+S('true').toBoolean() //true
+S('false').toBoolean() //false
+S('hello').toBoolean() //false
+S(true).toBoolean() //true
+S('on').toBoolean() //true
+S('yes').toBoolean() //true
+S('TRUE').toBoolean() //true
+S('TrUe').toBoolean() //true
+S('YES').toBoolean() //true
+S('ON').toBoolean() //true
+S('').toBoolean() //false
+S(undefined).toBoolean() //false
+S('undefined').toBoolean() //false
+S(null).toBoolean() //false
+S(false).toBoolean() //false
+S({}).toBoolean() //false
+S(1).toBoolean() //true
+S(-1).toBoolean() //false
+S(0).toBoolean() //false
+
+S(['a', 'b', 'c']).toCSV().s //'"a","b","c"'
+S(['a', 'b', 'c']).toCSV(':').s //'"a":"b":"c"'
+S(['a', 'b', 'c']).toCSV(':', null).s //'a:b:c')
+S(['a', 'b', 'c']).toCSV('*', "'").s //"'a'*'b'*'c'"
+S(['a"', 'b', 4, 'c']).toCSV({delimiter: ',', qualifier: '"', escape: '\\',  encloseNumbers: false}).s //'"a\\"","b",4,"c"'
+S({firstName: 'JP', lastName: 'Richardson'}).toCSV({keys: true}).s //'"firstName","lastName"'
+S({firstName: 'JP', lastName: 'Richardson'}).toCSV().s //'"JP","Richardson"'
+
+S('5').toFloat() // 5
+S('5.3').toFloat()  //5.3
+S(5.3).toFloat()  //5.3
+S('-10').toFloat()  //-10
+S('55.3 adfafaf').toFloat() // 55.3
+S('afff 44').toFloat()  //NaN
+S(3.45522222333232).toFloat(2) // 3.46
+
+S('5').toInt(); //5
+S('5.3').toInt(); //5;
+S(5.3).toInt(); //5;
+S('-10').toInt(); //-10
+S('55 adfafaf').toInt(); //55
+S('afff 44').toInt(); //NaN
+S('0xff').toInt() //255
+
+S('my name is JP.').capitalize().toString(); //My name is JP.
+var a = "Hello " + S('joe!'); //a = "Hello joe!"
+S("Hello").toString() === S("Hello").s; //true
+
+S('hello ').trim().s; //'hello'
+S(' hello ').trim().s; //'hello'
+S('\nhello').trim().s; //'hello'
+S('\nhello\r\n').trim().s; //'hello'
+S('\thello\t').trim().s; //'hello'
+
+S('  How are you?').trimLeft().s; //'How are you?';
+
+S('How are you?   ').trimRight().s; //'How are you?';
+
+S('this is some long text').truncate(3).s //'...'
+S('this is some long text').truncate(7).s //'this is...'
+S('this is some long text').truncate(11).s //'this is...'
+S('this is some long text').truncate(12).s //'this is some...'
+S('this is some long text').truncate(11).s //'this is...'
+S('this is some long text').truncate(14, ' read more').s //'this is some read more'
+
+S('dataRate').underscore().s; //'data_rate'
+S('CarSpeed').underscore().s; //'_car_speed'
+S('yesWeCan').underscore().s; //'yes_we_can'
+
+S('&lt;div&gt;hi&lt;/div&gt;').unescapeHTML().s; //<div>hi</div>
+
+S('Venkat').wrapHTML().s //<span>Venkat</span>
+S('Venkat').wrapHTML('div').s //<div>Venkat</div>
+S('Venkat').wrapHTML('div', {
+    "class": "left bullet"
+}).s //<div class="left bullet">Venkat</div>
+S('Venkat').wrapHTML('div', {
+    "id": "content",
+    "class": "left bullet"
+}).s // <div id="content" class="left bullet">Venkat</div>
+
+S.VERSION; //1.0.0
\ No newline at end of file
diff --git a/string/string.d.ts b/string/string.d.ts
new file mode 100644
index 0000000000..d99a78111c
--- /dev/null
+++ b/string/string.d.ts
@@ -0,0 +1,134 @@
+// Type definitions for string.js
+// Project: http://stringjs.com
+// Definitions by: Bas Pennings <https://github.com/basp/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface StringJS {
+	length: number;
+	
+	s: string;
+	
+	between(left: string, right?: string): StringJS;
+	
+	camelize(): StringJS;
+	
+	capitalize(): StringJS;
+	
+	chompLeft(prefix: string): StringJS;
+	
+	chompRight(suffix: string): StringJS;
+	
+	collapseWhitespace(): StringJS;
+	
+	contains(ss: string): boolean;
+	
+	count(substring: string): number;
+	
+	dasherize(): StringJS;
+	
+	decodeHTMLEntities(): StringJS;
+	
+	endsWith(ss: string): boolean;
+	
+	escapeHTML(): StringJS;
+	
+	ensureLeft(prefix: string): StringJS;
+	
+	ensureRight(suffix: string): StringJS;
+	
+	humanize(): StringJS;
+	
+	include(ss: string): boolean;
+	
+	isAlpha(): boolean;
+	
+	isAlphaNumeric(): boolean;
+	
+	isEmpty(): boolean;
+	
+	isLower(): boolean;
+	
+	isNumeric(): boolean;
+	
+	isUpper(): boolean;
+	
+	latinise(): StringJS;
+	
+	left(n: number): StringJS;
+	
+	lines(): string[];
+	
+	pad(len: number, char?: string|number): StringJS;
+	
+	padLeft(len: number, char?: string|number): StringJS;
+	
+	padRight(len: number, char?: string|number): StringJS;
+	
+	parseCSV(delimiter?: string, qualifier?: string, escape?: string, lineDelimiter?: string): string[];
+	
+	repeat(n: number): StringJS;
+	
+	replaceAll(ss: string, newStr: string): StringJS;
+	
+	strip(...strings: string[]): StringJS;
+	
+	right(n: number): StringJS;
+	
+	setValue(string: any): StringJS;
+	
+	slugify(): StringJS;
+	
+	startsWith(prefix: string): boolean;
+	
+	stripPunctuation(): StringJS;
+	
+	stripTags(...tags: string[]): StringJS;
+	
+	template(values: Object, open?: string, close?: string): StringJS;
+	
+	times(n: number): StringJS;
+	
+	toBoolean(): boolean;
+	
+	toCSV(delimiter?: string, qualifier?: string): StringJS;
+	toCSV(options: {
+		delimiter?: string,
+		qualifier?: string,
+		escape?: string,
+		encloseNumbers?: boolean,
+		keys?: boolean
+	}): StringJS;
+	
+	toFloat(precision?: number): number;
+	
+	toInt(): number;
+	
+	toInteger(): number;
+	
+	toString(): string;
+	
+	trim(): StringJS;
+	
+	trimLeft(): StringJS;
+	
+	trimRight(): StringJS;
+	
+	truncate(length: number, chars?: string): StringJS;
+	
+	underscore(): StringJS;
+	
+	unescapeHTML(): StringJS;
+	
+	wrapHTML(element?: string, attributes?: Object): StringJS;
+}
+
+declare module "string" {
+	var S: {
+		(o: any): StringJS;
+		VERSION: string;
+		TMPL_OPEN: string;
+		TMPL_CLOSE: string;
+	}
+	
+	export = S;
+}
\ No newline at end of file
diff --git a/svg-sprite/svg-sprite-tests.ts b/svg-sprite/svg-sprite-tests.ts
new file mode 100644
index 0000000000..74097962f0
--- /dev/null
+++ b/svg-sprite/svg-sprite-tests.ts
@@ -0,0 +1,327 @@
+/// <reference path="svg-sprite.d.ts" />
+
+import SVGSpriter = require('svg-sprite');
+import * as fs from 'fs';
+
+var config: SVGSpriter.Config;
+
+
+//
+// README.md
+//
+
+// Create spriter instance (see below for `config` examples)
+var spriter       = new SVGSpriter(config);
+
+// Add SVG source files — the manual way ...
+spriter.add('assets/svg-1.svg', null, fs.readFileSync('assets/svg-1.svg', {encoding: 'utf-8'}));
+spriter.add('assets/svg-2.svg', null, fs.readFileSync('assets/svg-2.svg', {encoding: 'utf-8'}));
+/* ... */
+
+// Compile the sprite
+spriter.compile(function(error: any, result: any) {
+    /* ... Write `result` files to disk or do whatever with them ... */
+});
+
+// General configuration options
+
+config                      = {
+    dest                    : '.',                      // Main output directory
+    log                     : null,                     // Logging verbosity (default: no logging)
+    shape                   : {                         // SVG shape related options
+        id                  : {                         // SVG shape ID related options
+            separator       : '--',                     // Separator for directory name traversal
+            generator       : function(svg: string) { /*...*/ return ''; },   // SVG shape ID generator callback
+            pseudo          : '~'                       // File name separator for shape states (e.g. ':hover')
+        },
+        dimension           : {                         // Dimension related options
+            maxWidth        : 2000,                     // Max. shape width
+            maxHeight       : 2000,                     // Max. shape height
+            precision       : 2,                        // Floating point precision
+            attributes      : false,                    // Width and height attributes on embedded shapes
+        },
+        spacing             : {                         // Spacing related options
+            padding         : 0,                        // Padding around all shapes
+            box             : 'content'                 // Padding strategy (similar to CSS `box-sizing`)
+        },
+        transform           : ['svgo'],                 // List of transformations / optimizations
+        meta                : null,                     // Path to YAML file with meta / accessibility data
+        align               : null,                     // Path to YAML file with extended alignment data
+        dest                : null                      // Output directory for optimized intermediate SVG shapes
+    },
+    svg                     : {                         // General options for created SVG files
+        xmlDeclaration      : true,                     // Add XML declaration to SVG sprite
+        doctypeDeclaration  : true,                     // Add DOCTYPE declaration to SVG sprite
+        namespaceIDs        : true,                     // Add namespace token to all IDs in SVG shapes
+        dimensionAttributes : true                      // Width and height attributes on the sprite
+    },
+    variables               : {}                        // Custom Mustache templating variables and functions
+};
+
+// Output modes
+
+config                  = {
+    mode                    : {
+    css                 : true,     // Create a «css» sprite
+    view                : true,     // Create a «view» sprite
+    defs                : true,     // Create a «defs» sprite
+    symbol              : true,     // Create a «symbol» sprite
+    stack               : true      // Create a «stack» sprite
+}
+};
+
+config                  = {
+    mode: {
+        css: {
+            // Configuration for the «css» sprite
+            // ...
+        }
+    }
+};
+
+// Common mode properties
+
+config                  = {
+    mode                    : {
+        mode1              : {
+    dest            : "<mode>",                     // Mode specific output directory
+        prefix          : "svg-%s",                     // Prefix for CSS selectors
+        dimensions      : "-dims",                      // Suffix for dimension CSS selectors
+        sprite          : "svg/sprite.<mode>.svg",       // Sprite path and name
+    bust            : true,                   // Cache busting (mode dependent default value)
+        render          : {                             // Stylesheet rendering definitions
+        /* -------------------------------------------
+         css         : false,                        // CSS stylesheet options
+         scss        : false,                        // Sass stylesheet options
+         less        : false,                        // LESS stylesheet options
+         styl        : false                         // Stylus stylesheet options
+         <custom>    : ...                           // Custom stylesheet options
+         ------------------------------------------- */
+    },
+    example         : false                         // Create an HTML example document
+}
+}
+};
+
+// Basic examples
+
+// A.) Standalone sprite
+
+config                  = {
+    mode                    : {
+    inline              : true,     // Prepare for inline embedding
+    symbol              : true      // Create a «symbol» sprite
+}
+};
+
+// B.) CSS sprite with Sass resource
+
+config                  = {
+    mode                    : {
+    css                 : {         // Create a «css» sprite
+    render          : {
+        scss        : true      // Render a Sass stylesheet
+    }
+}
+}
+};
+
+// C.) Multiple sprites
+
+config                  = {
+    mode                    : {
+    defs                : true,
+    symbol              : true,
+    stack               : true
+}
+};
+
+// D.) No sprite at all
+
+config                  = {
+    shape                   : {
+    dest                : 'path/to/out/dir'
+}
+};
+
+
+
+//
+// docs/configuration.md
+//
+
+config = {
+    shape               : {
+        id              : {                         // SVG shape ID related options
+            separator   : '--',                     // Separator for directory name traversal
+            generator   : function(svg: string) { /*...*/ return ''; },   // SVG shape ID generator callback
+            pseudo      : '~',                      // File name separator for shape states (e.g. ':hover')
+            whitespace  : '_'                       // Whitespace replacement for shape IDs
+        },
+        dimension       : {                         // Dimension related options
+            maxWidth    : 2000,                     // Max. shape width
+            maxHeight   : 2000,                     // Max. shape height
+            precision   : 2,                        // Floating point precision
+            attributes  : false,                    // Width and height attributes on embedded shapes
+        },
+        spacing         : {                         // Spacing related options
+            padding     : 0,                        // Padding around all shapes
+            box         : 'content'                 // Padding strategy (similar to CSS `box-sizing`)
+        },
+        transform       : ['svgo'],                 // List of transformations / optimizations
+        meta            : null,                     // Path to YAML file with meta / accessibility data
+        align           : null,                     // Path to YAML file with extended alignment data
+        dest            : null                      // Output directory for optimized intermediate SVG shapes
+    }
+};
+
+config = // SVGO transformation with default configuration
+{
+    shape               : {
+        transform       : ['svgo']
+        /* ... */
+    }
+};
+
+config = // Equivalent transformation to ['svgo']
+{
+    shape               : {
+        transform       : [
+            {svgo       : {}}
+        ]
+        /* ... */
+    }
+};
+
+config = // SVGO transformation with custom plugin configuration
+{
+    shape               : {
+        transform       : [
+            {svgo       : {
+                plugins : [
+                    {transformsWithOnePath: true},
+                    {moveGroupAttrsToElems: false}
+                ]
+            }}
+        ]
+        /* ... */
+    }
+};
+
+config = // SVGO transformation with custom plugin configuration
+{
+    shape               : {
+        transform       : [
+            {custom     :
+
+                /**
+                 * Custom callback transformation
+                 *
+                 * @param {SVGShape} shape              SVG shape object
+                 * @param {SVGSpriter} spriter          SVG spriter
+                 * @param {Function} callback           Callback
+                 * @return {void}
+                 */
+                    function(shape, sprite, callback) {
+                    /* ... */
+                    callback(null);
+                }
+            }
+        ]
+        /* ... */
+    }
+};
+
+config = // Custom global post-processing transformation
+{
+    svg                 : {
+        transform       : [
+            /**
+             * Custom sprite SVG transformation
+             *
+             * @param {String} svg                  Sprite SVG
+             * @return {String}                     Processed SVG
+             */
+                function(svg) {
+                /* ... */
+                return svg;
+            },
+
+            /* ... */
+        ]
+    }
+};
+
+config = {
+    variables   : {
+        now     : +new Date(),
+        png     : function() {
+            return function(sprite: any, render: any) {
+                return render(sprite).split('.svg').join('.png');
+            }
+        }
+    }
+};
+
+config = // Activate the «css» mode with default configuration
+{
+    mode            : {
+        css         : true
+    }
+};
+
+config = // Equivalent: Provide an empty configuration object
+{
+    mode            : {
+        css         : {}
+    }
+};
+
+config = // Multiple sprites of the same output mode
+{
+    mode            : {
+        sprite1     : {
+            mode    : 'css'     // Sprite with «css» mode
+        },
+        sprite2     : {
+            mode    : 'css'     // Another sprite with «css» mode
+        }
+    }
+};
+
+config = {
+    mode                : {
+        css             : {
+            example     : true
+        }
+    }
+};
+
+config = {
+    mode                : {
+        css             : {
+            example     : {}
+        }
+    }
+};
+
+config = {
+    mode                : {
+        css             : {
+            render      : {
+                css     : {
+                    template    : 'path/to/template.html',  // relative to current working directory
+                    dest        : 'path/to/demo.html'       // relative to current output directory
+                }
+            }
+        }
+    }
+};
+
+config = {
+    mode                : {
+        css             : {
+            example     : false
+        }
+    }
+};
diff --git a/svg-sprite/svg-sprite.d.ts b/svg-sprite/svg-sprite.d.ts
new file mode 100644
index 0000000000..c319fb174b
--- /dev/null
+++ b/svg-sprite/svg-sprite.d.ts
@@ -0,0 +1,362 @@
+// Type definitions for svg-sprite
+// Project: https://github.com/jkphl/svg-sprite
+// Definitions by: Qubo <https://github.com/tkqubo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+/// <reference path="../vinyl/vinyl.d.ts" />
+/// <reference path="../winston/winston.d.ts" />
+
+declare module "svg-sprite" {
+    import File = require('vinyl');
+    import winston = require('winston');
+
+    namespace sprite {
+        interface SVGSpriterConstructor extends NodeJS.EventEmitter {
+            /**
+             * The spriter's constructor (always the entry point)
+             * @param config Main configuration for the spriting process
+             */
+            new(config: Config): SVGSpriter;
+        }
+
+        interface SVGSpriter {
+            /**
+             * Registering source SVG files
+             * @param file Absolute path to the SVG file or a vinyl file object carrying all the necessary values (the following arguments are ignored then).
+             * @param name The "local" part of the file path, possibly including subdirectories which will get traversed to CSS selectors using the shape.id.separator configuration option.
+             * @param svg SVG file content.
+             */
+            add(file: string|File, name: string, svg: string): SVGSpriter;
+            /**
+             * Registering source SVG files
+             * @param file Absolute path to the SVG file or a vinyl file object carrying all the necessary values (the following arguments are ignored then).
+             */
+            add(file: File): SVGSpriter;
+            /**
+             * Triggering the sprite compilation
+             * @param config Configuration object setting the output mode parameters for a single compilation run. If omitted, the mode property of the main configuration used for the constructor will be used.
+             * @param callback Callback triggered when the compilation has finished.
+             */
+            compile(config: Config, callback: CompileCallback): SVGSpriter;
+            /**
+             * Triggering the sprite compilation
+             * @param callback Callback triggered when the compilation has finished.
+             */
+            compile(callback: CompileCallback): void;
+            /**
+             * Accessing the intermediate SVG resources
+             * @param dest Base directory for the SVG files in case the will be written to disk.
+             * @param callback Callback triggered when the shapes are available.
+             */
+            getShapes(dest: string, callback: GetShapesCallback): void;
+        }
+
+        interface Config {
+            /**
+             * Main output directory
+             * @default '.'
+             */
+            dest?: string;
+            /**
+             * Logging verbosity or custom logger
+             */
+            log?: string|winston.LoggerInstance;
+            /**
+             * SVG shape configuration
+             */
+            shape?: Shape;
+            /**
+             * Sprite SVG options
+             */
+            svg?: Svg;
+            /**
+             * Custom templating variables
+             */
+            variables?: any;
+            /**
+             * Output mode configurations
+             */
+            mode?: Mode;
+        }
+
+        /**
+         * All settings affecting the SVG shapes of the sprite
+         */
+        interface Shape {
+            /**
+             * SVG shape ID related options
+             */
+            id?: {
+                /**
+                 * Separator for directory name traversal
+                 */
+                separator?: string;
+                /**
+                 * SVG shape ID generator callback
+                 */
+                generator?: string|((svg: string) => string);
+                /**
+                 * File name separator for shape states (e.g. ':hover')
+                 */
+                pseudo?: string;
+                /**
+                 * Whitespace replacement for shape IDs
+                 */
+                whitespace?: string;
+            };
+            /**
+             * Dimension related options
+             */
+            dimension?: {
+                /**
+                 * Max. shape width
+                 */
+                maxWidth?: number;
+                /**
+                 * Max. shape height
+                 */
+                maxHeight?: number;
+                /**
+                 * Floating point precision
+                 */
+                precision?: number;
+                /**
+                 * Width and height attributes on embedded shapes
+                 */
+                attributes?: boolean;
+            };
+            /**
+             * Spacing related options
+             */
+            spacing?: {
+                /**
+                 * Padding around all shapes
+                 */
+                padding?: number|number[];
+                /**
+                 * Padding strategy (similar to CSS `box-sizing`)
+                 */
+                box?: string;
+            };
+            /**
+             * List of transformations / optimizations
+             */
+            transform?: (string|CustomConfigurationTransform|CustomCallbackTransform)[];
+            /**
+             * Path to YAML file with meta / accessibility data
+             */
+            meta?: string;
+            /**
+             * Path to YAML file with extended alignment data
+             */
+            align?: string;
+            /**
+             * Output directory for optimized intermediate SVG shapes
+             */
+            dest?: string;
+        }
+
+        /**
+         * Pre-defined shape transformation with custom configuration
+         */
+        interface CustomConfigurationTransform {
+            [transformationName: string]: {
+                plugins?: { [transformationName: string]: boolean }[];
+            }
+        }
+
+        /**
+         * Custom callback transformation
+         */
+        interface CustomCallbackTransform {
+            [transformationName: string]: {
+                /**
+                 * Custom callback transformation
+                 * @param shape SVG shape object
+                 * @param sprite SVG spriter
+                 * @param callback Callback
+                 */
+                (shape: any, sprite: SVGSpriter, callback: Function): any;
+            }
+        }
+
+        interface Svg {
+            /**
+             * Output an XML declaration at the very beginning of each compiled sprite.
+             * If you provide a non-empty string here, it will be used one-to-one as declaration (e.g. <?xml version="1.0" encoding="utf-8"?>).
+             * If you set this to TRUE, *svg-sprite* will look at the registered shapes for an XML declaration and use the first one it can find.
+             * @default true
+             */
+            xmlDeclaration?: boolean|string;
+            /**
+             * Include a <DOCTYPE> declaration in each compiled sprite. If you provide a non-empty string here,
+             * it will be used one-to-one as declaration (e.g. <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1 Basic//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11-basic.dtd">).
+             * If you set this to TRUE, *svg-sprite* will look at the registered shapes for a DOCTYPE declaration and use the first one it can find.
+             * @default true
+             */
+            doctypeDeclaration?: boolean|string;
+            /**
+             * In order to avoid ID clashes, the default behavior is to namespace all IDs in the source SVGs before compiling them into a sprite.
+             * Each ID is prepended with a unique string. In some situations, it might be desirable to disable ID namespacing, e.g. when you want to script the resulting sprite.
+             * Just set svg.namespaceIDs to FALSE then and be aware that you might also want to disable SVGO's ID minification (shape.transform.svgo.plugins: [{cleanupIDs: false}]).
+             * @default true
+             */
+            namespaceIDs?: boolean;
+            /**
+             * In order to avoid CSS class name ambiguities, the default behavior is to namespace CSS class names in the source SVGs before compiling them into a sprite.
+             * Each class name is prepended with a unique string. Disable this option to keep the class names untouched.
+             * @default true
+             */
+            namespaceClassnames?: boolean;
+            /**
+             * If truthy, width and height attributes will be set on the sprite's <svg> element (where applicable).
+             * @default true
+             */
+            dimensionAttributes?: boolean;
+            /**
+             * Shorthand for applying custom attributes to the outermost <svg> element.
+             * Please be aware that certain attributes (e.g. viewBox) will be calculated dynamically and override custom rootAttributes in any case.
+             */
+            rootAttributes?: any;
+            /**
+             * Floating point precision for CSS positioning values (defaults to -1 meaning highest possible precision).
+             */
+            precision?: number;
+            /**
+             * Callback (or list of callbacks) that will be applied to the resulting SVG sprites as global [post-processing transformation](#svg-sprite-customization).
+             * transform: Function∣Array
+             */
+            transform?: SvgTransformer|SvgTransformer[];
+        }
+
+        interface SvgTransformer {
+            /**
+             * Custom sprite SVG transformation
+             * @param svg Sprite SVG
+             * @return Processed SVG
+             */
+            (svg: string): string;
+        }
+
+        interface Mode {
+            css?: CssAndViewSpecificModeConfig|boolean;
+            view?: CssAndViewSpecificModeConfig|boolean;
+            defs?: DefsAndSymbolSpecificModeConfig|boolean;
+            symbol?: DefsAndSymbolSpecificModeConfig|boolean;
+            stack?: ModeConfig|boolean;
+            [customConfigName: string]: ModeConfig;
+        }
+
+        interface ModeConfig {
+            /**
+             * Base directory for sprite and CSS file output. If not absolute, the path will be resolved using the main output directory (see global dest option).
+             * @default "<mode>"
+             */
+            dest?: string;
+            /**
+             * Used for prefixing the [shape ID](#shape-ids) during CSS selector construction. If the value is empty,
+             * no prefix will be used. The prefix may contain the placeholder "%s" (e.g. ".svg %s-svg"),
+             * which will then get replaced by the shape ID. Please be aware that "%" is a special character
+             * in this context and that you'll have to escape it by another percent sign ("%%") in case you want
+             * to output it to your stylesheets (e.g. for a [Sass placeholder selector](http://sass-lang.com/documentation/file.SASS_REFERENCE.html#placeholder_selectors_)).
+             * @default ".svg-%s"
+             */
+            prefix?: string;
+            /**
+             * A non-empty string value will trigger the creation of additional CSS rules specifying the dimensions of each shape in the sprite.
+             * The string will be used as suffix to mode.<mode>.prefix during CSS selector construction and may contain the placeholder "%s",
+             * which will get replaced by the value of mode.<mode>.prefix.
+             * A boolean TRUE will cause the dimensions to be included directly into each shape's CSS rule (only available for «css» and «view» sprites).
+             * @default "-dims"
+             */
+            dimensions?: string|boolean;
+            /**
+             * SVG sprite path and file name, relative to the mode.<mode>.dest directory.
+             * You may omit the file extension, in which case it will be set to ".svg" automatically.
+             * @default "svg/sprite.<mode>.svg"
+             */
+            sprite?: string;
+            /**
+             * Add a content based hash to the name of the sprite file so that clients reliably reload the sprite
+             * when it's content changes («cache busting»). Defaults to false except for «css» and «view» sprites.
+             * @default true∣false
+             */
+            bust?: boolean;
+            /**
+             * Collection of [stylesheet rendering configurations](#rendering-configurations).
+             * The keys are used as file extensions as well as file return keys. At present,
+             * there are default templates for the file extensions css ([CSS](http://www.w3.org/Style/CSS/)),
+             * scss ([Sass](http://sass-lang.com/)), less ([Less](http://lesscss.org/)) and styl ([Stylus](http://learnboost.github.io/stylus/)),
+             * which all reside in the directory tmpl/css. Example: {css: true, scss: {dest: '_sprite.scss'}}
+             * @default {}
+             */
+            render?: { [key: string]: RenderingConfiguration };
+            /**
+             * Enabling this will trigger the creation of an HTML document demoing the usage of the sprite. Please see below for details on [rendering configurations](#rendering-configurations).
+             * @default false
+             */
+            example?: RenderingConfiguration;
+            /**
+             * Specify svg-sprite which output mode to use with this configuration
+             */
+            mode?: string;
+        }
+
+        interface RenderingConfiguration {
+            /**
+             * HTML document Mustache template
+             * @default "tmpl/<mode>/sprite.html"
+             */
+            template?: string;
+            /**
+             * HTML document destination
+             * @default "sprite.<mode>.html"
+             */
+            dest?: string;
+        }
+
+        interface CssAndViewSpecificModeConfig extends ModeConfig {
+            /**
+             * The arrangement of the shapes within the sprite. Might be "vertical", "horizontal", "diagonal" or "packed"
+             * (with the latter being the most compact type). It depends on your project which layout is best for you.
+             * @default "packed"
+             */
+            layout?: string;
+            /**
+             * If given and not empty, this will be the selector name of a CSS rule commonly specifying the background-image
+             * and background-repeat properties for all the shapes in the sprite (thus saving some bytes by not unnecessarily repeating them for each shape)
+             */
+            common?: string;
+            /**
+             * If given and not empty, a mixin with this name will be added to supporting output formats (e.g. Sass, LESS, Stylus),
+             * specifying the background-image and background-repeat properties for all the shapes in the sprite.
+             * You may use it for creating custom CSS within @media rules. The mixin acts much like the common rule.
+             * In fact, you can even combine the two - if both are enabled, the common rule will use the mixin internally.
+             */
+            mixin?: string;
+        }
+
+        interface DefsAndSymbolSpecificModeConfig extends ModeConfig {
+            /**
+             * If you want to embed the sprite into your HTML source, you will want to set this to true
+             * in order to prevent the creation of SVG namespace declarations and to set some other attributes for effectively hiding the library sprite.
+             * @default false
+             */
+            inline?: boolean;
+        }
+
+        interface CompileCallback {
+            (error: Error, result: any, data: any): any;
+        }
+
+        interface GetShapesCallback {
+            (error: Error, result: File[]): any;
+        }
+    }
+
+    var sprite: sprite.SVGSpriterConstructor;
+
+    export = sprite;
+}
+
diff --git a/through/through-tests.ts b/through/through-tests.ts
index 93fc6d2fa8..35822c9e89 100644
--- a/through/through-tests.ts
+++ b/through/through-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./through.d.ts" />
+
 import through = require('through');
 
 var i = 0;
@@ -6,4 +8,4 @@ through(
 		this.queue((i++).toString());
 	}, function () {
 		this.queue(null);
-	}, { autoDestroy: true }).pipe(process.stdout);
\ No newline at end of file
+	}, { autoDestroy: true }).pipe(process.stdout);
diff --git a/tooltipster/tooltipster-tests.ts b/tooltipster/tooltipster-tests.ts
new file mode 100644
index 0000000000..0af2cf4f32
--- /dev/null
+++ b/tooltipster/tooltipster-tests.ts
@@ -0,0 +1,15 @@
+/// <reference path="tooltipster.d.ts" />
+
+$(function() {
+	var tooltips = <JQueryTooltipster.ITooltipsterInstance[]>$("#tooltip").tooltipster({
+		content: "hi friend!",
+		delay: 300,
+		functionAfter: (origin) => {
+			console.log("tooltip closed!");
+		},
+		multiple: true
+	});
+	tooltips[0].show();
+	tooltips[0].hide();
+	tooltips[0].destroy();
+});
\ No newline at end of file
diff --git a/tooltipster/tooltipster.d.ts b/tooltipster/tooltipster.d.ts
new file mode 100644
index 0000000000..7afa46ddbf
--- /dev/null
+++ b/tooltipster/tooltipster.d.ts
@@ -0,0 +1,278 @@
+// Type definitions for tooltipster
+// Project: https://github.com/iamceege/tooltipster
+// Definitions by: Stephen Lautier <https://github.com/stephenlautier>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../jquery/jquery.d.ts" />
+
+
+declare module JQueryTooltipster {
+	/**
+	* Tooltipster options @see http://iamceege.github.io/tooltipster/
+	*/
+	export interface ITooltipsterOptions {
+
+		/**
+		 * Determines how the tooltip will animate in and out. Feel free to modify or create custom transitions in the tooltipster.css file. 
+		 * In IE9 and 8, all animations default to a JavaScript generated, fade animation. Default: 'fade'
+		 */
+		animation?: string;
+
+		/**
+		 * Adds the "speech bubble arrow" to the tooltip. Default: true
+		 */
+		arrow?: boolean;
+
+		/**
+		 * Select a specific color for the "speech bubble arrow". Default: will inherit the tooltip's background color
+		 */
+		arrowColor?: string;
+
+		/**
+		 * If autoClose is set to false, the tooltip will never close unless you call the 'hide' method yourself. Default: true
+		 */
+		autoClose?: boolean;
+
+		/**
+		 * If set, this will override the content of the tooltip. Default: null
+		 */
+		content?: string;
+
+		/**
+		 * If the content of the tooltip is provided as a string, it is displayed as plain text by default. 
+		 * If this content should actually be interpreted as HTML, set this option to true. Default: false
+		 */
+		contentAsHTML?: string;
+
+		/**
+		 * If you provide a jQuery object to the 'content' option, this sets if it is a clone of this object that should actually be used. Default: true
+		 */
+		contentCloning?: boolean;
+
+		/**
+		 * Tooltipster logs notices into the console when you're doing something you ideally shouldn't be doing. Set to false to disable logging. Default: true
+		 */
+		debug?: boolean;
+
+		/**
+		 * Delay how long it takes (in milliseconds) for the tooltip to start animating in. Default: 200
+		 */
+		delay?: number;
+
+		/**
+		 * Set a minimum width for the tooltip. Default: 0 (auto width)
+		 */
+		minWidth?: number;
+
+		/**
+		 * Set a maximum width for the tooltip. Default: null (no max width)
+		 */
+		maxWidth?: number;
+
+		/**
+		 * Create a custom function to be fired only once at instantiation. If the function returns a value, this value will become the content of the tooltip.
+		 * @param origin
+		 * @param content
+		 */
+		functionInit?: (origin: JQuery, content: string) => void;
+
+		/**
+		 * Create a custom function to be fired before the tooltip opens. This function may prevent or hold off the opening.
+		 * @param origin
+		 * @param continueTooltip
+		 */
+		functionBefore?: (origin: JQuery, continueTooltip: () => void) => void;
+
+		/**
+		 * Create a custom function to be fired when the tooltip and its contents have been added to the DOM.
+		 * @param origin
+		 * @param tooltip
+		 */
+		functionReady?: (origin: JQuery, tooltip: JQuery) => void;
+
+		/**
+		 * Create a custom function to be fired once the tooltip has been closed and removed from the DOM.
+		 * @param origin
+		 */
+		functionAfter?: (origin: JQuery) => void;
+
+		/**
+		 * If true, the tooltip will close if its origin is clicked. This option only applies when 'trigger' is 'hover' and 'autoClose' is false. Default: false
+		 */
+		hideOnClick?: boolean;
+
+		/**
+		 * If using the iconDesktop or iconTouch options, this sets the content for your icon. Default: '(?)'
+		 */
+		icon?: string|JQuery;
+
+		/**
+		 * If you provide a jQuery object to the 'icon' option, this sets if it is a clone of this object that should actually be used. Default: true
+		 */
+		iconCloning?: boolean;
+
+		/**
+		 * Generate an icon next to your content that is responsible for activating the tooltip on non-touch devices. Default: false
+		 */
+		iconDesktop?: boolean;
+
+		/**
+		 * If using the iconDesktop or iconTouch options, this sets the class on the icon (used to style the icon). Default: 'tooltipster-icon'
+		 */
+		iconTheme?: string;
+
+		/**
+		 * Generate an icon next to your content that is responsible for activating the tooltip on touch devices (tablets, phones, etc). Default: false
+		 */
+		iconTouch?: boolean;
+
+		/**
+		 * Give users the possibility to interact with the tooltip. Unless autoClose is set to false, the tooltip will still close if the user moves away from or clicks out of the tooltip. 
+		 * Default: false
+		 */
+		interactive?: boolean;
+
+		/**
+		 * If the tooltip is interactive and activated by a hover event, set the amount of time (milliseconds) allowed for a user to hover off 
+		 * of the tooltip activator (origin) on to the tooltip itself - keeping the tooltip from closing. Default: 350
+		 */
+		interactiveTolerance?: number;
+
+		/**
+		 * Allows you to put multiple tooltips on a single element. Read further instructions down this page. Default: false
+		 */
+		multiple?: boolean;
+
+		/**
+		 * Offsets the tooltip (in pixels) farther left/right from the origin. Default: 0
+		 */
+		offsetX?: number;
+
+		/**
+		 * Offsets the tooltip (in pixels) farther up/down from the origin. Default: 0
+		 */
+		offsetY?: number;
+
+		/**
+		 * If true, only one tooltip will be allowed to be active at a time. Non-autoclosing tooltips will not be closed though. Default: false
+		 */
+		onlyOne?: boolean;
+
+		/**
+		 * Set the position of the tooltip. Default: 'top'
+		 * Possible values: right, left, top, top-right, top-left, bottom, bottom-right, bottom-left
+		 */
+		position?: string;
+
+		/**
+		 * Will reposition the tooltip if the origin moves. As this option may have an impact on performance, we suggest you enable it only if you need to. Default: false
+		 */
+		positionTracker?: boolean;
+
+		/**
+		 * Called after the tooltip has been repositioned by the position tracker (if enabled). 
+		 * Default: A function that will close the tooltip if the trigger is 'hover' and autoClose is false.
+		 */
+		positionTrackerCallback?: Function;
+
+		/**
+		 * Specify if a TITLE attribute should be restored on the HTML element after a call to the 'destroy' method. 
+		 * This attribute may be omitted, or be restored with the value that existed before Tooltipster was initialized, or be restored with the stringified value of the current content. 
+		 * Note: in case of multiple tooltips on a single element, only the last destroyed tooltip may trigger a restoration. Default: 'current'
+		 *
+		 * Possible values: 'none', 'previous' or 'current'
+		 */
+		restoration?: string;
+
+		/**
+		 * Set the speed of the animation. Default: 350
+		 */
+		speed?: number;
+
+		/**
+		 * How long the tooltip should be allowed to live before closing. Default: 0 (disabled)
+		 */
+		timer?: number;
+
+		/**
+		 * Set the theme (CSS class) used for your tooltip. Default: 'tooltipster-default'
+		 */
+		theme?: string;
+
+		/**
+		 * 
+		 * If set to false, tooltips will not show on pure-touch devices, unless you open them yourself with the 'show' method. 
+		 * Touch gestures on devices which also have a mouse will still open the tooltips though. Default: true
+		 */
+		touchDevices?: boolean;
+
+		/**
+		 * Set how tooltips should be activated and closed.
+		 * Possible values: hover, click or custom.
+		 */
+		trigger?: string;
+
+		/**
+		 * If a tooltip is open while its content is updated, play a subtle animation when the content changes. Default: true
+		 */
+		updateAnimation?: boolean;
+	}
+
+	/**
+	* Tooltipster tooltip instance object.
+	*/
+	export interface ITooltipsterInstance {
+
+		/**
+		 * Updates the content of the tooltip.
+		 * @param value 
+		 * @returns {} 
+		 */
+		content(value: string): JQuery;
+
+		/**
+		 * Shows the tooltip.
+		 */
+		show(): void;
+
+		/**
+		 * Hides the tooltip (this will aslo causo it to be removed from the DOM, not simply hides it), however leaving the listeners.
+		 */
+		hide(): void;
+
+		/**
+		 * Disables the tooltip, causing it to not show unless its re-enabled.
+		 */
+		disable(): void;
+
+		/**
+		 * Enables the tooltip.
+		 */
+		enable(): void;
+
+		/**
+		 * Destroy the tooltip and its listeners.
+		 */
+		destroy(): void;
+		
+		/**
+		 * Reposition and resize the tooltip.
+		 */
+		reposition(): void;
+
+		/**
+		 * Returns the root element of the tooltip.
+		 */
+		elementTooltip(): JQuery;
+
+		/**
+		 * Returns the root element of the icon if there is one, otherwise 'undefined'.
+		 */
+		elementIcon(): JQuery;
+	}
+}
+
+
+interface JQuery {
+	tooltipster(options?: JQueryTooltipster.ITooltipsterOptions): JQuery|JQueryTooltipster.ITooltipsterInstance[];
+}
\ No newline at end of file
diff --git a/tspromise/tspromise-tests.ts b/tspromise/tspromise-tests.ts
index fcb52212a6..e1ce0c1d5c 100644
--- a/tspromise/tspromise-tests.ts
+++ b/tspromise/tspromise-tests.ts
@@ -4,7 +4,7 @@ import Promise = require('tspromise');
 
 var MyFuncFunc = Promise.async((a: boolean, b: number) => {
 	console.log('[a] ' + a);
-	yield(Promise.waitAsync(1000));
+	// NOTE( https://github.com/borisyankov/DefinitelyTyped/pull/5590 ) yield(Promise.waitAsync(1000));
 	console.log('[b]' + b);
 });
 
@@ -18,4 +18,4 @@ Promise.all([Promise.waitAsync(10), Promise.waitAsync(20)]).then(() => {
 	throw (new Error());
 }).catch((e) => {
 	console.log(e.message);
-});
\ No newline at end of file
+});
diff --git a/tv4/tv4-1.2.4-tests.ts b/tv4/tv4-1.2.4-tests.ts
new file mode 100644
index 0000000000..d899be50fb
--- /dev/null
+++ b/tv4/tv4-1.2.4-tests.ts
@@ -0,0 +1,43 @@
+///<reference path="tv4-1.2.4.d.ts" />
+
+var str:string;
+var strArr:string[];
+var bool:boolean;
+var num:number;
+var obj:any;
+var tv4:TV4;
+var err:TV4Error;
+var errs:TV4Error[];
+var single:TV4SingleResult;
+var multi:TV4MultiResult;
+
+single = tv4.validateResult(obj, obj);
+bool = single.valid;
+strArr = single.missing;
+err = single.error;
+
+num = err.code;
+str = err.message;
+str = err.dataPath;
+str = err.schemaPath;
+
+multi = tv4.validateMultiple(obj, obj);
+bool = multi.valid;
+strArr = multi.missing;
+errs = multi.errors;
+
+bool = tv4.addSchema(str, obj);
+obj = tv4.getSchema(str);
+obj = tv4.normSchema(str, str);
+str = tv4.resolveUrl(str, str);
+
+tv4 = tv4.freshApi();
+tv4.dropSchemas();
+tv4.reset();
+
+strArr = tv4.getMissingUris(/abc/);
+strArr = tv4.getSchemaUris(/abc/);
+obj = tv4.getSchemaMap()[str];
+num = tv4.errorCodes['bla'];
+
+num = tv4.errorCodes['MY_NAME'];
diff --git a/tv4/tv4-1.2.4.d.ts b/tv4/tv4-1.2.4.d.ts
new file mode 100644
index 0000000000..02b7ebba2f
--- /dev/null
+++ b/tv4/tv4-1.2.4.d.ts
@@ -0,0 +1,48 @@
+// Type definitions for Tiny Validator tv4 1.0.6
+// Project: https://github.com/geraintluff/tv4
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface TV4ErrorCodes {
+	[key:string]:number;
+}
+interface TV4Error {
+	code:number;
+	message:string;
+	dataPath:string;
+	schemaPath:string;
+}
+interface TV4SchemaMap {
+	[uri:string]:any;
+}
+interface TV4BaseResult {
+	missing:string[];
+	valid:boolean;
+}
+interface TV4SingleResult extends TV4BaseResult {
+	error:TV4Error;
+}
+interface TV4MultiResult extends TV4BaseResult {
+	errors:TV4Error[];
+}
+interface TV4 {
+	validateResult(data:any, schema:any):TV4SingleResult;
+	validateMultiple(data:any, schema:any):TV4MultiResult;
+
+	addSchema(uri:string, schema:any):boolean;
+	getSchema(uri:string):any;
+	normSchema(schema:any, baseUri:string):any;
+	resolveUrl(base:string, href:string):string;
+	freshApi():TV4;
+	dropSchemas():void;
+	reset():void;
+
+	getMissingUris(exp?:RegExp):string[];
+	getSchemaUris(exp?:RegExp):string[];
+	getSchemaMap():TV4SchemaMap;
+	errorCodes:TV4ErrorCodes;
+}
+declare module "tv4" {
+	var tv4: TV4
+	export = tv4;
+}
diff --git a/tv4/tv4-tests.ts b/tv4/tv4-tests.ts
index 2768d9f5fe..84a4ee328f 100644
--- a/tv4/tv4-tests.ts
+++ b/tv4/tv4-tests.ts
@@ -5,13 +5,13 @@ var strArr:string[];
 var bool:boolean;
 var num:number;
 var obj:any;
-var tv4:TV4;
-var err:TV4Error;
-var errs:TV4Error[];
-var single:TV4SingleResult;
-var multi:TV4MultiResult;
+var validator: tv4.TV4;
+var err:tv4.ValidationError;
+var errs:tv4.ValidationError[];
+var single:tv4.SingleResult;
+var multi:tv4.MultiResult;
 
-single = tv4.validateResult(obj, obj);
+single = validator.validateResult(obj, obj);
 bool = single.valid;
 strArr = single.missing;
 err = single.error;
@@ -21,23 +21,154 @@ str = err.message;
 str = err.dataPath;
 str = err.schemaPath;
 
-multi = tv4.validateMultiple(obj, obj);
+multi = validator.validateMultiple(obj, obj);
 bool = multi.valid;
 strArr = multi.missing;
 errs = multi.errors;
 
-bool = tv4.addSchema(str, obj);
-obj = tv4.getSchema(str);
-obj = tv4.normSchema(str, str);
-str = tv4.resolveUrl(str, str);
+validator.addSchema(str, obj);
+obj = validator.getSchema(str);
+str = validator.resolveUrl(str, str);
+
+validator = validator.freshApi();
+validator.dropSchemas();
+validator.reset();
+
+strArr = validator.getMissingUris(/abc/);
+strArr = validator.getSchemaUris(/abc/);
+obj = validator.getSchemaMap()[str];
+num = validator.errorCodes['bla'];
+
+num = validator.errorCodes['MY_NAME'];
+
+
+// Here are all the examples from the v1.2.3 documentation at https://www.npmjs.com/package/validator
+var data = '';
+var schema : tv4.JsonSchema = {type: "string"}
+var valid = validator.validate(data, schema);
+var url = 'http://example.com/schema';
+validator.addSchema(url, schema);
+var singleErrorResult = validator.validateResult(data, schema);
+var multiErrorResult = validator.validateMultiple(data, schema);
+// async
+validator.validate(data, schema, function (isValid, validationError) {});
+
+// checkRecursive
+var a : tv4.JsonSchema = {};
+var b = { a: a };
+a['b'] = b;
+var aSchema : tv4.JsonSchema = { properties: { b: { $ref: 'bSchema' }}};
+var bSchema : tv4.JsonSchema = { properties: { a: { $ref: 'aSchema' }}};
+validator.addSchema('aSchema', aSchema);
+validator.addSchema('bSchema', bSchema);
+validator.validate(a, aSchema, true);
+validator.validateResult(data, aSchema, true);
+validator.validateMultiple(data, aSchema, true);
+
+
+// banUnknownProperties
+var checkRecursive = true;
+validator.validate(data, schema, checkRecursive, true);
+validator.validateResult(data, schema, checkRecursive, true);
+validator.validateMultiple(data, schema, checkRecursive, true);
+
+// API
+validator.addSchema('http://example.com/schema', {});
+validator.addSchema({});
+var schema = validator.getSchema('http://example.com/schema');
+var map = validator.getSchemaMap();
+var schema = map[uri];
+var arr = validator.getSchemaUris();
+// optional filter using a RegExp
+arr = validator.getSchemaUris(/^https?:\/\/example.com/);
+var arr = validator.getMissingUris();
+// optional filter using a RegExp
+var arr = validator.getMissingUris(/^https?:\/\/example.com/);
+validator.dropSchemas();
+var other_tv4 = validator.freshApi();
+validator.reset();
+validator.setErrorReporter(function (error, data, schema) {
+    return "Error code: " + error.code;
+});
+validator.language('en-gb');
+validator.addLanguage('fr', {});
+validator.language('fr')
+validator.addFormat('decimal-digits', function (data, schema) {
+    if (typeof data === 'string' && !/^[0-9]+$/.test(data)) {
+        return null;
+    }
+    return "must be string of decimal digits";
+});
+validator.addFormat({
+    'my-format': function (data: any, schema: any): string {return null;},
+    'other-format': function (data: any, schema: any): string {return 'oops';}
+});
+function simpleFailure() {return true;}
+function detailedFailure() {return true;}
+validator.defineKeyword('my-custom-keyword', function (data, value, schema) {
+    if (simpleFailure()) {
+        return "Failure";
+    } else if (detailedFailure()) {
+        return {code: validator.errorCodes['MY_CUSTOM_CODE'], message: {param1: 'a', param2: 'b'}};
+    } else {
+        return null;
+    }
+});
+
+
+// Demos
+schema = {
+    "items": {
+        "type": "boolean"
+    }
+};
+{
+    let data1 = [true, false];
+    let data2 = [true, 123];
+    alert("data 1: " + validator.validate(data1, schema)); // true
+    alert("data 2: " + validator.validate(data2, schema)); // false
+    alert("data 2 error: " + JSON.stringify(validator.error, null, 4));
+
+    schema = {
+        "type": "array",
+        "items": {"$ref": "#"}
+    };
+}
+{
+let data1 : any = [[], [[]]];
+let data2 : any = [[], [true, []]];
+alert("data 1: " + validator.validate(data1, schema)); // true
+alert("data 2: " + validator.validate(data2, schema)); // false
+}
+
+{
+    schema = {
+        "type": "array",
+        "items": {"$ref": "http://example.com/schema" }
+    };
+    let data = [1, 2, 3];
+    alert("Valid: " + validator.validate(data, schema)); // true
+    alert("Missing schemas: " + JSON.stringify(validator.missing));
+}
+{
+    validator.addSchema("http://example.com/schema", {
+        "definitions": {
+            "arrayItem": {"type": "boolean"}
+        }
+    });
+    let schema : tv4.JsonSchema = {
+        "type": "array",
+        "items": {"$ref": "http://example.com/schema#/definitions/arrayItem" }
+    };
+    let data1 : any = [true, false, true];
+    let data2 : any = [1, 2, 3];
+    alert("data 1: " + validator.validate(data1, schema)); // true
+    alert("data 2: " + validator.validate(data2, schema)); // false
+}
+
+// undocumented functions
+var uri = '';
+obj = validator.normSchema(schema, uri);
 
-tv4 = tv4.freshApi();
-tv4.dropSchemas();
-tv4.reset();
 
-strArr = tv4.getMissingUris(/abc/);
-strArr = tv4.getSchemaUris(/abc/);
-obj = tv4.getSchemaMap()[str];
-num = tv4.errorCodes['bla'];
 
-num = tv4.errorCodes['MY_NAME'];
diff --git a/tv4/tv4.d.ts b/tv4/tv4.d.ts
index 02b7ebba2f..5e762155a5 100644
--- a/tv4/tv4.d.ts
+++ b/tv4/tv4.d.ts
@@ -1,48 +1,103 @@
-// Type definitions for Tiny Validator tv4 1.0.6
+// Type definitions for Tiny Validator tv4 1.2.5
 // Project: https://github.com/geraintluff/tv4
-// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>, Peter Snider <https://github.com/psnider>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-interface TV4ErrorCodes {
-	[key:string]:number;
-}
-interface TV4Error {
-	code:number;
-	message:string;
-	dataPath:string;
-	schemaPath:string;
-}
-interface TV4SchemaMap {
-	[uri:string]:any;
-}
-interface TV4BaseResult {
-	missing:string[];
-	valid:boolean;
-}
-interface TV4SingleResult extends TV4BaseResult {
-	error:TV4Error;
-}
-interface TV4MultiResult extends TV4BaseResult {
-	errors:TV4Error[];
-}
-interface TV4 {
-	validateResult(data:any, schema:any):TV4SingleResult;
-	validateMultiple(data:any, schema:any):TV4MultiResult;
+declare module tv4 {
+    
+    // Note that every top-level property is optional in json-schema
+    export interface JsonSchema {
+        [key: string]: any;
+        title?: string;          // used for humans only, and not used for computation
+        description?: string;    // used for humans only, and not used for computation
+        id?: string;
+        $schema?: string;
+        type?: string;
+        items?: any;
+        properties?: any;
+        patternProperties?: any; 
+        additionalProperties?: boolean;
+        required?: string[];
+        definitions?: any;
+        default?: any;
+    }
 
-	addSchema(uri:string, schema:any):boolean;
-	getSchema(uri:string):any;
-	normSchema(schema:any, baseUri:string):any;
-	resolveUrl(base:string, href:string):string;
-	freshApi():TV4;
-	dropSchemas():void;
-	reset():void;
+    export type SchemaMap = {[uri: string]: JsonSchema;};
+    // maps error codes/names to human readable error description for a single language
+    export type ErrorMap  = {[errorCode: string]: string;};
 
-	getMissingUris(exp?:RegExp):string[];
-	getSchemaUris(exp?:RegExp):string[];
-	getSchemaMap():TV4SchemaMap;
-	errorCodes:TV4ErrorCodes;
+
+    export interface ErrorCodes {
+        [key:string]:number;
+    }
+    export interface ValidationError {
+        code:number;
+        message:any;
+        dataPath?:string;
+        schemaPath?:string;
+        subErrors?: ValidationError[];
+    }
+    export interface ErrorVar extends ValidationError {
+        params: any;
+        subErrors: any;
+        stack: string;
+    }
+    export interface BaseResult {
+        missing:string[];
+        valid:boolean;
+    }
+    export interface SingleResult extends BaseResult {
+        error:ValidationError;
+    }
+    export interface MultiResult extends BaseResult {
+        errors:ValidationError[];
+    }
+    export type FormatValidationFunction = (data: any, schema: JsonSchema) => string;
+    // documentation doesnt agree with code in tv4, this type agrees with code
+    export type KeywordValidationFunction = (data: any, value: any, schema: JsonSchema, dataPointerPath: string) => string | ValidationError;
+    export type AsyncValidationCallback = (isValid: boolean, error: ValidationError) => void;
+    export interface TV4 {
+        error: ErrorVar;
+        missing: string[];
+        // primary API
+        validate(data: any, schema: JsonSchema, checkRecursive?: boolean): boolean;
+        validate(data: any, schema: JsonSchema, checkRecursive: boolean, banUnknownProperties: boolean): boolean;
+        validateResult(data: any, schema: JsonSchema, checkRecursive?: boolean): SingleResult;
+        validateResult(data: any, schema: JsonSchema, checkRecursive: boolean, banUnknownProperties: boolean): SingleResult;
+        validateMultiple(data: any, schema: JsonSchema, checkRecursive?: boolean): MultiResult;
+        validateMultiple(data: any, schema: JsonSchema, checkRecursive: boolean, banUnknownProperties: boolean): MultiResult;
+        // from including: tv4.async-jquery.js
+        validate(data: any, schema: JsonSchema, callback: AsyncValidationCallback, checkRecursive?: boolean): void;
+        validate(data: any, schema: JsonSchema, callback: AsyncValidationCallback, checkRecursive: boolean, banUnknownProperties: boolean): void;
+
+        // additional API for more complex cases
+        addSchema(schema: JsonSchema): void;
+        addSchema(uri:string, schema: JsonSchema): void;
+        getSchema(uri:string): JsonSchema;
+        getSchemaMap(): SchemaMap;
+        getSchemaUris(filter?: RegExp): string[];
+        getMissingUris(filter?: RegExp): string[];
+        dropSchemas(): void;
+        freshApi(): TV4;
+        reset(): void;
+        setErrorReporter(lang: string): void;
+        setErrorReporter(reporter: (error: ValidationError, data: any, schema: JsonSchema) => string): void;
+        language(code: string): void;
+        addLanguage(code: string, map: ErrorMap): void;
+        addFormat(format: string, validationFunction: FormatValidationFunction): void;
+        addFormat(formats: {[formatName: string]: FormatValidationFunction;}): void;
+        defineKeyword(keyword: string, validationFunction: KeywordValidationFunction): void;
+        defineError(codeName: string, codeNumber: number, defaultMessage: string): void;
+
+        // not documented
+        normSchema(schema: JsonSchema, baseUri:string):any;
+        resolveUrl(base:string, href:string):string;
+
+        errorCodes:ErrorCodes;
+    }
 }
+
 declare module "tv4" {
-	var tv4: TV4
-	export = tv4;
+    var out: tv4.TV4
+    export = out;
 }
diff --git a/typeahead/typeahead.d.ts b/typeahead/typeahead.d.ts
index 159caaacdd..7317aa4c79 100644
--- a/typeahead/typeahead.d.ts
+++ b/typeahead/typeahead.d.ts
@@ -119,8 +119,8 @@ declare module Twitter.Typeahead {
          * For a given suggestion object, determines the string representation of it.
          * This will be used when setting the value of the input control after a suggestion is selected. Can be either a key string or a function that transforms a suggestion object into a string.
          * Defaults to value.
-          */
-        displayKey?: string;
+         */
+        displayKey?: string | ((obj: any) => string);
 
         /**
          * A hash of templates to be used when rendering the dataset.
diff --git a/ui-grid/ui-grid-tests.ts b/ui-grid/ui-grid-tests.ts
index 21d42c021a..f4bcdce7e7 100644
--- a/ui-grid/ui-grid-tests.ts
+++ b/ui-grid/ui-grid-tests.ts
@@ -100,3 +100,11 @@ gridApi.core.queueGridRefresh()
 gridApi.core.queueRefresh();
 gridApi.core.registerColumnsProcessor(colProcessor, 100);
 
+var rowEntityToScrollTo = {anObject: 'inGridOptionsData'};
+var columnDefToScrollTo: uiGrid.IColumnDef;
+gridInstance.scrollTo();
+gridInstance.scrollTo(rowEntityToScrollTo);
+gridInstance.scrollTo(rowEntityToScrollTo, columnDefToScrollTo);
+
+var selectedRowEntities: Array<any> = gridApi.selection.getSelectedRows();
+var selectedGridRows: Array<uiGrid.IGridRow> = gridApi.selection.getSelectedGridRows();
diff --git a/ui-grid/ui-grid.d.ts b/ui-grid/ui-grid.d.ts
index 5f66eca1f8..f9371fc5cc 100644
--- a/ui-grid/ui-grid.d.ts
+++ b/ui-grid/ui-grid.d.ts
@@ -445,7 +445,7 @@ declare module uiGrid {
          * @param {IColumnDef} colDef to make visible
          * @returns {ng.IPromise<any>} a promise that is resolved after any scrolling is finished
          */
-        scrollTo(rowEntity: IGridRow, colDef: IColumnDef): ng.IPromise<any>;
+        scrollTo(rowEntity?: any, colDef?: IColumnDef): ng.IPromise<any>;
         /**
          * Scrolls the grid to make a certain row and column combo visible,
          * in the case that it is not completely visible on the screen already.
@@ -2823,12 +2823,12 @@ declare module uiGrid {
              * returns all selected rows as gridRows
              * @returns {Array<IGridRow>} The selected rows
              */
-            getSelectedGridRows(): Array<IGridRow>;
+            getSelectedGridRows(): Array<uiGrid.IGridRow>;
             /**
              * Gets selected rows as entities
              * @returns {Array<any>} Selected row entities
              */
-            getSelectedRows(): Array<IGridRow>;
+            getSelectedRows(): Array<any>;
             /**
              * Selects all rows.  Does nothing if multiselect = false
              * @param {ng.IAngularEvent} event object if raised from event
diff --git a/ui-router-extras/ui-router-extras-tests.ts b/ui-router-extras/ui-router-extras-tests.ts
index 22d9e4f733..a87b95863c 100644
--- a/ui-router-extras/ui-router-extras-tests.ts
+++ b/ui-router-extras/ui-router-extras-tests.ts
@@ -3,10 +3,24 @@
 var myApp = angular.module('testModule')
 
 myApp.config(($stateProvider: angular.ui.IStateProvider, $stickyStateProvider: angular.ui.IStickyStateProvider) => {
-	var state: angular.ui.IStickyState = {
+    var state: angular.ui.IStickyState = {
 		name: 'test',
-		sticky: true,
-		controller: ($previousState: angular.ui.IPreviousStateService) => {
+        sticky: true,
+        dsr: {
+            default: 'substate',
+            params: ['param1', 'param2'],
+            fn: function ($dsr$) {               
+
+                return $dsr$.to;
+            }            
+        },
+        onInactivate: function ($state: angular.ui.IState) {
+            var iAmInjectedByInjector = $state;
+        },
+        onReactivate: function ($state: angular.ui.IState) {
+            var iAmInjectedByInjector = $state;
+        },
+        controller: ($previousState: angular.ui.IPreviousStateService, $deepstateRedirect: angular.ui.IDeepStateRedirectService) => {
 			$previousState.memo('test-memo1');
 			$previousState.memo('test-memo2', 'test-state-name2');
 			$previousState.memo('test-memo3', 'test-state-name3', {});
@@ -14,8 +28,19 @@ myApp.config(($stateProvider: angular.ui.IStateProvider, $stickyStateProvider: a
 			$previousState.go('test-memo2', {
 				location: true,
 				notify: true
-			});
-		}
+            });
+            $previousState.get();
+            $previousState.get('test-memo1');
+
+            $deepstateRedirect.reset('statename1', {
+                'stateParam1': ['value1', 'value2'],
+                'stateParam2': 'value'
+            });
+        }, 
+        views: {
+            //named views are mandatory
+            'name1': {}            
+        }
 	};
 
 	$stickyStateProvider.enableDebug(true);
diff --git a/ui-router-extras/ui-router-extras.d.ts b/ui-router-extras/ui-router-extras.d.ts
index 8e0c42828e..df0d0aa3ed 100644
--- a/ui-router-extras/ui-router-extras.d.ts
+++ b/ui-router-extras/ui-router-extras.d.ts
@@ -1,6 +1,6 @@
 // Type definitions for UI-Router Extras 0.0.14+ (ct.ui.router.extras module)
 // Project: https://github.com/christopherthielen/ui-router-extras
-// Definitions by: Michael Putters <https://github.com/mputters>
+// Definitions by: Michael Putters <https://github.com/mputters/>, Marcel van de Kamp <https://github.com/marcel-k/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 /// <reference path="../angular-ui-router/angular-ui-router.d.ts" />
@@ -13,12 +13,54 @@ declare module 'angular-ui-router-extras' {
 
 declare module angular.ui {
 
-    /**
+
+    /*
+     * $deepStateRedirect
+     */
+    interface IDeepStateRedirectService {
+        /*
+         * This method resets stored $deepStateRedirect data so following transitions will behave like there have not been previous transitions.
+         * @param stateParams Can be passed in to select specific states to reset:
+         *  { 
+         *    'paramName': 'paramvalue' | ['list', 'of', 'possible', 'paramvalues']
+         *  }
+         */
+        reset(stateName: string, stateParams?: { [key: string]: string | string[] }): void;
+    }
+
+    /*
+     * Docs: http://christopherthielen.github.io/ui-router-extras/#/dsr
+     */
+    interface IDeepStateRedirectConfig {
+        /*
+         * If no deep state has been recorded, DSR will instead redirect to the default substate and params that you specify. 
+         * If default is a string it is interpreted as the substate.
+         */
+        default?: string | IRedirectParams;
+        /*
+         * Specify params: true if your DSR state takes parameters.
+         * If only a subset of the parameters should be included in the parameter grouping for recording deep states, 
+         * specify an array of parameter names.
+         */
+        params?: boolean | string[];
+        /*
+         * A callback function that determines whether or not the redirect should actually occur, or changes the redirect to some other state.
+        * Return an object: IRedirectParams to change the redirect
+         */
+        fn?($dsr$: { redirect: IRedirectParams; to: IRedirectParams }): boolean | IRedirectParams;
+    }
+
+    interface IRedirectParams {
+        state: string;
+        params?: ui.IStateParamsService;
+    }
+
+    /*
      * Previous state
      */
-    interface IPreviousState {
-        state: IState;
-        params?: {};
+    interface IPreviousState {      
+        state: IState;     
+        params?: ui.IStateParamsService;
     }
 
     /**
@@ -54,16 +96,42 @@ declare module angular.ui {
          * @param memoName Memo name
          */
         forget(memoName: string): void;
-
-    }
+    }    
 
     /**
-     * Sticky state
-     */
+    * Sticky state
+    */
     interface IStickyState extends angular.ui.IState {
+        /*
+        * When marking a state sticky, the state must target its own unique named ui-view.
+        * Docs: http://christopherthielen.github.io/ui-router-extras/#/sticky
+        */
         sticky?: boolean;
+        /*
+         * The most-recently-activate substate of the DSR marked state is remembered.
+         * When the DSR marked state is transitioned to directly, UI-Router Extras will instead redirect to the remembered state and parameters.
+         * Docs: http://christopherthielen.github.io/ui-router-extras/#/dsr
+         */
+        deepStateRedirect?: boolean | IDeepStateRedirectConfig;
+        /*
+         * Shortname deepStateRedirect prop
+         */
+        dsr?: boolean | IDeepStateRedirectConfig;
+        /*
+         * Function (injectable). Called when a sticky state is navigated away from (inactivated).
+         */
+        onInactivate?: Function;
+        /*
+         * Function (injectable). Called when an inactive sticky state is navigated to (reactivated).
+         */
+        onReactivate?: Function;
+        /*
+         * Note: named views are mandatory when using sticky states!
+         */
+        views?: {};
     }
 
+
     /**
      * Sticky state service
      */
diff --git a/underscore/underscore.d.ts b/underscore/underscore.d.ts
index 1f8faf2e24..7dea66a84a 100644
--- a/underscore/underscore.d.ts
+++ b/underscore/underscore.d.ts
@@ -1614,13 +1614,6 @@ interface UnderscoreStatic {
 	**/
 	chain<T>(obj: T[]): _Chain<T>;
 	chain<T extends {}>(obj: T): _Chain<T>;
-
-	/**
-	* Extracts the value of a wrapped object.
-	* @param obj Wrapped object to extract the value from.
-	* @return Value of `obj`.
-	**/
-	value<T, TResult>(obj: T): TResult;
 }
 
 interface Underscore<T> {
@@ -2463,7 +2456,8 @@ interface Underscore<T> {
 
 	/**
 	* Wrapped type `any`.
-	* @see _.value
+	* Extracts the value of a wrapped object.
+	* @return Value of the wrapped object.
 	**/
 	value<TResult>(): TResult;
 }
diff --git a/uniq/uniq-tests.ts b/uniq/uniq-tests.ts
index b9facc8e23..1dc3d6fd81 100644
--- a/uniq/uniq-tests.ts
+++ b/uniq/uniq-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./uniq.d.ts" />
+
 import unique = require("uniq");
 var data = [1, 2, 2, 3, 4, 5, 5, 5, 6];
 var datastr = ["1", "2", "2", "3", "4", "5", "5", "5", "6"];
diff --git a/vinyl-fs/vinyl-fs-tests.ts b/vinyl-fs/vinyl-fs-tests.ts
index a29746166e..c8ca090700 100644
--- a/vinyl-fs/vinyl-fs-tests.ts
+++ b/vinyl-fs/vinyl-fs-tests.ts
@@ -229,7 +229,7 @@ var dataWrap = function (fn: any) {
 };
 
 var realMode = function (n: any) {
-   return n & 07777;
+   return n & parseInt("07777", 8);
 };
 
 describe('dest stream', function () {
@@ -372,7 +372,7 @@ describe('dest stream', function () {
       var expectedContents = fs.readFileSync(inputPath);
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, "./out-fixtures");
-      var expectedMode = 0655;
+      var expectedMode = parseInt("0655", 8);
 
       var expectedFile = new File({
          base: inputBase,
@@ -412,7 +412,7 @@ describe('dest stream', function () {
       var expectedContents = fs.readFileSync(inputPath);
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, "./out-fixtures");
-      var expectedMode = 0655;
+      var expectedMode = parseInt("0655", 8);
 
       var contentStream = through.obj();
       var expectedFile = new File({
@@ -456,7 +456,7 @@ describe('dest stream', function () {
       var expectedPath = path.join(__dirname, "./out-fixtures/test");
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, "./out-fixtures");
-      var expectedMode = 0655;
+      var expectedMode = parseInt("0655", 8);
 
       var expectedFile = new File({
          base: inputBase,
@@ -555,7 +555,7 @@ var dataWrap = function (fn: any) {
 };
 
 var realMode = function (n: any) {
-   return n & 07777;
+   return n & parseInt("07777", 8);
 };
 
 describe('symlink stream', function () {
@@ -706,7 +706,7 @@ describe('symlink stream', function () {
       var expectedContents = fs.readFileSync(inputPath);
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, './out-fixtures');
-      var expectedMode = 0655;
+      var expectedMode = parseInt("0655", 8);
 
       var expectedFile = new File({
          base: inputBase,
@@ -746,7 +746,7 @@ describe('symlink stream', function () {
       var expectedContents = fs.readFileSync(inputPath);
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, './out-fixtures');
-      var expectedMode = 0655;
+      var expectedMode = parseInt("0655", 8);
 
       var contentStream = through.obj();
       var expectedFile = new File({
@@ -790,7 +790,7 @@ describe('symlink stream', function () {
       var expectedPath = path.join(__dirname, './out-fixtures/wow');
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, './out-fixtures');
-      var expectedMode = 0655;
+      var expectedMode = parseInt("0655", 8);
 
       var expectedFile = new File({
          base: inputBase,
@@ -830,8 +830,8 @@ describe('symlink stream', function () {
       var inputBase = path.join(__dirname, './fixtures');
       var inputPath = path.join(__dirname, './fixtures/wow/suchempty');
       var expectedBase = path.join(__dirname, './out-fixtures/wow');
-      var expectedDirMode = 0755;
-      var expectedFileMode = 0655;
+      var expectedDirMode = parseInt("0755", 8);
+      var expectedFileMode = parseInt("0655", 8);
 
       var firstFile = new File({
          base: inputBase,
@@ -867,7 +867,7 @@ describe('symlink stream', function () {
       var expectedContents = fs.readFileSync(inputPath);
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, './out-fixtures');
-      var expectedMode = 0722;
+      var expectedMode = parseInt("0722", 8);
 
       var expectedFile = new File({
          base: inputBase,
diff --git a/vinyl-fs/vinyl-fs.d.ts b/vinyl-fs/vinyl-fs.d.ts
index 98bb34339b..70fc32abaa 100644
--- a/vinyl-fs/vinyl-fs.d.ts
+++ b/vinyl-fs/vinyl-fs.d.ts
@@ -21,7 +21,7 @@ declare module "vinyl-fs" {
       cwd?: string;
 
       /**
-      * Specifies the folder relative to the cwd 
+      * Specifies the folder relative to the cwd
       * This is used to determine the file names when saving in .dest()
       * Default is where the glob begins
       */
@@ -34,16 +34,16 @@ declare module "vinyl-fs" {
       */
       buffer?: boolean;
 
-      /** 
+      /**
       * Setting this to false will ignore the contents of the file and disable writing to disk to speed up operations
-      * Defaults to true 
+      * Defaults to true
       */
       read?: boolean;
 
       /**  Only find files that have been modified since the time specified */
       since?: Date|number;
 
-      /** Setting this to true will create a duplex stream, one that passes through items and emits globbed files. 
+      /** Setting this to true will create a duplex stream, one that passes through items and emits globbed files.
       * Defaults to false */
       passthrough?: boolean;
 
@@ -63,7 +63,7 @@ declare module "vinyl-fs" {
 
    /**
    * This is just a glob-watcher
-   * 
+   *
    * @param globs Takes a glob string or an array of glob strings as the first argument
    * Globs are executed in order, so negations should follow positive globs
    * fs.src(['!b*.js', '*.js']) would not exclude any files, but this would: fs.src(['*.js', '!b*.js'])
@@ -72,7 +72,7 @@ declare module "vinyl-fs" {
 
    /**
    * This is just a glob-watcher
-   * 
+   *
    * @param globs Takes a glob string or an array of glob strings as the first argument
    * Globs are executed in order, so negations should follow positive globs
    * fs.src(['!b*.js', '*.js']) would not exclude any files, but this would: fs.src(['*.js', '!b*.js'])
@@ -89,8 +89,8 @@ declare module "vinyl-fs" {
    * @param folder destination folder
    */
    function dest(folder: string, opt?: {
-      /** Specify the working directory the folder is relative to 
-      * Default is process.cwd() 
+      /** Specify the working directory the folder is relative to
+      * Default is process.cwd()
       */
       cwd?: string;
 
@@ -125,14 +125,17 @@ declare module "vinyl-fs" {
    * cwd, base, and path will be overwritten to match the folder
    */
    function symlink(folder: string, opts?: {
-      /** 
-      * Specify the working directory the folder is relative to 
+      /**
+      * Specify the working directory the folder is relative to
       * Default is process.cwd()
       */
       cwd?: string;
 
-      /** 
-      * Specify the mode the directory should be created with 
+      /** Specify the mode the directory should be created with. Default is the process mode */
+      mode?: number|string;
+
+      /**
+      * Specify the mode the directory should be created with
       * Default is the process mode
       */
       dirMode?: number
@@ -146,14 +149,14 @@ declare module "vinyl-fs" {
    */
    function symlink(getFolderPath: (File: File) => string, opts?:
       {
-         /** 
-         * Specify the working directory the folder is relative to 
+         /**
+         * Specify the working directory the folder is relative to
          * Default is process.cwd()
          */
          cwd?: string;
 
-         /** 
-         * Specify the mode the directory should be created with 
+         /**
+         * Specify the mode the directory should be created with
          * Default is the process mode
          */
          dirMode?: number
diff --git a/webrtc/RTCPeerConnection.d.ts b/webrtc/RTCPeerConnection.d.ts
index 9e96a86c80..0e186fd278 100644
--- a/webrtc/RTCPeerConnection.d.ts
+++ b/webrtc/RTCPeerConnection.d.ts
@@ -360,5 +360,4 @@ interface Window{
   RTCIceCandidate: RTCIceCandidate;
   webkitRTCIceCandidate: webkitRTCIceCandidate;
   mozRTCIceCandidate: mozRTCIceCandidate;
-  URL: URL;
 }
diff --git a/when/when-tests.ts b/when/when-tests.ts
index 6ed82dd32d..7cd7e8e45c 100644
--- a/when/when-tests.ts
+++ b/when/when-tests.ts
@@ -101,6 +101,21 @@ when.settle<number>([when(1), when(2), when.reject(new Error("Foo"))]).then(desc
 	return descriptors.filter(d => d.state === 'rejected').reduce((r, d) => r + d.value, 0);
 });
 
+/* when.iterate(f, predicate, handler, seed) */
+
+when.iterate(function (x) {
+	return x + 1;
+}, function (x) {
+	// Stop when x >= 100000000000
+	return x >= 100000000000;
+}, function (x) {
+	console.log(x);
+}, 0).done(function (x) {
+	console.log(x === 100000000000);
+}, function (err) {
+	console.log(err);
+});
+
 /* when.promise(resolver) */
 
 promise = when.promise<number>(resolve => resolve(5));
diff --git a/when/when.d.ts b/when/when.d.ts
index 7ec7213902..432a76b366 100644
--- a/when/when.d.ts
+++ b/when/when.d.ts
@@ -127,6 +127,20 @@ declare module When {
      */
     function settle<T>(promisesOrValues: any[]): Promise<Descriptor<T>[]>;
 
+    /**
+     * Generates a potentially infinite stream of promises by repeatedly calling f until predicate becomes true.
+     * @memberOf when
+     * @param f function that, given a seed, returns the next value or a promise for it.
+     * @param predicate function that receives the current iteration value, and should return truthy when the iterating should stop
+     * @param handler function that receives each value as it is produced by f. It may return a promise to delay the next iteration.
+     * @param seed initial value provided to the handler, and first f invocation. May be a promise.
+     */
+    function iterate<U>(f: (seed: U) => U | Promise<U>,
+                        predicate: (value: U) => boolean,
+                        handler: (value: U) => Promise<any> | void,
+                        seed: U | Promise<U>): Promise<U>;
+
+
     /**
      * Creates a {promise, resolver} pair, either or both of which
      * may be given out safely to consumers.
diff --git a/winrt/winrt.d.ts b/winrt/winrt.d.ts
index 47aad9302a..63b438fb42 100644
--- a/winrt/winrt.d.ts
+++ b/winrt/winrt.d.ts
@@ -91,8 +91,8 @@ declare module Windows {
                 every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg: any): boolean;
                 some(callbackfn: (value: T, index: number, array: T[]) => boolean): boolean;
                 some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg: any): boolean;
-                forEach(callbackfn: (value: T, index: number, array: T[]) => void ): void;
-                forEach(callbackfn: (value: T, index: number, array: T[]) => void , thisArg: any): void;
+                forEach(callbackfn: (value: T, index: number, array: T[]) => void): void;
+                forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg: any): void;
                 map(callbackfn: (value: T, index: number, array: T[]) => any): any[];
                 map(callbackfn: (value: T, index: number, array: T[]) => any, thisArg: any): any[];
                 filter(callbackfn: (value: T, index: number, array: T[]) => boolean): T[];
@@ -138,8 +138,8 @@ declare module Windows {
                 every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg: any): boolean;
                 some(callbackfn: (value: T, index: number, array: T[]) => boolean): boolean;
                 some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg: any): boolean;
-                forEach(callbackfn: (value: T, index: number, array: T[]) => void ): void;
-                forEach(callbackfn: (value: T, index: number, array: T[]) => void , thisArg: any): void;
+                forEach(callbackfn: (value: T, index: number, array: T[]) => void): void;
+                forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg: any): void;
                 map(callbackfn: (value: T, index: number, array: T[]) => any): any[];
                 map(callbackfn: (value: T, index: number, array: T[]) => any, thisArg: any): any[];
                 filter(callbackfn: (value: T, index: number, array: T[]) => boolean): T[];
@@ -238,8 +238,8 @@ declare module Windows {
             every(callbackfn: (value: Windows.Foundation.IWwwFormUrlDecoderEntry, index: number, array: Windows.Foundation.IWwwFormUrlDecoderEntry[]) => boolean, thisArg: any): boolean;
             some(callbackfn: (value: Windows.Foundation.IWwwFormUrlDecoderEntry, index: number, array: Windows.Foundation.IWwwFormUrlDecoderEntry[]) => boolean): boolean;
             some(callbackfn: (value: Windows.Foundation.IWwwFormUrlDecoderEntry, index: number, array: Windows.Foundation.IWwwFormUrlDecoderEntry[]) => boolean, thisArg: any): boolean;
-            forEach(callbackfn: (value: Windows.Foundation.IWwwFormUrlDecoderEntry, index: number, array: Windows.Foundation.IWwwFormUrlDecoderEntry[]) => void ): void;
-            forEach(callbackfn: (value: Windows.Foundation.IWwwFormUrlDecoderEntry, index: number, array: Windows.Foundation.IWwwFormUrlDecoderEntry[]) => void , thisArg: any): void;
+            forEach(callbackfn: (value: Windows.Foundation.IWwwFormUrlDecoderEntry, index: number, array: Windows.Foundation.IWwwFormUrlDecoderEntry[]) => void): void;
+            forEach(callbackfn: (value: Windows.Foundation.IWwwFormUrlDecoderEntry, index: number, array: Windows.Foundation.IWwwFormUrlDecoderEntry[]) => void, thisArg: any): void;
             map(callbackfn: (value: Windows.Foundation.IWwwFormUrlDecoderEntry, index: number, array: Windows.Foundation.IWwwFormUrlDecoderEntry[]) => any): any[];
             map(callbackfn: (value: Windows.Foundation.IWwwFormUrlDecoderEntry, index: number, array: Windows.Foundation.IWwwFormUrlDecoderEntry[]) => any, thisArg: any): any[];
             filter(callbackfn: (value: Windows.Foundation.IWwwFormUrlDecoderEntry, index: number, array: Windows.Foundation.IWwwFormUrlDecoderEntry[]) => boolean): Windows.Foundation.IWwwFormUrlDecoderEntry[];
@@ -516,7 +516,7 @@ declare module Windows {
             then<U>(success?: () => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
             then<U>(success?: () => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>;
             then<U>(success?: () => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
-            done? <U>(success?: () => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
+            done?<U>(success?: () => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
 
             cancel(): void;
 
@@ -1802,31 +1802,31 @@ declare module Windows {
         }
         export interface IPackage {
             dependencies: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Package>;
-			description: string;
-			displayName: string;
+            description: string;
+            displayName: string;
             id: Windows.ApplicationModel.PackageId;
             installedLocation: Windows.Storage.StorageFolder;
-			isBundle: boolean;
-			isDevelopmentMode: boolean;
+            isBundle: boolean;
+            isDevelopmentMode: boolean;
             isFramework: boolean;
-			isResourcePackage: boolean;
-			logo: Windows.Foundation.Uri;
-			publisherDisplayName: string;
+            isResourcePackage: boolean;
+            logo: Windows.Foundation.Uri;
+            publisherDisplayName: string;
         }
         export class Package implements Windows.ApplicationModel.IPackage {
-			static current: Windows.ApplicationModel.Package;
+            static current: Windows.ApplicationModel.Package;
 
             dependencies: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Package>;
-			description: string;
-			displayName: string;
+            description: string;
+            displayName: string;
             id: Windows.ApplicationModel.PackageId;
             installedLocation: Windows.Storage.StorageFolder;
-			isBundle: boolean;
-			isDevelopmentMode: boolean;
+            isBundle: boolean;
+            isDevelopmentMode: boolean;
             isFramework: boolean;
-			isResourcePackage: boolean;
-			logo: Windows.Foundation.Uri;
-			publisherDisplayName: string;
+            isResourcePackage: boolean;
+            logo: Windows.Foundation.Uri;
+            publisherDisplayName: string;
         }
         export interface IPackageStatics {
             current: Windows.ApplicationModel.Package;
@@ -2033,8 +2033,8 @@ declare module Windows {
                     every(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceQualifier, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceQualifier[]) => boolean, thisArg: any): boolean;
                     some(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceQualifier, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceQualifier[]) => boolean): boolean;
                     some(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceQualifier, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceQualifier[]) => boolean, thisArg: any): boolean;
-                    forEach(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceQualifier, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceQualifier[]) => void ): void;
-                    forEach(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceQualifier, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceQualifier[]) => void , thisArg: any): void;
+                    forEach(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceQualifier, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceQualifier[]) => void): void;
+                    forEach(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceQualifier, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceQualifier[]) => void, thisArg: any): void;
                     map(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceQualifier, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceQualifier[]) => any): any[];
                     map(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceQualifier, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceQualifier[]) => any, thisArg: any): any[];
                     filter(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceQualifier, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceQualifier[]) => boolean): Windows.ApplicationModel.Resources.Core.ResourceQualifier[];
@@ -2072,8 +2072,8 @@ declare module Windows {
                     every(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceCandidate, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceCandidate[]) => boolean, thisArg: any): boolean;
                     some(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceCandidate, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceCandidate[]) => boolean): boolean;
                     some(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceCandidate, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceCandidate[]) => boolean, thisArg: any): boolean;
-                    forEach(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceCandidate, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceCandidate[]) => void ): void;
-                    forEach(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceCandidate, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceCandidate[]) => void , thisArg: any): void;
+                    forEach(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceCandidate, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceCandidate[]) => void): void;
+                    forEach(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceCandidate, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceCandidate[]) => void, thisArg: any): void;
                     map(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceCandidate, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceCandidate[]) => any): any[];
                     map(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceCandidate, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceCandidate[]) => any, thisArg: any): any[];
                     filter(callbackfn: (value: Windows.ApplicationModel.Resources.Core.ResourceCandidate, index: number, array: Windows.ApplicationModel.Resources.Core.ResourceCandidate[]) => boolean): Windows.ApplicationModel.Resources.Core.ResourceCandidate[];
@@ -2111,8 +2111,8 @@ declare module Windows {
                     every(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg: any): boolean;
                     some(callbackfn: (value: string, index: number, array: string[]) => boolean): boolean;
                     some(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg: any): boolean;
-                    forEach(callbackfn: (value: string, index: number, array: string[]) => void ): void;
-                    forEach(callbackfn: (value: string, index: number, array: string[]) => void , thisArg: any): void;
+                    forEach(callbackfn: (value: string, index: number, array: string[]) => void): void;
+                    forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg: any): void;
                     map(callbackfn: (value: string, index: number, array: string[]) => any): any[];
                     map(callbackfn: (value: string, index: number, array: string[]) => any, thisArg: any): any[];
                     filter(callbackfn: (value: string, index: number, array: string[]) => boolean): string[];
@@ -2364,8 +2364,8 @@ declare module Windows {
                 every(callbackfn: (value: Windows.Data.Json.IJsonValue, index: number, array: Windows.Data.Json.IJsonValue[]) => boolean, thisArg: any): boolean;
                 some(callbackfn: (value: Windows.Data.Json.IJsonValue, index: number, array: Windows.Data.Json.IJsonValue[]) => boolean): boolean;
                 some(callbackfn: (value: Windows.Data.Json.IJsonValue, index: number, array: Windows.Data.Json.IJsonValue[]) => boolean, thisArg: any): boolean;
-                forEach(callbackfn: (value: Windows.Data.Json.IJsonValue, index: number, array: Windows.Data.Json.IJsonValue[]) => void ): void;
-                forEach(callbackfn: (value: Windows.Data.Json.IJsonValue, index: number, array: Windows.Data.Json.IJsonValue[]) => void , thisArg: any): void;
+                forEach(callbackfn: (value: Windows.Data.Json.IJsonValue, index: number, array: Windows.Data.Json.IJsonValue[]) => void): void;
+                forEach(callbackfn: (value: Windows.Data.Json.IJsonValue, index: number, array: Windows.Data.Json.IJsonValue[]) => void, thisArg: any): void;
                 map(callbackfn: (value: Windows.Data.Json.IJsonValue, index: number, array: Windows.Data.Json.IJsonValue[]) => any): any[];
                 map(callbackfn: (value: Windows.Data.Json.IJsonValue, index: number, array: Windows.Data.Json.IJsonValue[]) => any, thisArg: any): any[];
                 filter(callbackfn: (value: Windows.Data.Json.IJsonValue, index: number, array: Windows.Data.Json.IJsonValue[]) => boolean): Windows.Data.Json.IJsonValue[];
@@ -2510,8 +2510,8 @@ declare module Windows {
                     every(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => boolean, thisArg: any): boolean;
                     some(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => boolean): boolean;
                     some(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => boolean, thisArg: any): boolean;
-                    forEach(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => void ): void;
-                    forEach(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => void , thisArg: any): void;
+                    forEach(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => void): void;
+                    forEach(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => void, thisArg: any): void;
                     map(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => any): any[];
                     map(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => any, thisArg: any): any[];
                     filter(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => boolean): Windows.Data.Xml.Dom.IXmlNode[];
@@ -2556,8 +2556,8 @@ declare module Windows {
                     every(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => boolean, thisArg: any): boolean;
                     some(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => boolean): boolean;
                     some(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => boolean, thisArg: any): boolean;
-                    forEach(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => void ): void;
-                    forEach(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => void , thisArg: any): void;
+                    forEach(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => void): void;
+                    forEach(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => void, thisArg: any): void;
                     map(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => any): any[];
                     map(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => any, thisArg: any): any[];
                     filter(callbackfn: (value: Windows.Data.Xml.Dom.IXmlNode, index: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => boolean): Windows.Data.Xml.Dom.IXmlNode[];
@@ -2566,7 +2566,7 @@ declare module Windows {
                     reduce(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => any, initialValue: any): any;
                     reduceRight(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => any): any;
                     reduceRight(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: Windows.Data.Xml.Dom.IXmlNode[]) => any, initialValue: any): any;
-                 }
+                }
                 export class XmlDocument implements Windows.Data.Xml.Dom.IXmlDocument, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer, Windows.Data.Xml.Dom.IXmlDocumentIO {
                     doctype: Windows.Data.Xml.Dom.XmlDocumentType;
                     documentElement: Windows.Data.Xml.Dom.XmlElement;
@@ -3248,11 +3248,11 @@ declare module Windows {
                 getResults(): void;
                 cancel(): void;
                 close(): void;
-                then<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: any) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: any) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: any) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                done<U>(success?: (value: any) => any, error?: (error: any) => any, progress?: (progress: any) => void ): void;
+                then<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: any) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: any) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: any) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                done<U>(success?: (value: any) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
                 operation: {
                     completed: Windows.Foundation.AsyncOperationCompletedHandler<any>;
                     getResults(): any;
@@ -3266,11 +3266,11 @@ declare module Windows {
                 getResults(): void;
                 cancel(): void;
                 close(): void;
-                then<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: any) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: any) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: any) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                done<U>(success?: (value: any) => any, error?: (error: any) => any, progress?: (progress: any) => void ): void;
+                then<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: any) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: any) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: any) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                done<U>(success?: (value: any) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
                 operation: {
                     completed: Windows.Foundation.AsyncOperationCompletedHandler<any>;
                     getResults(): any;
@@ -3284,11 +3284,11 @@ declare module Windows {
                 getResults(): Windows.Devices.Sms.ISmsMessage;
                 cancel(): void;
                 close(): void;
-                then<U>(success?: (value: Windows.Devices.Sms.ISmsMessage) => U, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: Windows.Devices.Sms.ISmsMessage) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: Windows.Devices.Sms.ISmsMessage) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: Windows.Devices.Sms.ISmsMessage) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                done<U>(success?: (value: Windows.Devices.Sms.ISmsMessage) => any, error?: (error: any) => any, progress?: (progress: any) => void ): void;
+                then<U>(success?: (value: Windows.Devices.Sms.ISmsMessage) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: Windows.Devices.Sms.ISmsMessage) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: Windows.Devices.Sms.ISmsMessage) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: Windows.Devices.Sms.ISmsMessage) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                done<U>(success?: (value: Windows.Devices.Sms.ISmsMessage) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
                 operation: {
                     completed: Windows.Foundation.AsyncOperationCompletedHandler<Windows.Devices.Sms.ISmsMessage>;
                     getResults(): Windows.Devices.Sms.ISmsMessage;
@@ -3303,11 +3303,11 @@ declare module Windows {
                 getResults(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage>;
                 cancel(): void;
                 close(): void;
-                then<U>(success?: (value: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage>) => U, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage>) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage>) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage>) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                done<U>(success?: (value: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage>) => any, error?: (error: any) => any, progress?: (progress: any) => void ): void;
+                then<U>(success?: (value: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage>) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage>) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage>) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage>) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                done<U>(success?: (value: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage>) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
                 operation: {
                     progress: Windows.Foundation.AsyncOperationProgressHandler<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage>, number>;
                     completed: Windows.Foundation.AsyncOperationCompletedHandler<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage>>;
@@ -3362,7 +3362,7 @@ declare module Windows {
                 then<U>(success?: () => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
                 then<U>(success?: () => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
                 then<U>(success?: () => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
-                done<U>(success?: () => any, error?: (error: any) => any, progress?: (progress: any) => void): void ;
+                done<U>(success?: () => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
                 operation: {
                     completed: Windows.Foundation.AsyncOperationCompletedHandler<any>;
                     getResults(): any;
@@ -3403,11 +3403,11 @@ declare module Windows {
                 getResults(): Windows.Devices.Sms.SmsDevice;
                 cancel(): void;
                 close(): void;
-                then<U>(success?: (value: Windows.Devices.Sms.SmsDevice) => U, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: Windows.Devices.Sms.SmsDevice) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: Windows.Devices.Sms.SmsDevice) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: Windows.Devices.Sms.SmsDevice) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                done<U>(success?: (value: Windows.Devices.Sms.SmsDevice) => any, error?: (error: any) => any, progress?: (progress: any) => void ): void;
+                then<U>(success?: (value: Windows.Devices.Sms.SmsDevice) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: Windows.Devices.Sms.SmsDevice) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: Windows.Devices.Sms.SmsDevice) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: Windows.Devices.Sms.SmsDevice) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                done<U>(success?: (value: Windows.Devices.Sms.SmsDevice) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
                 operation: {
                     completed: Windows.Foundation.AsyncOperationCompletedHandler<Windows.Devices.Sms.SmsDevice>;
                     getResults(): Windows.Devices.Sms.SmsDevice;
@@ -3527,8 +3527,8 @@ declare module Windows {
                 every(callbackfn: (value: Windows.Devices.Enumeration.DeviceInformation, index: number, array: Windows.Devices.Enumeration.DeviceInformation[]) => boolean, thisArg: any): boolean;
                 some(callbackfn: (value: Windows.Devices.Enumeration.DeviceInformation, index: number, array: Windows.Devices.Enumeration.DeviceInformation[]) => boolean): boolean;
                 some(callbackfn: (value: Windows.Devices.Enumeration.DeviceInformation, index: number, array: Windows.Devices.Enumeration.DeviceInformation[]) => boolean, thisArg: any): boolean;
-                forEach(callbackfn: (value: Windows.Devices.Enumeration.DeviceInformation, index: number, array: Windows.Devices.Enumeration.DeviceInformation[]) => void ): void;
-                forEach(callbackfn: (value: Windows.Devices.Enumeration.DeviceInformation, index: number, array: Windows.Devices.Enumeration.DeviceInformation[]) => void , thisArg: any): void;
+                forEach(callbackfn: (value: Windows.Devices.Enumeration.DeviceInformation, index: number, array: Windows.Devices.Enumeration.DeviceInformation[]) => void): void;
+                forEach(callbackfn: (value: Windows.Devices.Enumeration.DeviceInformation, index: number, array: Windows.Devices.Enumeration.DeviceInformation[]) => void, thisArg: any): void;
                 map(callbackfn: (value: Windows.Devices.Enumeration.DeviceInformation, index: number, array: Windows.Devices.Enumeration.DeviceInformation[]) => any): any[];
                 map(callbackfn: (value: Windows.Devices.Enumeration.DeviceInformation, index: number, array: Windows.Devices.Enumeration.DeviceInformation[]) => any, thisArg: any): any[];
                 filter(callbackfn: (value: Windows.Devices.Enumeration.DeviceInformation, index: number, array: Windows.Devices.Enumeration.DeviceInformation[]) => boolean): Windows.Devices.Enumeration.DeviceInformation[];
@@ -3654,8 +3654,8 @@ declare module Windows {
                     every(callbackfn: (value: Windows.Devices.Enumeration.Pnp.PnpObject, index: number, array: Windows.Devices.Enumeration.Pnp.PnpObject[]) => boolean, thisArg: any): boolean;
                     some(callbackfn: (value: Windows.Devices.Enumeration.Pnp.PnpObject, index: number, array: Windows.Devices.Enumeration.Pnp.PnpObject[]) => boolean): boolean;
                     some(callbackfn: (value: Windows.Devices.Enumeration.Pnp.PnpObject, index: number, array: Windows.Devices.Enumeration.Pnp.PnpObject[]) => boolean, thisArg: any): boolean;
-                    forEach(callbackfn: (value: Windows.Devices.Enumeration.Pnp.PnpObject, index: number, array: Windows.Devices.Enumeration.Pnp.PnpObject[]) => void ): void;
-                    forEach(callbackfn: (value: Windows.Devices.Enumeration.Pnp.PnpObject, index: number, array: Windows.Devices.Enumeration.Pnp.PnpObject[]) => void , thisArg: any): void;
+                    forEach(callbackfn: (value: Windows.Devices.Enumeration.Pnp.PnpObject, index: number, array: Windows.Devices.Enumeration.Pnp.PnpObject[]) => void): void;
+                    forEach(callbackfn: (value: Windows.Devices.Enumeration.Pnp.PnpObject, index: number, array: Windows.Devices.Enumeration.Pnp.PnpObject[]) => void, thisArg: any): void;
                     map(callbackfn: (value: Windows.Devices.Enumeration.Pnp.PnpObject, index: number, array: Windows.Devices.Enumeration.Pnp.PnpObject[]) => any): any[];
                     map(callbackfn: (value: Windows.Devices.Enumeration.Pnp.PnpObject, index: number, array: Windows.Devices.Enumeration.Pnp.PnpObject[]) => any, thisArg: any): any[];
                     filter(callbackfn: (value: Windows.Devices.Enumeration.Pnp.PnpObject, index: number, array: Windows.Devices.Enumeration.Pnp.PnpObject[]) => boolean): Windows.Devices.Enumeration.Pnp.PnpObject[];
@@ -4867,8 +4867,8 @@ declare module Windows {
                 every(callbackfn: (value: Windows.Globalization.Collation.CharacterGrouping, index: number, array: Windows.Globalization.Collation.CharacterGrouping[]) => boolean, thisArg: any): boolean;
                 some(callbackfn: (value: Windows.Globalization.Collation.CharacterGrouping, index: number, array: Windows.Globalization.Collation.CharacterGrouping[]) => boolean): boolean;
                 some(callbackfn: (value: Windows.Globalization.Collation.CharacterGrouping, index: number, array: Windows.Globalization.Collation.CharacterGrouping[]) => boolean, thisArg: any): boolean;
-                forEach(callbackfn: (value: Windows.Globalization.Collation.CharacterGrouping, index: number, array: Windows.Globalization.Collation.CharacterGrouping[]) => void ): void;
-                forEach(callbackfn: (value: Windows.Globalization.Collation.CharacterGrouping, index: number, array: Windows.Globalization.Collation.CharacterGrouping[]) => void , thisArg: any): void;
+                forEach(callbackfn: (value: Windows.Globalization.Collation.CharacterGrouping, index: number, array: Windows.Globalization.Collation.CharacterGrouping[]) => void): void;
+                forEach(callbackfn: (value: Windows.Globalization.Collation.CharacterGrouping, index: number, array: Windows.Globalization.Collation.CharacterGrouping[]) => void, thisArg: any): void;
                 map(callbackfn: (value: Windows.Globalization.Collation.CharacterGrouping, index: number, array: Windows.Globalization.Collation.CharacterGrouping[]) => any): any[];
                 map(callbackfn: (value: Windows.Globalization.Collation.CharacterGrouping, index: number, array: Windows.Globalization.Collation.CharacterGrouping[]) => any, thisArg: any): any[];
                 filter(callbackfn: (value: Windows.Globalization.Collation.CharacterGrouping, index: number, array: Windows.Globalization.Collation.CharacterGrouping[]) => boolean): Windows.Globalization.Collation.CharacterGrouping[];
@@ -8428,11 +8428,11 @@ declare module Windows {
                     getResults(): Windows.Security.Authentication.OnlineId.UserIdentity;
                     cancel(): void;
                     close(): void;
-                    then<U>(success?: (value: Windows.Security.Authentication.OnlineId.UserIdentity) => U, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                    then<U>(success?: (value: Windows.Security.Authentication.OnlineId.UserIdentity) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                    then<U>(success?: (value: Windows.Security.Authentication.OnlineId.UserIdentity) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                    then<U>(success?: (value: Windows.Security.Authentication.OnlineId.UserIdentity) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                    done<U>(success?: (value: Windows.Security.Authentication.OnlineId.UserIdentity) => any, error?: (error: any) => any, progress?: (progress: any) => void ): void;
+                    then<U>(success?: (value: Windows.Security.Authentication.OnlineId.UserIdentity) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                    then<U>(success?: (value: Windows.Security.Authentication.OnlineId.UserIdentity) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                    then<U>(success?: (value: Windows.Security.Authentication.OnlineId.UserIdentity) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                    then<U>(success?: (value: Windows.Security.Authentication.OnlineId.UserIdentity) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                    done<U>(success?: (value: Windows.Security.Authentication.OnlineId.UserIdentity) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
                     operation: {
                         completed: Windows.Foundation.AsyncOperationCompletedHandler<Windows.Security.Authentication.OnlineId.UserIdentity>;
                         getResults(): Windows.Security.Authentication.OnlineId.UserIdentity;
@@ -9287,11 +9287,11 @@ declare module Windows {
                 getResults(): number;
                 cancel(): void;
                 close(): void;
-                then<U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: number) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                done<U>(success?: (value: number) => any, error?: (error: any) => any, progress?: (progress: any) => void ): void;
+                then<U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: number) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                done<U>(success?: (value: number) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
                 operation: {
                     completed: Windows.Foundation.AsyncOperationCompletedHandler<number>;
                     getResults(): number;
@@ -9367,11 +9367,11 @@ declare module Windows {
                 getResults(): number;
                 cancel(): void;
                 close(): void;
-                then<U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: number) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                then<U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void ): Windows.Foundation.IPromise<U>;
-                done<U>(success?: (value: number) => any, error?: (error: any) => any, progress?: (progress: any) => void ): void;
+                then<U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: number) => U, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                then<U>(success?: (value: number) => Windows.Foundation.IPromise<U>, error?: (error: any) => Windows.Foundation.IPromise<U>, progress?: (progress: any) => void): Windows.Foundation.IPromise<U>;
+                done<U>(success?: (value: number) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
                 operation: {
                     completed: Windows.Foundation.AsyncOperationCompletedHandler<number>;
                     getResults(): number;
@@ -10613,8 +10613,8 @@ declare module Windows {
                 every(callbackfn: (value: Windows.Storage.Search.SortEntry, index: number, array: Windows.Storage.Search.SortEntry[]) => boolean, thisArg: any): boolean;
                 some(callbackfn: (value: Windows.Storage.Search.SortEntry, index: number, array: Windows.Storage.Search.SortEntry[]) => boolean): boolean;
                 some(callbackfn: (value: Windows.Storage.Search.SortEntry, index: number, array: Windows.Storage.Search.SortEntry[]) => boolean, thisArg: any): boolean;
-                forEach(callbackfn: (value: Windows.Storage.Search.SortEntry, index: number, array: Windows.Storage.Search.SortEntry[]) => void ): void;
-                forEach(callbackfn: (value: Windows.Storage.Search.SortEntry, index: number, array: Windows.Storage.Search.SortEntry[]) => void , thisArg: any): void;
+                forEach(callbackfn: (value: Windows.Storage.Search.SortEntry, index: number, array: Windows.Storage.Search.SortEntry[]) => void): void;
+                forEach(callbackfn: (value: Windows.Storage.Search.SortEntry, index: number, array: Windows.Storage.Search.SortEntry[]) => void, thisArg: any): void;
                 map(callbackfn: (value: Windows.Storage.Search.SortEntry, index: number, array: Windows.Storage.Search.SortEntry[]) => any): any[];
                 map(callbackfn: (value: Windows.Storage.Search.SortEntry, index: number, array: Windows.Storage.Search.SortEntry[]) => any, thisArg: any): any[];
                 filter(callbackfn: (value: Windows.Storage.Search.SortEntry, index: number, array: Windows.Storage.Search.SortEntry[]) => boolean): Windows.Storage.Search.SortEntry[];
@@ -10665,8 +10665,8 @@ declare module Windows {
                 every(callbackfn: (value: Windows.Storage.AccessCache.AccessListEntry, index: number, array: Windows.Storage.AccessCache.AccessListEntry[]) => boolean, thisArg: any): boolean;
                 some(callbackfn: (value: Windows.Storage.AccessCache.AccessListEntry, index: number, array: Windows.Storage.AccessCache.AccessListEntry[]) => boolean): boolean;
                 some(callbackfn: (value: Windows.Storage.AccessCache.AccessListEntry, index: number, array: Windows.Storage.AccessCache.AccessListEntry[]) => boolean, thisArg: any): boolean;
-                forEach(callbackfn: (value: Windows.Storage.AccessCache.AccessListEntry, index: number, array: Windows.Storage.AccessCache.AccessListEntry[]) => void ): void;
-                forEach(callbackfn: (value: Windows.Storage.AccessCache.AccessListEntry, index: number, array: Windows.Storage.AccessCache.AccessListEntry[]) => void , thisArg: any): void;
+                forEach(callbackfn: (value: Windows.Storage.AccessCache.AccessListEntry, index: number, array: Windows.Storage.AccessCache.AccessListEntry[]) => void): void;
+                forEach(callbackfn: (value: Windows.Storage.AccessCache.AccessListEntry, index: number, array: Windows.Storage.AccessCache.AccessListEntry[]) => void, thisArg: any): void;
                 map(callbackfn: (value: Windows.Storage.AccessCache.AccessListEntry, index: number, array: Windows.Storage.AccessCache.AccessListEntry[]) => any): any[];
                 map(callbackfn: (value: Windows.Storage.AccessCache.AccessListEntry, index: number, array: Windows.Storage.AccessCache.AccessListEntry[]) => any, thisArg: any): any[];
                 filter(callbackfn: (value: Windows.Storage.AccessCache.AccessListEntry, index: number, array: Windows.Storage.AccessCache.AccessListEntry[]) => boolean): Windows.Storage.AccessCache.AccessListEntry[];
@@ -10943,8 +10943,8 @@ declare module Windows {
                 every(callbackfn: (value: Windows.Storage.StorageFile, index: number, array: Windows.Storage.StorageFile[]) => boolean, thisArg: any): boolean;
                 some(callbackfn: (value: Windows.Storage.StorageFile, index: number, array: Windows.Storage.StorageFile[]) => boolean): boolean;
                 some(callbackfn: (value: Windows.Storage.StorageFile, index: number, array: Windows.Storage.StorageFile[]) => boolean, thisArg: any): boolean;
-                forEach(callbackfn: (value: Windows.Storage.StorageFile, index: number, array: Windows.Storage.StorageFile[]) => void ): void;
-                forEach(callbackfn: (value: Windows.Storage.StorageFile, index: number, array: Windows.Storage.StorageFile[]) => void , thisArg: any): void;
+                forEach(callbackfn: (value: Windows.Storage.StorageFile, index: number, array: Windows.Storage.StorageFile[]) => void): void;
+                forEach(callbackfn: (value: Windows.Storage.StorageFile, index: number, array: Windows.Storage.StorageFile[]) => void, thisArg: any): void;
                 map(callbackfn: (value: Windows.Storage.StorageFile, index: number, array: Windows.Storage.StorageFile[]) => any): any[];
                 map(callbackfn: (value: Windows.Storage.StorageFile, index: number, array: Windows.Storage.StorageFile[]) => any, thisArg: any): any[];
                 filter(callbackfn: (value: Windows.Storage.StorageFile, index: number, array: Windows.Storage.StorageFile[]) => boolean): Windows.Storage.StorageFile[];
@@ -11000,8 +11000,8 @@ declare module Windows {
                 every(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg: any): boolean;
                 some(callbackfn: (value: string, index: number, array: string[]) => boolean): boolean;
                 some(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg: any): boolean;
-                forEach(callbackfn: (value: string, index: number, array: string[]) => void ): void;
-                forEach(callbackfn: (value: string, index: number, array: string[]) => void , thisArg: any): void;
+                forEach(callbackfn: (value: string, index: number, array: string[]) => void): void;
+                forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg: any): void;
                 map(callbackfn: (value: string, index: number, array: string[]) => any): any[];
                 map(callbackfn: (value: string, index: number, array: string[]) => any, thisArg: any): any[];
                 filter(callbackfn: (value: string, index: number, array: string[]) => boolean): string[];
@@ -11605,12 +11605,12 @@ declare module Windows {
 				/**
 				 * Gets the window (app view) for the current app.
 				**/
-				static getForCurrentView(): ApplicationView;
+                static getForCurrentView(): ApplicationView;
 				
 				/**
 				 * Attempts to unsnap a previously snapped app. This call will only succeed when the app is running in the foreground.
 				**/
-				static tryUnsnap(): boolean;
+                static tryUnsnap(): boolean;
 				
 				/**
 				 * Gets the state of the current app view.
@@ -11620,55 +11620,60 @@ declare module Windows {
 				/**
 				 * Indicates whether the app terminates when the last window is closed.
 				**/
-				static terminateAppOnFinalViewClose: boolean;
+                static terminateAppOnFinalViewClose: boolean;
 
 				/**
 				 * Gets the current orientation of the window (app view) with respect to the display.
 				**/
-				orientation: ApplicationViewOrientation;
+                orientation: ApplicationViewOrientation;
 
 				/**
 				 * Gets or sets the displayed title of the window.
 				**/
-				title: string;
+                title: string;
 
 				/**
 				 * Gets or sets whether screen capture is enabled for the window (app view).
 				**/
-				isScreenCaptureEnabled: boolean;
+                isScreenCaptureEnabled: boolean;
 
 				/**
 				 * Gets whether the window (app view) is on the Windows lock screen.
 				**/
-				isOnLockScreen: boolean;
+                isOnLockScreen: boolean;
 
 				/**
 				 * Gets whether the window(app view) is full screen or not.
 				**/
-				isFullScreen: boolean;
+                isFullScreen: boolean;
 
 				/**
 				 * Gets the current ID of the window (app view) .
 				**/
-				id: number;
+                id: number;
 
 				/**
 				 * Gets whether the current window (app view) is adjacent to the right edge of the screen.
 				**/
-				adjacentToRightDisplayEdge: boolean;
+                adjacentToRightDisplayEdge: boolean;
 
 				/**
 				 * Gets whether the current window (app view) is adjacent to the left edge of the screen.
 				**/
-				adjacentToLeftDisplayEdge: number;
-			}
+                adjacentToLeftDisplayEdge: number;
+                
+                /**
+                 * Gets the title bar of the app.
+                **/
+                titleBar: ApplicationViewTitleBar;
+            }
 
 			/**
 			 * Defines the set of display orientation modes for a window (app view).
 			**/
-			export enum ApplicationViewOrientation {
-				landscape,
-				portrait
+            export enum ApplicationViewOrientation {
+                landscape,
+                portrait
             }
             export interface IInputPaneVisibilityEventArgs {
                 ensuredFocusedElementInView: boolean;
@@ -14786,10 +14791,10 @@ declare module Windows {
 }
 declare module Windows.Foundation {
     export interface IPromise<T> {
-        then<U>(success?: (value: T) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void ): IPromise<U>;
-        then<U>(success?: (value: T) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void ): IPromise<U>;
-        then<U>(success?: (value: T) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void ): IPromise<U>;
-        then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void ): IPromise<U>;
+        then<U>(success?: (value: T) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>;
+        then<U>(success?: (value: T) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
+        then<U>(success?: (value: T) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>;
+        then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
         done<U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
 
         cancel(): void;
@@ -14799,4 +14804,57 @@ declare module Windows.Foundation {
         dispatchEvent?(type: string, details: any): boolean;
         removeEventListener?(eventType: string, listener: Function, capture?: boolean): void;
     }
+}
+
+declare module Windows.UI.ViewManagement {
+    export class ApplicationViewTitleBar {
+        /**
+         * Gets or sets the color of the title bar background.
+        **/
+        backgroundColor: Color;
+        /**
+         * Gets or sets the background color of the title bar buttons.
+        **/
+        buttonBackgroundColor: Color;
+        /**
+         * Gets or sets the foreground color of the title bar buttons.
+        **/
+        buttonForegroundColor: Color;
+        /**
+         * Gets or sets the background color of a title bar button when the pointer is over it.
+        **/
+        buttonHoverBackgroundColor: Color;
+        /**
+         * Gets or sets the foreground color of a title bar button when the pointer is over it.
+        **/
+        buttonHoverForegroundColor: Color;
+        /**
+         * Gets or sets the background color of a title bar button when it's inactive.
+        **/
+        buttonInactiveBackgroundColor: Color;
+        /**
+         * Gets or sets the foreground color of a title bar button when it's inactive.
+        **/
+        buttonInactiveForegroundColor: Color;
+        /**
+         * Gets or sets the background color of a title bar button when it's pressed.
+        **/
+        buttonPressedBackgroundColor: Color;
+        /**
+         * Gets or sets the foreground color of a title bar button when it's pressed.
+        **/
+        buttonPressedForegroundColor: Color;
+        /**
+         * Gets or sets the color of the title bar foreground.
+        **/
+        foregroundColor: Color;
+        /**
+         * Gets or sets the color of the title bar background when it's inactive.
+        **/
+        inactiveBackgroundColor: Color;
+        /**
+         * Gets or sets the color of the title bar foreground when it's inactive.
+        **/
+        inactiveForegroundColor: Color;
+    }
 }
\ No newline at end of file
diff --git a/winston/winston-tests.ts b/winston/winston-tests.ts
index 3bfd0d5a56..7157fb7420 100644
--- a/winston/winston-tests.ts
+++ b/winston/winston-tests.ts
@@ -165,25 +165,46 @@ var logger: winston.LoggerInstance = new (winston.Logger)({
     new (winston.transports.Console)({
       level: str,
       silent: bool,
+      json: bool,
       colorize: bool,
       timestamp: bool,
+      showLevel: bool,
+      label: str,
+      logstash: bool,
+      debugStdout: bool,
+      depth: num,
     }),
     new (winston.transports.DailyRotateFile)({
       level: str,
       silent: bool,
+      json: bool,
       colorize: bool,
       maxsize: num,
       maxFiles: num,
+      maxRetries: num,
       prettyPrint: bool,
       timestamp: bool,
       filename: str,
       dirname: str,
-      datePattern: str
+      datePattern: str,
+      eol: str,
+      stream: writeableStream,
     }),
     new (winston.transports.File)({
       level: str,
       silent: bool,
+      json: bool,
+      colorize: bool,
+      prettyPrint: bool,
       timestamp: bool,
+      showLevel: bool,
+      logstash: bool,
+      rotationFormat: bool,
+      depth: num,
+      zippedArchive: bool,
+      eol: str,
+      tailable: bool,
+      maxRetries: num,
       filename: str,
       maxsize: num,
       maxFiles: num,
@@ -195,7 +216,7 @@ var logger: winston.LoggerInstance = new (winston.Logger)({
       port: num,
       path: str,
       auth: { username: str, password: str },
-      ssl: {},
+      ssl: bool,
     }),
     new (winston.transports.Loggly)({
       level: str,
@@ -206,6 +227,10 @@ var logger: winston.LoggerInstance = new (winston.Logger)({
     }),
     new (winston.transports.Memory)({
       level: str,
+      json: bool,
+      colorize: bool,
+      showLevel: bool,
+      depth: num,
       timestamp: bool,
       label: str,
     }),
@@ -217,7 +242,7 @@ var logger: winston.LoggerInstance = new (winston.Logger)({
       method: str,
       path: str,
       auth: { username: str, password: str },
-      ssl: {},
+      ssl: {ca: {}},
     }),
   ]
 });
diff --git a/winston/winston.d.ts b/winston/winston.d.ts
index c816a533a3..30ca71268a 100644
--- a/winston/winston.d.ts
+++ b/winston/winston.d.ts
@@ -8,7 +8,6 @@
 /// <reference path="../node/node.d.ts" />
 
 declare module "winston" {
-
   export var transports: Transports;
   export var Transport: TransportStatic;
   export var Logger: LoggerStatic;
@@ -110,10 +109,38 @@ declare module "winston" {
   }
 
   export interface TransportInstance extends TransportStatic, NodeJS.EventEmitter {
-    formatQuery(query: any): any;
+    formatQuery(query: (string|Object)): (string|Object);
     normalizeQuery(options: QueryOptions): QueryOptions;
-    formatResults(results: any, options: any): any;
-    logException(msg: string, meta: any, callback: () => void): void;
+    formatResults(results: (Object|Array<any>), options?: Object): (Object|Array<any>);
+    logException(msg: string, meta: Object, callback: () => void): void;
+  }
+
+  export interface ConsoleTransportInstance extends TransportInstance {
+    new (options?: ConsoleTransportOptions): ConsoleTransportInstance;
+  }
+
+  export interface DailyRotateFileTransportInstance extends TransportInstance {
+    new (options?: DailyRotateFileTransportOptions): DailyRotateFileTransportInstance;
+  }
+
+  export interface FileTransportInstance extends TransportInstance {
+    new (options?: FileTransportOptions): FileTransportInstance;
+  }
+
+  export interface HttpTransportInstance extends TransportInstance {
+    new (options?: HttpTransportOptions): HttpTransportInstance;
+  }
+
+  export interface MemoryTransportInstance extends TransportInstance {
+    new (options?: MemoryTransportOptions): MemoryTransportInstance;
+  }
+
+  export interface WebhookTransportInstance extends TransportInstance {
+    new (options?: WebhookTransportOptions): WebhookTransportInstance;
+  }
+
+  export interface WinstonModuleTrasportInstance extends TransportInstance {
+    new (options?: WinstonMoudleTransportOptions): WinstonModuleTrasportInstance;
   }
 
   export interface ContainerStatic {
@@ -131,13 +158,13 @@ declare module "winston" {
   }
 
   export interface Transports {
-    File: TransportInstance;
-    Console: TransportInstance;
-    Loggly: TransportInstance;
-    DailyRotateFile: TransportInstance;
-    Http: TransportInstance;
-    Memory: TransportInstance;
-    Webhook: TransportInstance;
+    File: FileTransportInstance;
+    Console: ConsoleTransportInstance;
+    Loggly: WinstonModuleTrasportInstance;
+    DailyRotateFile: DailyRotateFileTransportInstance;
+    Http: HttpTransportInstance;
+    Memory: MemoryTransportInstance;
+    Webhook: WebhookTransportInstance;
   }
 
   export interface TransportOptions {
@@ -145,11 +172,110 @@ declare module "winston" {
     silent?: boolean;
     raw?: boolean;
     name?: string;
+    formatter?: Function;
     handleExceptions?: boolean;
+    exceptionsLevel?: string;
+    humanReadableUnhandledException?: boolean;
+  }
 
-    // TODO: Need to make instances specific,
-    //       and need to get options for each instance.
-    //       Unfortunately, the documentation is unhelpful.
+  export interface ConsoleTransportOptions extends TransportOptions {
+    json?: boolean;
+    colorize?: boolean;
+    prettyPrint?: boolean;
+    timestamp?: (Function|boolean);
+    showLevel?: boolean;
+    label?: string;
+    logstash?: boolean;
+    debugStdout?: boolean;
+    depth?: number;
+  }
+
+  export interface DailyRotateFileTransportOptions extends TransportOptions {
+    json?: boolean;
+    colorize?: boolean;
+    prettyPrint?: boolean;
+    timestamp?: (Function|boolean);
+    showLevel?: boolean;
+    label?: string;
+    logstash?: boolean;
+    depth?: number;
+    maxsize?: number;
+    maxFiles?: number;
+    eol?: string;
+    maxRetries?: number;
+    datePattern?: string;
+    filename?: string;
+    dirname?: string;
+    options?: {
+      flags?: string;
+      highWaterMark?: number;
+    }
+    stream?: NodeJS.WritableStream;
+  }
+
+  export interface FileTransportOptions extends TransportOptions {
+    json?: boolean;
+    colorize?: boolean;
+    prettyPrint?: boolean;
+    timestamp?: (Function|boolean);
+    showLevel?: boolean;
+    label?: string;
+    logstash?: boolean;
+    depth?: number;
+    maxsize?: number;
+    rotationFormat?: boolean;
+    zippedArchive?: boolean;
+    maxFiles?: number;
+    eol?: string;
+    tailable?: boolean;
+    maxRetries?: number;
+    filename?: string;
+    dirname?: string;
+    options?: {
+      flags?: string;
+      highWaterMark?: number;
+    }
+    stream?: NodeJS.WritableStream;
+  }
+
+  export interface HttpTransportOptions extends TransportOptions {
+    ssl?: boolean;
+    host?: string;
+    port?: number;
+    auth?: {
+      username: string;
+      password: string;
+    };
+    path?: string;
+  }
+
+  export interface MemoryTransportOptions extends TransportOptions {
+    json?: boolean;
+    colorize?: boolean;
+    prettyPrint?: boolean;
+    timestamp?: (Function|boolean);
+    showLevel?: boolean;
+    label?: string;
+    depth?: number;
+  }
+
+  export interface WebhookTransportOptions extends TransportOptions {
+    host?: string;
+    port?: number;
+    method?: string;
+    path?: string;
+    auth?: {
+      username?: string;
+      password?: string;
+    };
+    ssl?: {
+      key?: any;
+      cert?: any;
+      ca: any;
+    };
+  }
+
+  export interface WinstonMoudleTransportOptions extends TransportOptions {
     [optionName: string]: any;
   }
 
diff --git a/ws/ws.d.ts b/ws/ws.d.ts
index 99983df851..321e0ec966 100644
--- a/ws/ws.d.ts
+++ b/ws/ws.d.ts
@@ -6,9 +6,9 @@
 /// <reference path="../node/node.d.ts" />
 
 declare module "ws" {
-    import events = require('events');
-    import http   = require('http');
-    import net    = require('net');
+    import * as events from 'events';
+    import * as http from 'http';
+    import * as net from 'net';
 
     class WebSocket extends events.EventEmitter {
         static CONNECTING: number;