diff --git a/amplifyjs/amplifyjs.d.ts.tscparams b/amplifyjs/amplifyjs.d.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/amplifyjs/amplifyjs.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/amqplib/amqplib-tests.ts b/amqplib/amqplib-tests.ts
new file mode 100644
index 000000000..7a1f51200
--- /dev/null
+++ b/amqplib/amqplib-tests.ts
@@ -0,0 +1,21 @@
+/// <reference path="amqplib.d.ts" />
+
+import amqp = require("amqplib");
+
+var msg = "Hello World";
+
+amqp.connect("amqp://localhost")
+    .then(connection => {
+        return connection.createChannel()
+            .tap(channel => channel.checkQueue("myQueue"))
+            .then(channel => channel.sendToQueue("myQueue", new Buffer(msg)))
+            .ensure(() => connection.close());
+    });
+
+amqp.connect("amqp://localhost")
+    .then(connection => {
+        return connection.createChannel()
+            .tap(channel => channel.checkQueue("myQueue"))
+            .then(channel => channel.consume("myQueue", newMsg => console.log("New Message: " + newMsg.content.toString())))
+            .ensure(() => connection.close());
+    });
diff --git a/amqplib/amqplib.d.ts b/amqplib/amqplib.d.ts
new file mode 100644
index 000000000..0c7f0720a
--- /dev/null
+++ b/amqplib/amqplib.d.ts
@@ -0,0 +1,144 @@
+// Type definitions for amqplib 0.3.x
+// Project: https://github.com/squaremo/amqp.node
+// Definitions by: Michael Nahkies <https://github.com/mnahkies>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../when/when.d.ts" />
+/// <reference path="../node/node.d.ts" />
+
+declare module "amqplib" {
+
+    import events = require("events");
+    import when = require("when");
+
+    interface Connection extends events.EventEmitter {
+        close(): when.Promise<void>;
+        createChannel(): when.Promise<Channel>;
+        createConfirmChannel(): when.Promise<Channel>;
+    }
+
+    module Replies {
+        interface Empty {
+        }
+        interface AssertQueue {
+            queue: string;
+            messageCount: number;
+            consumerCount: number;
+        }
+        interface DeleteQueue {
+            messageCount: number;
+        }
+        interface AssertExchange {
+            exchange: string;
+        }
+        interface Consume {
+            consumerTag: string;
+        }
+    }
+
+    module Options {
+        interface AssertQueue {
+            exclusive?: boolean;
+            durable?: boolean;
+            autoDelete?: boolean;
+            arguments?: any;
+            messageTtl?: number;
+            expires?: number;
+            deadLetterExchange?: string;
+            maxLength?: number;
+        }
+        interface DeleteQueue {
+            ifUnused?: boolean;
+            ifEmpty?: boolean;
+        }
+        interface AssertExchange {
+            durable?: boolean;
+            internal?: boolean;
+            autoDelete?: boolean;
+            alternateExchange?: string;
+            arguments?: any;
+        }
+        interface DeleteExchange {
+            ifUnused?: boolean;
+        }
+        interface Publish {
+            expiration?: string;
+            userId?: string;
+            CC?: string | string[];
+
+            mandatory?: boolean;
+            persistent?: boolean;
+            deliveryMode?: boolean | number;
+            BCC?: string | string[];
+
+            contentType?: string;
+            contentEncoding?: string;
+            headers?: Object;
+            priority?: number;
+            correlationId?: string;
+            replyTo?: string;
+            messageId?: string;
+            timestamp?: number;
+            type?: string;
+            appId?: string;
+        }
+        interface Consume {
+            consumerTag?: string;
+            noLocal?: boolean;
+            noAck?: boolean;
+            exclusive?: boolean;
+            priority?: number;
+            arguments?: Object;
+        }
+        interface Get {
+            noAck?: boolean;
+        }
+    }
+
+    interface Message {
+        content: Buffer;
+        fields: Object;
+        properties: Object;
+    }
+
+    interface Channel extends events.EventEmitter {
+        close(): when.Promise<void>;
+
+        assertQueue(queue: string, options?: Options.AssertQueue): when.Promise<Replies.AssertQueue>;
+        checkQueue(queue: string): when.Promise<Replies.AssertQueue>;
+
+        deleteQueue(queue: string, options?: Options.DeleteQueue): when.Promise<Replies.DeleteQueue>;
+        purgeQueue(queue: string): when.Promise<Replies.DeleteQueue>;
+
+        bindQueue(queue: string, source: string, pattern: string, args?: any): when.Promise<Replies.Empty>;
+        unbindQueue(queue: string, source: string, pattern: string, args?: any): when.Promise<Replies.Empty>;
+
+        assertExchange(exchange: string, type: string, options?: Options.AssertExchange): when.Promise<Replies.AssertExchange>;
+        checkExchange(exchange: string): when.Promise<Replies.Empty>;
+
+        deleteExchange(exchange: string, options?: Options.DeleteExchange): when.Promise<Replies.Empty>;
+
+        bindExchange(destination: string, source: string, pattern: string, args?: any): when.Promise<Replies.Empty>;
+        unbindExchange(destination: string, source: string, pattern: string, args?: any): when.Promise<Replies.Empty>;
+
+        publish(exchange: string, routingKey: string, content: Buffer, options?: Options.Publish): boolean;
+        sendToQueue(queue: string, content: Buffer, options?: Options.Publish): boolean;
+
+        consume(queue: string, onMessage: (msg: Message) => any, options?: Options.Consume): when.Promise<Replies.Consume>;
+
+        cancel(consumerTag: string): when.Promise<Replies.Empty>;
+        get(queue: string, options?: Options.Get): when.Promise<Message | boolean>;
+
+        ack(message: Message, allUpTo?: boolean): void;
+        ackAll(): void;
+
+        nack(message: Message, allUpTo?: boolean, requeue?: boolean): void;
+        nackAll(requeue?: boolean): void;
+        reject(message: Message, requeue?: boolean): void;
+
+        prefetch(count: number, global?: boolean): when.Promise<Replies.Empty>;
+        recover(): when.Promise<Replies.Empty>;
+    }
+
+    function connect(url: string, socketOptions?: any): when.Promise<Connection>;
+}
diff --git a/angular-signalr-hub/angular-signalr-hub-tests.ts b/angular-signalr-hub/angular-signalr-hub-tests.ts
new file mode 100644
index 000000000..b46ff63ac
--- /dev/null
+++ b/angular-signalr-hub/angular-signalr-hub-tests.ts
@@ -0,0 +1,77 @@
+/// <reference path='angular-signalr-hub.d.ts' />
+/// <reference path='../angularjs/angular.d.ts' />
+
+angular
+    .module('app', ['SignalR'])
+    .factory('Employees', ngSignalrTest.EmployeesFactory);
+
+module ngSignalrTest {
+    export class EmployeesFactory {
+        static $inject = ['$rootScope', 'Hub', '$timeout'];
+        private hub: ngSignalr.Hub;
+        public all: Array<Employee>;
+        
+        constructor($rootScope: ng.IRootScopeService, Hub: ngSignalr.HubFactory, $timeout: ng.ITimeoutService) {
+            // declaring the hub connection
+            this.hub = new Hub('employee', {
+                // client-side methods
+                listeners: {
+                    'lockEmployee': (id: number) => {
+                        var employee = this.find(id);
+                        employee.Locked = true;
+                        $rootScope.$apply();
+                    },
+                    'unlockEmployee': (id: number) => {
+                        var employee = this.find(id);
+                        employee.Locked = false;
+                        $rootScope.$apply();
+                    }
+                },
+                
+                // server-side methods
+                methods: ['lock', 'unlock'],
+                
+                // query params sent on initial connection
+                queryParams:{
+                        'token': 'exampletoken'
+                },
+                
+                // handle connection error
+                errorHandler: (message: string) => {
+                    console.error(message);
+                },
+                
+                stateChanged: (state: SignalRStateChange) => {
+                    // your code here
+                }
+            });
+        }
+        
+        private find(id: number) {
+            for (var i = 0; i < this.all.length; i++) {
+                if (this.all[i].Id === id) return this.all[i];
+            }
+            
+            return null;
+        }
+        
+        public edit = (employee: Employee) => {
+            employee.Edit = true;
+            this.hub.invoke('lock', employee.Id);
+        };
+        
+        public done = (employee: Employee) => {
+            employee.Edit = false;
+            this.hub.invoke('unlock', employee.Id);
+        }
+    }
+    
+    interface Employee {
+        Id: number;
+        Name: string;
+        Email: string;
+        Salary: number;
+        Edit: boolean;
+        Locked: boolean;
+    }
+}
\ No newline at end of file
diff --git a/angular-signalr-hub/angular-signalr-hub.d.ts b/angular-signalr-hub/angular-signalr-hub.d.ts
new file mode 100644
index 000000000..1edae69c7
--- /dev/null
+++ b/angular-signalr-hub/angular-signalr-hub.d.ts
@@ -0,0 +1,73 @@
+// Type definitions for angular-signalr-hub v1.5.0
+// Project: https://github.com/JustMaier/angular-signalr-hub
+// Definitions by: Adam Santaniello <https://github.com/AdamSantaniello>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path='../signalr/signalr.d.ts' />
+
+declare module ngSignalr {
+    interface HubFactory {
+        /**
+         * Creates a new Hub connection
+         */
+        new(hubName: string, options: HubOptions) : Hub
+    }
+    
+    class Hub {
+        hubName: string;
+        connection: SignalR;
+        proxy: HubProxy;
+        
+        on(event: string, fn: ((...args: any[]) => void)): void;
+        invoke(method: string, ...args: any[]): JQueryDeferred<any>;
+        disconnect(): void;
+        connect(): JQueryPromise<any>;
+    }
+    
+    interface HubOptions {
+        /**
+         * Collection of client side callbacks
+         */
+        listeners?: { [index: string] : (...args: any[]) => void };
+        
+        /**
+         * String array of server side methods which the client can call
+         */
+        methods?: Array<string>;
+        
+        /**
+         * Sets the root path for the SignalR web service
+         */
+        rootPath?: string;
+        
+        /**
+         * Object representing additional query params to be sent on connection
+         */
+        queryParams?: { [index: string] : string };
+        
+        /**
+         * Function to handle hub connection errors
+         */
+        errorHandler?: (error: string) => void;
+        
+        /**
+         * Enable/disable logging
+         */
+        logging?: boolean;
+        
+        /**
+         * Use a shared global connection or create a new one just for this hub, defaults to true 
+         */
+        useSharedConnection?: boolean;
+        
+        /**
+         * Sets transport method (e.g    'longPolling'    or    ['webSockets', 'longPolling'] )
+         */
+        transport?: any;
+        
+        /**
+         * Function to handle hub connection state changed event
+         */
+        stateChanged?: (state: SignalRStateChange) => void;
+    }
+}
\ No newline at end of file
diff --git a/angular-translate/angular-translate.d.ts b/angular-translate/angular-translate.d.ts
index ab4c1db5f..e4f69c688 100644
--- a/angular-translate/angular-translate.d.ts
+++ b/angular-translate/angular-translate.d.ts
@@ -13,7 +13,7 @@ declare module "angular-translate" {
 declare module angular.translate {
 
     interface ITranslationTable {
-        [key: string]: string;
+        [key: string]: any;
     }
 
     interface ILanguageKeyAlias {
diff --git a/angular2/angular2-2.0.0-alpha.34.d.ts b/angular2/angular2-2.0.0-alpha.34.d.ts
new file mode 100644
index 000000000..aa3b6b6f4
--- /dev/null
+++ b/angular2/angular2-2.0.0-alpha.34.d.ts
@@ -0,0 +1,6564 @@
+// Type definitions for Angular v2.0.0-alpha.34
+// 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.
+// ***********************************************************
+
+// Angular depends transitively on these libraries.
+// If you don't have them installed you can run
+// $ tsd query es6-promise rx rx-lite --action install --save
+///<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 */ {
+    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?: List<Type | Binding | List<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 View}.
+   * 
+   * ## Example
+   * 
+   * ```
+   * @Component({
+   *   selector: 'greet'
+   * })
+   * @View({
+   *   template: 'Hello {{name}}!'
+   * })
+   * class Greet {
+   *   name: string;
+   * 
+   *   constructor() {
+   *     this.name = 'World';
+   *   }
+   * }
+   * ```
+   */
+  class ComponentAnnotation extends DirectiveAnnotation {
+    
+
+    /**
+     * 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: string;
+    
+
+    /**
+     * 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: List<any>;
+  }
+  
+
+  /**
+   * Directives allow you to attach behavior to elements in the DOM.
+   * 
+   * {@link Directive}s with an embedded view are called {@link Component}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 View}:
+   * 
+   * 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 Directive} 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'
+   *   ],
+   *   hostListeners: {
+   *     'onmouseenter': 'onMouseEnter()',
+   *     'onmouseleave': '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 View}, 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 DirectiveAnnotation 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 Pipe} 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 also use pipes when writing binding definitions for a directive.
+     * 
+     * For example, we could write a binding that updates the directive on structural changes, rather
+     * than on reference changes, as normally occurs in change detection.
+     * 
+     * See {@link Pipe} and {@link KeyValueChanges} documentation for more details.
+     * 
+     * ```
+     * @Directive({
+     *   selector: '[class-set]',
+     *   properties: [
+     *     'classChanges: classSet | keyValDiff'
+     *   ]
+     * })
+     * class ClassSet {
+     *   set classChanges(changes: KeyValueChanges) {
+     *     // This will get called every time the `class-set` expressions changes its structure.
+     *   }
+     * }
+     * ```
+     * 
+     * The template that this directive is used in may also contain its own pipes. For example:
+     * 
+     * ```html
+     * <div [class-set]="someExpression | somePipe">
+     * ```
+     * 
+     * In this case, the two pipes compose as if they were inlined: `someExpression | somePipe |
+     * keyValDiff`.
+     */
+     properties: List<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>;
+    
+
+    /**
+     * 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.
+     * 
+     * ## 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>;
+    
+
+    /**
+     * 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: List<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;
+  }
+  
+
+  /**
+   * 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`
+   */
+  enum LifecycleEvent {
+    onDestroy,
+    onChange,
+    onCheck,
+    onInit,
+    onAllChangesDone
+  }
+  
+
+  /**
+   * 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 Component}.
+   * 
+   * ## Example
+   * 
+   * ```
+   * @Component({
+   *   selector: 'greet'
+   * })
+   * @View({
+   *   template: 'Hello {{name}}!',
+   *   directives: [GreetUser, Bold]
+   * })
+   * class Greet {
+   *   name: string;
+   * 
+   *   constructor() {
+   *     this.name = 'World';
+   *   }
+   * }
+   * ```
+   */
+  class ViewAnnotation {
+    
+
+    /**
+     * 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>;
+    
+
+    /**
+     * Specifies an inline stylesheet for an angular component.
+     */
+     styles: List<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: List<Type | any | List<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 {
+    EMULATED,
+    NATIVE,
+    NONE
+  }
+  
+
+  /**
+   * Specifies that a {@link QueryList} should be injected.
+   * 
+   * See {@link QueryList} for usage and example.
+   */
+  class QueryAnnotation extends DependencyMetadata {
+    
+     descendants: boolean;
+    
+     isViewQuery: void;
+    
+     selector: void;
+    
+     isVarBindingQuery: boolean;
+    
+     varBindings: List<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 AttributeAnnotation extends DependencyMetadata {
+    
+     attributeName: string;
+    
+     token: void;
+    
+     toString(): string;
+  }
+  
+
+  /**
+   * Defines lifecycle method
+   * {@link annotations/LifeCycleEvent#onAllChangesDone `LifeCycleEvent.onAllChangesDone`}
+   * called when the bindings of all its children have been changed.
+   */
+  interface OnAllChangesDone {
+    
+     onAllChangesDone(): void;
+  }
+  
+
+  /**
+   * Defines lifecycle method {@link annotations/LifeCycleEvent#onChange `LifeCycleEvent.onChange`}
+   * called after all of component's bound properties are updated.
+   */
+  interface OnChange {
+    
+     onChange(changes: StringMap<string, any>): void;
+  }
+  
+
+  /**
+   * Defines lifecycle method {@link annotations/LifeCycleEvent#onDestroy `LifeCycleEvent.onDestroy`}
+   * called when a directive is being destroyed.
+   */
+  interface OnDestroy {
+    
+     onDestroy(): void;
+  }
+  
+
+  /**
+   * Defines lifecycle method {@link annotations/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`}
+   * called when a directive is being checked.
+   */
+  interface OnCheck {
+    
+     onCheck(): void;
+  }
+  
+
+  /**
+   * 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 | Array<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: Array<any>;
+    
+
+    /**
+     * Generate a class from the definition and annotate it with {@link TypeDecorator#annotations}.
+     */
+     Class(obj: ClassDefinition): Type;
+  }
+  
+
+  /**
+   * {@link Attribute} factory function.
+   */
+  var Attribute : AttributeFactory ;
+  
+
+  /**
+   * {@link Attribute} 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): AttributeAnnotation;
+  
+    
+     (name: string): TypeDecorator;
+  
+  }
+  
+
+  /**
+   * {@link Component} factory function.
+   */
+  var Component : ComponentFactory ;
+  
+
+  /**
+   * Interface for the {@link Component} decorator function.
+   * 
+   * See {@link ComponentFactory}.
+   */
+  interface ComponentDecorator extends TypeDecorator {
+    
+
+    /**
+     * Chain {@link View} annotation.
+     */
+     View(obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: List<Type | any | List<any>>,
+    renderer?: string,
+    styles?: List<string>,
+    styleUrls?: List<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?: List<string>,
+    events?: List<string>,
+    host?: StringMap<string, string>,
+    lifecycle?: List<LifecycleEvent>,
+    bindings?: List<any>,
+    exportAs?: string,
+    compileChildren?: boolean,
+    viewBindings?: List<any>,
+    changeDetection?: string,
+  }): ComponentAnnotation;
+  
+    
+     (obj: {
+    selector?: string,
+    properties?: List<string>,
+    events?: List<string>,
+    host?: StringMap<string, string>,
+    lifecycle?: List<LifecycleEvent>,
+    bindings?: List<any>,
+    exportAs?: string,
+    compileChildren?: boolean,
+    viewBindings?: List<any>,
+    changeDetection?: string,
+  }): ComponentDecorator;
+  
+  }
+  
+
+  /**
+   * {@link Directive} factory function.
+   */
+  var Directive : DirectiveFactory ;
+  
+
+  /**
+   * Interface for the {@link Directive} decorator function.
+   * 
+   * See {@link DirectiveFactory}.
+   */
+  interface DirectiveDecorator extends TypeDecorator {
+  }
+  
+
+  /**
+   * {@link Directive} 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?: List<string>, events?: List<string>,
+        host?: StringMap<string, string>, lifecycle?: List<LifecycleEvent>, bindings?: List<any>,
+        exportAs?: string, compileChildren?: boolean;
+  }): DirectiveAnnotation;
+  
+    
+     (obj: {
+    selector?: string, properties?: List<string>, events?: List<string>,
+        host?: StringMap<string, string>, lifecycle?: List<LifecycleEvent>, bindings?: List<any>,
+        exportAs?: string, compileChildren?: boolean;
+  }): DirectiveDecorator;
+  
+  }
+  
+
+  /**
+   * {@link View} factory function.
+   */
+  var View : ViewFactory ;
+  
+
+  /**
+   * Interface for the {@link View} decorator function.
+   * 
+   * See {@link ViewFactory}.
+   */
+  interface ViewDecorator extends TypeDecorator {
+    
+
+    /**
+     * Chain {@link View} annotation.
+     */
+     View(obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: List<Type | any | List<any>>,
+    renderer?: string,
+    styles?: List<string>,
+    styleUrls?: List<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?: List<Type | any | List<any>>,
+    encapsulation?: ViewEncapsulation,
+    styles?: List<string>,
+    styleUrls?: List<string>,
+  }): ViewAnnotation;
+  
+    
+     (obj: {
+    templateUrl?: string,
+    template?: string,
+    directives?: List<Type | any | List<any>>,
+    encapsulation?: ViewEncapsulation,
+    styles?: List<string>,
+    styleUrls?: List<string>,
+  }): ViewDecorator;
+  
+  }
+  
+
+  /**
+   * {@link Query} factory function.
+   */
+  var Query : QueryFactory ;
+  
+
+  /**
+   * {@link Query} 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}): QueryAnnotation;
+  
+    
+     (selector: Type | string, {descendants}?: {descendants?: boolean}): ParameterDecorator;
+  
+  }
+  
+
+  /**
+   * {@link ViewQuery} factory function.
+   */
+  var ViewQuery : QueryFactory ;
+  
+
+  /**
+   * CHECK_ONCE means that after calling detectChanges the mode of the change detector
+   * will become CHECKED.
+   */
+  const CHECK_ONCE : string ;
+  
+
+  /**
+   * 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 ;
+  
+
+  /**
+   * 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 ;
+  
+
+  /**
+   * 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;
+    
+     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;
+    
+     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.
+     */
+     requestCheck(): 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 Pipe} 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.
+   */
+  class WrappedValue {
+    
+     wrapped: any;
+  }
+  
+  const defaultPipes : Pipes ;
+  
+
+  /**
+   * An interface which all pipes must implement.
+   * 
+   * #Example
+   * 
+   * ```
+   * class DoublePipe implements Pipe {
+   *  supports(obj) {
+   *    return true;
+   *  }
+   * 
+   *  onDestroy() {}
+   * 
+   *  transform(value, args = []) {
+   *    return `${value}${value}`;
+   *  }
+   * }
+   * ```
+   */
+  interface Pipe {
+    
+
+    /**
+     * Query if a pipe supports a particular object instance.
+     */
+     supports(obj: any): boolean;
+    
+     onDestroy(): void;
+    
+     transform(value: any, args: List<any>): any;
+  }
+  
+  class Pipes {
+    
+
+    /**
+     * Map of {@link Pipe} names to {@link PipeFactory} lists used to configure the
+     * {@link Pipes} registry.
+     * 
+     * #Example
+     * 
+     * ```
+     * var pipesConfig = {
+     *   'json': [jsonPipeFactory]
+     * }
+     * @Component({
+     *   viewBindings: [
+     *     bind(Pipes).toValue(new Pipes(pipesConfig))
+     *   ]
+     * })
+     * ```
+     */
+     config: StringMap<string, PipeFactory[]>;
+    
+     get(type: string, obj: any, cdRef?: ChangeDetectorRef, existingPipe?: Pipe): Pipe;
+  }
+  
+
+  /**
+   * A repository of different iterable diffing strategies used by NgFor, NgClass, and others.
+   */
+  class IterableDiffers {
+    
+     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 {
+    
+     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;
+  }
+  
+  interface PipeFactory {
+    
+     supports(obs: any): boolean;
+    
+     create(cdRef: ChangeDetectorRef): Pipe;
+  }
+  
+
+  /**
+   * Provides default implementation of `supports` and `onDestroy` method.
+   * 
+   * #Example
+   * 
+   * ```
+   * class DoublePipe extends BasePipe {
+   *  transform(value) {
+   *    return `${value}${value}`;
+   *  }
+   * }
+   * ```
+   */
+  class BasePipe implements Pipe {
+    
+     supports(obj: any): boolean;
+    
+     onDestroy(): void;
+    
+     transform(value: any, args: List<any>): any;
+  }
+  
+  class NullPipe extends BasePipe {
+    
+     called: boolean;
+    
+     supports(obj: any): boolean;
+    
+     transform(value: any, args?: List<any>): WrappedValue;
+  }
+  
+  class NullPipeFactory implements PipeFactory {
+    
+     supports(obj: any): boolean;
+    
+     create(cdRef: ChangeDetectorRef): Pipe;
+  }
+  
+
+  /**
+   * 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 appComponentTypeToken : OpaqueToken ;
+  
+
+  /**
+   * 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 Component} type.
+     */
+     hostComponentType: Type;
+    
+
+    /**
+     * Returns the current {@link Component} instance.
+     */
+     hostComponent: any;
+    
+
+    /**
+     * Dispose (un-load) the application.
+     */
+     dispose(): void;
+    
+
+    /**
+     * Returns the root application {@link Injector}.
+     */
+     injector: Injector;
+  }
+  
+
+  /**
+   * Runtime representation of a type.
+   * 
+   * In JavaScript a Type is a constructor function.
+   */
+  interface Type extends Function {
+    
+     new(args: any): any;
+  
+  }
+  
+
+  /**
+   * 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: void;
+  }
+  
+
+  /**
+   * 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 Component} 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 Directive}.
+   * 
+   * This interface can be overridden by the application developer to create custom behavior.
+   * 
+   * See {@link Compiler}
+   */
+  class DirectiveResolver {
+    
+
+    /**
+     * Return {@link Directive} for a given `Type`.
+     */
+     resolve(type: Type): DirectiveAnnotation;
+  }
+  
+
+  /**
+   * ## 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 live list of components in the Light DOM.
+   * 
+   * Injectable Objects that contains a live list of child directives in the light 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.
+   * 
+   * 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;
+   * }
+   * ```
+   */
+  interface IQueryList<T> {
+  }
+  
+
+  /**
+   * Injectable Objects that contains a live list of child directives in the light Dom of a directive.
+   * The directives are kept in depth-first pre-order traversal of the DOM.
+   * 
+   * In the future this class will implement an Observable interface.
+   * For now it uses a plain list of observable callbacks.
+   */
+  class QueryList<T> implements IQueryList<T> {
+    
+     reset(newList: List<T>): void;
+    
+     add(obj: T): void;
+    
+     fireCallbacks(): void;
+    
+     onChange(callback: () => void): void;
+    
+     removeCallback(callback: () => void): void;
+    
+     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;
+  }
+  
+
+  /**
+   * 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;
+  }
+  
+
+  /**
+   * 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} and {@link AppViewManager#createRootHostView}).
+   * 
+   * A `ProtoView` is a foctary 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: void;
+    
+     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: void;
+  }
+  
+
+  /**
+   * 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 {
+    
+
+    /**
+     * 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;
+    
+
+    /**
+     * 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;
+    
+     displayName: string;
+    
+     toString(): string;
+  }
+  
+  class ProtoInjector {
+    
+     numberOfBindings: number;
+    
+     getBindingAtIndex(index: number): any;
+  }
+  
+  class BindingWithVisibility {
+    
+     binding: ResolvedBinding;
+    
+     visibility: number;
+    
+     getKeyId(): number;
+  }
+  
+
+  /**
+   * Used to provide dependencies that cannot be easily expressed as bindings.
+   */
+  interface DependencyProvider {
+    
+     getDependency(injector: Injector, binding: ResolvedBinding, dependency: Dependency): any;
+  }
+  
+  const PUBLIC_AND_PRIVATE : number ;
+  
+  const PUBLIC : number ;
+  
+  const PRIVATE : number ;
+  
+  const undefinedValue : 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: void;
+    
+
+    /**
+     * 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: void;
+    
+
+    /**
+     * 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: void;
+    
+
+    /**
+     * 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>;
+    
+
+    /**
+     * 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: void;
+    
+
+    /**
+     * 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?: List<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>;
+  }
+  
+
+  /**
+   * @private
+   */
+  class Dependency {
+    
+     key: Key;
+    
+     optional: boolean;
+    
+     lowerBoundVisibility: any;
+    
+     upperBoundVisibility: any;
+    
+     properties: List<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.
+   */
+  interface Key {
+    
+     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: List<Key>;
+    
+     injectors: List<Injector>;
+    
+     constructResolvingMessage: Function;
+    
+     addKey(injector: Injector, key: Key): void;
+    
+     context: void;
+    
+     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 {If, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault} from 'angular2/angular2';
+   * import {OtherDirective} from 'myDirectives';
+   * 
+   * @Component({
+   *  selector: 'my-component'
+   * })
+   * @View({
+   *   templateUrl: 'myComponent.html',
+   *   directives: [If, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault, OtherDirective]
+   * })
+   * export class MyComponent {
+   *   ...
+   * }
+   * ```
+   * one could enumerate all the core directives at once:
+   * 
+   * ```
+   * import {coreDirectives} from 'angular2/angular2';
+   * import {OtherDirective} from 'myDirectives';
+   * 
+   * @Component({
+   *  selector: 'my-component'
+   * })
+   * @View({
+   *   templateUrl: 'myComponent.html',
+   *   directives: [coreDirectives, OtherDirective]
+   * })
+   * export class MyComponent {
+   *   ...
+   * }
+   * ```
+   */
+  const coreDirectives : List<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" [class]="{error: errorCount > 0}">
+   *     Please check errors.
+   * </div>
+   * ```
+   */
+  class CSSClass {
+    
+     rawClass: void;
+    
+     onCheck(): 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 {
+    
+     viewContainer: ViewContainerRef;
+    
+     templateRef: TemplateRef;
+    
+     iterableDiffers: IterableDiffers;
+    
+     cdr: ChangeDetectorRef;
+    
+     ngForOf: void;
+    
+     onCheck(): 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 {
+    
+     viewContainer: ViewContainerRef;
+    
+     templateRef: TemplateRef;
+    
+     prevCondition: boolean;
+    
+     ngIf: void;
+  }
+  
+
+  /**
+   * 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 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': alignEpr}"></div>
+   * ```
+   * 
+   * In the above example the `text-align` style will be updated based on the `alignEpr` value
+   * changes.
+   * 
+   * # Syntax
+   * 
+   * - `<div ng-style="{'text-align': alignEpr}"></div>`
+   * - `<div ng-style="styleExp"></div>`
+   */
+  class NgStyle {
+    
+     rawStyle: void;
+    
+     onCheck(): 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: void;
+  }
+  
+
+  /**
+   * 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 {
+    
+     onDestroy(): void;
+    
+     ngSwitchWhen: void;
+  }
+  
+
+  /**
+   * 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 {
+  }
+  
+
+  /**
+   * Mock Connection to represent a {@link Connection} for tests.
+   */
+  class MockConnection {
+    
+
+    /**
+     * 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: 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 {
+    
+
+    /**
+     * {@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: 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: Array<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: 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 IRequestOptions {
+    
+     url?: string;
+    
+     method?: RequestMethods;
+    
+     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 IResponseOptions {
+    
+     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: 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 implements IRequestOptions {
+    
+
+    /**
+     * 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;
+    
+
+    /**
+     * Creates a copy of the `RequestOptions` instance, using the optional input as values to override
+     * existing values.
+     */
+     merge(options?: IRequestOptions): 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 implements IResponseOptions {
+    
+     body: string | Object;
+    
+     status: number;
+    
+     headers: Headers;
+    
+     statusText: string;
+    
+     type: ResponseTypes;
+    
+     url: string;
+    
+     merge(options?: IResponseOptions): 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, httpInjectables, BaseRequestOptions} from 'angular2/http';
+   * @Component({
+   *   viewBindings: [
+   *     httpInjectables,
+   *     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: 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: 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, httpInjectables} from 'angular2/http';
+   * @Component({selector: 'http-app', viewBindings: [httpInjectables]})
+   * @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?: IRequestOptions): EventEmitter;
+    
+
+    /**
+     * Performs a request with `get` http method.
+     */
+     get(url: string, options?: IRequestOptions): EventEmitter;
+    
+
+    /**
+     * Performs a request with `post` http method.
+     */
+     post(url: string, body: string, options?: IRequestOptions): EventEmitter;
+    
+
+    /**
+     * Performs a request with `put` http method.
+     */
+     put(url: string, body: string, options?: IRequestOptions): EventEmitter;
+    
+
+    /**
+     * Performs a request with `delete` http method.
+     */
+     delete(url: string, options?: IRequestOptions): EventEmitter;
+    
+
+    /**
+     * Performs a request with `patch` http method.
+     */
+     patch(url: string, body: string, options?: IRequestOptions): EventEmitter;
+    
+
+    /**
+     * Performs a request with `head` http method.
+     */
+     head(url: string, options?: IRequestOptions): 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?: IRequestOptions): 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(): List<string>;
+    
+
+    /**
+     * Sets or overrides header value for given name.
+     */
+     set(header: string, value: string | List<string>): void;
+    
+
+    /**
+     * Returns values of all headers.
+     */
+     values(): List<List<string>>;
+    
+
+    /**
+     * Returns list of header values for a given name.
+     */
+     getAll(header: string): Array<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,
+    HEADERS_RECEIVED,
+    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.
+   */
+  class URLSearchParams {
+    
+     paramsMap: Map<string, List<string>>;
+    
+     rawParams: string;
+    
+     has(param: string): boolean;
+    
+     get(param: string): string;
+    
+     getAll(param: string): List<string>;
+    
+     append(param: string, val: string): void;
+    
+     toString(): string;
+    
+     delete(param: string): void;
+  }
+  
+
+  /**
+   * Provides a basic set of injectables to use the {@link Http} service in any application.
+   * 
+   * #Example
+   * 
+   * ```
+   * import {httpInjectables, Http} from 'angular2/http';
+   * @Component({selector: 'http-app', viewBindings: [httpInjectables]})
+   * @View({template: '{{data}}'})
+   * class MyApp {
+   *   constructor(http:Http) {
+   *     http.request('data.txt').subscribe(res => this.data = res.text());
+   *   }
+   * }
+   * ```
+   */
+  var httpInjectables : List<any> ;
+  
+  var jsonpInjectables : List<any> ;
+  
+
+  /**
+   * 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;
+  }
+  
+
+  /**
+   * 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: List<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>;
+  }
+  
+
+  /**
+   * 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: [formDirectives],
+   *      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: [formDirectives],
+   *      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: void;
+    
+     model: any;
+    
+     viewModel: any;
+    
+     ngValidators: QueryList<NgValidator>;
+    
+     onChange(c: StringMap<string, any>): void;
+    
+     onDestroy(): void;
+    
+     viewToModelUpdate(newValue: any): void;
+    
+     path: List<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: [formDirectives],
+   *      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: [formDirectives],
+   *      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: void;
+    
+     model: any;
+    
+     viewModel: any;
+    
+     ngValidators: QueryList<NgValidator>;
+    
+     onChange(c: StringMap<string, any>): void;
+    
+     path: List<string>;
+    
+     control: Control;
+    
+     validator: Function;
+    
+     viewToModelUpdate(newValue: any): void;
+  }
+  
+
+  /**
+   * Binds a domain model to the form.
+   * 
+   * # Example
+   *  ```
+   * @Component({selector: "search-comp"})
+   * @View({
+   *      directives: [formDirectives],
+   *      template: `
+   *               <input type='text' [(ng-model)]="searchQuery">
+   *      `})
+   * class SearchComp {
+   *  searchQuery: string;
+   * }
+   *  ```
+   */
+  class NgModel extends NgControl {
+    
+     update: void;
+    
+     model: any;
+    
+     viewModel: any;
+    
+     ngValidators: QueryList<NgValidator>;
+    
+     onChange(c: StringMap<string, any>): void;
+    
+     control: Control;
+    
+     path: List<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>;
+    
+     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: [formDirectives],
+   *      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: List<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: [formDirectives],
+   *      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: [formDirectives],
+   *      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: List<NgControl>;
+    
+     ngSubmit: void;
+    
+     onChange(_: any): void;
+    
+     formDirective: Form;
+    
+     control: ControlGroup;
+    
+     path: List<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: [formDirectives],
+   *      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: void;
+    
+     formDirective: Form;
+    
+     control: ControlGroup;
+    
+     path: List<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: void;
+    
+     onTouched: void;
+    
+     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: void;
+    
+     onTouched: void;
+    
+     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: void;
+    
+     onTouched: void;
+    
+     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 formDirectives : List<Type> ;
+  
+
+  /**
+   * Provides a set of validators used by form controls.
+   * 
+   * # Example
+   * 
+   * ```
+   * var loginControl = new Control("", Validators.required)
+   * ```
+   */
+  class Validators {
+  }
+  
+  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, formDirectives, 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: [
+   *     formDirectives
+   *   ]
+   * })
+   * 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: List<any>, validator?: Function): ControlArray;
+  }
+  
+  const formInjectables : List<Type> ;
+  
+  class DirectiveMetadata {
+    
+     id: any;
+    
+     selector: string;
+    
+     compileChildren: boolean;
+    
+     events: List<string>;
+    
+     properties: List<string>;
+    
+     readAttributes: List<string>;
+    
+     type: number;
+    
+     callOnDestroy: boolean;
+    
+     callOnChange: boolean;
+    
+     callOnCheck: boolean;
+    
+     callOnInit: boolean;
+    
+     callOnAllChangesDone: boolean;
+    
+     changeDetection: string;
+    
+     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>;
+    
+     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;
+    
+     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
+     */
+     dispatchRenderEvent(elementIndex: number, eventName: string, locals: Map<string, any>): void;
+  }
+  
+  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: List<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;
+  }
+  
+  class RenderViewRef {
+  }
+  
+  class RenderProtoViewRef {
+  }
+  
+  class RenderFragmentRef {
+  }
+  
+  class RenderViewWithFragments {
+    
+     viewRef: RenderViewRef;
+    
+     fragmentRefs: RenderFragmentRef[];
+  }
+  
+  class ViewDefinition {
+    
+     componentId: string;
+    
+     templateAbsUrl: string;
+    
+     template: string;
+    
+     directives: List<DirectiveMetadata>;
+    
+     styleAbsUrls: List<string>;
+    
+     styles: List<string>;
+    
+     encapsulation: ViewEncapsulation;
+  }
+  
+  const DOCUMENT_TOKEN : OpaqueToken ;
+  
+
+  /**
+   * A unique id (string) for an angular application.
+   */
+  const APP_ID_TOKEN : OpaqueToken ;
+  
+  const DOM_REFLECT_PROPERTIES_AS_ATTRIBUTES : 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_TOKEN : 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)');
+   * 
+   *     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;
+  
+  var Key: InjectableReference;
+  
+}
+
+declare module "angular2/angular2" {
+  export = ng;
+}
+
+
diff --git a/angular2/angular2.d.ts b/angular2/angular2.d.ts
index 8007ebb06..aa3b6b6f4 100644
--- a/angular2/angular2.d.ts
+++ b/angular2/angular2.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Angular v2.0.0-alpha.33
+// Type definitions for Angular v2.0.0-alpha.34
 // Project: http://angular.io/
 // Definitions by: angular team <https://github.com/angular/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -20,12 +20,6 @@ interface Map<K,V> {}
 interface StringMap<K,V> extends Map<K,V> {}
 
 declare module ng {
-  type SetterFn = typeof Function;
-  type int = number;
-  interface Type extends Function {
-    new (...args: any[]): any;
-  }
-
   // See https://github.com/Microsoft/TypeScript/issues/1168
   class BaseException /* extends Error */ {
     message: string;
@@ -183,7 +177,7 @@ declare module ng {
    * 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 `hostInjector` and `viewInjector`.
+   * - creates all the injectable objects configured with `bindings` and `viewBindings`.
    * 
    * All template expressions and statements are then evaluated against the component instance.
    * 
@@ -251,7 +245,7 @@ declare module ng {
      * 
      * @Component({
      *   selector: 'greet',
-     *   viewInjector: [
+     *   viewBindings: [
      *     Greeter
      *   ]
      * })
@@ -264,7 +258,7 @@ declare module ng {
      * 
      * ```
      */
-     viewInjector: List<any>;
+     viewBindings: List<any>;
   }
   
 
@@ -318,11 +312,9 @@ declare module ng {
    * 
    * To inject other directives, declare the constructor parameter as:
    * - `directive:DirectiveType`: a directive on the current element only
-   * - `@Ancestor() directive:DirectiveType`: any directive that matches the type between the current
+   * - `@Host() directive:DirectiveType`: any directive that matches the type between the current
    * element and the
-   *    Shadow DOM root. Current element is not included in the resolution, therefore even if it could
-   * resolve it, it will
-   *    be ignored.
+   *    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
@@ -429,21 +421,19 @@ declare module ng {
    * ### 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
-   * parent element and its parents. By definition, a directive with an `@Ancestor` annotation does
-   * not attempt to
-   * resolve dependencies for the current element, even if this would satisfy the dependency.
-   * 
+   * DOM), i.e. on the current element, the
+   * parent element, or its parents.
    * ```
    * @Directive({ selector: '[my-directive]' })
    * class MyDirective {
-   *   constructor(@Ancestor() dependency: Dependency) {
+   *   constructor(@Host() dependency: Dependency) {
    *     expect(dependency.id).toEqual(2);
    *   }
    * }
    * ```
    * 
-   * `@Ancestor` checks the parent, as well as its parents recursively. If `dependency="2"` didn't
+   * `@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"`.
@@ -982,7 +972,7 @@ declare module ng {
      * 
      * @Directive({
      *   selector: 'greet',
-     *   hostInjector: [
+     *   bindings: [
      *     Greeter
      *   ]
      * })
@@ -995,7 +985,7 @@ declare module ng {
      * }
      * ```
      */
-     hostInjector: List<any>;
+     bindings: List<any>;
     
 
     /**
@@ -1078,7 +1068,7 @@ declare module ng {
     
 
     /**
-     * Specifies an inline template for an angular component.
+     * Specifies a template URL for an angular component.
      * 
      * NOTE: either `templateUrl` or `template` should be used, but not both.
      */
@@ -1086,7 +1076,7 @@ declare module ng {
     
 
     /**
-     * Specifies a template URL for an angular component.
+     * Specifies an inline template for an angular component.
      * 
      * NOTE: either `templateUrl` or `template` should be used, but not both.
      */
@@ -1132,8 +1122,9 @@ declare module ng {
 
     /**
      * Specify how the template and the styles should be encapsulated.
-     * The default is {@link ViewEncapsulation.EMULATED} if the view has styles,
-     * otherwise {@link ViewEncapsulation.NONE}.
+     * The default is {@link ViewEncapsulation#EMULATED `ViewEncapsulation.EMULATED`} if the view
+     * has styles,
+     * otherwise {@link ViewEncapsulation#NONE `ViewEncapsulation.NONE`}.
      */
      encapsulation: ViewEncapsulation;
   }
@@ -1207,8 +1198,9 @@ declare module ng {
   
 
   /**
-   * Defines lifecycle method [onAllChangesDone ] called when the bindings of all its children have
-   * been changed.
+   * Defines lifecycle method
+   * {@link annotations/LifeCycleEvent#onAllChangesDone `LifeCycleEvent.onAllChangesDone`}
+   * called when the bindings of all its children have been changed.
    */
   interface OnAllChangesDone {
     
@@ -1217,8 +1209,8 @@ declare module ng {
   
 
   /**
-   * Defines lifecycle method [onChange] called after all of component's bound
-   * properties are updated.
+   * Defines lifecycle method {@link annotations/LifeCycleEvent#onChange `LifeCycleEvent.onChange`}
+   * called after all of component's bound properties are updated.
    */
   interface OnChange {
     
@@ -1227,7 +1219,8 @@ declare module ng {
   
 
   /**
-   * Defines lifecycle method [onDestroy] called when a directive is being destroyed.
+   * Defines lifecycle method {@link annotations/LifeCycleEvent#onDestroy `LifeCycleEvent.onDestroy`}
+   * called when a directive is being destroyed.
    */
   interface OnDestroy {
     
@@ -1236,7 +1229,8 @@ declare module ng {
   
 
   /**
-   * Defines lifecycle method [onInit] called when a directive is being checked the first time.
+   * Defines lifecycle method {@link annotations/LifeCycleEvent#onInit `LifeCycleEvent.onInit`}
+   * called when a directive is being checked the first time.
    */
   interface OnInit {
     
@@ -1245,7 +1239,8 @@ declare module ng {
   
 
   /**
-   * Defines lifecycle method [onCheck] called when a directive is being checked.
+   * Defines lifecycle method {@link annotations/LifeCycleEvent#onCheck `LifeCycleEvent.onCheck`}
+   * called when a directive is being checked.
    */
   interface OnCheck {
     
@@ -1362,21 +1357,6 @@ declare module ng {
   }
   
 
-  /**
-   * An interface implemented by all Angular parameter decorators, which allows them to be used as ES7
-   * decorators.
-   */
-  interface ParameterDecorator {
-    
-
-    /**
-     * Invoke as ES7 decorator.
-     */
-     (cls: Type, unusedKey: any, index: number): void;
-  
-  }
-  
-
   /**
    * An interface implemented by all Angular type decorators, which allows them to be used as ES7
    * decorators as well as
@@ -1565,10 +1545,10 @@ declare module ng {
     events?: List<string>,
     host?: StringMap<string, string>,
     lifecycle?: List<LifecycleEvent>,
-    hostInjector?: List<any>,
+    bindings?: List<any>,
     exportAs?: string,
     compileChildren?: boolean,
-    viewInjector?: List<any>,
+    viewBindings?: List<any>,
     changeDetection?: string,
   }): ComponentAnnotation;
   
@@ -1579,10 +1559,10 @@ declare module ng {
     events?: List<string>,
     host?: StringMap<string, string>,
     lifecycle?: List<LifecycleEvent>,
-    hostInjector?: List<any>,
+    bindings?: List<any>,
     exportAs?: string,
     compileChildren?: boolean,
-    viewInjector?: List<any>,
+    viewBindings?: List<any>,
     changeDetection?: string,
   }): ComponentDecorator;
   
@@ -1648,15 +1628,15 @@ declare module ng {
     
      new(obj: {
     selector?: string, properties?: List<string>, events?: List<string>,
-        host?: StringMap<string, string>, lifecycle?: List<LifecycleEvent>,
-        hostInjector?: List<any>, exportAs?: string, compileChildren?: boolean;
+        host?: StringMap<string, string>, lifecycle?: List<LifecycleEvent>, bindings?: List<any>,
+        exportAs?: string, compileChildren?: boolean;
   }): DirectiveAnnotation;
   
     
      (obj: {
     selector?: string, properties?: List<string>, events?: List<string>,
-        host?: StringMap<string, string>, lifecycle?: List<LifecycleEvent>,
-        hostInjector?: List<any>, exportAs?: string, compileChildren?: boolean;
+        host?: StringMap<string, string>, lifecycle?: List<LifecycleEvent>, bindings?: List<any>,
+        exportAs?: string, compileChildren?: boolean;
   }): DirectiveDecorator;
   
   }
@@ -1892,6 +1872,48 @@ declare module ng {
      location: string;
   }
   
+  interface ChangeDetector {
+    
+     parent: ChangeDetector;
+    
+     mode: string;
+    
+     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;
+    
+     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.
@@ -1938,6 +1960,8 @@ declare module ng {
      wrapped: any;
   }
   
+  const defaultPipes : Pipes ;
+  
 
   /**
    * An interface which all pipes must implement.
@@ -1985,7 +2009,7 @@ declare module ng {
      *   'json': [jsonPipeFactory]
      * }
      * @Component({
-     *   viewInjector: [
+     *   viewBindings: [
      *     bind(Pipes).toValue(new Pipes(pipesConfig))
      *   ]
      * })
@@ -1996,6 +2020,64 @@ declare module ng {
      get(type: string, obj: any, cdRef?: ChangeDetectorRef, existingPipe?: Pipe): Pipe;
   }
   
+
+  /**
+   * A repository of different iterable diffing strategies used by NgFor, NgClass, and others.
+   */
+  class IterableDiffers {
+    
+     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 {
+    
+     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;
+  }
+  
   interface PipeFactory {
     
      supports(obs: any): boolean;
@@ -2097,6 +2179,18 @@ declare module ng {
   }
   
 
+  /**
+   * Runtime representation of a type.
+   * 
+   * In JavaScript a Type is a constructor function.
+   */
+  interface Type extends Function {
+    
+     new(args: any): any;
+  
+  }
+  
+
   /**
    * Specifies app root url for the application.
    * 
@@ -2606,6 +2700,59 @@ declare module ng {
   }
   
 
+  /**
+   * 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.
    * 
@@ -3099,21 +3246,6 @@ declare module ng {
   }
   
 
-  /**
-   * Specifies how injector should resolve a dependency.
-   * 
-   * See {@link Self}, {@link Ancestor}, {@link Unbounded}.
-   */
-  class VisibilityMetadata {
-    
-     crossBoundaries: boolean;
-    
-     includeSelf: boolean;
-    
-     toString(): string;
-  }
-  
-
   /**
    * Specifies that an injector should retrieve a dependency from itself.
    * 
@@ -3132,14 +3264,15 @@ declare module ng {
    * expect(nd.dependency).toBeAnInstanceOf(Dependency);
    * ```
    */
-  class SelfMetadata extends VisibilityMetadata {
+  class SelfMetadata {
     
      toString(): string;
   }
   
 
   /**
-   * Specifies that an injector should retrieve a dependency from any ancestor from the same boundary.
+   * Specifies that an injector should retrieve a dependency from any injector until reaching the
+   * closest host.
    * 
    * ## Example
    * 
@@ -3148,65 +3281,52 @@ declare module ng {
    * }
    * 
    * class NeedsDependency {
-   *   constructor(public @Ancestor() dependency:Dependency) {}
+   *   constructor(public @Host() dependency:Dependency) {}
    * }
    * 
    * var parent = Injector.resolveAndCreate([
-   *   bind(Dependency).toClass(AncestorDependency)
+   *   bind(Dependency).toClass(HostDependency)
    * ]);
    * var child = parent.resolveAndCreateChild([]);
    * var grandChild = child.resolveAndCreateChild([NeedsDependency, Depedency]);
    * var nd = grandChild.get(NeedsDependency);
-   * expect(nd.dependency).toBeAnInstanceOf(AncestorDependency);
-   * ```
-   * 
-   * You can make an injector to retrive a dependency either from itself or its ancestor by setting
-   * self to true.
-   * 
-   * ```
-   * class NeedsDependency {
-   *   constructor(public @Ancestor({self:true}) dependency:Dependency) {}
-   * }
+   * expect(nd.dependency).toBeAnInstanceOf(HostDependency);
    * ```
    */
-  class AncestorMetadata extends VisibilityMetadata {
+  class HostMetadata {
     
      toString(): string;
   }
   
 
   /**
-   * Specifies that an injector should retrieve a dependency from any ancestor, crossing boundaries.
+   * Specifies that the dependency resolution should start from the parent injector.
    * 
    * ## Example
    * 
+   * 
    * ```
-   * class Dependency {
+   * class Service {}
+   * 
+   * class ParentService implements Service {
    * }
    * 
-   * class NeedsDependency {
-   *   constructor(public @Ancestor() dependency:Dependency) {}
+   * class ChildService implements Service {
+   *   constructor(public @SkipSelf() parentService:Service) {}
    * }
    * 
    * var parent = Injector.resolveAndCreate([
-   *   bind(Dependency).toClass(AncestorDependency)
+   *   bind(Service).toClass(ParentService)
    * ]);
-   * var child = parent.resolveAndCreateChild([]);
-   * var grandChild = child.resolveAndCreateChild([NeedsDependency, Depedency]);
-   * var nd = grandChild.get(NeedsDependency);
-   * expect(nd.dependency).toBeAnInstanceOf(AncestorDependency);
-   * ```
-   * 
-   * You can make an injector to retrive a dependency either from itself or its ancestor by setting
-   * self to true.
-   * 
-   * ```
-   * class NeedsDependency {
-   *   constructor(public @Ancestor({self:true}) dependency:Dependency) {}
-   * }
+   * var child = parent.resolveAndCreateChild([
+   *   bind(Service).toClass(ChildSerice)
+   * ]);
+   * var s = child.get(Service);
+   * expect(s).toBeAnInstanceOf(ChildService);
+   * expect(s.parentService).toBeAnInstanceOf(ParentService);
    * ```
    */
-  class UnboundedMetadata extends VisibilityMetadata {
+  class SkipSelfMetadata {
     
      toString(): string;
   }
@@ -3243,8 +3363,6 @@ declare module ng {
      token: void;
   }
   
-  const DEFAULT_VISIBILITY : VisibilityMetadata ;
-  
 
   /**
    * Allows to refer to references which are not yet defined.
@@ -3749,7 +3867,9 @@ declare module ng {
     
      optional: boolean;
     
-     visibility: VisibilityMetadata;
+     lowerBoundVisibility: any;
+    
+     upperBoundVisibility: any;
     
      properties: List<any>;
   }
@@ -3971,27 +4091,27 @@ declare module ng {
   
 
   /**
-   * Factory for creating {@link AncestorMetadata}.
+   * Factory for creating {@link HostMetadata}.
    */
-  interface AncestorFactory {
+  interface HostFactory {
     
-     new(visibility?: {self: boolean}): AncestorMetadata;
+     new(): HostMetadata;
   
     
-     (visibility?: {self: boolean}): any;
+     (): any;
   
   }
   
 
   /**
-   * Factory for creating {@link UnboundedMetadata}.
+   * Factory for creating {@link SkipSelfMetadata}.
    */
-  interface UnboundedFactory {
+  interface SkipSelfFactory {
     
-     new(visibility?: {self: boolean}): UnboundedMetadata;
+     new(): SkipSelfMetadata;
   
     
-     (visibility?: {self: boolean}): any;
+     (): any;
   
   }
   
@@ -4021,15 +4141,15 @@ declare module ng {
   
 
   /**
-   * Factory for creating {@link AncestorMetadata}.
+   * Factory for creating {@link HostMetadata}.
    */
-  var Ancestor : AncestorFactory ;
+  var Host : HostFactory ;
   
 
   /**
-   * Factory for creating {@link UnboundedMetadata}.
+   * Factory for creating {@link SkipSelfMetadata}.
    */
-  var Unbounded : UnboundedFactory ;
+  var SkipSelf : SkipSelfFactory ;
   
 
   /**
@@ -4142,7 +4262,7 @@ declare module ng {
     
      templateRef: TemplateRef;
     
-     pipes: Pipes;
+     iterableDiffers: IterableDiffers;
     
      cdr: ChangeDetectorRef;
     
@@ -4855,7 +4975,7 @@ declare module ng {
    * ```
    * import {Http, MyNodeBackend, httpInjectables, BaseRequestOptions} from 'angular2/http';
    * @Component({
-   *   viewInjector: [
+   *   viewBindings: [
    *     httpInjectables,
    *     bind(Http).toFactory((backend, options) => {
    *       return new Http(backend, options);
@@ -4944,7 +5064,7 @@ declare module ng {
    * 
    * ```
    * import {Http, httpInjectables} from 'angular2/http';
-   * @Component({selector: 'http-app', viewInjector: [httpInjectables]})
+   * @Component({selector: 'http-app', viewBindings: [httpInjectables]})
    * @View({templateUrl: 'people.html'})
    * class PeopleComponent {
    *   constructor(http: Http) {
@@ -5226,7 +5346,7 @@ declare module ng {
    * 
    * ```
    * import {httpInjectables, Http} from 'angular2/http';
-   * @Component({selector: 'http-app', viewInjector: [httpInjectables]})
+   * @Component({selector: 'http-app', viewBindings: [httpInjectables]})
    * @View({template: '{{data}}'})
    * class MyApp {
    *   constructor(http:Http) {
@@ -6029,7 +6149,7 @@ declare module ng {
    * 
    * @Component({
    *   selector: 'login-comp',
-   *   viewInjector: [
+   *   viewBindings: [
    *     FormBuilder
    *   ]
    * })
@@ -6093,6 +6213,82 @@ declare module ng {
   
   const formInjectables : List<Type> ;
   
+  class DirectiveMetadata {
+    
+     id: any;
+    
+     selector: string;
+    
+     compileChildren: boolean;
+    
+     events: List<string>;
+    
+     properties: List<string>;
+    
+     readAttributes: List<string>;
+    
+     type: number;
+    
+     callOnDestroy: boolean;
+    
+     callOnChange: boolean;
+    
+     callOnCheck: boolean;
+    
+     callOnInit: boolean;
+    
+     callOnAllChangesDone: boolean;
+    
+     changeDetection: string;
+    
+     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>;
+    
+     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;
+    
+     setText(viewRef: RenderViewRef, textNodeIndex: number, text: string): void;
+    
+     setEventDispatcher(viewRef: RenderViewRef, dispatcher: any): void;
+  }
+  
 
   /**
    * A dispatcher for all events happening in a view.
@@ -6236,41 +6432,21 @@ declare module ng {
      fragmentRefs: RenderFragmentRef[];
   }
   
-  class DomRenderer extends Renderer {
+  class ViewDefinition {
     
-     createRootHostView(hostProtoViewRef: RenderProtoViewRef, fragmentCount: number, hostElementSelector: string): RenderViewWithFragments;
+     componentId: string;
     
-     createView(protoViewRef: RenderProtoViewRef, fragmentCount: number): RenderViewWithFragments;
+     templateAbsUrl: string;
     
-     destroyView(viewRef: RenderViewRef): void;
+     template: string;
     
-     getNativeElementSync(location: RenderElementRef): any;
+     directives: List<DirectiveMetadata>;
     
-     getRootNodes(fragment: RenderFragmentRef): List<Node>;
+     styleAbsUrls: List<string>;
     
-     attachFragmentAfterFragment(previousFragmentRef: RenderFragmentRef, fragmentRef: RenderFragmentRef): void;
+     styles: List<string>;
     
-     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;
-    
-     setText(viewRef: RenderViewRef, textNodeIndex: number, text: string): void;
-    
-     setEventDispatcher(viewRef: RenderViewRef, dispatcher: any): void;
+     encapsulation: ViewEncapsulation;
   }
   
   const DOCUMENT_TOKEN : OpaqueToken ;
@@ -6283,6 +6459,84 @@ declare module ng {
   
   const DOM_REFLECT_PROPERTIES_AS_ATTRIBUTES : 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_TOKEN : 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)');
+   * 
+   *     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;
@@ -6303,8 +6557,8 @@ declare module ng {
   
 }
 
-
-
 declare module "angular2/angular2" {
   export = ng;
 }
+
+
diff --git a/angular2/router-2.0.0-alpha.34.d.ts b/angular2/router-2.0.0-alpha.34.d.ts
new file mode 100644
index 000000000..e61aaa5ff
--- /dev/null
+++ b/angular2/router-2.0.0-alpha.34.d.ts
@@ -0,0 +1,469 @@
+// Type definitions for Angular v2.0.0-alpha.34
+// 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.
+// ***********************************************************
+///<reference path="./angular2-2.0.0-alpha.34.d.ts"/>
+
+
+
+/**
+ * @module
+ * @description
+ * Maps application URLs into application states, to support deep-linking and navigation.
+ */
+declare module ng {
+
+  /**
+   * # 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.
+     */
+     registerOutlet(outlet: RouterOutlet): Promise<boolean>;
+    
+
+    /**
+     * Dynamically update the routing configuration and trigger a navigation.
+     * 
+     * # Usage
+     * 
+     * ```
+     * router.config([
+     *   { 'path': '/', 'component': IndexComp },
+     *   { 'path': '/user/:id', 'component': UserComp },
+     * ]);
+     * ```
+     */
+     config(definitions: List<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>;
+    
+
+    /**
+     * 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): void;
+    
+
+    /**
+     * 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>): string;
+  }
+  
+  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;
+    
+
+    /**
+     * Given an instruction, update the contents of this outlet.
+     */
+     commit(instruction: Instruction): Promise<any>;
+    
+
+    /**
+     * Called by Router during recognition phase
+     */
+     canDeactivate(nextInstruction: Instruction): Promise<boolean>;
+    
+
+    /**
+     * Called by Router during recognition phase
+     */
+     canReuse(nextInstruction: Instruction): Promise<boolean>;
+    
+     deactivate(nextInstruction: Instruction): Promise<any>;
+  }
+  
+
+  /**
+   * 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;
+    
+     routeParams: void;
+    
+     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, isRootLevelRoute?: boolean): void;
+    
+
+    /**
+     * Reads the annotations of a component and configures the registry based on them
+     */
+     configFromComponent(component: any, isRootComponent?: boolean): 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): string;
+  }
+  
+  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 HTML5LocationStrategy 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 {
+    
+     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 appBaseHrefToken : OpaqueToken ;
+  
+
+  /**
+   * Responsible for performing each step of navigation.
+   * "Steps" are conceptually similar to "middleware"
+   */
+  class Pipeline {
+    
+     steps: List<Function>;
+    
+     process(instruction: Instruction): Promise<any>;
+  }
+  
+
+  /**
+   * Defines route lifecycle method [onActivate]
+   */
+  interface OnActivate {
+    
+     onActivate(nextInstruction: Instruction, prevInstruction: Instruction): any;
+  }
+  
+
+  /**
+   * Defines route lifecycle method [onDeactivate]
+   */
+  interface OnDeactivate {
+    
+     onDeactivate(nextInstruction: Instruction, prevInstruction: Instruction): any;
+  }
+  
+
+  /**
+   * Defines route lifecycle method [onReuse]
+   */
+  interface OnReuse {
+    
+     onReuse(nextInstruction: Instruction, prevInstruction: Instruction): any;
+  }
+  
+
+  /**
+   * Defines route lifecycle method [canDeactivate]
+   */
+  interface CanDeactivate {
+    
+     canDeactivate(nextInstruction: Instruction, prevInstruction: Instruction): any;
+  }
+  
+
+  /**
+   * Defines route lifecycle method [canReuse]
+   */
+  interface CanReuse {
+    
+     canReuse(nextInstruction: Instruction, prevInstruction: Instruction): any;
+  }
+  
+  var CanActivate : (hook: (next: Instruction, prev: Instruction) => Promise<boolean>| boolean) => ClassDecorator ;
+  
+
+  /**
+   * An `Instruction` represents the component hierarchy of the application based on a given route
+   */
+  class Instruction {
+    
+     accumulatedUrl: string;
+    
+     reuse: boolean;
+    
+     specificity: number;
+    
+     component: any;
+    
+     capturedUrl: string;
+    
+     child: Instruction;
+    
+     params(): StringMap<string, string>;
+  }
+  
+  const routerDirectives : List<any> ;
+  
+  var routerInjectables : List<any> ;
+  
+  class Route implements RouteDefinition {
+    
+     path: string;
+    
+     component: Type;
+    
+     as: string;
+    
+     loader: Function;
+    
+     redirectTo: string;
+  }
+  
+  class Redirect implements RouteDefinition {
+    
+     path: string;
+    
+     redirectTo: string;
+    
+     as: string;
+  }
+  
+  class AsyncRoute implements RouteDefinition {
+    
+     path: string;
+    
+     loader: Function;
+    
+     as: string;
+  }
+  
+  interface RouteDefinition {
+    
+     path: string;
+    
+     component?: Type | ComponentDefinition;
+    
+     loader?: Function;
+    
+     redirectTo?: string;
+    
+     as?: string;
+  }
+  
+  var RouteConfig : (configs: List<RouteDefinition>) => ClassDecorator ;
+  
+  interface ComponentDefinition {
+    
+     type: string;
+    
+     loader?: Function;
+    
+     component?: Type;
+  }
+  
+}
+
+declare module "angular2/router" {
+  export = ng;
+}
+
+
diff --git a/angular2/router.d.ts b/angular2/router.d.ts
index 580490540..684f8c8e9 100644
--- a/angular2/router.d.ts
+++ b/angular2/router.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Angular v2.0.0-alpha.31
+// Type definitions for Angular v2.0.0-alpha.34
 // Project: http://angular.io/
 // Definitions by: angular team <https://github.com/angular/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -18,120 +18,56 @@
  * Maps application URLs into application states, to support deep-linking and navigation.
  */
 declare module ng {
-  interface List<T> extends Array<T> {}
-  interface Map<K,V> {}
-  interface StringMap<K,V> extends Map<K,V> {}
-
-  export class Instruction {
-    // "capturedUrl" is the part of the URL captured by this instruction
-    // "accumulatedUrl" is the part of the URL captured by this instruction and all children
-    accumulatedUrl: string;
-    reuse: boolean;
-    specificity: number;
-
-    private _params: StringMap<string, string>;
-
-    constructor (component: any, capturedUrl: string,
-      _recognizer: PathRecognizer, child: Instruction);
-
-    params(): StringMap<string, string>;
-  }
-
-  class TouchMap {
-    map: StringMap<string, string>;
-    keys: StringMap<string, boolean>;
-
-    constructor(map: StringMap<string, any>);
-
-    get(key: string): string;
-
-    getUnused(): StringMap<string, any>;
-  }
-
-  export class Segment {
-    name: string;
-    regex: string;
-    generate(params: TouchMap): string;
-  }
-
-  export class PathRecognizer {
-    segments: List<Segment>;
-    regex: RegExp;
-    specificity: number;
-    terminal: boolean;
-    path: string;
-    handler: RouteHandler;
-
-    constructor(path: string, handler: RouteHandler);
-
-    parseParams(url: string): StringMap<string, string>;
-
-    generate(params: StringMap<string, any>): string;
-
-    resolveComponentType(): Promise<any>;
-  }
-
-
-  export interface RouteHandler {
-    componentType: Function;
-    resolveComponentType(): Promise<any>;
-  }
 
   /**
    * # 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.
      */
      registerOutlet(outlet: RouterOutlet): Promise<boolean>;
-
+    
 
     /**
      * Dynamically update the routing configuration and trigger a navigation.
-     *
+     * 
      * # Usage
-     *
-     * ```
-     * router.config({ 'path': '/', 'component': IndexCmp});
-     * ```
-     *
-     * Or:
-     *
+     * 
      * ```
      * router.config([
      *   { 'path': '/', 'component': IndexComp },
@@ -139,48 +75,48 @@ declare module ng {
      * ]);
      * ```
      */
-     config(config: StringMap<string, any>| List<StringMap<string, any>>): Promise<any>;
-
+     config(definitions: List<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): Promise<any>;
-
+     navigate(url: string, _skipLocationChange?: boolean): Promise<any>;
+    
 
     /**
      * Updates this router and all descendant routers according to the given instruction
      */
-     commit(instruction: Instruction): Promise<any>;
-
+     commit(instruction: Instruction, _skipLocationChange?: boolean): Promise<any>;
+    
 
     /**
      * Subscribe to URL updates from the router
      */
-     subscribe(onNext: any): void;
-
+     subscribe(onNext: (value: any) => void): void;
+    
 
     /**
      * 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
@@ -188,71 +124,71 @@ declare module ng {
      */
      generate(linkParams: List<any>): string;
   }
-
+  
   class RootRouter extends Router {
-
-     commit(instruction: any): Promise<any>;
+    
+     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;
-
+    
 
     /**
      * Given an instruction, update the contents of this outlet.
      */
      commit(instruction: Instruction): Promise<any>;
-
+    
 
     /**
      * Called by Router during recognition phase
      */
      canDeactivate(nextInstruction: Instruction): Promise<boolean>;
-
+    
 
     /**
      * Called by Router during recognition phase
      */
      canReuse(nextInstruction: Instruction): Promise<boolean>;
-
+    
      deactivate(nextInstruction: Instruction): Promise<any>;
   }
-
+  
 
   /**
    * The RouterLink directive lets you link to specific parts of your app.
-   *
+   * 
    * Consider the following route configuration:
-   *
+   * 
    * ```
-   * @RouteConfig({
-   *   path: '/user', component: UserCmp, as: 'user'
-   * });
+   * @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
@@ -260,21 +196,21 @@ declare module ng {
    * current component's parent.
    */
   class RouterLink {
-
+    
      visibleHref: string;
-
+    
      routeParams: void;
-
+    
      onClick(): boolean;
   }
-
+  
   class RouteParams {
-
+    
      params: StringMap<string, string>;
-
+    
      get(param: string): string;
   }
-
+  
 
   /**
    * The RouteRegistry holds route configurations for each component in an Angular app.
@@ -282,26 +218,26 @@ declare module ng {
    * parameters.
    */
   class RouteRegistry {
-
+    
 
     /**
      * Given a component and a configuration object, add the route to this registry
      */
-     config(parentComponent: any, config: StringMap<string, any>): void;
-
+     config(parentComponent: any, config: RouteDefinition, isRootLevelRoute?: boolean): void;
+    
 
     /**
      * Reads the annotations of a component and configures the registry based on them
      */
-     configFromComponent(component: any): void;
-
+     configFromComponent(component: any, isRootComponent?: boolean): 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 }]`
@@ -309,56 +245,56 @@ declare module ng {
      */
      generate(linkParams: List<any>, parentComponent: any): string;
   }
-
+  
   class LocationStrategy {
-
+    
      path(): string;
-
+    
      pushState(ctx: any, title: string, url: string): void;
-
+    
      forward(): void;
-
+    
      back(): void;
-
-     onPopState(fn: any): 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 HTML5LocationStrategy 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:
@@ -367,93 +303,167 @@ declare module ng {
    * - `/my/app/user/123/` **is not** normalized
    */
   class Location {
-
+    
      path(): string;
-
+    
      normalize(url: string): string;
-
+    
      normalizeAbsolutely(url: string): string;
-
+    
      go(url: string): void;
-
+    
      forward(): void;
-
+    
      back(): void;
-
-     subscribe(onNext: any, onThrow?: any, onReturn?: any): void;
+    
+     subscribe(onNext: (value: any) => void, onThrow?: (exception: any) => void, onReturn?: () => void): void;
   }
-
-  var appBaseHrefToken : OpaqueToken ;
-
+  
+  const appBaseHrefToken : OpaqueToken ;
+  
 
   /**
    * Responsible for performing each step of navigation.
    * "Steps" are conceptually similar to "middleware"
    */
   class Pipeline {
-
+    
      steps: List<Function>;
-
+    
      process(instruction: Instruction): Promise<any>;
   }
-
+  
 
   /**
    * Defines route lifecycle method [onActivate]
    */
   interface OnActivate {
-
+    
      onActivate(nextInstruction: Instruction, prevInstruction: Instruction): any;
   }
-
+  
 
   /**
    * Defines route lifecycle method [onDeactivate]
    */
   interface OnDeactivate {
-
+    
      onDeactivate(nextInstruction: Instruction, prevInstruction: Instruction): any;
   }
-
+  
 
   /**
    * Defines route lifecycle method [onReuse]
    */
   interface OnReuse {
-
+    
      onReuse(nextInstruction: Instruction, prevInstruction: Instruction): any;
   }
-
+  
 
   /**
    * Defines route lifecycle method [canDeactivate]
    */
   interface CanDeactivate {
-
+    
      canDeactivate(nextInstruction: Instruction, prevInstruction: Instruction): any;
   }
-
+  
 
   /**
    * Defines route lifecycle method [canReuse]
    */
   interface CanReuse {
-
+    
      canReuse(nextInstruction: Instruction, prevInstruction: Instruction): any;
   }
+  
+  var CanActivate : (hook: (next: Instruction, prev: Instruction) => Promise<boolean>| boolean) => ClassDecorator ;
+  
 
-  var CanActivate:any;
-
-  var routerDirectives : List<any> ;
-
+  /**
+   * An `Instruction` represents the component hierarchy of the application based on a given route
+   */
+  class Instruction {
+    
+     accumulatedUrl: string;
+    
+     reuse: boolean;
+    
+     specificity: number;
+    
+     component: any;
+    
+     capturedUrl: string;
+    
+     child: Instruction;
+    
+     params(): StringMap<string, string>;
+  }
+  
+  const routerDirectives : List<any> ;
+  
   var routerInjectables : List<any> ;
-
-  var RouteConfig:any;
-
+  
+  class Route implements RouteDefinition {
+    
+     path: string;
+    
+     component: Type;
+    
+     as: string;
+    
+     loader: Function;
+    
+     redirectTo: string;
+  }
+  
+  class Redirect implements RouteDefinition {
+    
+     path: string;
+    
+     redirectTo: string;
+    
+     as: string;
+  }
+  
+  class AsyncRoute implements RouteDefinition {
+    
+     path: string;
+    
+     loader: Function;
+    
+     as: string;
+  }
+  
+  interface RouteDefinition {
+    
+     path: string;
+    
+     component?: Type | ComponentDefinition;
+    
+     loader?: Function;
+    
+     redirectTo?: string;
+    
+     as?: string;
+  }
+  
+  var RouteConfig : (configs: List<RouteDefinition>) => ClassDecorator ;
+  
+  interface ComponentDefinition {
+    
+     type: string;
+    
+     loader?: Function;
+    
+     component?: Type;
+  }
+  
 }
 
-
-
 declare module "angular2/router" {
   export = ng;
 }
+
+
diff --git a/angularjs/angular-tests.ts b/angularjs/angular-tests.ts
index 6b79b93cc..11f1e327b 100644
--- a/angularjs/angular-tests.ts
+++ b/angularjs/angular-tests.ts
@@ -242,6 +242,18 @@ foo.then((x) => {
     x.toFixed();
 });
 
+// $q signature tests
+module TestQ {
+    var $q: ng.IQService;
+    var promise1: ng.IPromise<any>;
+    var promise2: ng.IPromise<any>;
+
+    // $q.all
+    $q.all([promise1, promise2]).then((results: any[]) => {});
+    $q.all<number>([promise1, promise2]).then((results: number[]) => {});
+    $q.all({a: promise1, b: promise2}).then((results: {[id: string]: any;}) => {});
+    $q.all<{a: number; b: string;}>({a: promise1, b: promise2}).then((results: {a: number; b: string;}) => {});
+}
 
 var httpFoo: ng.IHttpPromise<number>;
 httpFoo.then((x) => {
diff --git a/angularjs/angular.d.ts b/angularjs/angular.d.ts
index 73629204a..17c0c9384 100644
--- a/angularjs/angular.d.ts
+++ b/angularjs/angular.d.ts
@@ -1006,7 +1006,7 @@ declare module angular {
          *
          * @param promises An array of promises.
          */
-        all(promises: IPromise<any>[]): IPromise<any[]>;
+        all<T>(promises: IPromise<any>[]): IPromise<T[]>;
         /**
          * Combines multiple promises into a single promise that is resolved when all of the input promises are resolved.
          *
@@ -1015,6 +1015,7 @@ declare module angular {
          * @param promises A hash of promises.
          */
         all(promises: { [id: string]: IPromise<any>; }): IPromise<{ [id: string]: any; }>;
+        all<T extends {}>(promises: { [id: string]: IPromise<any>; }): IPromise<T>;
         /**
          * Creates a Deferred object which represents a task which will finish in the future.
          */
diff --git a/backbone-associations/backbone-associations.d.ts.tscparams b/backbone-associations/backbone-associations.d.ts.tscparams
deleted file mode 100644
index 8b1378917..000000000
--- a/backbone-associations/backbone-associations.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/body-parser/body-parser.d.ts b/body-parser/body-parser.d.ts
index 994aa4e1b..bf318d946 100644
--- a/body-parser/body-parser.d.ts
+++ b/body-parser/body-parser.d.ts
@@ -6,7 +6,7 @@
 /// <reference path="../express/express.d.ts" />
 
 declare module "body-parser" {
-    import express = require('express');
+    import * as express from "express";
 
     /**
      * bodyParser: use individual json/urlencoded middlewares
diff --git a/boom/boom.d.ts b/boom/boom.d.ts
index d0f05065c..e1539d21b 100644
--- a/boom/boom.d.ts
+++ b/boom/boom.d.ts
@@ -6,7 +6,8 @@
 /// <reference path="../node/node.d.ts" />
 
 declare module Boom {
-    interface BoomError {
+
+    export interface BoomError {
         data: any;
         reformat: () => void;
         isBoom: boolean;
diff --git a/bootbox/bootbox-tests.ts b/bootbox/bootbox-tests.ts
index dbdfa252d..463170cd7 100644
--- a/bootbox/bootbox-tests.ts
+++ b/bootbox/bootbox-tests.ts
@@ -27,14 +27,12 @@ bootbox.prompt("Enter 'ok' to pass test", function (result) {
 	console.log(result);
 });
 bootbox.prompt({
-	title: "Wassup?",
 	message: "Enter 'ok' to pass test", callback: function (result) {
 		console.log(result);
 	}
 });
 bootbox.prompt({
 	size: "large",
-	title: "Wassup?",
 	message: "Enter 'ok' to pass test", callback: function (result) {
 		console.log(result);
 	}
@@ -42,6 +40,7 @@ bootbox.prompt({
 
 
 bootbox.dialog({
+	title: "Wassup?",
 	message: "Test Dialog",
 	callback: function (result) { }
 });
diff --git a/chocolatechipjs/chocolatechipjs-tests.ts b/chocolatechipjs/chocolatechipjs-tests.ts
index e0eec9c53..cfb2ce854 100644
--- a/chocolatechipjs/chocolatechipjs-tests.ts
+++ b/chocolatechipjs/chocolatechipjs-tests.ts
@@ -16,7 +16,6 @@ var nodeName = divTag2[0].nodeName;
 var version = $.version;
 var libraryName = $.libraryName;
 var els = $('li');
-var listItems = $.slice(els);
 var madeEls = $.make('<p>Stuff</p>');
 var moreEls = $.html('<p>Stuff</p>');
 var oldTag = $('#oldTag');
@@ -241,108 +240,119 @@ var myPromise = new Promise(function(resolve, reject) {
 myPromise.then(function(value) {
     // Success:
     console.log(value);
-},
-    // Opps! There was a problem:
-    function(reason) {
-        console.log(reason);
-    });
+  },
+  // Opps! There was a problem:
+  function(reason) {
+    console.log(reason);
+});
 
-// Ajax:
-$.ajax({
-    url: "announcement.html",
-    dataType: "html",
-    success: function(data) {
-        // Insert the fragment into the page:
-        $("#content").html(data);
-    },
-    error: function(data) {
-        $("#content").html("<h4>There was an error while trying to get the file.</h4>");
-    }
+// Fetch API
+//===========
+// GET:
+interface WineObject {
+  data: Array<WineInterface>;
+}
+interface WineInterface {
+  wine: {
+    name: string;
+  }
+}
+fetch('../data/wines.json')
+.then($.json)
+.then(function<WineObject>(obj: any):any {
+  $('#message_ajax').empty();
+  obj.data.forEach(function(wine: any) {
+    $('#message_ajax').append('<li>' + wine.name + '</li>');
+  })
 });
-$.ajax({
-    url: "me.json",
-    success: function(data) {
-        // Before using a JSON object, you need to parse it.
-        // Here we parse it and assign it to a variable:
-        var me = JSON.parse(data);
-        // Here we access the properties of the JSON object:
-        $("#content").html(me.firstName + " " + me.lastName);
-    },
-    error: function(data) {
-        $('#content').html("<h4>There was an error while trying to get the file.</h4>");
-    }
-});
-var myData = {
-    "name": "Bozo the Clown",
-    "occupation": "Clown"
-};
-var mySuccessCallback = function() {
-    console.log('The post was a success!');
-};
-var myErrorCallback = function() {
-    console.log('Ooops! There was a problem posting this.');
-};
-$.ajax({
-    url: "/path/to/controller",
-    method: 'POST',
-    headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        "async": true,
-        "Access-Control-Allow-Origin": "*",
-        "Accept": "text/plain"
-    },
-    data: myData,
-    success: mySuccessCallback,
-    error: myErrorCallback
-});
-$.get('http://my.com/data/stuff.html')
-    .then(function(response) {
-        console.log("Success!", response);
-    }, function(error) {
-        console.error("Failed!", error);
-    });
 
-$.get('http://my.com/data/stuff.html')
-    .then(function(response) {
-        console.log("Success!", response);
-    })
-    .catch(function(error) {
-        console.error("Failed!", error);
-    });
-$.get('story.json')
-    .then(JSON.parse)
-    .then(function(response) {
-        console.log("Yey JSON!", response);
-    });
-$.getJSON('/data/deserts.json', function(desserts: Array<any>) {
-    desserts.forEach(function(dessert) {
-        $('#deserts').append('<li>' + dessert.name + '</li>');
-    });
-});
-$.post("updateUser.php",
-    { "name": "Joe", "time": "10PM" },
-    function() {
-        console.log('The POST was successful.')
-    },
-    "json"
-    );
-$.JSONP({ url: 'https://api.github.com/users/yui?callback=?' })
-    .then(function(users) {
-        $('.list').append('<li><h3>The name of the library</h3><h4>' + users.data.name + '</h4></li>');
-    })
-    .catch(function(err) {
-        console.log('Unable to get data.')
-    });
-
-$.JSONP({
-    url: 'http://www.geonames.org/postalCodeLookupJSON?postalcode=94102&'
+// POST:
+interface postData {
+  email: string;
+  name: string;
+  msg: string;
+}
+var formData = $.serialize($('form')[0]);
+fetch('../controllers/php-post.php', {
+  method: 'post',
+  headers: {
+    "Content-type": "application/x-www-form-urlencoded; charset=UTF-8"
+  },
+  body: formData
 })
-    .then(function(data) {
-        $('.list').append('<li><h3>My Location</h3><h4>' + data.postalcodes[0].adminName2 + ', ' + data.postalcodes[0].adminName1 + '</h4></li>');
-    })
-    .catch(function(err) {
-        console.log('Unable to get data.')
-    });
+.then($.json) 
+.then(function<postData>(data: any): any {
+  if(data.email_check == "valid"){
+    $("#message_ajax").html("<div class='successMessage'>" + data.email + " is a valid e-mail address. Thank you, " + data.name + ".</div>");
+    $("#message_ajax").append('<p>' + data.msg + '</p>');
+  } else {
+    $("#message_ajax").html("<div class='errorMessage'>Sorry " + data.name + ", " + data.email + " is NOT a valid e-mail address. Try again.</div>");
+  }
+});
+// PUT:
+interface putData {
+  base: string;
+  result: string;
+  fileName: string;
+}
+var putData = $('#fileText').val();
+fetch('../controllers/php-put.php', {
+  method: 'put',
+  headers: {  
+    "Content-type": "application/x-www-form-urlencoded; charset=UTF-8"  
+  },
+  body: putData
+})
+.then($.json) 
+.then(function<putData>(data:any): any {
+   console.dir(data.base);
+   $("#message_ajax").append('<p>' + data.result + '</p>');
+   $("#message_ajax").append('<p>The file name is: ' + data.fileName + '</p>');
+})
+.catch(function(error:Error) {
+   console.log(error);
+   $("#message_ajax").html("<div class='errorMessage'>Sorry, put was not successful.</div>");
+});
+
+
+// DELETE:
+interface deleteData {
+  result: string;
+}
+var file = $('#fileName').val();
+fetch('../controllers/php-delete.php', {
+  method: 'delete',
+  headers: {  
+    "Content-type": "application/x-www-form-urlencoded; charset=UTF-8"  
+  },
+  body: file
+})
+.then($.json) 
+.then(function<deleteData>(data: any): any {
+   $("#message_ajax").html("<div>DELETE was sent to the server successfully.</div>");
+   $("#message_ajax").append('<p>' + data.result + '</p>');
+},
+function(data: any) {
+  console.log('PROBLEM')
+  console.log(data);
+})
+.catch(function(error: any) {
+   $("#message_ajax").html("<div class='errorMessage'>Sorry, 'DELETE' was not successful.</div>");
+   error.reject();
+});
+
+// $.jsonp:
+$.jsonp('https://api.github.com/users/rbiggs/repos?name=chipper', {timeout: 10000})
+.then($.json)
+.then(function(obj: any): any {
+  console.log(obj);
+  obj.data.forEach(function(repo: any): any {
+    $('#message_ajax').append("<li>" + repo.name + "</li>");
+  });
+})
+.catch(function(error: any): any {
+  $('#message_ajax').append("<li>" + error.message + "</li>")
+});
 
 // Templates:
 var myTemplate = '<li>Name: [[= data.name]]</li>';
@@ -376,10 +386,10 @@ var repeaterTmplate2 = '<li>[[= data.firstName ]], [[= data.lastName]]</li>';
 $.template.repeater($('#objectArrayList'), repeaterTmplate2, luminaries.persons);
 
 // Pub/Sub:
-var arraySubscriber = function(topic: string, data: any) {
+var arraySubscriber = function(topic: string, data: any): any {
     $('.list').append('<li><h3>' + topic + '</h3><h4>' + data + '</h4></li>');
-    var newsSubscription = $.subscribe('news/update', arraySubscriber);
 };
+var newsSubscription = $.subscribe('news/update', arraySubscriber);
 $.publish('news/update', 'The New York Stock Exchange rose an unprecedented 1000 points in just three minutes. Analysts and investors are confused and uncertain how to respond.');
 $.unsubscribe('news/update');
 // Due to being unsubscribed above, this does nothing:
diff --git a/chocolatechipjs/chocolatechipjs.d.ts b/chocolatechipjs/chocolatechipjs.d.ts
index 9b79934b7..9a1b4c849 100644
--- a/chocolatechipjs/chocolatechipjs.d.ts
+++ b/chocolatechipjs/chocolatechipjs.d.ts
@@ -1,526 +1,502 @@
-// Type definitions for chocolatechip v3.8.11
+// Type definitions for chocolatechip v4.0.0
 // Project: https://github.com/chocolatechipui/ChocolateChipJS
 // Definitions by: Robert Biggs <http://chocolatechip-ui.com>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-
-/**
- * Defines the base object namespace for ChocolateChipJS.
- */
-declare var $chocolatechipjs: ChocolateChipStatic;
-declare var $: ChocolateChipStatic;
-
-/**
- * Static members of ChocolateChip (those on $ and ChocolateChipJS themselves)
- */
 interface ChocolateChipStatic {
 
-    /**
-     * Contains the version of ChocolateChipJS in use.
-     */
-    version: string;
+  /**
+   * Accepts a string containing a CSS selector which is then used to match a set of elements.
+   *
+   * @param selector A string containing a selector expression
+   * @param context A DOM HTMLElement to use as context
+   * @return HTMLElement[]
+   */
+  (selector: string | HTMLElement | Document, context?: HTMLElement | ChocolateChipElementArray): ChocolateChipElementArray;
 
-    /**
-     * Contains the name of the library (ChocolateChip).
-     */
-    libraryName: string;
+  /**
+   * Binds a function to be executed when the DOM has finished loading.
+   *
+   * @param callback A function to execute after the DOM is ready.
+   * @return void
+   */
+  (callback: () => any): void;
 
-    /*
-     * This method takes an array-like object and returns its members as an array.
+
+  /**
+   * Accepts a string containing a CSS selector which is then used to match a set of elements.
+   *
+   * @param element A DOM element to wrap in an array.
+   * @return HTMLElement[]
+   */
+  (element: HTMLElement): ChocolateChipElementArray;
+
+  /**
+   * Accepts a string containing a CSS selector which is then used to match a set of elements.
+   *
+   * @param elementArray An array of DOM elements to convert into a ChocolateChip Collection.
+   * @return HTMLElement[]
+   */
+  (elementArray: ChocolateChipElementArray): ChocolateChipElementArray;
+
+  (document: Document): Document[];
+  /**
+   * If no argument is provided, return the document as a ChocolateChipElementArray.
+   * @return Document[]
+   */
+  (): Document[];
+
+  /**
+   * Extend the ChocolateChipJS object itself with the provided object.
+   *
+   * @param object The object to add to ChocolateChipJS.
+   * @return The ChocolateChipJS object.
+   */
+  extend(object: Object): Object;
+
+  /**
+   * Extend a target object with another object.
+   *
+   * @param target An object to extend.
+   * @param object The object to add to the target.
+   * @return The extended object.
+   */
+  extend(target: Object, object: Object): Object;
+
+  /**
+   * The base for extending ChocolateChipJS collections, which are arrays of elements.
+   */
+  fn: {
+    /**
+     * This method adds the provided object to the Array prototype to make it available to all arrays of HTML elements.
      *
-     * @param arrayLikeObject Either the arguents object or an node collection.
-     */
-    slice(arrayLikeObject: any): Array<any>;
-
-    /**
-     * Merge the contents of one object into the first object. If only one argument is provided, it is merged into ChocolateChipStatic.
-     *
-     * @param target An object that will receive the new properties if additional objects are passed in or that will extend the ChocolateChipStatic namespace if there is a single argument.
-     * @param object An object containing additional properties to merge in.
-     */
-    extend(target: any, object?: any): any;
-
-    /**
-     * Create a ChocolateChip collection object by creating elements from an HTML string.
-     *
-     * @param selector
-     * @return any
-     */
-    make(selector: string): ChocolateChipElementArray;
-
-    /**
-     * Create a ChocolateChip collection object by creating elements from an HTML string. This is an alias for $.make.
-     *
-     * @param selector
-     * @return any
-     */
-    html(selector: string): ChocolateChipElementArray;
-
-    /**
-     * Replace one element with another.
-     *
-     * @param new HTMLElement
-     * @param old HTMLElement
-     * @return HTMLElement[]
-     */
-    replace(newElement: ChocolateChipElementArray, oldElement: ChocolateChipElementArray): void;
-
-    /**
-     * Load a JavaScript file from a url, then execute it.
-     *
-     * @param url A string containing the URL where the script resides.
-     * @param callback A callback function that is executed after the script loads.
-     * @return void
-     */
-    require(url: string, callback: Function): Function;
-
-    /**
-     * Process JavaScript returned by Ajax request. An optional name can be used to create a custom variable name by which the data is exposed, otherwise it is exposed with the variable "data".
-     *
-     * @param url A string containing the URL where the script resides.
-     * @param callback A callback function that is executed after the script loads.
-     * @return Function
-     */
-    processJSON(json: string, name?: string): any;
-
-    /**
-     * This method will defer the execution of a function until the call stack is clear.
-     *
-     * @param callback A function to execute.
-     * @param duration The number of milliseconds to delay execution.
-     * @return any
-     */
-    delay(callback: Function, duration?: number): any;
-
-    /**
-     * The method will defer the execution of its callback until the call stack is clear.
-     *
-     * @param callback A callback to execute after a delay.
-     * @return    Function.
-     */
-    defer(callback: Function): Function;
-
-    /**
-     * An empty function.
-     *
-     * @return any
-     */
-    noop(): void;
-
-    /**
-     * This method will concatenate strings or values as a cleaner alternative to using the '+' operator.
-     *
-     * @param string or number A comma separated series of strings to concatenate.
-     * @return string
-     */
-    concat(...string: string[]): string;
-
-    /**
-     * This method takes a space-delimited string of words and returns it as an array where the individual words are indices.
-     *
-     * @param string Any string with values separated by spaces.
-     * @return string[]
-     */
-    w(string: string): string[];
-
-    /**
-     * Determine whether the argument is a string.
-     *
-     * @param obj Object to test whether or not it is a string.
-     * @return boolean
-     */
-    isString(obj: any): boolean;
-
-    /**
-     * Determine whether the argument is an array.
-     *
-     * @param obj Object to test whether or not it is an array.
-     * @return boolean
-     */
-    isArray(obj: any): boolean;
-
-    /**
-     * Determine whether the argument is a function.
-     *
-     * @param obj Object to test whether or not it is an function.
-     * @return boolean
-     */
-    isFunction(obj: any): boolean;
-
-    /**
-     * Determine whether the argument is an object.
-     *
-     * @param obj Object to test whether or not it is an object.
-     * @return boolean
-     */
-    isObject(obj: any): boolean;
-
-    /**
-     * Determine whether the argument is an empty object.
-     *
-     * @param obj Object to test whether or not it is an empty object.
-     * @return boolean
-     */
-    isEmptyObject(obj: any): boolean;
-
-    /**
-     * Determine whether the argument is an empty object.
-     *
-     * @param obj Object to test whether or not it is an empty object.
-     * @return boolean
-     */
-    isEmptyObject(obj: any): boolean;
-
-    /**
-     * Determine whether the argument is a number.
-     *
-     * @param obj Object to test whether or not it is a number.
-     * @return boolean
-     */
-    isNumber(obj: any): boolean;
-
-    /**
-     * Determine whether the argument is an integer.
-     *
-     * @param obj Object to test whether or not it is an integer.
-     * @return boolean
-     */
-    isInteger(obj: any): boolean;
-
-    /**
-     * Determine whether the argument is a float.
-     *
-     * @param obj Object to test whether or not it is a float.
-     * @return boolean
-     */
-    isFloat(obj: any): boolean;
-
-    /**
-     * Creates a Uuid and returns it as a string with the prefix: "chch_".
-     */
-    makeUuid(): string;
-
-    /**
-     * A generic iterator function, which can be used to seamlessly iterate over arrays. Arrays and array-like objects with a length property (such as a function's arguments object) are iterated by numeric index, from 0 to length-1.
-     *
-     * @param collection The object or array to iterate over.
-     * @param callback The function that will be executed on every object.
-     * @return any
-     */
-    each(
-            collection: any,
-            callback: (valueOfElement: any, indexInArray: number) => any
-        ): any;
-
-
-    /**
-     * This method converts a string of hyphenated tokens into a camel cased string.
-     *
-     * @param string A string of hyphenated tokens.
-     * @return string
-     */
-    camelize(string: string): string;
-
-    /**
-     * This method converts a camel case string into lowercase with hyphens.
-     *
-     * @param string A camel case string.
-     * @return string
-     */
-    deCamelize(string: string): string;
-
-    /**
-     * This method capitalizes the first letter of a string.
-     *
-     * @param string A string.
-     * @param boolean A boolean value.
-     * @return string
-     */
-    capitalize(string: string, boolean?: boolean): string;
-
-    /**
-     * Object used to store string templates and parsed templates.
-     *
-     * @param string A string defining the template.
-     * @param string A label used to access an object's properties in the template. If none is provided it defaults to "data": [[= data.name]].
-     * @return void
-     */
-    templates: Object;
-
-    /**
-     * This method returns a parsed template.
-     *
-     */
-    template: ChocolateChipTemplate;
-
-
-    /**
-     * This is the base for the plugin "extend" interface, which allows you to add methods that can iterate over element collections.
-     */
-    fn: ChocolateChipPlugin;
-
-    /**
-     * Replace each element in the set of matched elements with the provided new content and return the set of elements that was removed.
-     *
-     * param newContent The content to insert. May be an HTML string, DOM element, or an array of DOM elements.
-     * @return void
-     */
-    replace(newELement: HTMLElement, oldElement: HTMLElement): void;
-
-    /**
-     * Perform an asynchronous HTTP (Ajax) request.
-     */
-    ajax(settings: ChocolateChipAjaxSettings): Promise<any>;
-
-    /**
-     * Load data from the server using a HTTP GET request.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param success A callback function that is executed if the request succeeds.
-     * @param dataType The type of data expected from the server. Default: Intelligent Guess (json, or html).
-     * @return Promise
-     */
-    get(url: string, data?: any, success?: (data: any) => any, dataType?: string): Promise<any>;
-
-    /**
-     * Load data from the server using a HTTP POST request.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param data A plain object or string that is sent to the server with the request.
-     * @param success A callback function that is executed if the request succeeds.
-     * @param dataType The type of data expected from the server.
-     * @return Promise
-     */
-    post(url: string, data?: any, success?: () => any, dataType?: string): Promise<any>;
-
-    /**
-     * Load JSON-encoded data from the server using a GET HTTP request.
-     *
-     * @param url A string containing the URL to which the request is sent.
-     * @param data A plain object or string that is sent to the server with the request.
-     * @param success A callback function that is executed if the request succeeds.
-     * @return Promise
-     */
-     //each(func: (ctx: any, idx: number) => any): void;
-    getJSON(url: string, data?: any, success?: (data: any) => any): Promise<any>;
-
-    /**
-     * Load JSON from a remote server using the JSONP technique.
-     *
-     * @param url A string
-     * @return Promise
-     */
-    JSONP(options: ChocolateChipJSONP): Promise<any>;
-    //JSONP({url: string, success?: (data: any), callbackType?: string, timeout?: number}): Promise<any>;
-
-
-
-    /**
-     * Specify a function to execute when the DOM is fully loaded.
-     *
-     * @param handler A function to execute after the DOM is ready.
-     * @return any
-     */
-    ready(handler: () => any): void;
-
-    /**
-     * Accepts a string containing a CSS selector which is then used to match a set of elements.
-     *
-     * @param selector A string containing a selector expression
-     * @param context A DOM HTMLElement to use as context
-     * @return HTMLElement[]
-     */
-    (selector: string, context?: HTMLElement|ChocolateChipElementArray): ChocolateChipElementArray;
-
-    /**
-     * Binds a function to be executed when the DOM has finished loading.
-     *
-     * @param callback A function to execute after the DOM is ready.
-     * @return void
-     */
-    (callback: () => any): void;
-
-
-    /**
-     * Accepts a string containing a CSS selector which is then used to match a set of elements.
-     *
-     * @param element A DOM element to wrap in an array.
-     * @return HTMLElement[]
-     */
-    (element: HTMLElement): ChocolateChipElementArray;
-
-    /**
-     * Accepts a string containing a CSS selector which is then used to match a set of elements.
-     *
-     * @param elementArray An array of DOM elements to convert into a ChocolateChip Collection.
-     * @return HTMLElement[]
-     */
-    (elementArray: ChocolateChipElementArray): ChocolateChipElementArray;
-
-    /**
-     * If no argument is provided, return the document as a ChocolateChipElementArray.
-     * @return Document[]
-     */
-    (): Document[];
-
-    /**
-     * Subscribe to a publication. You provide the topic you want to subscribe to, as well as a callback to execute when a publication occurs.
-     * Any data passed by the publisher is exposed to the callback as its second parameter. The callback's first parameter is the published topic.
-     *
-     * @param topic string A topic to subscribe to. This can be a single term, or any type of namespaced term with delimiters.
-     * @data any You can receive any type: string, number, array, object, etc.
-     * @return any
-     */
-    subscribe(topic: string, callback: (topic: string, data: any) => any):any;
-
-    /**
-     * Unsubscribe from a topic. Pass this the topic you wish to unsubscribe from. The subscription will be terminated immediately.
-     *
-     * @param topic string The name of the topic to unsubscribe from.
-     * @return void
-     */
-    unsubscribe(topic: string): void;
-
-    /**
-     *    Publish a topic with data for the topic's subscribers to receive.
-     *
-     * @param topic string The topic you wish to publish.
-     * @param data The data to send with the publication. This can be of any type: string, number, array, object, etc.
-     * @return void
-     */
-    publish(topic: string, data: any): void;
-
-    /**
-     * Whether device is iPhone.
-     */
-    isiPhone: boolean;
-
-    /**
-     * Whether device is iPad.
-     */
-    isiPad: boolean;
-
-    /**
-     * Whether device is iPod.
-     */
-    isiPod: boolean;
-
-    /**
-     * Whether OS is iOS.
-     */
-    isiOS: boolean;
-
-    /**
-     * Whether OS is Android
-     */
-    isAndroid: boolean;
-
-    /**
-     * Whether OS is WebOS.
-     */
-    isWebOS: boolean;
-
-    /**
-     * Whether OS is Blackberry.
-     */
-    isBlackberry: boolean;
-
-    /**
-     * Whether OS supports touch events.
-     */
-    isTouchEnabled: boolean;
-
-    /**
-     * Whether there is a network connection.
-     */
-    isOnline: boolean;
-
-    /**
-     * Whether app is running in stanalone mode.
-     */
-    isStandalone: boolean;
-
-    /**
-     * Whether OS is iOS 6.
-     */
-    isiOS6: boolean;
-
-    /**
-     * Whether OS i iOS 7.
-     */
-    isiOS7: boolean;
-
-    /**
-     * Whether OS is Windows.
-     */
-    isWin: boolean;
-
-    /**
-     * Whether device is Windows Phone.
-     */
-    isWinPhone: boolean;
-
-    /**
-     * Whether browser is IE10.
-     */
-    isIE10: boolean;
-
-    /**
-     * Whether browser is IE11.
-     */
-    isIE11: boolean;
-
-    /**
-     * Whether browser is Webkit based.
-     */
-    isWebkit: boolean;
-
-    /**
-     * Whether browser is running on mobile device.
-     */
-    isMobile: boolean;
-
-    /**
-     * Whether browser is running on desktop.
-     */
-    isDesktop: boolean;
-
-    /**
-     * Whether browser is Safari.
-     */
-    isSafari: boolean;
-
-    /**
-     * Whether browser is Chrome.
-     */
-    isChrome: boolean;
-
-    /**
-     * Is native Android browser (not mobile Chrome).
-     */
-    isNativeAndroid: boolean;
-
-    /**
-     * Grabs values from a form and converts them into a JSON object.
-     *
-     * @param rootNode: string|HTMLElement A form whose values you want to convert to JSON.
-     * @param delimiter string A delimiter to namespace your form values. The default is "."
-     * You use the form input's name to set up the namespace structure for your JSON, e.g. name="newUser.name.first".
-     */
-    form2JSON(rootNode: string | HTMLElement, delimiter: string): Object;
-}
-
-interface ChocolateChipPlugin {
-    /**
-     * This method extends ChocolateChipElementArray, enabling iteration over collection items.
-     *
-     * @param object Object literal of properties and values. Value can be strings, number, array, objects or functions.
-     * @return HTMLElement[]
-     */
-    extend: (object: any) => ChocolateChipElementArray;
-}
+     * @param object And object to add to element arrays.
+     * @return The extended array of elements.
+     */
+    extend(object: Object): HTMLElement[];
+  };
+
+  /**
+   * Contains the version of ChocolateChipJS in use.
+   */
+  version: string;
+
+  /**
+   * Contains the name of the library (ChocolateChip).
+   */
+  libraryName: string;
+
+  /**
+   * An empty function.
+   *
+   * @return void.
+   */
+  noop(): void;
+
+  /**
+   * Uuid number.
+   */
+  uuid: number;
+
+  /**
+   * Create a random number to use as a uuid.
+   *
+   * @return number.
+   */
+  uuidNum(): number;
+
+  /**
+   * Creates a Uuid and returns it as a string with the prefix: "chch_".
+   *
+   * @return A string.
+   */
+  makeUuid(): string;
+
+
+  /**
+   * Create a ChocolateChip collection object by creating elements from an HTML string.
+   *
+   * @param selector
+   * @return any
+   */
+  make(selector: string): ChocolateChipElementArray;
+
+  /**
+   * Create a ChocolateChip collection object by creating elements from an HTML string. This is an alias for $.make.
+   *
+   * @param selector
+   * @return any
+   */
+  html(selector: string): ChocolateChipElementArray;
+
+  /**
+   * Replace one element with another.
+   *
+   * @param new HTMLElement
+   * @param old HTMLElement
+   * @return HTMLElement[]
+   */
+  replace(newElement: ChocolateChipElementArray, oldElement: ChocolateChipElementArray): void;
+
+  /**
+   * Load a JavaScript file from a url, then execute it.
+   *
+   * @param url A string containing the URL where the script resides.
+   * @param callback A callback function that is executed after the script loads.
+   * @return void
+   */
+  require(url: string, callback: Function): Function;
+
+  /**
+   * Process JavaScript returned by Ajax request. An optional name can be used to create a custom variable name by which the data is exposed, otherwise it is exposed with the variable "data".
+   *
+   * @param url A string containing the URL where the script resides.
+   * @param callback A callback function that is executed after the script loads.
+   * @return Function
+   */
+  processJSON(json: string, name?: string): any;
+
+  /**
+   * This method takes a referenced form and serializes its element names and values, which it returns as a string. This is required if you want to send form data.
+   *
+   * @param element A string, HTML element or ChocolateChipElementArray containing a reference to a from.
+   * @return An encode string form element names and values.
+   */
+  serialize(element: any): string;
+  
+  /**
+   * Parse the data in a Promise response as JSON.
+   * 
+   * @param response The response from a Promise.
+   * @result 
+   */
+   json(reponse: Response): JSON;
+  /**
+   * This method will defer the execution of a function until the call stack is clear.
+   *
+   * @param callback A function to execute.
+   * @param duration The number of milliseconds to delay execution.
+   * @return any
+   */
+  delay(callback: Function, duration?: number): any;
+
+  /**
+   * The method will defer the execution of its callback until the call stack is clear.
+   *
+   * @param callback A callback to execute after a delay.
+   * @return    Function.
+   */
+  defer(callback: Function): Function;
+
+  /**
+   * This method makes sure a method always returns an array. If no values are available to return, it returns and empty array. This is to make sure that methods that expect a chainable array will not throw and exception.
+   *
+   * @param result The result of a method to test if it can be returned in an array.
+   * @return An array hold the results of a method, otherwise an empty array.
+   */
+  returnResult(result: HTMLElement[]): any[];
+
+  /**
+   * This method allows you to execute a callback on each item in an array of elements.
+   *
+   * @param array An array of elements.
+   * @param callback A callback to execute on each element. This has two parameters: the context, followed by the index of the current iteration.
+   */
+  each(array: any[], callback: (ctx: any, idx?: number) => any): any[];
+
+  /**
+   * This method will concatenate strings or values as a cleaner alternative to using the '+' operator.
+   *
+   * @param string or number A comma separated series of strings to concatenate.
+   * @return string
+   */
+  concat(...string: string[]): string;
+
+  /**
+   * This method takes a space-delimited string of words and returns it as an array where the individual words are indices.
+   *
+   * @param string Any string with values separated by spaces.
+   * @return string[]
+   */
+  w(string: string): string[];
+
+  /**
+   * This method converts a string of hyphenated tokens into a camel cased string.
+   *
+   * @param string A string of hyphenated tokens.
+   * @return string
+   */
+  camelize(string: string): string;
+
+  /**
+   * This method converts a camel case string into lowercase with hyphens.
+   *
+   * @param string A camel case string.
+   * @return string
+   */
+  deCamelize(string: string): string;
+
+  /**
+   * This method capitalizes the first letter of a string.
+   *
+   * @param string A string.
+   * @param boolean A boolean value.
+   * @return string
+   */
+  capitalize(string: string, boolean?: boolean): string;
+
+  /**
+   * Determine whether the argument is a string.
+   *
+   * @param obj Object to test whether or not it is a string.
+   * @return boolean
+   */
+  isString(obj: any): boolean;
+
+  /**
+   * Determine whether the argument is an array.
+   *
+   * @param obj Object to test whether or not it is an array.
+   * @return boolean
+   */
+  isArray(obj: any): boolean;
+
+  /**
+   * Determine whether the argument is a function.
+   *
+   * @param obj Object to test whether or not it is an function.
+   * @return boolean
+   */
+  isFunction(obj: any): boolean;
+
+  /**
+   * Determine whether the argument is an object.
+   *
+   * @param obj Object to test whether or not it is an object.
+   * @return boolean
+   */
+  isObject(obj: any): boolean;
+
+  /**
+   * Determine whether the argument is an empty object.
+   *
+   * @param obj Object to test whether or not it is an empty object.
+   * @return boolean
+   */
+  isEmptyObject(obj: any): boolean;
+
+  /**
+   * Determine whether the argument is an empty object.
+   *
+   * @param obj Object to test whether or not it is an empty object.
+   * @return boolean
+   */
+  isEmptyObject(obj: any): boolean;
+
+  /**
+   * Determine whether the argument is a number.
+   *
+   * @param obj Object to test whether or not it is a number.
+   * @return boolean
+   */
+  isNumber(obj: any): boolean;
+
+  /**
+   * Determine whether the argument is an integer.
+   *
+   * @param obj Object to test whether or not it is an integer.
+   * @return boolean
+   */
+  isInteger(obj: any): boolean;
+
+  /**
+   * Determine whether the argument is a float.
+   *
+   * @param obj Object to test whether or not it is a float.
+   * @return boolean
+   */
+  isFloat(obj: any): boolean;
+
+  /**
+   * Whether device is iPhone.
+   */
+  isiPhone: boolean;
+
+  /**
+   * Whether device is iPad.
+   */
+  isiPad: boolean;
+
+  /**
+   * Whether device is iPod.
+   */
+  isiPod: boolean;
+
+  /**
+   * Whether OS is iOS.
+   */
+  isiOS: boolean;
+
+  /**
+   * Whether OS is Android
+   */
+  isAndroid: boolean;
+
+  /**
+   * Whether OS is WebOS.
+   */
+  isWebOS: boolean;
+
+  /**
+   * Whether OS is Blackberry.
+   */
+  isBlackberry: boolean;
+
+  /**
+   * Whether OS supports touch events.
+   */
+  isTouchEnabled: boolean;
+
+  /**
+   * Whether there is a network connection.
+   */
+  isOnline: boolean;
+
+  /**
+   * Whether app is running in stanalone mode.
+   */
+  isStandalone: boolean;
+
+  /**
+   * Whether OS is iOS 6.
+   */
+  isiOS6: boolean;
+
+  /**
+   * Whether OS i iOS 7.
+   */
+  isiOS7: boolean;
+
+  /**
+   * Whether OS is Windows.
+   */
+  isWin: boolean;
+
+  /**
+   * Whether device is Windows Phone.
+   */
+  isWinPhone: boolean;
+
+  /**
+   * Whether browser is IE10.
+   */
+  isIE10: boolean;
+
+  /**
+   * Whether browser is IE11.
+   */
+  isIE11: boolean;
+
+  /**
+   * Whether browser is Webkit based.
+   */
+  isWebkit: boolean;
+
+  /**
+   * Whether browser is running on mobile device.
+   */
+  isMobile: boolean;
+
+  /**
+   * Whether browser is running on desktop.
+   */
+  isDesktop: boolean;
+
+  /**
+   * Whether browser is Safari.
+   */
+  isSafari: boolean;
+
+  /**
+   * Whether browser is Chrome.
+   */
+  isChrome: boolean;
+
+  /**
+   * Is native Android browser (not mobile Chrome).
+   */
+  isNativeAndroid: boolean;
+
+  JSONPCallbacks: string[];
+  /**
+   * Load JSON from a remote server using the JSONP technique.
+   *
+   * @param url A string
+   * @return Promise
+   */
+  jsonp(
+    options: {
+      timeout?: number;
+      callbackName?: string;
+      clear?: boolean;
+    }
+    ): Promise<any>;
+
+  /**
+   * Serialize
+   */
+   serialize(form: HTMLFormElement | ChocolateChipElementArray): string;
+   
+  /**
+   * Grabs values from a form and converts them into a JSON object.
+   *
+   * @param rootNode: string | HTMLElement A form whose values you want to convert to JSON.
+   * @param delimiter string A delimiter to namespace your form values. The default is "."
+   * You use the form input's name to set up the namespace structure for your JSON, e.g. name="newUser.name.first".
+   */
+  form2JSON(rootNode: string | HTMLElement, delimiter: string): Object;
+  
+  /**
+   * Subscribe to a publication. You provide the topic you want to subscribe to, as well as a callback to execute when a publication occurs.
+   * Any data passed by the publisher is exposed to the callback as its second parameter. The callback's first parameter is the published topic.
+   *
+   * @param topic string A topic to subscribe to. This can be a single term, or any type of namespaced term with delimiters.
+   * @data any You can receive any type: string, number, array, object, etc.
+   * @return any
+   */
+  subscribe(topic: string, callback: (topic: string, data: any) => boolean): boolean;
+
+  /**
+   * Unsubscribe from a topic. Pass this the topic you wish to unsubscribe from. The subscription will be terminated immediately.
+   *
+   * @param topic string The name of the topic to unsubscribe from.
+   * @return void
+   */
+  unsubscribe(topic: string): void;
+
+  /**
+   *    Publish a topic with data for the topic's subscribers to receive.
+   *
+   * @param topic string The topic you wish to publish.
+   * @param data The data to send with the publication. This can be of any type: string, number, array, object, etc.
+   * @return void
+   */
+  publish(topic: string, data: any): string;
+
+  /**
+   * Object used to store string templates and parsed templates.
+   *
+   * @param string A string defining the template.
+   * @param string A label used to access an object's properties in the template. If none is provided it defaults to "data": [[= data.name]].
+   * @return void
+   */
+  templates: Object;
+
+  /**
+   * This method returns a parsed template.
+   *
+   */
+  template: {
 
-interface ChocolateChipTemplate {
     /**
      * This method parses a string and an optoinal variable name and returns a parsed template in the form of a function. You can then pass this function data to get rendered nodes.
      *
@@ -539,855 +515,884 @@ interface ChocolateChipTemplate {
      * @return void.
      */
     repeater: (element: ChocolateChipElementArray, template: string, data: any) => void;
+  };
+
+}
+
+
+/**
+ * Interface for ChocolateChipJS Element Collections.
+ */
+
+interface ChocolateChipElementArray extends Array<HTMLElement> {
+
+  /**
+   * Iterate over an Array object, executing a function for each matched element.
+   *
+   * @param Function
+   * @return void
+   */
+  each(func: (ctx: any, idx: number) => any): void;
+
+  /**
+   * Sorts an array and removes duplicates before returning it.
+   *
+   * @return Array
+   */
+  unique(): ChocolateChipElementArray;
+
+  /**
+   * This method returns the element at the position in the array indicated by the argument. This is a zero-based number.
+   * When dealing with document nodes, this allows you to cherry pick a node from its collection based on its
+   * position amongst its siblings.
+   *
+   * @param number Index value indicating the node you wish to access from a collection. This is zero-based.
+   * @return HTMLElement
+   */
+  eq(index: number): ChocolateChipElementArray;
+
+  /**
+   * Search for a given element from among the matched elements on a collection.
+   * This method returns the index value as an integer.
+   *
+   * @return number
+   */
+  index(): number;
+
+  /**
+   * Search for a given element from among the matched elements on a collection.
+   * This method returns the index value as an integer.
+   *
+   * @param selector A selector representing an element to look for in a collection of elements.
+   * @return number
+   */
+  index(selector: string | HTMLElement[]): number;
+
+  /**
+   * Check the current matched set of elements against a selector or element and return it
+   * if it matches the given arguments.
+   *
+   * @param selector A string containing a selector expression to match elements against.
+   * @return HTMLElement[]
+   */
+  is(selector: string): ChocolateChipElementArray;
+
+  /**
+   * Check the current matched set of elements against a selector or element and return it
+   * if it matches the given arguments.
+   *
+   * @param elements One or more elements to match the current set of elements against.
+   * @ return HTMLElement[]
+   */
+  is(element: any): ChocolateChipElementArray;
+
+
+  /**
+   * Check the current matched set of elements against a selector or element and return it
+   * if it does not match the given arguments.
+   *
+   * @param selector A string containing a selector expression to match elements against.
+   * @ return HTMLElement[]
+   */
+  isnt(selector: string): ChocolateChipElementArray;
+
+  /**
+   * Check the current matched set of elements against a selector or element and return it
+   * if it does not match the given arguments.
+   *
+   * @param elements One or more elements to match the current set of elements against.
+   * @ return HTMLElement[]
+   */
+  isnt(element: any): ChocolateChipElementArray;
+
+  /**
+   * Reduce the set of matched elements to those that have a descendant that matches the selector or DOM element.
+   *
+   * @param selector A string containing a selector expression to match elements against.
+   * @ return HTMLElement[]
+   */
+  has(selector: string): ChocolateChipElementArray;
+  /**
+   * Reduce the set of matched elements to those that have a descendant that matches the selector or DOM element.
+   *
+   * @param contained A DOM element to match elements against.
+   * @ return HTMLElement[]
+   */
+  has(contained: HTMLElement): ChocolateChipElementArray;
+
+  /**
+   * Reduce the set of matched elements to those that have a descendant that does not match the selector or DOM element.
+   *
+   * @param selector A string containing a selector expression to match elements against.
+   * @ return HTMLElement[]
+   */
+  hasnt(selector: string): ChocolateChipElementArray;
+  /**
+   * Reduce the set of matched elements to those that have a descendant that does not match the selector or DOM element.
+   *
+   * @param contained A DOM element to match elements against.
+   * @ return HTMLElement[]
+   */
+  hasnt(contained: HTMLElement): ChocolateChipElementArray;
+
+  /**
+   * Get the descendants of each element in the current set of matched elements, filtered by a selector or element.
+   *
+   * @param selector A string containing a selector expression to match elements against.
+   * @ return HTMLElement[]
+   */
+  find(selector: string): ChocolateChipElementArray;
+
+  /**
+   * Get the descendants of each element in the current set of matched elements, filtered by a selector or element.
+   *
+   * @param element An element to match elements against.
+   * @ return HTMLElement[]
+   */
+  find(element: HTMLElement): ChocolateChipElementArray;
+
+  /**
+   * Get the immediately preceding sibling of each element in the set of matched elements.
+   *
+   * @ return HTMLElement[]
+   */
+  prev(): ChocolateChipElementArray;
+
+  /**
+   * Get the immediately following sibling of each element in the set of matched elements.
+   *
+   * @ return HTMLElement[]
+   */
+  next(): ChocolateChipElementArray;
+
+  /**
+   * Reduce the set of matched elements to the first in the set.
+   */
+  first(): ChocolateChipElementArray;
+
+  /**
+   * Reduce the set of matched elements to the last in the set.
+   *
+   * @return HTMLElement[]
+   */
+  last(): ChocolateChipElementArray;
+
+  /**
+   * Get the children of each element in the set of matched elements, optionally filtered by a selector.
+   *
+   * @param selector A string containing a selector expression to match elements against.
+   * @return HTMLElement[]
+   */
+  children(selector?: string): ChocolateChipElementArray;
+
+  /**
+   * Get the parent of each element in the current set of matched elements, optionally filtered by a selector.
+   * If multiple elements have the same parent, only one instance of the parent is returned.
+   *
+   * @param selector A string containing a selector expression to match elements against.
+   * @return HTMLElement[]
+   */
+  parent(selector?: string): ChocolateChipElementArray;
+
+  /**
+   * For each element in the set, get the first element that matches the selector by testing the element
+   * itself and traversing up through its ancestors in the DOM tree, or, if a number is provided,
+   * retrieving that ancestor based on its distance from the element.
+   *
+   * @param selector A string containing a selector expression to match elements against.
+   * @return HTMLElement[]
+   */
+  ancestor(selector: string | number): ChocolateChipElementArray;
+
+  /**
+   * For each element in the set, get the first element that matches the selector by testing the element
+   * itself and traversing up through its ancestors in the DOM tree.
+   *
+   * @param selector A string containing a selector expression to match elements against.
+   * @return HTMLElement[]
+   */
+  closest(selector: string | number): ChocolateChipElementArray;
+
+
+  /**
+   * Get the siblings of each element in the set of matched elements, optionally filtered by a selector.
+   *
+   * @param selector A string containing a selector expression to match elements against.
+   * @return HTMLElement[]
+   */
+  siblings(selector?: string): ChocolateChipElementArray;
+
+  /**
+   * Get the HTML contents of the first element in the set of matched elements.
+   *
+   * @return HTMLElement[]
+   */
+  html(): ChocolateChipElementArray;
+
+  /**
+   * Set the HTML contents of each element in the set of matched elements.
+   *
+   * @param htmlString A string of HTML to set as the content of each matched element.
+   * @return HTMLElement[]
+   */
+  html(htmlString: string): ChocolateChipElementArray;
+
+
+  /**
+   * Get the value of style properties for the first element in the set of matched elements.
+   *
+   * @param propertyName A CSS property.
+   * @return string
+   */
+  css(propertyName: string): string;
+
+  /**
+   * Set one or more CSS properties for the set of matched elements using a quoted string.
+   *
+   * @param propertyName A CSS property name.
+   * @param value A value to set for the property.
+   * @return HTMLElement[]
+   */
+  css(propertyName: string, value: string): ChocolateChipElementArray;
+
+  /**
+   * Set one or more CSS properties for the set of matched elements.
+   *
+   * @param properties An object of property-value pairs to set.
+   * @return HTMLElement[]
+   */
+  css(properties: Object): ChocolateChipElementArray;
+
+  /**
+   * Get the value of an attribute for the first element in the set of matched elements.
+   *
+   * @param attributeName The name of the attribute to get.
+   * @return string
+   */
+  attr(attributeName: string): string;
+
+  /**
+   * Set an attribute for the set of matched elements.
+   *
+   * @param attributeName A string indicating the attribute to set.
+   * @param value A string indicating the value to set the attribute to.
+   * @return HTMLElement[]
+   */
+  attr(attributeName: string, value: string): ChocolateChipElementArray;
+
+  /**
+   * Remove an attribute from a node.
+   *
+   * @param attributeName A string indicating the attribute to remove.
+   * @return HTMLElement[]
+   */
+  removeAttr(attributeName: string): ChocolateChipElementArray;
+
+  /**
+   * Return any of the matched elements that have the given attribute.
+   *
+   * @param className The class name to search for.
+   * @return HTMLElement[]
+   */
+  hasAttr(attributeName: string): ChocolateChipElementArray;
+
+
+  /**
+   * Get the value of an attribute for the first element in the set of matched elements.
+   *
+   * @param attributeName The name of the attribute to get.
+   * @return string
+   */
+  prop(attributeName: string): string;
+
+  /**
+   * Set an property for the set of matched elements.
+   *
+   * @param propertyName A string indicating the property to set.
+   * @param value A string indicating the value to set the property to.
+   * @return HTMLElement[]
+   */
+  prop(propertyName: string, value: string): ChocolateChipElementArray;
+
+  /**
+   * Adds the specified class(es) to each of the set of matched elements.
+   *
+   * @param className One or more space-separated classes to be added to the class attribute of each matched element.
+   * @return HTMLElement[]
+   */
+  addClass(className: string): ChocolateChipElementArray;
+
+  /**
+   * Remove a single class or multiple classes from each element in the set of matched elements.
+   *
+   * @param className One or more space-separated classes to be removed from the class attribute of each matched element.
+   * @return HTMLElement[]
+   */
+  removeClass(className?: string): ChocolateChipElementArray;
+
+  /**
+   * Add or remove a classe from each element in the set of matched elements, depending on whether the class is present or not.
+   *
+   * @param className One or more class names (separated by spaces) to be toggled for each element in the matched set.
+   * @return HTMLElement[]
+   */
+  toggleClass(className: string, swtch?: boolean): ChocolateChipElementArray;
+
+  /**
+   * Return any of the matched elements that have the given class.
+   *
+   * @param className The class name to search for.
+   * @return HTMLElement[]
+   */
+  hasClass(className: string): ChocolateChipElementArray;
+
+  /**
+   * Store arbitrary data associated with the matched elements.
+   *
+   * @param key A string naming the piece of data to set.
+   * @param value The new data value; it can be any Javascript type including Array or Object.
+   * @return HTMLElement[]
+   */
+  data(key: string, value: any): ChocolateChipElementArray;
+
+  /**
+   * Return the value at the named data store for the first element in the element collection, as set by
+   * data(name).
+   *
+   * @param key Name of the data stored.
+   * @return any
+   */
+  data(key: string): any;
+
+  /**
+   * Remove the value at the named data store for the first element in the element collection, as set by data(name, value).
+   *
+   * @param key Name of the data stored.
+   * @return any
+   */
+  removeData(key: string): any;
+
+  /**
+   * Store string data associated with the matched elements.
+   *
+   * @param key A string naming the piece of data to set.
+   * @param value The new data value; it must be a string. You can convert JSON into a string to use with this.
+   * @return HTMLElement[]
+   */
+  dataset(key: string, value: any): ChocolateChipElementArray;
+
+  /**
+ * Retrieve a dataset key's value for the first element in the element collection.
+  *
+  * @param key A string naming the piece of data to set.
+  * @return HTMLElement[]
+  */
+  dataset(key: string): ChocolateChipElementArray;
+
+  /**
+   * Return the value at the named data store for the first element in the element collection, as set by data(name, value).
+   *
+   * @param key Name of the data stored.
+   * @return any
+   */
+  data(key: string): any;
+
+  /**
+   * Store arbitrary data associated with the matched element.
+   *
+   * @param key A string naming the piece of data to set.
+   * @param value The new data value; it can be any Javascript type including Array or Object.
+   * @return HTMLElement[]
+   */
+  data(key: string, value?: any): ChocolateChipElementArray;
+
+  /**
+   * Get the current value of the first element in the set of matched elements.
+   */
+  val(): any;
+
+  /**
+   * Set the value of each element in the set of matched elements.
+   *
+   * @param value A string of text or an array of strings corresponding to the value of each matched element
+   * to set as selected/checked.
+   * @return any
+   */
+  val(value: string): ChocolateChipElementArray;
+
+  /**
+   * Set the property of an element to enabled by removing the "disabled" attribute.
+   *
+   * @return HTMLElement[]
+   */
+  enable(): ChocolateChipElementArray;
+
+  /**
+   * Set the property of an element to "disabled".
+   *
+   * @return HTMLElement[]
+   */
+  disable(): ChocolateChipElementArray;
+
+  /**
+   * Display the matched elements.
+   *
+   * @param speed A string or number determining how long the animation will run.
+   * @param callback A function to call once the animation is complete.
+   * @return HTMLElement[]
+   */
+  show(duration?: number | string, callback?: Function): ChocolateChipElementArray;
+
+  /**
+   * Hide the matched elements.
+   *
+   * @param duration A string or number determining how long the animation will run.
+   * @param callback A function to call once the animation is complete.
+   * @return HTMLElement[]
+   */
+  hide(duration?: number | string, callback?: Function): ChocolateChipElementArray;
+
+  /**
+   * Insert content, specified by the parameter, before each element in the set of matched elements.
+   *
+   * @param content HTML string, DOM element, array of elements to insert before each element in the set of matched elements.
+   * @return HTMLElement[]
+   */
+  before(content: ChocolateChipElementArray | HTMLElement | string): ChocolateChipElementArray;
+
+  /**
+   * Insert content, specified by the parameter, after each element in the set of matched elements.
+   *
+   * @param content HTML string, DOM element, array of elements to insert after each element in the set of matched elements.
+   * @return HTMLElement[]
+   */
+  after(content: ChocolateChipElementArray | HTMLElement | string): ChocolateChipElementArray;
+
+  /**
+   * Insert content, specified by the parameter, to the end of each element in the set of matched elements.
+   *
+   * @param content DOM element, array of elements, or HTML string to insert at the end of each element in the set
+   * of matched elements.
+   * @return HTMLElement[]
+   */
+  append(content: ChocolateChipElementArray | HTMLElement | Text | string): ChocolateChipElementArray;
+
+  /**
+   * Insert content, specified by the parameter, at the beginning of each element in the set of matched elements.
+   *
+   * @param content DOM element, array of elements, or HTML string to insert at the beginning of each element in the set of matched elements.
+   * @return HTMLElement[]
+   */
+  prepend(content: ChocolateChipElementArray | HTMLElement | Text | string): ChocolateChipElementArray;
+
+  /**
+   * Insert every element in the set of matched elements to the beginning of the target.
+   *
+   * @param target A selector, element, or HTML string. The matched set of elements will be inserted at the beginning of the element specified by this parameter.
+   * @return HTMLElement[]
+   */
+  prependTo(target: any[] | HTMLElement | string): ChocolateChipElementArray;
+
+  /**
+   * Insert every element in the set of matched elements to the end of the target.
+   *
+   * @param target A selector, element, or HTML string. The matched set of elements will be inserted at the end of the element specified by this parameter.
+   * If no position value is provided it will simply append the content to the target.
+   * @return HTMLElement[]
+   */
+  appendTo(target: any[] | HTMLElement | string): ChocolateChipElementArray;
+
+  /**
+   * Insert element(s) into the target element.
+   *
+   * @return HTMLElement[]
+   */
+  insert(content: string, position?: number | string): ChocolateChipElementArray;
+
+  /**
+   * Create a copy of the set of matched elements.
+   *
+   * @param value A Boolean indicating whether to copy the element(s) with their children. A true value copies the children.
+   * @return HTMLElement[]
+   */
+  clone(value?: boolean): ChocolateChipElementArray;
+
+  /**
+   * Wrap an HTML structure around each element in the set of matched elements.
+   *
+   * @param wrappingElement A selector or HTML string specifying the structure to wrap around the matched elements.
+   * @return HTMLElement[]
+   */
+  wrap(wrappingElement: string): ChocolateChipElementArray;
+
+  /**
+   * Remove the parents of the set of matched elements from the DOM, leaving the matched elements in their place.
+   *
+   * @return HTMLElement[]
+   */
+  unwrap(): ChocolateChipElementArray;
+
+  /**
+   * Remove the set of matched elements from the DOM. If there are any attached events, this will remove them to prevent memory leaks.
+   *
+   * @param selector A selector expression that filters the set of matched elements to be removed.
+   * @return HTMLElement[]
+   */
+  remove(selector?: string): ChocolateChipElementArray;
+
+  /**
+   * Remove all child nodes of the set of matched elements from the DOM.
+   *
+   * @return HTMLElement[]
+   */
+  empty(): ChocolateChipElementArray;
+
+  /**
+   * Get an object of the current coordinates of the first element in the set of matched elements, relative to the document.
+   * These are: top, left, bottom and right. The values are numbers representing pixel values.
+   * @return Object
+   */
+  offset(): {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+  };
+
+  /**
+   * Get the current computed width for the first element in the set of matched elements,
+   * including padding but excluding borders.
+   *
+   * @return number
+   */
+  width(): number;
+
+  /**
+   * Get the current computed height for the first element in the set of matched elements,
+   * including padding but excluding borders.
+   *
+   * @return number
+   */
+  height(): number;
+
+  /**
+   * Get the combined text contents of each element in the set of matched elements, including their descendants.
+   *
+   * @return string
+   */
+  text(): string;
+
+  /**
+   * Set the content of each element in the set of matched elements to the specified text.
+   *
+   * @param text The text to set as the content of each matched element. When Number is supplied, it will be converted to a String representation. To delete text, use ChocolateChipElementArray.empty() or ChocolateChipElementArray.remove().
+   * @return HTMLElement
+   */
+  text(text: string | number): HTMLElement;
+
+  /**
+   * A method to animate DOM nodes using CSS. This uses CSS transitions.
+   *
+   * @param options And object of key value pairs define the CSS properties and values to animate.
+   * @param duration A string representing the time. Should have a time identifier: "200s", "200ms", etc.
+   * @param easing A string indicating the easing for the animation, such as "ease-out", "ease-in", "ease-in-out".
+   * @return void
+   */
+  animate(options: Object, duration?: string, easing?: string): void;
+
+
+  /**
+   * Attach a handler to an event for the elements.
+   *
+   * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
+   * @param handler A function to execute each time the event is triggered.
+   * @param useCapture Setting the third argument to true will trigger event bubbling. The default is false.
+   * @return ChocolateChipStatic
+   */
+  bind(eventType: string, handler: (eventObject: Event) => any, useCapture?: boolean): ChocolateChipStatic;
+
+  /**
+   * Remove a handler for an event from the elements.
+   *
+   * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
+   * @param handler A function to execute each time the event is triggered.
+   * @param useCapture Setting the third argument to true will trigger event bubbling. The default is false.
+   * @return ChocolateChipStatic
+   */
+  unbind(eventType: string, handler: (eventObject: Event) => any, useCapture?: boolean): ChocolateChipStatic;
+
+  /**
+   * Add a delegated event to listen for the provided event on the descendant elements.
+   *
+   * @param selector A string defining the descendant elements to listen on for the designated event.
+   * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
+   * @param handler A function to execute each time the event is triggered. The keyword "this" will refer
+   * to the element receiving the event.
+   * @param useCapture Setting the third argument to true will trigger event bubbling. The default is false.
+   * @return ChocolateChipStatic
+   */
+  delegate(selector: any, eventType: string, handler: (eventObject: Event) => any, useCapture?: boolean): ChocolateChipStatic;
+
+  /**
+   * Add a delegated event to listen for the provided event on the descendant elements.
+   *
+   * @param selector A string defining the descendant elements are listening for the event.
+   * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
+   * @param handler A function handler assigned to this event.
+   * @param useCapture Setting the third argument to true will trigger event bubbling. The default is false.
+   * @return ChocolateChipStatic
+   */
+  undelegate(selector: any, eventType: string, handler: (eventObject: Event) => any, useCapture?: boolean): ChocolateChipStatic;
+
+  /**
+   * Add a handler to an event for elements. If a selector is provided as the second argument, this implements a delegated event.
+   *
+   * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
+   * @param selector A string defining the descendant elements are listening for the event.
+   * @param handler A function handler assigned to this event.
+   * @param useCapture Setting the third argument to true will trigger event bubbling. The default is false.
+   * @return ChocolateChipStatic
+   */
+  on(eventType: string, selector: any, handler?: (eventObject: Event) => any, capturePhase?: boolean): ChocolateChipStatic;
+
+  /**
+   * Remove a handler for an event from the elements. If the second argument is a selector, it tries to undelegate the event.
+   * If no arugments are provided, it removes all events from the element(s).
+   *
+   * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
+   * @param selector A string defining the descendant elements are listening for the event.
+   * @param handler A function handler assigned to this event.
+   * @param useCapture Setting the third argument to true will trigger event bubbling. The default is false.
+   * @return ChocolateChipStatic
+   */
+  off(eventType?: string, selector?: any, handler?: (eventObject: Event) => any, capturePhase?: boolean): ChocolateChipStatic;
+
+  /**
+  *
+  */
+  trigger(eventType: string): void;
 }
 
 /**
  * Represents the completion of an asynchronous operation
  */
 interface Promise<T> {
-    /**
-     * Attaches callbacks for the resolution and/or rejection of the Promise.
-     *
-     * @param onfulfilled The callback to execute when the Promise is resolved.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @return Promise A Promise for the completion of which ever callback is executed.
-     * @return Promise A new Promise
-     */
-    then<TResult>(onfulfilled?: (value: T) => TResult | Promise<TResult>, onrejected?: (reason: any) => TResult | Promise<TResult>): Promise<TResult>;
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   *
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @return Promise A Promise for the completion of which ever callback is executed.
+   * @return Promise A new Promise
+   */
+  then<TResult>(onfulfilled?: (value: T) => TResult | Promise<TResult>, onrejected?: (reason: any) => TResult | Promise<TResult>): Promise<TResult>;
 
-    /**
-     * Attaches a callback for only the rejection of the Promise.
-     *
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @return Promise A Promise for the completion of the callback.
-     * @return Promise A new Promise
-     */
-    catch(onrejected?: (reason: any) => T | Promise<T>): Promise<T>;
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   *
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @return Promise A Promise for the completion of the callback.
+   * @return Promise A new Promise
+   */
+  catch(onrejected?: (reason: any) => T | Promise<T>): Promise<T>;
 }
 
 interface PromiseConstructor {
-    /**
-     * A reference to the prototype.
-     */
-    prototype: Promise<any>;
+  /**
+   * A reference to the prototype.
+   */
+  prototype: Promise<any>;
 
-    /**
-     * Creates a new Promise.
-     *
-     * @param init 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.
-     * @return Promise A new Proimise
-     */
-    new <T>(init: (resolve: (value?: T | Promise<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
+  /**
+   * Creates a new Promise.
+   *
+   * @param init 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.
+   * @return Promise A new Proimise
+   */
+  new <T>(init: (resolve: (value?: T | Promise<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
 
-    <T>(init: (resolve: (value?: T | Promise<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
+  <T>(init: (resolve: (value?: T | Promise<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 resolve, or rejected when any Promise is rejected.
-     *
-     * @param values An array of Promises.
-     * @return Promise A new Promise.
-     */
-    all<T>(values: (T | Promise<T>)[]): Promise<T[]>;
+  /**
+   * 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.
+   * @return Promise A new Promise.
+   */
+  all<T>(values: (T | Promise<T>)[]): Promise<T[]>;
 
-    /**
-     * 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 values.
-     * @returns A new Promise.
-     */
-    all(values: Promise<void>[]): Promise<void>;
+  /**
+   * 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 values.
+   * @returns A new Promise.
+   */
+  all(values: Promise<void>[]): Promise<void>;
 
-    /**
-     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved or rejected.
-     *
-     * @param values An array of Promises.
-     * @return Promise A new Promise.
-     */
-    race<T>(values: (T | Promise<T>)[]): Promise<T>;
+  /**
+   * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved or rejected.
+   *
+   * @param values An array of Promises.
+   * @return Promise A new Promise.
+   */
+  race<T>(values: (T | Promise<T>)[]): Promise<T>;
 
-    /**
-     * Creates a new rejected promise for the provided reason.
-     *
-     * @param reason The reason the promise was rejected.
-     * @return Promise A new rejected Promise.
-     */
-    reject(reason: any): Promise<void>;
+  /**
+   * Creates a new rejected promise for the provided reason.
+   *
+   * @param reason The reason the promise was rejected.
+   * @return Promise A new rejected Promise.
+   */
+  reject(reason: any): Promise<void>;
 
-    /**
-     * Creates a new rejected promise for the provided reason.
-     *
-     * @param reason The reason the promise was rejected.
-     * @return void A Promise is rejected.
-     */
-    reject<T>(reason: any): Promise<T>;
+  /**
+   * Creates a new rejected promise for the provided reason.
+   *
+   * @param reason The reason the promise was rejected.
+   * @return void A Promise is rejected.
+   */
+  reject<T>(reason: any): Promise<T>;
 
-    /**
-     * Creates a new resolved promise for the provided value.
-     *
-     * @param value A promise.
-     * @return Promise A promise whose internal state matches the provided promise.
-     */
-    resolve<T>(value: T | Promise<T>): Promise<T>;
+  /**
+   * Creates a new resolved promise for the provided value.
+   *
+   * @param value A promise.
+   * @return Promise A promise whose internal state matches the provided promise.
+   */
+  resolve<T>(value: T | Promise<T>): Promise<T>;
 
-    /**
-     * Creates a new resolved promise.
-     *
-     * @return Promise A resolved promise.
-     */
-    resolve(): Promise<void>;
+  /**
+   * Creates a new resolved promise.
+   *
+   * @return Promise A resolved promise.
+   */
+  resolve(): Promise<void>;
 }
 
 declare var Promise: PromiseConstructor;
 
 
+declare type ByteString = string;
+declare type USVString = string;
+declare type DOMString = string;
+declare type OpenEndedDictionary = Object;
 /**
- * Interface for the Ajax setting that will configure the Ajax request.
+ * Interface for fetch API.
+ *
+ * @param input A string representing a valid url.
+ * @param init An object literal of key value pairs to set method, headers, body, credentials or cache.
+ * @return Promise.
  */
-interface ChocolateChipAjaxSettings {
-    /**
-     * A string containing the URL to which the request is sent.
-     */
-    url?: string;
 
-    /**
-     * A username to be used with XMLHttpRequest in response to an HTTP access authentication request.
-     */
-    user?: string;
-
-    /**
-     * A password to be used with XMLHttpRequest in response to an HTTP access authentication request.
-     */
-    password?: string;
-
-    /**
-     * The type of data that you're expecting back from the server. If none is specified, ChocolateChipJS will
-     * infer it based on the MIME type of the response.
-     */
-    dataType?: string;
-
-    /**
-     * The type of request to make ("POST" or "GET"), default is "GET". Note: Other HTTP request methods,
-     * such as PUT and DELETE, can also be used here, but they are not supported by all browsers.
-     */
-    type?: string;
-
-    /**
-     * A property that does not seem to be officially documented, but is used in the documentation.
-     * Its functionality seems to be identical to that of 'type' which *is* documented.
-     */
+interface fetch {
+  (input: string, 
+    init?: {
     method?: string;
+    headers?: {};
+    body?: any;
+    mode?:  {
+      cors: string;
+      "no-cors": string;
+      "same-origin": string;
+    };
+    credentials?: {
+      omit: string;
+      "same-origin": string;
+      include: string;
+    };
+    cache?: {
+      default: string;
+      "no-store": string;
+      reload: string;
+      "no-cache": string;
+      "force-cache": string;
+      "only-if-cached": string;
+    }
+  }): Promise<any>;
+}
 
-    /**
-     * A pre-request callback function that can be used to modify the XMLHTTPRequest object before it is sent.
-     * Use this to set custom headers, etc. This is an Ajax Event. Returning false in the beforeSend function will cancel the request.
-     * @return void
-     */
-    beforeSend?: (xhr: XMLHttpRequest, settings: ChocolateChipAjaxSettings) => void;
+interface XMLHttpRequest {
+   responseURL: string;
+}
 
-    /**
-     * A function to be called if the request succeeds. The function gets passed three arguments: The data returned from the server,
-     * formatted according to the dataType parameter; a string describing the status; and the XMLHttpRequest object. This is an Ajax Event.
-     * @return void
-     */
-    success?: (data: any) => void;
+interface Headers {
+   (headers?: any): void;
+   append(name: string, value: string): void;
+   delete(name: string): any;
+   get(name: string): any;
+   getAll(name: string): any;
+   has(name: string): any;
+   set(name: string, value: string): any;
+   forEach(callback: Function, thisArg: any): any;
+}
 
-    /**
-     * A function to be called if the request fails. The function receives three arguments: The XMLHttpRequest object, a string describing
-     * the type of error that occurred and an optional exception object, if one occurred. Possible values for the second argument (besides null)
-     * are "timeout", "error", "abort", and "parsererror". When an HTTP error occurs, errorThrown receives the textual portion of the HTTP status,
-     * such as "Not Found" or "Internal Server Error." This is an Ajax Event.
-     */
-    error?: (error: Error) => void;
+interface decode {
+  (body: any): FormData;
+}
 
-    /**
-     * This object will be made the context of all Ajax-related callbacks. By default, the context is null.
-     */
-    context?: any;
+interface Request {
+  (input: {
+    url: string;
+    request: Request;
+  }, init: Object): Request;
+  clone(): Request;
+  arrayBuffer(): ArrayBuffer;
+  blob(): Blob;
+  formData(): FormData;
+  json(): JSON;
+  text(): string;
 
-    /**
-     * By default, all requests are sent asynchronously (i.e. this is set to true by default). If you need synchronous requests, set this option to false.
-     * Cross-domain requests and dataType: "jsonp" requests do not support synchronous operation. Note that synchronous requests may temporarily lock the
-     * browser, disabling any actions while the request is active.
-     */
-    async?: boolean;
+  method: string;
+  url: string;
+  heaers: Headers;
+  context: any;
+  referrer: any;
+  mode: string;
+  credentials: any;
+  cache: string;
+  bodyUsed: boolean;
+}
 
-    /**
-     * Set a timeout (in milliseconds) for the request. The timeout period starts at the point the $.ajax call is made; if several other requests are in progress
-     * and the browser has no connections available, it is possible for a request to time out before it can be sent.
-     */
+interface URLSearchParams {
+  ():URLSearchParams;
+}
+
+interface Response {
+  (body?: {
+    blob: Blob;
+    bormData: FormData;
+    urlParams: URLSearchParams;
+    url: string;
+   },
+   init?: {
+    status?: string | number;
+    statusText?: string;
+    headers: Headers;
+  }): Response;
+  clone(): Response;
+  redirect(): Response;
+  arrayBuffer(): ArrayBuffer;
+  blob(): Blob;
+  formData(): FormData;
+  json(): JSON;
+  text(): string;
+
+  type: string;
+  url: string;
+  useFinalURL: boolean;
+  ok: boolean;
+  statusText: string;
+  headers: Headers;
+  bodyUsed: boolean;
+}
+interface ChocolateChipStatic {
+  jsonp(url: string, options?: {
     timeout?: number;
-
-    /**
-     * An object of additional header key/value pairs to send along with requests using the XMLHttpRequest transport. The header X-Requested-With: XMLHttpRequest is always added,
-     * but its default XMLHttpRequest value can be changed here. Values in the headers setting can also be overwritten from within the beforeSend function.
-     */
-    headers?: Object;
-
-    /**
-     * Data to be sent to the server. It is converted to a query string, if not already a string. It's appended to the url for GET-requests. Object must be Key/Value pairs.
-     */
-    data?: any;
+    callbackName?: string;
+    clear?: boolean;
+  }): any 
 }
 
-interface ChocolateChipXHR {
-    ajax: (settings: ChocolateChipAjaxSettings) => PromiseConstructor;
-}
 
-interface ChocolateChipJSONP {
-        url: string; 
-        success?: (data: any) => Promise<any>; 
-        callbackType?: string; 
-        timeout?: number; 
-}
-
-interface ChocolateChipElementArray extends Array<HTMLElement> {
-    /**
-     * Iterate over an Array object, executing a function for each matched element.
-     *
-     * @param Function
-     * @return void
-     */
-    each(func: (ctx: any, idx: number) => any): void;
-
-    /**
-     * Sorts an array and removes duplicates before returning it.
-     *
-     * @return Array
-     */
-    unique<T, TSort>(): T[];
-
-    /**
-     * This method returns the element at the position in the array indicated by the argument. This is a zero-based number.
-     * When dealing with document nodes, this allows you to cherry pick a node from its collection based on its
-     * position amongst its siblings.
-     *
-     * @param number Index value indicating the node you wish to access from a collection. This is zero-based.
-     * @return HTMLElement
-     */
-    eq(index: number): ChocolateChipElementArray;
-
-    /**
-     * Search for a given element from among the matched elements on a collection.
-     * This method returns the index value as an integer.
-     *
-     * @return number
-     */
-    index(): number;
-
-    /**
-     * Search for a given element from among the matched elements on a collection.
-     * This method returns the index value as an integer.
-     *
-     * @param selector A selector representing an element to look for in a collection of elements.
-     * @return number
-     */
-    index(selector: string | HTMLElement[]): number;
-
-    /**
-     * Check the current matched set of elements against a selector or element and return it
-     * if it matches the given arguments.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @return HTMLElement[]
-     */
-    is(selector: string): ChocolateChipElementArray;
-
-    /**
-     * Check the current matched set of elements against a selector or element and return it
-     * if it matches the given arguments.
-     *
-     * @param elements One or more elements to match the current set of elements against.
-     * @ return HTMLElement[]
-     */
-    is(element: any): ChocolateChipElementArray;
-
-
-    /**
-     * Check the current matched set of elements against a selector or element and return it
-     * if it does not match the given arguments.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @ return HTMLElement[]
-     */
-    isnt(selector: string): ChocolateChipElementArray;
-
-    /**
-     * Check the current matched set of elements against a selector or element and return it
-     * if it does not match the given arguments.
-     *
-     * @param elements One or more elements to match the current set of elements against.
-     * @ return HTMLElement[]
-     */
-    isnt(element: any): ChocolateChipElementArray;
-
-    /**
-     * Reduce the set of matched elements to those that have a descendant that matches the selector or DOM element.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @ return HTMLElement[]
-     */
-    has(selector: string): ChocolateChipElementArray;
-    /**
-     * Reduce the set of matched elements to those that have a descendant that matches the selector or DOM element.
-     *
-     * @param contained A DOM element to match elements against.
-     * @ return HTMLElement[]
-     */
-    has(contained: HTMLElement): ChocolateChipElementArray;
-
-    /**
-     * Reduce the set of matched elements to those that have a descendant that does not match the selector or DOM element.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @ return HTMLElement[]
-     */
-    hasnt(selector: string): ChocolateChipElementArray;
-    /**
-     * Reduce the set of matched elements to those that have a descendant that does not match the selector or DOM element.
-     *
-     * @param contained A DOM element to match elements against.
-     * @ return HTMLElement[]
-     */
-    hasnt(contained: HTMLElement): ChocolateChipElementArray;
-
-    /**
-     * Get the descendants of each element in the current set of matched elements, filtered by a selector or element.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @ return HTMLElement[]
-     */
-    find(selector: string): ChocolateChipElementArray;
-
-    /**
-     * Get the descendants of each element in the current set of matched elements, filtered by a selector or element.
-     *
-     * @param element An element to match elements against.
-     * @ return HTMLElement[]
-     */
-    find(element: HTMLElement): ChocolateChipElementArray;
-
-    /**
-     * Get the immediately preceding sibling of each element in the set of matched elements.
-     *
-     * @ return HTMLElement[]
-     */
-    prev(): ChocolateChipElementArray;
-
-    /**
-     * Get the immediately following sibling of each element in the set of matched elements.
-     *
-     * @ return HTMLElement[]
-     */
-    next(): ChocolateChipElementArray;
-
-    /**
-     * Reduce the set of matched elements to the first in the set.
-     */
-    first(): ChocolateChipElementArray;
-
-    /**
-     * Reduce the set of matched elements to the last in the set.
-     *
-     * @return HTMLElement[]
-     */
-    last(): ChocolateChipElementArray;
-
-    /**
-     * Get the children of each element in the set of matched elements, optionally filtered by a selector.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @return HTMLElement[]
-     */
-    children(selector?: string): ChocolateChipElementArray;
-
-    /**
-     * Get the parent of each element in the current set of matched elements, optionally filtered by a selector.
-     * If multiple elements have the same parent, only one instance of the parent is returned.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @return HTMLElement[]
-     */
-    parent(selector?: string): ChocolateChipElementArray;
-
-    /**
-     * For each element in the set, get the first element that matches the selector by testing the element
-     * itself and traversing up through its ancestors in the DOM tree, or, if a number is provided,
-     * retrieving that ancestor based on its distance from the element.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @return HTMLElement[]
-     */
-    ancestor(selector: string | number): ChocolateChipElementArray;
-
-    /**
-     * For each element in the set, get the first element that matches the selector by testing the element
-     * itself and traversing up through its ancestors in the DOM tree.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @return HTMLElement[]
-     */
-    closest(selector: string | number): ChocolateChipElementArray;
-
-
-    /**
-     * Get the siblings of each element in the set of matched elements, optionally filtered by a selector.
-     *
-     * @param selector A string containing a selector expression to match elements against.
-     * @return HTMLElement[]
-     */
-    siblings(selector?: string): ChocolateChipElementArray;
-
-    /**
-     * Get the HTML contents of the first element in the set of matched elements.
-     *
-     * @return HTMLElement[]
-     */
-    html(): ChocolateChipElementArray;
-
-    /**
-     * Set the HTML contents of each element in the set of matched elements.
-     *
-     * @param htmlString A string of HTML to set as the content of each matched element.
-     * @return HTMLElement[]
-     */
-    html(htmlString: string): ChocolateChipElementArray;
-
-
-    /**
-     * Get the value of style properties for the first element in the set of matched elements.
-     *
-     * @param propertyName A CSS property.
-     * @return string
-     */
-    css(propertyName: string): string;
-
-    /**
-     * Set one or more CSS properties for the set of matched elements using a quoted string.
-     *
-     * @param propertyName A CSS property name.
-     * @param value A value to set for the property.
-     * @return HTMLElement[]
-     */
-    css(propertyName: string, value: string): ChocolateChipElementArray;
-
-    /**
-     * Set one or more CSS properties for the set of matched elements.
-     *
-     * @param properties An object of property-value pairs to set.
-     * @return HTMLElement[]
-     */
-    css(properties: Object): ChocolateChipElementArray;
-
-    /**
-     * Get the value of an attribute for the first element in the set of matched elements.
-     *
-     * @param attributeName The name of the attribute to get.
-     * @return string
-     */
-    attr(attributeName: string): string;
-
-    /**
-     * Set an attribute for the set of matched elements.
-     *
-     * @param attributeName A string indicating the attribute to set.
-     * @param value A string indicating the value to set the attribute to.
-     * @return HTMLElement[]
-     */
-    attr(attributeName: string, value: string): ChocolateChipElementArray;
-
-    /**
-     * Remove an attribute from a node.
-     *
-     * @param attributeName A string indicating the attribute to remove.
-     * @return HTMLElement[]
-     */
-    removeAttr(attributeName: string): ChocolateChipElementArray;
-
-    /**
-     * Return any of the matched elements that have the given attribute.
-     *
-     * @param className The class name to search for.
-     * @return HTMLElement[]
-     */
-    hasAttr(attributeName: string): ChocolateChipElementArray;
-
-
-    /**
-     * Get the value of an attribute for the first element in the set of matched elements.
-     *
-     * @param attributeName The name of the attribute to get.
-     * @return string
-     */
-    prop(attributeName: string): string;
-
-    /**
-     * Set an property for the set of matched elements.
-     *
-     * @param propertyName A string indicating the property to set.
-     * @param value A string indicating the value to set the property to.
-     * @return HTMLElement[]
-     */
-    prop(propertyName: string, value: string): ChocolateChipElementArray;
-
-    /**
-     * Adds the specified class(es) to each of the set of matched elements.
-     *
-     * @param className One or more space-separated classes to be added to the class attribute of each matched element.
-     * @return HTMLElement[]
-     */
-    addClass(className: string): ChocolateChipElementArray;
-
-    /**
-     * Remove a single class or multiple classes from each element in the set of matched elements.
-     *
-     * @param className One or more space-separated classes to be removed from the class attribute of each matched element.
-     * @return HTMLElement[]
-     */
-    removeClass(className?: string): ChocolateChipElementArray;
-
-    /**
-     * Add or remove a classe from each element in the set of matched elements, depending on whether the class is present or not.
-     *
-     * @param className One or more class names (separated by spaces) to be toggled for each element in the matched set.
-     * @return HTMLElement[]
-     */
-    toggleClass(className: string, swtch?: boolean): ChocolateChipElementArray;
-
-    /**
-     * Return any of the matched elements that have the given class.
-     *
-     * @param className The class name to search for.
-     * @return HTMLElement[]
-     */
-    hasClass(className: string): ChocolateChipElementArray;
-
-    /**
-     * Store arbitrary data associated with the matched elements.
-     *
-     * @param key A string naming the piece of data to set.
-     * @param value The new data value; it can be any Javascript type including Array or Object.
-     * @return HTMLElement[]
-     */
-    data(key: string, value: any): ChocolateChipElementArray;
-
-    /**
-     * Return the value at the named data store for the first element in the element collection, as set by
-     * data(name).
-     *
-     * @param key Name of the data stored.
-     * @return any
-     */
-    data(key: string): any;
-
-    /**
-     * Remove the value at the named data store for the first element in the element collection, as set by data(name, value).
-     *
-     * @param key Name of the data stored.
-     * @return any
-     */
-    removeData(key: string): any;
-
-    /**
-     * Store string data associated with the matched elements.
-     *
-     * @param key A string naming the piece of data to set.
-     * @param value The new data value; it must be a string. You can convert JSON into a string to use with this.
-     * @return HTMLElement[]
-     */
-    dataset(key: string, value: any): ChocolateChipElementArray;
-
-     /**
-    * Retrieve a dataset key's value for the first element in the element collection.
-     *
-     * @param key A string naming the piece of data to set.
-     * @return HTMLElement[]
-     */
-    dataset(key: string): ChocolateChipElementArray;
-
-    /**
-     * Return the value at the named data store for the first element in the element collection, as set by data(name, value).
-     *
-     * @param key Name of the data stored.
-     * @return any
-     */
-    data(key: string): any;
-
-    /**
-     * Store arbitrary data associated with the matched element.
-     *
-     * @param key A string naming the piece of data to set.
-     * @param value The new data value; it can be any Javascript type including Array or Object.
-     * @return HTMLElement[]
-     */
-    data(key: string, value?: any): ChocolateChipElementArray;
-
-    /**
-     * Get the current value of the first element in the set of matched elements.
-     */
-    val(): any;
-
-    /**
-     * Set the value of each element in the set of matched elements.
-     *
-     * @param value A string of text or an array of strings corresponding to the value of each matched element
-     * to set as selected/checked.
-     * @return any
-     */
-    val(value: string): ChocolateChipElementArray;
-
-    /**
-     * Set the property of an element to enabled by removing the "disabled" attribute.
-     *
-     * @return HTMLElement[]
-     */
-    enable(): ChocolateChipElementArray;
-
-    /**
-     * Set the property of an element to "disabled".
-     *
-     * @return HTMLElement[]
-     */
-    disable(): ChocolateChipElementArray;
-
-    /**
-     * Display the matched elements.
-     *
-     * @param speed A string or number determining how long the animation will run.
-     * @param callback A function to call once the animation is complete.
-     * @return HTMLElement[]
-     */
-    show(duration?: number | string, callback?: Function): ChocolateChipElementArray;
-
-    /**
-     * Hide the matched elements.
-     *
-     * @param duration A string or number determining how long the animation will run.
-     * @param callback A function to call once the animation is complete.
-     * @return HTMLElement[]
-     */
-    hide(duration?: number | string, callback?: Function): ChocolateChipElementArray;
-
-    /**
-     * Insert content, specified by the parameter, before each element in the set of matched elements.
-     *
-     * @param content HTML string, DOM element, array of elements to insert before each element in the set of matched elements.
-     * @return HTMLElement[]
-     */
-    before(content: ChocolateChipElementArray | HTMLElement | string): ChocolateChipElementArray;
-
-    /**
-     * Insert content, specified by the parameter, after each element in the set of matched elements.
-     *
-     * @param content HTML string, DOM element, array of elements to insert after each element in the set of matched elements.
-     * @return HTMLElement[]
-     */
-    after(content: ChocolateChipElementArray | HTMLElement | string): ChocolateChipElementArray;
-
-    /**
-     * Insert content, specified by the parameter, to the end of each element in the set of matched elements.
-     *
-     * @param content DOM element, array of elements, or HTML string to insert at the end of each element in the set
-     * of matched elements.
-     * @return HTMLElement[]
-     */
-    append(content: ChocolateChipElementArray|HTMLElement|Text|string): ChocolateChipElementArray;
-
-    /**
-     * Insert content, specified by the parameter, at the beginning of each element in the set of matched elements.
-     *
-     * @param content DOM element, array of elements, or HTML string to insert at the beginning of each element in the set of matched elements.
-     * @return HTMLElement[]
-     */
-    prepend(content: ChocolateChipElementArray|HTMLElement|Text|string): ChocolateChipElementArray;
-
-    /**
-     * Insert every element in the set of matched elements to the beginning of the target.
-     *
-     * @param target A selector, element, or HTML string. The matched set of elements will be inserted at the beginning of the element specified by this parameter.
-     * @return HTMLElement[]
-     */
-    prependTo(target: any[]|HTMLElement|string): ChocolateChipElementArray;
-
-    /**
-     * Insert every element in the set of matched elements to the end of the target.
-     *
-     * @param target A selector, element, or HTML string. The matched set of elements will be inserted at the end of the element specified by this parameter.
-     * If no position value is provided it will simply append the content to the target.
-     * @return HTMLElement[]
-     */
-    appendTo(target: any[]|HTMLElement|string): ChocolateChipElementArray;
-
-    /**
-     * Insert element(s) into the target element.
-     *
-     * @return HTMLElement[]
-     */
-    insert(content: string, position?: number | string): ChocolateChipElementArray;
-
-    /**
-     * Create a copy of the set of matched elements.
-     *
-     * @param value A Boolean indicating whether to copy the element(s) with their children. A true value copies the children.
-     * @return HTMLElement[]
-     */
-    clone(value?: boolean): ChocolateChipElementArray;
-
-    /**
-     * Wrap an HTML structure around each element in the set of matched elements.
-     *
-     * @param wrappingElement A selector or HTML string specifying the structure to wrap around the matched elements.
-     * @return HTMLElement[]
-     */
-    wrap(wrappingElement: string): ChocolateChipElementArray;
-
-    /**
-     * Remove the parents of the set of matched elements from the DOM, leaving the matched elements in their place.
-     *
-     * @return HTMLElement[]
-     */
-    unwrap(): ChocolateChipElementArray;
-
-    /**
-     * Remove the set of matched elements from the DOM. If there are any attached events, this will remove them to prevent memory leaks.
-     *
-     * @param selector A selector expression that filters the set of matched elements to be removed.
-     * @return HTMLElement[]
-     */
-    remove(selector?: string): ChocolateChipElementArray;
-
-    /**
-     * Remove all child nodes of the set of matched elements from the DOM.
-     *
-     * @return HTMLElement[]
-     */
-    empty(): ChocolateChipElementArray;
-
-    /**
-     * Get an object of the current coordinates of the first element in the set of matched elements, relative to the document.
-     * These are: top, left, bottom and right. The values are numbers representing pixel values.
-     * @return Object
-     */
-    offset(): ChocolateChipOffsetObject;
-
-    /**
-     * Get the current computed width for the first element in the set of matched elements,
-     * including padding but excluding borders.
-     *
-     * @return number
-     */
-    width(): number;
-
-    /**
-     * Get the current computed height for the first element in the set of matched elements,
-     * including padding but excluding borders.
-     *
-     * @return number
-     */
-    height(): number;
-
-    /**
-     * Get the combined text contents of each element in the set of matched elements, including their descendants.
-     *
-     * @return string
-     */
-    text(): string;
-
-    /**
-     * Set the content of each element in the set of matched elements to the specified text.
-     *
-     * @param text The text to set as the content of each matched element. When Number is supplied, it will be converted to a String representation. To delete text, use ChocolateChipElementArray.empty() or ChocolateChipElementArray.remove().
-     * @return HTMLElement
-     */
-    text(text: string | number): HTMLElement;
-
-    /**
-     * Attach a handler to an event for the elements.
-     *
-     * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
-     * @param handler A function to execute each time the event is triggered.
-     * @param useCapture Setting the third argument to true will trigger event bubbling. The default is false.
-     * @return ChocolateChipStatic
-     */
-    bind(eventType: string, handler: (eventObject: Event) => any, useCapture?: boolean): ChocolateChipStatic;
-
-    /**
-     * Remove a handler for an event from the elements.
-     *
-     * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
-     * @param handler A function to execute each time the event is triggered.
-     * @param useCapture Setting the third argument to true will trigger event bubbling. The default is false.
-     * @return ChocolateChipStatic
-     */
-    unbind(eventType: string, handler: (eventObject: Event) => any, useCapture?: boolean): ChocolateChipStatic;
-
-    /**
-     * Add a delegated event to listen for the provided event on the descendant elements.
-     *
-     * @param selector A string defining the descendant elements to listen on for the designated event.
-     * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
-     * @param handler A function to execute each time the event is triggered. The keyword "this" will refer
-     * to the element receiving the event.
-     * @param useCapture Setting the third argument to true will trigger event bubbling. The default is false.
-     * @return ChocolateChipStatic
-     */
-    delegate(selector: any, eventType: string, handler: (eventObject: Event) => any, useCapture?: boolean): ChocolateChipStatic;
-
-    /**
-     * Add a delegated event to listen for the provided event on the descendant elements.
-     *
-     * @param selector A string defining the descendant elements are listening for the event.
-     * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
-     * @param handler A function handler assigned to this event.
-     * @param useCapture Setting the third argument to true will trigger event bubbling. The default is false.
-     * @return ChocolateChipStatic
-     */
-    undelegate(selector: any, eventType: string, handler: (eventObject: Event) => any, useCapture?: boolean): ChocolateChipStatic;
-
-    /**
-     * Add a handler to an event for elements. If a selector is provided as the second argument, this implements a delegated event.
-     *
-     * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
-     * @param selector A string defining the descendant elements are listening for the event.
-     * @param handler A function handler assigned to this event.
-     * @param useCapture Setting the third argument to true will trigger event bubbling. The default is false.
-     * @return ChocolateChipStatic
-     */
-    on( eventType: string, selector: any, handler?: (eventObject: Event) => any, capturePhase?: boolean): ChocolateChipStatic;
-
-    /**
-     * Remove a handler for an event from the elements. If the second argument is a selector, it tries to undelegate the event.
-     * If no arugments are provided, it removes all events from the element(s).
-     *
-     * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names.
-     * @param selector A string defining the descendant elements are listening for the event.
-     * @param handler A function handler assigned to this event.
-     * @param useCapture Setting the third argument to true will trigger event bubbling. The default is false.
-     * @return ChocolateChipStatic
-     */
-    off( eventType?: string, selector?: any, handler?: (eventObject: Event) => any, capturePhase?: boolean): ChocolateChipStatic;
-
-    /**
-    *
-    */
-    trigger(eventType: string): void;
-
-    /**
-     * A method to animate DOM nodes using CSS. This uses CSS transitions.
-     *
-     * @param options And object of key value pairs define the CSS properties and values to animate.
-     * @param duration A string representing the time. Should have a time identifier: "200s", "200ms", etc.
-     * @param easing A string indicating the easing for the animation, such as "ease-out", "ease-in", "ease-in-out".
-     * @return void
-     */
-     animate(options: Object, duration?: string, easing?: string ): void;
-}
-
-/**
- * Interface for offset object.
- */
-interface ChocolateChipOffsetObject {
-    top: number;
-    left: number;
-    bottom: number;
-    right: number;
-}
+declare var $: ChocolateChipStatic;
+declare var fetch: fetch;
diff --git a/codemirror/codemirror.d.ts b/codemirror/codemirror.d.ts
index 71113ee82..86c01141e 100644
--- a/codemirror/codemirror.d.ts
+++ b/codemirror/codemirror.d.ts
@@ -326,15 +326,15 @@ declare module CodeMirror {
         /** Fires every time the content of the editor is changed. */
         on(eventName: 'change', handler: (instance: CodeMirror.Editor, change: CodeMirror.EditorChangeLinkedList) => void ): void;
         off(eventName: 'change', handler: (instance: CodeMirror.Editor, change: CodeMirror.EditorChangeLinkedList) => void ): void;
-
-        /** Like the "change" event, but batched per operation, passing an
-         * array containing all the changes that happened in the operation.
-         * This event is fired after the operation finished, and display
-         * changes it makes will trigger a new operation. */
+
+        /** Like the "change" event, but batched per operation, passing an
+         * array containing all the changes that happened in the operation.
+         * This event is fired after the operation finished, and display
+         * changes it makes will trigger a new operation. */
         on(eventName: 'changes', handler: (instance: CodeMirror.Editor, change: CodeMirror.EditorChangeLinkedList[]) => void ): void;
         off(eventName: 'changes', handler: (instance: CodeMirror.Editor, change: CodeMirror.EditorChangeLinkedList[]) => void ): void;
-
-        /** This event is fired before a change is applied, and its handler may choose to modify or cancel the change.
+
+        /** This event is fired before a change is applied, and its handler may choose to modify or cancel the change.
         The changeObj never has a next property, since this is fired for each individual change, and not batched per operation.
         Note: you may not do anything from a "beforeChange" handler that would cause changes to the document or its visualization.
         Doing so will, since this handler is called directly from the bowels of the CodeMirror implementation,
@@ -471,6 +471,10 @@ declare module CodeMirror {
         It may be "start" , "end" , "head"(the side of the selection that moves when you press shift + arrow),
         or "anchor"(the fixed side of the selection).Omitting the argument is the same as passing "head".A { line , ch } object will be returned. */
         getCursor(start?: string): CodeMirror.Position;
+        
+        /** Retrieves a list of all current selections. These will always be sorted, and never overlap (overlapping selections are merged). 
+        Each object in the array contains anchor and head properties referring to {line, ch} objects. */
+        listSelections(): { anchor: CodeMirror.Position; head: CodeMirror.Position }[];
 
         /** Return true if any text is selected. */
         somethingSelected(): boolean;
@@ -612,7 +616,7 @@ declare module CodeMirror {
         /** Array of strings representing the text that replaced the changed range (split by line). */
         text: string[];
         /**  Text that used to be between from and to, which is overwritten by this change. */
-        removed: string[];
+        removed: string[];
         /**  String representing the origin of the change event and wether it can be merged with history */
         origin: string;
     }
@@ -780,9 +784,9 @@ declare module CodeMirror {
         This affects the amount of updates needed when scrolling, and the amount of work that such an update does.
         You should usually leave it at its default, 10. Can be set to Infinity to make sure the whole document is always rendered,
         and thus the browser's text search works on it. This will have bad effects on performance of big documents. */
-        viewportMargin?: number;
-
-        /** Optional lint configuration to be used in conjunction with CodeMirror's linter addon. */
+        viewportMargin?: number;
+
+        /** Optional lint configuration to be used in conjunction with CodeMirror's linter addon. */
         lint?: LintOptions;
     }
 
@@ -796,8 +800,8 @@ declare module CodeMirror {
         /** Like inclusiveLeft , but for the right side. */
         inclusiveRight?: boolean;
 
-        /** Atomic ranges act as a single unit when cursor movement is concerned — i.e. it is impossible to place the cursor inside of them.
-        In atomic ranges, inclusiveLeft and inclusiveRight have a different meaning — they will prevent the cursor from being placed
+        /** Atomic ranges act as a single unit when cursor movement is concerned — i.e. it is impossible to place the cursor inside of them.
+        In atomic ranges, inclusiveLeft and inclusiveRight have a different meaning — they will prevent the cursor from being placed
         respectively directly before and directly after the range. */
         atomic?: boolean;
 
@@ -808,19 +812,19 @@ declare module CodeMirror {
         This is mostly useful for text - replacement widgets that need to 'snap open' when the user tries to edit them.
         The "clear" event fired on the range handle can be used to be notified when this happens. */
         clearOnEnter?: boolean;
-
-        /** Determines whether the mark is automatically cleared when it becomes empty. Default is true. */
-        clearWhenEmpty?: boolean;
+
+        /** Determines whether the mark is automatically cleared when it becomes empty. Default is true. */
+        clearWhenEmpty?: boolean;
 
         /** Use a given node to display this range.Implies both collapsed and atomic.
         The given DOM node must be an inline element(as opposed to a block element). */
         replacedWith?: HTMLElement;
-
-        /** When replacedWith is given, this determines whether the editor will
-         * capture mouse and drag events occurring in this widget. Default is
-         * false—the events will be left alone for the default browser handler,
-         * or specific handlers on the widget, to capture. */
-        handleMouseEvents?: boolean;
+
+        /** When replacedWith is given, this determines whether the editor will
+         * capture mouse and drag events occurring in this widget. Default is
+         * false—the events will be left alone for the default browser handler,
+         * or specific handlers on the widget, to capture. */
+        handleMouseEvents?: boolean;
 
         /** A read - only span can, as long as it is not cleared, not be modified except by calling setValue to reset the whole document.
         Note: adding a read - only span currently clears the undo history of the editor,
@@ -835,12 +839,12 @@ declare module CodeMirror {
 
         /** Equivalent to startStyle, but for the rightmost span. */
         endStyle?: string;
-
-        /** A string of CSS to be applied to the covered text. For example "color: #fe3". */
-        css?: string;
-
-        /** When given, will give the nodes created for this span a HTML title attribute with the given value. */
-        title?: string;
+
+        /** A string of CSS to be applied to the covered text. For example "color: #fe3". */
+        css?: string;
+
+        /** When given, will give the nodes created for this span a HTML title attribute with the given value. */
+        title?: string;
 
         /** When the target document is linked to other documents, you can set shared to true to make the marker appear in all documents.
         By default, a marker appears only in its target document. */
@@ -1041,48 +1045,48 @@ declare module CodeMirror {
      * Both modes get to parse all of the text, but when both assign a non-null style to a piece of code, the overlay wins, unless
      * the combine argument was true and not overridden, or state.overlay.combineTokens was true, in which case the styles are combined.
      */
-    function overlayMode<T, S>(base: Mode<T>, overlay: Mode<S>, combine?: boolean): Mode<any>
-
-    /**
-     * async specifies that the lint process runs asynchronously. hasGutters specifies that lint errors should be displayed in the CodeMirror
-     * gutter, note that you must use this in conjunction with [ "CodeMirror-lint-markers" ] as an element in the gutters argument on
-     * initialization of the CodeMirror instance.
-     */
-    interface LintStateOptions {
-        async: boolean;
-        hasGutters: boolean;
-    }
-
-    /**
-     * Adds the getAnnotations callback to LintStateOptions which may be overridden by the user if they choose use their own
-     * linter.
-     */
-    interface LintOptions extends LintStateOptions {
-        getAnnotations: AnnotationsCallback;
-    }
-
-    /**
-     * A function that calls the updateLintingCallback with any errors found during the linting process.
-     */
-    interface AnnotationsCallback {
-        (content: string, updateLintingCallback: UpdateLintingCallback, options: LintStateOptions, codeMirror: Editor): void;
-    }
-
-    /**
-     * A function that, given an array of annotations, updates the CodeMirror linting GUI with those annotations
-     */
-    interface UpdateLintingCallback {
-        (codeMirror: Editor, annotations: Annotation[]): void;
-    }
-
-    /**
-     * An annotation contains a description of a lint error, detailing the location of the error within the code, the severity of the error,
-     * and an explaination as to why the error was thrown.
-     */
-    interface Annotation {
-        from: Position;
-        message?: string;
-        severity?: string;
-        to?: Position;
+    function overlayMode<T, S>(base: Mode<T>, overlay: Mode<S>, combine?: boolean): Mode<any>
+
+    /**
+     * async specifies that the lint process runs asynchronously. hasGutters specifies that lint errors should be displayed in the CodeMirror
+     * gutter, note that you must use this in conjunction with [ "CodeMirror-lint-markers" ] as an element in the gutters argument on
+     * initialization of the CodeMirror instance.
+     */
+    interface LintStateOptions {
+        async: boolean;
+        hasGutters: boolean;
+    }
+
+    /**
+     * Adds the getAnnotations callback to LintStateOptions which may be overridden by the user if they choose use their own
+     * linter.
+     */
+    interface LintOptions extends LintStateOptions {
+        getAnnotations: AnnotationsCallback;
+    }
+
+    /**
+     * A function that calls the updateLintingCallback with any errors found during the linting process.
+     */
+    interface AnnotationsCallback {
+        (content: string, updateLintingCallback: UpdateLintingCallback, options: LintStateOptions, codeMirror: Editor): void;
+    }
+
+    /**
+     * A function that, given an array of annotations, updates the CodeMirror linting GUI with those annotations
+     */
+    interface UpdateLintingCallback {
+        (codeMirror: Editor, annotations: Annotation[]): void;
+    }
+
+    /**
+     * An annotation contains a description of a lint error, detailing the location of the error within the code, the severity of the error,
+     * and an explaination as to why the error was thrown.
+     */
+    interface Annotation {
+        from: Position;
+        message?: string;
+        severity?: string;
+        to?: Position;
     }
 }
diff --git a/contextjs/contextjs-tests.ts b/contextjs/contextjs-tests.ts
index 7d54e80e6..0b0d55d09 100644
--- a/contextjs/contextjs-tests.ts
+++ b/contextjs/contextjs-tests.ts
@@ -7,7 +7,7 @@ context.settings({compress: true});
 context.attach('#test', [
   {header: 'header 1'},
   {divider: true},
-  {text:'foobar', submenu: [
+  {text:'foobar', subMenu: [
     {text:'sub1'},
     {text:'sub2'}
   ]}
diff --git a/convert-source-map/convert-source-map-tests.ts.tscparams b/convert-source-map/convert-source-map-tests.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/convert-source-map/convert-source-map-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/convert-source-map/convert-source-map.d.ts.tscparams b/convert-source-map/convert-source-map.d.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/convert-source-map/convert-source-map.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/core-js/core-js-tests.ts.tscparams b/core-js/core-js-tests.ts.tscparams
deleted file mode 100644
index 09674b570..000000000
Binary files a/core-js/core-js-tests.ts.tscparams and /dev/null differ
diff --git a/crossroads/crossroads-tests.ts.tscparams b/crossroads/crossroads-tests.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/crossroads/crossroads-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/crossroads/crossroads.d.ts.tscparams b/crossroads/crossroads.d.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/crossroads/crossroads.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/d3/d3-tests.ts.tscparams b/d3/d3-tests.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/d3/d3-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/d3/plugins/d3.superformula-tests.ts.tscparams b/d3/plugins/d3.superformula-tests.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/d3/plugins/d3.superformula-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/dragula/dragula-amd-tests.ts b/dragula/dragula-amd-tests.ts
new file mode 100644
index 000000000..99cb5e043
--- /dev/null
+++ b/dragula/dragula-amd-tests.ts
@@ -0,0 +1,37 @@
+import dragula = require("dragula");
+
+// containers
+var d1 = dragula([document.querySelector('#left'), document.querySelector('#right')]);
+
+// all options
+var d2 = dragula({
+    isContainer: function (el) {
+        return false;
+    },
+    moves: function (el, container, handle) {
+        return true;
+    },
+    accepts: function (el, target, source, sibling) {
+        return true;
+    },
+    invalid: function (el, target) {
+        return el.tagName === 'A' || el.tagName === 'BUTTON';
+    },
+    direction: 'vertical',
+    copy: false,
+    revertOnSpill: false,
+    removeOnSpill: false,
+    delay: false,
+    mirrorContainer: document.body
+});
+
+// empty call
+var d3 = dragula();
+
+
+// drake API
+var drake = dragula({
+    copy: true
+});
+
+drake.containers.push(document.querySelector('#container'));
diff --git a/dragula/dragula-tests.ts b/dragula/dragula-tests.ts
new file mode 100644
index 000000000..f5481f1d8
--- /dev/null
+++ b/dragula/dragula-tests.ts
@@ -0,0 +1,31 @@
+/// <reference path="dragula.d.ts" />
+
+var d1 = dragula([document.querySelector('#left'), document.querySelector('#right')]);
+
+var d2 = dragula({
+    isContainer: function (el) {
+        return false;
+    },
+    moves: function (el, container, handle) {
+        return true;
+    },
+    accepts: function (el, target, source, sibling) {
+        return true;
+    },
+    invalid: function (el, target) {
+        return el.tagName === 'A' || el.tagName === 'BUTTON';
+    },
+    direction: 'vertical',
+    copy: false,
+    revertOnSpill: false,
+    removeOnSpill: false,
+    delay: false,
+    mirrorContainer: document.body
+});
+
+var d3 = dragula();
+
+var drake = dragula({
+    copy: true
+});
+drake.containers.push(document.querySelector('#container'));
diff --git a/dragula/dragula.d.ts b/dragula/dragula.d.ts
new file mode 100644
index 000000000..8a707ef6f
--- /dev/null
+++ b/dragula/dragula.d.ts
@@ -0,0 +1,46 @@
+// Type definitions for dragula v2.1.2
+// Project: http://bevacqua.github.io/dragula/
+// Definitions by: Paul Welter <https://github.com/pwelter34/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module dragula {
+    interface DragulaOptions {
+        containers?: Element[];
+        isContainer?: (el?: Element) => boolean;
+        moves?: (el?: Element, container?: Element, handle?: Element) => boolean;
+        accepts?: (el?: Element, target?: Element, source?: Element, sibling?: Element) => boolean;
+        invalid?: (el?: Element, target?: Element) => boolean;
+        direction?: string;
+        copy?: boolean;
+        revertOnSpill?: boolean;
+        removeOnSpill?: boolean;
+        delay?: boolean | number;
+        mirrorContainer?: Element;
+    }
+
+    interface Drake {
+        containers: Element[];
+        dragging: boolean;
+        start(item:Element): void;
+        end(): void;
+        cancel(revert:boolean): void;
+        cancel(): void;
+        remove(): void;
+        on(events: string, callback: Function): void;
+        destroy(): void;
+    }
+
+    interface Dragula {
+        (containers: Element[], options: DragulaOptions): Drake;
+        (containers: Element, options: DragulaOptions): Drake;
+        (containers: Element[]): Drake;
+        (options: DragulaOptions): Drake;
+        (): Drake;
+    }
+}
+
+declare var dragula: dragula.Dragula;
+
+declare module "dragula" {
+    export = dragula;
+}
diff --git a/dw-bxslider-4/dw-bxslider-4-tests.ts b/dw-bxslider-4/dw-bxslider-4-tests.ts
index 8844fcdbe..d4138cca1 100644
--- a/dw-bxslider-4/dw-bxslider-4-tests.ts
+++ b/dw-bxslider-4/dw-bxslider-4-tests.ts
@@ -26,7 +26,7 @@ $(document).ready(function() {
 
 	$('.slider1').bxSlider({
 		slideWidth: 200,
-		minSldies: 2,
+		minSlides: 2,
 		maxSlides: 3,
 		slideMargin: 10
 	});
diff --git a/es6-collections/es6-collections-tests.ts.tscparams b/es6-collections/es6-collections-tests.ts.tscparams
deleted file mode 100644
index 4169d3605..000000000
--- a/es6-collections/es6-collections-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
---noImplicitAny --module commonjs --target es5
\ No newline at end of file
diff --git a/es6-shim/es6-shim-tests.ts.tscparams b/es6-shim/es6-shim-tests.ts.tscparams
deleted file mode 100644
index 4169d3605..000000000
--- a/es6-shim/es6-shim-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
---noImplicitAny --module commonjs --target es5
\ No newline at end of file
diff --git a/express/express-tests.ts b/express/express-tests.ts
index 22ae73e72..72beb0790 100644
--- a/express/express-tests.ts
+++ b/express/express-tests.ts
@@ -1,6 +1,6 @@
 /// <reference path="express.d.ts" />
 
-import express = require('express');
+import * as express from 'express';
 var app = express();
 
 app.engine('jade', require('jade').__express);
diff --git a/express/express.d.ts b/express/express.d.ts
index 1cba6909c..97b4ef2b8 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -5,7 +5,7 @@
 
 /* =================== USAGE ===================
 
-    import express = require('express');
+    import * as express from "express";
     var app = express();
 
  =============================================== */
@@ -24,8 +24,8 @@ declare module Express {
 
 
 declare module "express" {
-    import http = require('http');
-    import serveStatic = require('serve-static');
+    import * as http from "http";
+    import * as serveStatic from "serve-static";
 
     function e(): e.Express;
 
diff --git a/fabricjs/fabricjs-tests.ts b/fabricjs/fabricjs-tests.ts
index 621b104bd..89c882b05 100644
--- a/fabricjs/fabricjs-tests.ts
+++ b/fabricjs/fabricjs-tests.ts
@@ -70,7 +70,7 @@ function sample2() {
   //
   // Rendering canvas #2
   //
-  var canvas2 = new fabric.Canvas('c2', { backgroundColor: "#000", renderOnAddition: false }),
+  var canvas2 = new fabric.Canvas('c2', { backgroundColor: "#000", renderOnAddRemove: false }),
     results2 = document.getElementById('results-c2');
 
   startTimer();
@@ -84,7 +84,7 @@ function sample2() {
     canvas2.add(dot);
   }
   canvas2.renderAll(); // Note, calling renderAll() is important in this case
-  results2.innerHTML = 'Rendering 1000 elements using canvas.renderOnAddition = false in ' + stopTimer() + 'ms';
+  results2.innerHTML = 'Rendering 1000 elements using canvas.renderOnAddRemove = false in ' + stopTimer() + 'ms';
 }
 
 function sample3() {
diff --git a/foundation/foundation-tests.ts.tscparams b/foundation/foundation-tests.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/foundation/foundation-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/foundation/foundation.d.ts b/foundation/foundation.d.ts
index c2dc4fc24..a51e47ae9 100644
--- a/foundation/foundation.d.ts
+++ b/foundation/foundation.d.ts
@@ -125,7 +125,8 @@ declare module Foundation {
             timer? : string;
             tip? : string;
             wrapper? : string;
-            button? : string;
+            button?: string;
+            prev_button?: string;
             modal? : string;
             expose? : string;
             expose_cover? : string;
diff --git a/foundation/foundation.d.ts.tscparams b/foundation/foundation.d.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/foundation/foundation.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/ftp/ftp-tests.ts b/ftp/ftp-tests.ts
index 2e37e53f9..a40df2e55 100644
--- a/ftp/ftp-tests.ts
+++ b/ftp/ftp-tests.ts
@@ -20,7 +20,7 @@ c.connect();
 c.connect({
 	host: "127.0.0.1",
 	port: 21,
-	username: "Boo",
+	user: "Boo",
 	password: "secret"
 });
 
diff --git a/gapi/gapi.d.ts b/gapi/gapi.d.ts
index 8c50826d4..cce0a2244 100644
--- a/gapi/gapi.d.ts
+++ b/gapi/gapi.d.ts
@@ -48,7 +48,11 @@ declare module gapi.auth {
         /**
          * The auth scope or scopes to authorize. Auth scopes for individual APIs can be found in their documentation.
          */
-        scope?: any
+        scope?: any;
+        /**
+         * The user to sign in as. -1 to toggle a multi-account chooser, 0 to default to the user's current account, and 1 to automatically sign in if the user is signed into Google Plus.
+         */
+        authuser?: number;
     }, callback: (token: GoogleApiOAuth2TokenObject) => any): void;
     /**
      * Initializes the authorization feature. Call this when the client loads to prevent popup blockers from blocking the auth window on gapi.auth.authorize calls.
diff --git a/github-electron/github-electron.d.ts b/github-electron/github-electron.d.ts
index 81896fcc5..5df526bfc 100644
--- a/github-electron/github-electron.d.ts
+++ b/github-electron/github-electron.d.ts
@@ -855,6 +855,10 @@ declare module GitHubElectron {
 		 * cleanup code will not run.
 		 */
 		terminate(): void;
+		/**
+		 * Returns the current application directory.
+		 */
+		getAppPath(): string;
 		/**
 		 * @param name One of: home, appData, userData, cache, userCache, temp, userDesktop, exe, module
 		 * @returns The path to a special directory or file associated with name.
diff --git a/globalize/globalize-tests.ts.tscparams b/globalize/globalize-tests.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/globalize/globalize-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/goJS/goJS.d.ts.tscparams b/goJS/goJS.d.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/goJS/goJS.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/gulp-load-plugins/gulp-load-plugins-tests.ts b/gulp-load-plugins/gulp-load-plugins-tests.ts
new file mode 100644
index 000000000..f479be00c
--- /dev/null
+++ b/gulp-load-plugins/gulp-load-plugins-tests.ts
@@ -0,0 +1,53 @@
+/// <reference path="../node/node" />
+/// <reference path="../gulp/gulp" />
+/// <reference path="../gulp-concat/gulp-concat" />
+/// <reference path="gulp-load-plugins" />
+
+import gulp = require('gulp');
+import gulpConcat = require('gulp-concat');
+import gulpLoadPlugins = require('gulp-load-plugins');
+
+interface GulpPlugins extends IGulpPlugins {
+	concat: typeof gulpConcat;
+}
+
+var plugins = gulpLoadPlugins<GulpPlugins>({
+    pattern: ['gulp-*', 'gulp.*'],
+    config: 'package.json',
+    scope: ['dependencies', 'devDependencies', 'peerDependencies'],
+    replaceString: /^gulp(-|\.)/,
+    camelize: true,
+    lazy: true,
+    rename: {}
+});
+plugins = gulpLoadPlugins<GulpPlugins>();
+
+gulp.task('taskName', () => {
+	gulp.src('*.*')
+		.pipe(plugins.concat('concatenated.js'))
+		.pipe(gulp.dest('output'));
+});
+
+/*
+ * From 0.8.0, you can pass in an object of mappings for renaming plugins. For example, 
+ * imagine you want to load the  gulp-ruby-sass  plugin, but want to refer to it as just 
+ *  sass :
+ */
+plugins = gulpLoadPlugins<GulpPlugins>({
+	rename: {
+		'gulp-ruby-sass': 'sass'
+	}
+});
+/*
+ * gulp-load-plugins  comes with npm scope support. The major difference is that scoped 
+ * plugins are accessible through an object on  plugins  that represents the scope. For 
+ * example, if the plugin is  @myco/gulp-test-plugin  then you can access the plugin as 
+ * shown in the following example:
+ */
+interface GulpPlugins {
+	myco: {
+		testPlugin(): NodeJS.ReadWriteStream;
+	}
+}
+ 
+plugins.myco.testPlugin();
diff --git a/gulp-load-plugins/gulp-load-plugins.d.ts b/gulp-load-plugins/gulp-load-plugins.d.ts
new file mode 100644
index 000000000..c8a11091d
--- /dev/null
+++ b/gulp-load-plugins/gulp-load-plugins.d.ts
@@ -0,0 +1,42 @@
+// Type definitions for gulp-load-plugins
+// Project: https://github.com/jackfranklin/gulp-load-plugins
+// Definitions by: Joe Skeen <http://github.com/joeskeen>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+/** Loads in any gulp plugins and attaches them to an object, freeing you up from having to manually require each gulp plugin. */
+declare module 'gulp-load-plugins' {
+	
+	interface IOptions {
+		/** the glob(s) to search for, default ['gulp-*', 'gulp.*'] */
+		pattern?: string[];
+		/** where to find the plugins, searched up from process.cwd(), default 'package.json' */
+		config?: string;
+		/** which keys in the config to look within, default ['dependencies', 'devDependencies', 'peerDependencies'] */
+		scope?: string[];
+		/** what to remove from the name of the module when adding it to the context, default /^gulp(-|\.)/ */
+		replaceString?: RegExp;
+		/** if true, transforms hyphenated plugin names to camel case, default true */
+		camelize?: boolean;
+		/** whether the plugins should be lazy loaded on demand, default true */
+		lazy?: boolean;
+		/** a mapping of plugins to rename, the key being the NPM name of the package, and the value being an alias you define */
+		rename?: IPluginNameMappings;
+	}
+	
+	interface IPluginNameMappings {
+		[npmPackageName: string]: string
+	}
+	
+	/** Loads in any gulp plugins and attaches them to an object, freeing you up from having to manually require each gulp plugin. */
+	function gulpLoadPlugins<T extends IGulpPlugins>(options?: IOptions): T;
+	
+	export = gulpLoadPlugins;
+}
+
+/**
+ * Extend this interface to use Gulp plugins in your gulpfile.js
+ */
+interface IGulpPlugins {
+}
diff --git a/gulp/gulp.d.ts b/gulp/gulp.d.ts
index d7a0dba57..13c12a811 100644
--- a/gulp/gulp.d.ts
+++ b/gulp/gulp.d.ts
@@ -28,6 +28,13 @@ declare module gulp {
          */
         buffer?: boolean;
 
+        /**
+         * The base path of a glob.
+         *
+         * Default is everything before a glob starts.
+         */
+        base?: string;
+
         /**
          * The current working directory in which to search.
          * Defaults to process.cwd().
diff --git a/highcharts/highcharts.d.ts b/highcharts/highcharts.d.ts
index 9bda29782..ee3a2ce4c 100644
--- a/highcharts/highcharts.d.ts
+++ b/highcharts/highcharts.d.ts
@@ -114,7 +114,7 @@ interface HighchartsAxisOptions {
     minRange?: number;
     minTickInterval?: number;
     minorTickColor?: string;
-    minorTickInterval?: number;
+    minorTickInterval?: number|string;
     minorTickLength?: number;
     minorTickPosition?: string; // 'inside' 'outside'
     minorTickWidth?: number;
@@ -191,11 +191,11 @@ interface HighchartsChartResetZoomButton {
 }
 
 interface HighchartsChartResetZoomButtonTheme {
-    fill?: string; //css HEX colours. 
-    stroke?: string;//css HEX colours. 
+    fill?: string; //css HEX colours.
+    stroke?: string;//css HEX colours.
     r?: number; // Radius %
-    states?: any; // HTML element states eg: hover, with css attributes in object. 
-    display?: string; // css attr eg: 'none' 
+    states?: any; // HTML element states eg: hover, with css attributes in object.
+    display?: string; // css attr eg: 'none'
 }
 
 interface HighchartsChartOptions {
@@ -873,11 +873,11 @@ interface HighchartsLineChart {
     states?: {
         hover: HighchartsAreaStates;
     };
-    step?: boolean;
+    step?: boolean|string;
     stickyTracking?: boolean;
     tooltip?: HighchartsTooltipOptions;
     turboThreshold?: number;
-    visible?: number;
+    visible?: boolean;
     zIndex?: number;
 }
 
@@ -911,7 +911,7 @@ interface HighchartsPieChart {
     };
     stickyTracking?: boolean;
     tooltip?: HighchartsTooltipOptions;
-    visible?: number;
+    visible?: boolean;
     zIndex?: number;
 }
 
@@ -953,7 +953,7 @@ interface HighchartsScatterChart {
     stickyTracking?: boolean;
     tooltip?: HighchartsTooltipOptions;
     turboThreshold?: number;
-    visible?: number;
+    visible?: boolean;
     zIndex?: number;
 }
 
@@ -986,7 +986,6 @@ interface HighchartsSeriesChart {
     dataLabels?: HighchartsDataLabels;
     enableMouseTracking?: boolean;
     events?: HighchartsPlotEvents;
-    id?: string;
     lineWidth?: number;
     marker?: HighchartsMarker;
     point?: {
@@ -1006,7 +1005,7 @@ interface HighchartsSeriesChart {
     stickyTracking?: boolean;
     tooltip?: HighchartsTooltipOptions;
     turboThreshold?: number;
-    visible?: number;
+    visible?: boolean;
     zIndex?: number;
 }
 
@@ -1041,13 +1040,14 @@ interface HighchartsPlotOptions {
  */
 interface HighchartsIndividualSeriesOptions {
     data?: number[]|[number, number][]| HighchartsDataPoint[]; // [value1,value2, ... ] | [[x1,y1],[x2,y2],... ] | HighchartsDataPoint[]
+    id?: string;
     index?: number;
     legendIndex?: number;
     name?: string;
     stack?: any; // type doesn't matter, as long as grouped series' stack options match each other.
     type?: string;
-    xAxis?: number;
-    yAxis?: number;
+    xAxis?: string | number;
+    yAxis?: string | number;
 }
 
 interface HighchartsSeriesOptions extends HighchartsIndividualSeriesOptions, HighchartsSeriesChart { }
@@ -1095,8 +1095,8 @@ interface HighchartsSeriesOptions extends HighchartsSeriesChart {
     legendIndex?: number;
     name?: string;
     stack?: string | number;
-    xAxis?: number;
-    yAxis?: number;
+    xAxis?: string | number;
+    yAxis?: string | number;
 }
 
 interface HighchartsSubtitleOptions {
@@ -1180,6 +1180,7 @@ interface HighchartsAxisObject {
     addPlotBand(options: HighchartsPlotBands): void;
     addPlotLine(options: HighchartsPlotLines): void;
     getExtremes(): HighchartsExtremes;
+    remove(redraw?: boolean): void;
     removePlotBand(id: string): void;
     removePlotLine(id: string): void;
     setCategories(categories: string[]): void;
@@ -1187,8 +1188,10 @@ interface HighchartsAxisObject {
     setExtremes(min: number, max: number): void;
     setExtremes(min: number, max: number, redraw: boolean): void;
     setExtremes(min: number, max: number, redraw: boolean, animation: boolean | HighchartsAnimation): void;
-    setTitle(title: HighchartsAxisTitle): void;
-    setTitle(title: HighchartsAxisTitle, redraw: boolean): void;
+    setTitle(title: HighchartsAxisTitle, redraw?: boolean): void;
+    toPixels(value: number, paneCoordinates?: boolean): number;
+    toValue(pixel: number, paneCoordinates?: boolean): number;
+    update(options: HighchartsAxisOptions, redraw?: boolean): void;
 }
 
 interface HighchartsChartObject {
@@ -1275,52 +1278,31 @@ declare var Highcharts: HighchartsStatic;
 interface HighchartsPointObject {
     category: string | number;
     percentage: number;
-    remove(): void;
-    remove(redraw: boolean): void;
-    remove(redraw: boolean, animation: boolean): void;
-    remove(redraw: boolean, animation: HighchartsAnimation): void;
+    remove(redraw?: boolean, animation?: boolean|HighchartsAnimation): void;
     select(): void;
     select(select: boolean): void;
     select(select: boolean, accumulate: boolean): void;
     selected: boolean;
     series: HighchartsSeriesObject;
-    slice(): void;
-    slice(sliced: boolean): void;
-    slice(sliced: boolean, redraw: boolean): void;
-    slice(sliced: boolean, redraw: boolean, animation: boolean): void;
-    slice(sliced: boolean, redraw: boolean, animation: HighchartsAnimation): void;
+    slice(sliced?: boolean, redraw?: boolean, animation?: boolean|HighchartsAnimation): void;
     total: number;
-    update(options: any): void;
-    update(options: any, redraw: boolean): void;
-    update(options: any, redraw: boolean, animation: boolean): void;
-    update(options: any, redraw: boolean, animation: HighchartsAnimation): void;
+    update(options: number | [number, number] | HighchartsDataPoint, redraw?: boolean, animation?: boolean | HighchartsAnimation): void;
     x: number;
     y: number;
 }
 
 interface HighchartsSeriesObject {
-    addPoint(options: number |[number, number]| HighchartsDataPoint): void;
-    addPoint(options: number |[number, number]| HighchartsDataPoint, redraw: boolean, shift: boolean): void;
-    addPoint(options: number |[number, number]| HighchartsDataPoint, redraw: boolean, shift: boolean, animation: boolean): void;
-    addPoint(options: number |[number, number]| HighchartsDataPoint, redraw: boolean, shift: boolean, animation: HighchartsAnimation): void;
+    addPoint(options: number |[number, number]| HighchartsDataPoint, redraw?: boolean, shift?: boolean, animation?: boolean | HighchartsAnimation): void;
     chart: HighchartsChartObject;
-    data: HighchartsDataPoint[];
+    data: HighchartsPointObject[];
     hide(): void;
     name: string;
     options: HighchartsSeriesOptions;
-    remove(): void;
-    remove(redraw: boolean): void;
-    select(): void;
-    select(selected: boolean): void;
+    remove(redraw?: boolean): void;
+    select(selected?: boolean): void;
     selected: boolean;
-    setData(data: number[]): void; // [value1,value2, ... ]
-    setData(data: number[], redraw: boolean): void;
-    setData(data: number[][]): void; // [[x1,y1],[x2,y2],... ]
-    setData(data: number[][], redraw: boolean): void;
-    setData(data: HighchartsDataPoint[]): void; // HighchartsDataPoint[]
-    setData(data: HighchartsDataPoint[], redraw: boolean): void;
-    setVisible(visible: boolean): void;
-    setVisible(visible: boolean, redraw: boolean): void;
+    setData(data: number[] | number[][] | HighchartsDataPoint[], redraw?: boolean, animation?: boolean | HighchartsAnimation, updatePoints?: boolean): void;
+    setVisible(visible: boolean, redraw?: boolean): void;
     show(): void;
     type: string;
     update(options: HighchartsSeriesOptions, redraw?: boolean): void;
diff --git a/jasmine-fixture/jasmine-fixture-tests.ts.tscparams b/jasmine-fixture/jasmine-fixture-tests.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/jasmine-fixture/jasmine-fixture-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/jasmine-jquery/jasmine-jquery.d.ts.tscparams b/jasmine-jquery/jasmine-jquery.d.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/jasmine-jquery/jasmine-jquery.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/jasmine/jasmine-tests.ts b/jasmine/jasmine-tests.ts
index d5eb228c9..9f57219b8 100644
--- a/jasmine/jasmine-tests.ts
+++ b/jasmine/jasmine-tests.ts
@@ -721,6 +721,17 @@ describe("Manually ticking the Jasmine Clock", function () {
         jasmine.clock().tick(50);
         expect(timerCallback.calls.count()).toEqual(2);
     });
+
+    describe("Mocking the Date object", function(){
+        it("mocks the Date object and sets it to a given time", function() {
+            var baseTime = new Date(2013, 9, 23);
+
+            jasmine.clock().mockDate(baseTime);
+
+            jasmine.clock().tick(50);
+            expect(new Date().getTime()).toEqual(baseTime.getTime() + 50);
+        });
+    });
 });
 
 describe("Asynchronous specs", function () {
diff --git a/joi/joi-tests.ts b/joi/joi-tests.ts
index 26048a9dc..fc1f8ef25 100644
--- a/joi/joi-tests.ts
+++ b/joi/joi-tests.ts
@@ -56,6 +56,7 @@ validOpts = {allowUnknown: bool};
 validOpts = {skipFunctions: bool};
 validOpts = {stripUnknown: bool};
 validOpts = {language: bool};
+validOpts = {presence: str};
 validOpts = {context: obj};
 
 // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
@@ -65,6 +66,34 @@ var renOpts: Joi.RenameOptions = null;
 renOpts = {alias: bool};
 renOpts = {multiple: bool};
 renOpts = {override: bool};
+renOpts = {ignoreUndefined: bool};
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+var emailOpts: Joi.EmailOptions = null;
+
+emailOpts = {errorLevel: num};
+emailOpts = {errorLevel: bool};
+emailOpts = {tldWhitelist: strArr};
+emailOpts = {tldWhitelist: obj};
+emailOpts = {minDomainAtoms: num};
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+var ipOpts: Joi.IpOptions = null;
+
+ipOpts = {version: str};
+ipOpts = {version: strArr};
+ipOpts = {cidr: str};
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+var uriOpts: Joi.UriOptions = null;
+
+uriOpts = {scheme: str};
+uriOpts = {scheme: exp};
+uriOpts = {scheme: strArr};
+uriOpts = {scheme: expArr};
 
 // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
 
@@ -144,15 +173,30 @@ module common {
 	anySchema = anySchema.valid(x);
 	anySchema = anySchema.valid(x, x);
 	anySchema = anySchema.valid([x, x, x]);
+	anySchema = anySchema.only(x);
+	anySchema = anySchema.only(x, x);
+	anySchema = anySchema.only([x, x, x]);
+	anySchema = anySchema.equal(x);
+	anySchema = anySchema.equal(x, x);
+	anySchema = anySchema.equal([x, x, x]);
 	anySchema = anySchema.invalid(x);
 	anySchema = anySchema.invalid(x, x);
 	anySchema = anySchema.invalid([x, x, x]);
+	anySchema = anySchema.disallow(x);
+	anySchema = anySchema.disallow(x, x);
+	anySchema = anySchema.disallow([x, x, x]);
+	anySchema = anySchema.not(x);
+	anySchema = anySchema.not(x, x);
+	anySchema = anySchema.not([x, x, x]);
 
+	anySchema = anySchema.default();
 	anySchema = anySchema.default(x);
+	anySchema = anySchema.default(x, str);
 
 	anySchema = anySchema.required();
 	anySchema = anySchema.optional();
 	anySchema = anySchema.forbidden();
+	anySchema = anySchema.strip();
 
 	anySchema = anySchema.description(str);
 	anySchema = anySchema.notes(str);
@@ -166,43 +210,65 @@ module common {
 
 	anySchema = anySchema.options(validOpts);
 	anySchema = anySchema.strict();
+	anySchema = anySchema.strict(bool);
 	anySchema = anySchema.concat(x);
 
 	altSchema = anySchema.when(str, whenOpts);
 	altSchema = anySchema.when(ref, whenOpts);
+
+	anySchema = anySchema.label(str);
+	anySchema = anySchema.raw();
+	anySchema = anySchema.raw(bool);
+	anySchema = anySchema.empty();
+	anySchema = anySchema.empty(str);
+	anySchema = anySchema.empty(anySchema);
 }
 
 // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
 
 arrSchema = Joi.array();
 
+arrSchema = arrSchema.sparse();
+arrSchema = arrSchema.sparse(bool);
+arrSchema = arrSchema.single();
+arrSchema = arrSchema.single(bool);
 arrSchema = arrSchema.min(num);
 arrSchema = arrSchema.max(num);
 arrSchema = arrSchema.length(num);
+arrSchema = arrSchema.unique();
 
-arrSchema = arrSchema.includes(numSchema);
-arrSchema = arrSchema.includes(numSchema, strSchema);
-arrSchema = arrSchema.includes([numSchema, strSchema]);
+arrSchema = arrSchema.items(numSchema);
+arrSchema = arrSchema.items(numSchema, strSchema);
+arrSchema = arrSchema.items([numSchema, strSchema]);
 
-arrSchema = arrSchema.excludes(numSchema);
-arrSchema = arrSchema.excludes(numSchema, strSchema);
-arrSchema = arrSchema.excludes([numSchema, strSchema]);
 
 // - - - - - - - -
 
 module common_copy_paste {
 	// use search & replace from any
-	anySchema = anySchema.allow(x);
-	anySchema = anySchema.allow(x, x);
-	anySchema = anySchema.allow([x, x, x]);
-	anySchema = anySchema.valid(x);
-	anySchema = anySchema.valid(x, x);
-	anySchema = anySchema.valid([x, x, x]);
-	anySchema = anySchema.invalid(x);
-	anySchema = anySchema.invalid(x, x);
-	anySchema = anySchema.invalid([x, x, x]);
-	
-	anySchema = anySchema.default(x);
+	arrSchema = arrSchema.allow(x);
+	arrSchema = arrSchema.allow(x, x);
+	arrSchema = arrSchema.allow([x, x, x]);
+	arrSchema = arrSchema.valid(x);
+	arrSchema = arrSchema.valid(x, x);
+	arrSchema = arrSchema.valid([x, x, x]);
+	arrSchema = arrSchema.only(x);
+	arrSchema = arrSchema.only(x, x);
+	arrSchema = arrSchema.only([x, x, x]);
+	arrSchema = arrSchema.equal(x);
+	arrSchema = arrSchema.equal(x, x);
+	arrSchema = arrSchema.equal([x, x, x]);
+	arrSchema = arrSchema.invalid(x);
+	arrSchema = arrSchema.invalid(x, x);
+	arrSchema = arrSchema.invalid([x, x, x]);
+	arrSchema = arrSchema.disallow(x);
+	arrSchema = arrSchema.disallow(x, x);
+	arrSchema = arrSchema.disallow([x, x, x]);
+	arrSchema = arrSchema.not(x);
+	arrSchema = arrSchema.not(x, x);
+	arrSchema = arrSchema.not([x, x, x]);
+
+	arrSchema = arrSchema.default(x);
 
 	arrSchema = arrSchema.required();
 	arrSchema = arrSchema.optional();
@@ -238,10 +304,22 @@ module common_copy_paste {
 	boolSchema = boolSchema.valid(x);
 	boolSchema = boolSchema.valid(x, x);
 	boolSchema = boolSchema.valid([x, x, x]);
+	boolSchema = boolSchema.only(x);
+	boolSchema = boolSchema.only(x, x);
+	boolSchema = boolSchema.only([x, x, x]);
+	boolSchema = boolSchema.equal(x);
+	boolSchema = boolSchema.equal(x, x);
+	boolSchema = boolSchema.equal([x, x, x]);
 	boolSchema = boolSchema.invalid(x);
 	boolSchema = boolSchema.invalid(x, x);
 	boolSchema = boolSchema.invalid([x, x, x]);
-	
+	boolSchema = boolSchema.disallow(x);
+	boolSchema = boolSchema.disallow(x, x);
+	boolSchema = boolSchema.disallow([x, x, x]);
+	boolSchema = boolSchema.not(x);
+	boolSchema = boolSchema.not(x, x);
+	boolSchema = boolSchema.not([x, x, x]);
+
 	boolSchema = boolSchema.default(x);
 
 	boolSchema = boolSchema.required();
@@ -270,6 +348,7 @@ module common_copy_paste {
 
 binSchema = Joi.binary();
 
+binSchema = binSchema.encoding(str);
 binSchema = binSchema.min(num);
 binSchema = binSchema.max(num);
 binSchema = binSchema.length(num);
@@ -281,10 +360,22 @@ module common {
 	binSchema = binSchema.valid(x);
 	binSchema = binSchema.valid(x, x);
 	binSchema = binSchema.valid([x, x, x]);
+	binSchema = binSchema.only(x);
+	binSchema = binSchema.only(x, x);
+	binSchema = binSchema.only([x, x, x]);
+	binSchema = binSchema.equal(x);
+	binSchema = binSchema.equal(x, x);
+	binSchema = binSchema.equal([x, x, x]);
 	binSchema = binSchema.invalid(x);
 	binSchema = binSchema.invalid(x, x);
 	binSchema = binSchema.invalid([x, x, x]);
-	
+	binSchema = binSchema.disallow(x);
+	binSchema = binSchema.disallow(x, x);
+	binSchema = binSchema.disallow([x, x, x]);
+	binSchema = binSchema.not(x);
+	binSchema = binSchema.not(x, x);
+	binSchema = binSchema.not([x, x, x]);
+
 	binSchema = binSchema.default(x);
 
 	binSchema = binSchema.required();
@@ -322,6 +413,14 @@ dateSchema = dateSchema.max(str);
 dateSchema = dateSchema.min(num);
 dateSchema = dateSchema.max(num);
 
+dateSchema = dateSchema.min(ref);
+dateSchema = dateSchema.max(ref);
+
+dateSchema = dateSchema.format(str);
+dateSchema = dateSchema.format(strArr);
+
+dateSchema = dateSchema.iso();
+
 module common {
 	dateSchema = dateSchema.allow(x);
 	dateSchema = dateSchema.allow(x, x);
@@ -329,10 +428,22 @@ module common {
 	dateSchema = dateSchema.valid(x);
 	dateSchema = dateSchema.valid(x, x);
 	dateSchema = dateSchema.valid([x, x, x]);
+	dateSchema = dateSchema.only(x);
+	dateSchema = dateSchema.only(x, x);
+	dateSchema = dateSchema.only([x, x, x]);
+	dateSchema = dateSchema.equal(x);
+	dateSchema = dateSchema.equal(x, x);
+	dateSchema = dateSchema.equal([x, x, x]);
 	dateSchema = dateSchema.invalid(x);
 	dateSchema = dateSchema.invalid(x, x);
 	dateSchema = dateSchema.invalid([x, x, x]);
-	
+	dateSchema = dateSchema.disallow(x);
+	dateSchema = dateSchema.disallow(x, x);
+	dateSchema = dateSchema.disallow([x, x, x]);
+	dateSchema = dateSchema.not(x);
+	dateSchema = dateSchema.not(x, x);
+	dateSchema = dateSchema.not([x, x, x]);
+
 	dateSchema = dateSchema.default(x);
 
 	dateSchema = dateSchema.required();
@@ -366,8 +477,18 @@ funcSchema = Joi.func();
 numSchema = Joi.number();
 
 numSchema = numSchema.min(num);
+numSchema = numSchema.min(ref);
 numSchema = numSchema.max(num);
+numSchema = numSchema.max(ref);
+numSchema = numSchema.greater(num);
+numSchema = numSchema.greater(ref);
+numSchema = numSchema.less(num);
+numSchema = numSchema.less(ref);
 numSchema = numSchema.integer();
+numSchema = numSchema.precision(num);
+numSchema = numSchema.multiple(num);
+numSchema = numSchema.positive();
+numSchema = numSchema.negative();
 
 module common {
 	numSchema = numSchema.allow(x);
@@ -376,10 +497,22 @@ module common {
 	numSchema = numSchema.valid(x);
 	numSchema = numSchema.valid(x, x);
 	numSchema = numSchema.valid([x, x, x]);
+	numSchema = numSchema.only(x);
+	numSchema = numSchema.only(x, x);
+	numSchema = numSchema.only([x, x, x]);
+	numSchema = numSchema.equal(x);
+	numSchema = numSchema.equal(x, x);
+	numSchema = numSchema.equal([x, x, x]);
 	numSchema = numSchema.invalid(x);
 	numSchema = numSchema.invalid(x, x);
 	numSchema = numSchema.invalid([x, x, x]);
-	
+	numSchema = numSchema.disallow(x);
+	numSchema = numSchema.disallow(x, x);
+	numSchema = numSchema.disallow([x, x, x]);
+	numSchema = numSchema.not(x);
+	numSchema = numSchema.not(x, x);
+	numSchema = numSchema.not([x, x, x]);
+
 	numSchema = numSchema.default(x);
 
 	numSchema = numSchema.required();
@@ -418,12 +551,23 @@ objSchema = objSchema.length(num);
 
 objSchema = objSchema.pattern(exp, schema);
 
+objSchema = objSchema.and(str);
+objSchema = objSchema.and(str, str);
 objSchema = objSchema.and(str, str, str);
 objSchema = objSchema.and(strArr);
 
+objSchema = objSchema.nand(str);
+objSchema = objSchema.nand(str, str);
+objSchema = objSchema.nand(str, str, str);
+objSchema = objSchema.nand(strArr);
+
+objSchema = objSchema.or(str);
+objSchema = objSchema.or(str, str);
 objSchema = objSchema.or(str, str, str);
 objSchema = objSchema.or(strArr);
 
+objSchema = objSchema.xor(str);
+objSchema = objSchema.xor(str, str);
 objSchema = objSchema.xor(str, str, str);
 objSchema = objSchema.xor(strArr);
 
@@ -442,6 +586,17 @@ objSchema = objSchema.assert(ref, schema, str);
 objSchema = objSchema.unknown();
 objSchema = objSchema.unknown(bool);
 
+objSchema = objSchema.type(func);
+objSchema = objSchema.type(func, str);
+
+objSchema = objSchema.requiredKeys(str);
+objSchema = objSchema.requiredKeys(str, str);
+objSchema = objSchema.requiredKeys(strArr);
+
+objSchema = objSchema.optionalKeys(str);
+objSchema = objSchema.optionalKeys(str, str);
+objSchema = objSchema.optionalKeys(strArr);
+
 module common {
 	objSchema = objSchema.allow(x);
 	objSchema = objSchema.allow(x, x);
@@ -449,10 +604,22 @@ module common {
 	objSchema = objSchema.valid(x);
 	objSchema = objSchema.valid(x, x);
 	objSchema = objSchema.valid([x, x, x]);
+	objSchema = objSchema.only(x);
+	objSchema = objSchema.only(x, x);
+	objSchema = objSchema.only([x, x, x]);
+	objSchema = objSchema.equal(x);
+	objSchema = objSchema.equal(x, x);
+	objSchema = objSchema.equal([x, x, x]);
 	objSchema = objSchema.invalid(x);
 	objSchema = objSchema.invalid(x, x);
 	objSchema = objSchema.invalid([x, x, x]);
-	
+	objSchema = objSchema.disallow(x);
+	objSchema = objSchema.disallow(x, x);
+	objSchema = objSchema.disallow([x, x, x]);
+	objSchema = objSchema.not(x);
+	objSchema = objSchema.not(x, x);
+	objSchema = objSchema.not([x, x, x]);
+
 	objSchema = objSchema.default(x);
 
 	objSchema = objSchema.required();
@@ -483,13 +650,33 @@ strSchema = Joi.string();
 
 strSchema = strSchema.insensitive();
 strSchema = strSchema.min(num);
+strSchema = strSchema.min(num, str);
+strSchema = strSchema.min(ref);
+strSchema = strSchema.min(ref, str);
 strSchema = strSchema.max(num);
+strSchema = strSchema.max(num, str);
+strSchema = strSchema.max(ref);
+strSchema = strSchema.max(ref, str);
+strSchema = strSchema.creditCard();
 strSchema = strSchema.length(num);
+strSchema = strSchema.length(num, str);
+strSchema = strSchema.length(ref);
+strSchema = strSchema.length(ref, str);
 strSchema = strSchema.regex(exp);
+strSchema = strSchema.regex(exp, str);
+strSchema = strSchema.replace(exp, str);
+strSchema = strSchema.replace(str, str);
 strSchema = strSchema.alphanum();
 strSchema = strSchema.token();
 strSchema = strSchema.email();
+strSchema = strSchema.email(emailOpts);
+strSchema = strSchema.ip();
+strSchema = strSchema.ip(ipOpts);
+strSchema = strSchema.uri();
+strSchema = strSchema.uri(uriOpts);
 strSchema = strSchema.guid();
+strSchema = strSchema.hex();
+strSchema = strSchema.hostname();
 strSchema = strSchema.isoDate();
 strSchema = strSchema.lowercase();
 strSchema = strSchema.uppercase();
@@ -502,10 +689,22 @@ module common {
 	strSchema = strSchema.valid(x);
 	strSchema = strSchema.valid(x, x);
 	strSchema = strSchema.valid([x, x, x]);
+	strSchema = strSchema.only(x);
+	strSchema = strSchema.only(x, x);
+	strSchema = strSchema.only([x, x, x]);
+	strSchema = strSchema.equal(x);
+	strSchema = strSchema.equal(x, x);
+	strSchema = strSchema.equal([x, x, x]);
 	strSchema = strSchema.invalid(x);
 	strSchema = strSchema.invalid(x, x);
 	strSchema = strSchema.invalid([x, x, x]);
-	
+	strSchema = strSchema.disallow(x);
+	strSchema = strSchema.disallow(x, x);
+	strSchema = strSchema.disallow([x, x, x]);
+	strSchema = strSchema.not(x);
+	strSchema = strSchema.not(x, x);
+	strSchema = strSchema.not([x, x, x]);
+
 	strSchema = strSchema.default(x);
 
 	strSchema = strSchema.required();
@@ -537,6 +736,7 @@ schema = Joi.alternatives(schema, anySchema, boolSchema);
 
 // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
 
+Joi.validate(value, obj);
 Joi.validate(value, schema);
 Joi.validate(value, schema, validOpts);
 Joi.validate(value, schema, validOpts, (err, value) => {
@@ -566,6 +766,8 @@ Joi.validate(value, {});
 schema = Joi.compile(obj);
 
 Joi.assert(obj, schema);
+Joi.assert(obj, schema, str);
+Joi.assert(obj, schema, err);
 
 ref = Joi.ref(str, refOpts);
 ref = Joi.ref(str);
diff --git a/joi/joi.d.ts b/joi/joi.d.ts
index 5e4bfc37b..b784ad23d 100644
--- a/joi/joi.d.ts
+++ b/joi/joi.d.ts
@@ -1,6 +1,6 @@
 // Type definitions for joi v4.6.0
 // Project: https://github.com/spumko/joi
-// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>, Laurence Dougal Myers <https://github.com/laurence-myers>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 // TODO express type of Schema in a type-parameter (.default, .valid, .example etc)
@@ -19,7 +19,9 @@ declare module 'joi' {
 		// when true, unknown keys are deleted (only when value is an object). Defaults to false.
 		stripUnknown?: boolean;
 		// overrides individual error messages. Defaults to no override ({}).
-		language?: Object
+		language?: Object;
+		// sets the default presence requirements. Supported modes: 'optional', 'required', and 'forbidden'. Defaults to 'optional'.
+		presence?: string;
 		// provides an external data set to be used in references
 		context?: Object;
 	}
@@ -33,6 +35,28 @@ declare module 'joi' {
 		override?: boolean;
 	}
 
+	export interface EmailOptions {
+		// Numerical threshold at which an email address is considered invalid
+		errorLevel?: number | boolean;
+		// Specifies a list of acceptable TLDs.
+		tldWhitelist?: string[] | Object;
+		// Number of atoms required for the domain. Be careful since some domains, such as io, directly allow email.
+		minDomainAtoms?: number;
+	}
+
+	export interface IpOptions {
+		// One or more IP address versions to validate against. Valid values: ipv4, ipv6, ipvfuture
+		version ?: string | string[];
+		// Used to determine if a CIDR is allowed or not. Valid values: optional, required, forbidden
+		cidr?: string;
+	}
+
+	export interface UriOptions {
+		// Specifies one or more acceptable Schemes, should only include the scheme name.
+		// Can be an Array or String (strings are automatically escaped for use in a Regular Expression).
+		scheme ?: string | RegExp | Array<string | RegExp>;
+	}
+
 	export interface WhenOptions {
 		// the required condition joi type.
 		is: Schema;
@@ -47,11 +71,16 @@ declare module 'joi' {
 		contextPrefix?: string;
 	}
 
+	export interface IPOptions {
+		version?: Array<string>;
+		cidr?: string
+	}
+
 	export interface ValidationError {
 		message: string;
 		details: ValidationErrorItem[];
-		simple (): string;
-		annotated (): string;
+		simple(): string;
+		annotated(): string;
 	}
 
 	export interface ValidationErrorItem {
@@ -82,20 +111,28 @@ declare module 'joi' {
 		/**
 		 * Whitelists a value
 		 */
-		allow(value: any, ...values : any[]): T;
+		allow(value: any, ...values: any[]): T;
 		allow(values: any[]): T;
 
 		/**
 		 * Adds the provided values into the allowed whitelist and marks them as the only valid values allowed.
 		 */
-		valid(value: any, ...values : any[]): T;
+		valid(value: any, ...values: any[]): T;
 		valid(values: any[]): T;
+		only(value: any, ...values : any[]): T;
+		only(values: any[]): T;
+		equal(value: any, ...values : any[]): T;
+		equal(values: any[]): T;
 
 		/**
 		 * Blacklists a value
 		 */
-		invalid(value: any, ...values : any[]): T;
+		invalid(value: any, ...values: any[]): T;
 		invalid(values: any[]): T;
+		disallow(value: any, ...values : any[]): T;
+		disallow(values: any[]): T;
+		not(value: any, ...values : any[]): T;
+		not(values: any[]): T;
 
 		/**
 		 * Marks a key as required which will not allow undefined as value. All keys are optional by default.
@@ -112,6 +149,11 @@ declare module 'joi' {
 		 */
 		forbidden(): T;
 
+		/**
+		 * Marks a key to be removed from a resulting object or array after validation. Used to sanitize output.
+		 */
+		strip(): T;
+
 		/**
 		 * Annotates the key
 		 */
@@ -152,12 +194,28 @@ declare module 'joi' {
 		/**
 		 * Sets the options.convert options to false which prevent type casting for the current key and any child keys.
 		 */
-		strict(): T;
+		strict(isStrict?: boolean): T;
 
 		/**
 		 * Sets a default value if the original value is undefined.
+		 * @param value - the value.
+		 *   value supports references.
+		 *   value may also be a function which returns the default value.
+		 *   If value is specified as a function that accepts a single parameter, that parameter will be a context
+		 *    object that can be used to derive the resulting value. This clones the object however, which incurs some
+		 *    overhead so if you don't need access to the context define your method so that it does not accept any
+		 *    parameters.
+		 *   Without any value, default has no effect, except for object that will then create nested defaults
+		 *    (applying inner defaults of that object).
+		 *
+		 * Note that if value is an object, any changes to the object after default() is called will change the
+		 *  reference and any future assignment.
+		 *
+		 * Additionally, when specifying a method you must either have a description property on your method or the
+		 *  second parameter is required.
 		 */
-		default(value: any): T;
+		default(value: any, description?: string): T;
+		default(): T;
 
 		/**
 		 * Returns a new type that is the result of adding the rules of one type to another.
@@ -169,6 +227,22 @@ declare module 'joi' {
 		 */
 		when(ref: string, options: WhenOptions): AlternativesSchema;
 		when(ref: Reference, options: WhenOptions): AlternativesSchema;
+
+		/**
+		 * Overrides the key name in error messages.
+		 */
+		label(name: string): T;
+
+		/**
+		 * Outputs the original untouched value instead of the casted value.
+		 */
+		raw(isRaw?: boolean): T;
+
+		/**
+		 * Considers anything that matches the schema to be empty (undefined).
+		 * @param schema - any object or joi schema to match. An undefined schema unsets that rule.
+		 */
+		empty(schema?: any) : T;
 	}
 
 	export interface BooleanSchema extends AnySchema<BooleanSchema> {
@@ -178,18 +252,57 @@ declare module 'joi' {
 	export interface NumberSchema extends AnySchema<NumberSchema> {
 		/**
 		 * Specifies the minimum value.
+		 * It can also be a reference to another field.
 		 */
 		min(limit: number): NumberSchema;
+		min(limit: Reference): NumberSchema;
 
 		/**
 		 * Specifies the maximum value.
+		 * It can also be a reference to another field.
 		 */
 		max(limit: number): NumberSchema;
+		max(limit: Reference): NumberSchema;
+
+		/**
+		 * Specifies that the value must be greater than limit.
+		 * It can also be a reference to another field.
+		 */
+		greater(limit: number): NumberSchema;
+		greater(limit: Reference): NumberSchema;
+
+		/**
+		 * Specifies that the value must be less than limit.
+		 * It can also be a reference to another field.
+		 */
+		less(limit: number): NumberSchema;
+		less(limit: Reference): NumberSchema;
 
 		/**
 		 * Requires the number to be an integer (no floating point).
 		 */
 		integer(): NumberSchema;
+
+		/**
+		 * Specifies the maximum number of decimal places where:
+		 *  limit - the maximum number of decimal places allowed.
+		 */
+		precision(limit: number): NumberSchema;
+
+		/**
+		 * Specifies that the value must be a multiple of base.
+		 */
+		multiple(base: number): NumberSchema;
+
+		/**
+		 * Requires the number to be positive.
+		 */
+		positive(): NumberSchema;
+
+		/**
+		 * Requires the number to be negative.
+		 */
+		negative(): NumberSchema;
 	}
 
 	export interface StringSchema extends AnySchema<StringSchema> {
@@ -200,23 +313,47 @@ declare module 'joi' {
 
 		/**
 		 * Specifies the minimum number string characters.
+		 * @param limit - the minimum number of string characters required. It can also be a reference to another field.
+		 * @param encoding - if specified, the string length is calculated in bytes using the provided encoding.
 		 */
-		min(limit: number): StringSchema;
+		min(limit: number, encoding?: string): StringSchema;
+		min(limit: Reference, encoding?: string): StringSchema;
 
 		/**
 		 * Specifies the maximum number of string characters.
+		 * @param limit - the maximum number of string characters allowed. It can also be a reference to another field.
+		 * @param encoding - if specified, the string length is calculated in bytes using the provided encoding.
 		 */
-		max(limit: number): StringSchema;
+		max(limit: number, encoding?: string): StringSchema;
+		max(limit: Reference, encoding?: string): StringSchema;
+
+		/**
+		 * Requires the number to be a credit card number (Using Lunh Algorithm).
+		 */
+		creditCard(): StringSchema;
 
 		/**
 		 * Specifies the exact string length required
+		 * @param limit - the required string length. It can also be a reference to another field.
+		 * @param encoding - if specified, the string length is calculated in bytes using the provided encoding.
 		 */
-		length(limit: number): StringSchema;
+		length(limit: number, encoding?: string): StringSchema;
+		length(limit: Reference, encoding?: string): StringSchema;
 
 		/**
 		 * Defines a regular expression rule.
+		 * @param pattern - a regular expression object the string value must match against.
+		 * @param name - optional name for patterns (useful with multiple patterns). Defaults to 'required'.
 		 */
-		regex(pattern: RegExp): StringSchema;
+		regex(pattern: RegExp, name?: string): StringSchema;
+
+		/**
+		 * Replace characters matching the given pattern with the specified replacement string where:
+		 * @param pattern - a regular expression object to match against, or a string of which all occurrences will be replaced.
+		 * @param replacement - the string that will replace the pattern.
+		 */
+		replace(pattern: RegExp, replacement: string): StringSchema;
+		replace(pattern: string, replacement: string): StringSchema;
 
 		/**
 		 * Requires the string value to only contain a-z, A-Z, and 0-9.
@@ -231,13 +368,33 @@ declare module 'joi' {
 		/**
 		 * Requires the string value to be a valid email address.
 		 */
-		email(): StringSchema;
+		email(options?: EmailOptions): StringSchema;
+
+		/**
+		 * Requires the string value to be a valid ip address.
+		 */
+		ip(options?: IpOptions): StringSchema;
+
+		/**
+		 * Requires the string value to be a valid RFC 3986 URI.
+		 */
+		uri(options?: UriOptions): StringSchema;
 
 		/**
 		 * Requires the string value to be a valid GUID.
 		 */
 		guid(): StringSchema;
 
+		/**
+		 * Requires the string value to be a valid hexadecimal string.
+		 */
+		hex(): StringSchema;
+
+		/**
+		 * Requires the string value to be a valid hostname as per RFC1123.
+		 */
+		hostname(): StringSchema;
+
 		/**
 		 * Requires the string value to be in valid ISO 8601 date format.
 		 */
@@ -257,25 +414,34 @@ declare module 'joi' {
 		 * Requires the string value to contain no whitespace before or after. If the validation convert option is on (enabled by default), the string will be trimmed.
 		 */
 		trim(): StringSchema;
-
-		/**
-		 * Requires the string value to be a valid uri with the passed scheme.
-		 */
-		uri(options?: { scheme?: string }): StringSchema;
 	}
 
 	export interface ArraySchema extends AnySchema<ArraySchema> {
 		/**
-		 * List the types allowed for the array value
+		 * Allow this array to be sparse.
+		 * enabled can be used with a falsy value to go back to the default behavior.
 		 */
-		includes(type: Schema, ...types: Schema[]): ArraySchema;
-		includes(types: Schema[]): ArraySchema;
+		sparse(enabled?: any): ArraySchema;
 
 		/**
-		 * List the types forbidden for the array values.
+		 * Allow single values to be checked against rules as if it were provided as an array.
+		 * enabled can be used with a falsy value to go back to the default behavior.
 		 */
-		excludes(type: Schema, ...types: Schema[]): ArraySchema;
-		excludes(types: Schema[]): ArraySchema;
+		single(enabled?: any): ArraySchema;
+
+		/**
+		 * List the types allowed for the array values.
+		 * type can be an array of values, or multiple values can be passed as individual arguments.
+		 * If a given type is .required() then there must be a matching item in the array.
+		 * If a type is .forbidden() then it cannot appear in the array.
+		 * Required items can be added multiple times to signify that multiple items must be found.
+		 * Errors will contain the number of items that didn't match.
+		 * Any unmatched item having a label will be mentioned explicitly.
+		 *
+		 * @param type - a joi schema object to validate each array item against.
+		 */
+		items(type: Schema, ...types: Schema[]): ArraySchema;
+		items(types: Schema[]): ArraySchema;
 
 		/**
 		 * Specifies the minimum number of items in the array.
@@ -292,6 +458,12 @@ declare module 'joi' {
 		 */
 		length(limit: number): ArraySchema;
 
+		/**
+		 * Requires the array values to be unique.
+		 * Be aware that a deep equality is performed on elements of the array having a type of object,
+		 * a performance penalty is to be expected for this kind of operation.
+		 */
+		unique(): ArraySchema;
 	}
 
 	export interface ObjectSchema extends AnySchema<ObjectSchema> {
@@ -322,20 +494,30 @@ declare module 'joi' {
 
 		/**
 		 * Defines an all-or-nothing relationship between keys where if one of the peers is present, all of them are required as well.
+		 * @param peers - the key names of which if one present, all are required. peers can be a single string value,
+		 * an array of string values, or each peer provided as an argument.
 		 */
-		and(peer1: string, peer2: string, ...peers: string[]): ObjectSchema;
+		and(peer1: string, ...peers: string[]): ObjectSchema;
 		and(peers: string[]): ObjectSchema;
 
+		/**
+		 * Defines a relationship between keys where not all peers can be present at the same time.
+		 * @param peers - the key names of which if one present, the others may not all be present.
+		 * peers can be a single string value, an array of string values, or each peer provided as an argument.
+		 */
+		nand(peer1: string, ...peers: string[]): ObjectSchema;
+		nand(peers: string[]): ObjectSchema;
+
 		/**
 		 * Defines a relationship between keys where one of the peers is required (and more than one is allowed).
 		 */
-		or(peer1: string, peer2: string, ...peers: string[]): ObjectSchema;
+		or(peer1: string, ...peers: string[]): ObjectSchema;
 		or(peers: string[]): ObjectSchema;
 
 		/**
 		 * Defines an exclusive relationship between a set of keys. one of them is required but not at the same time where:
 		 */
-		xor(peer1: string, peer2: string, ...peers: string[]): ObjectSchema;
+		xor(peer1: string, ...peers: string[]): ObjectSchema;
 		xor(peers: string[]): ObjectSchema;
 
 		/**
@@ -364,10 +546,48 @@ declare module 'joi' {
 		/**
 		 * Overrides the handling of unknown keys for the scope of the current object only (does not apply to children).
 		 */
-		unknown(allow?:boolean): ObjectSchema;
+		unknown(allow?: boolean): ObjectSchema;
+
+		/**
+		 * Requires the object to be an instance of a given constructor.
+		 *
+		 * @param constructor - the constructor function that the object must be an instance of.
+		 * @param name - an alternate name to use in validation errors. This is useful when the constructor function does not have a name.
+		 */
+		type(constructor: Function, name?: string): ObjectSchema;
+
+		/**
+		 * Sets the specified children to required.
+		 *
+		 * @param children - can be a single string value, an array of string values, or each child provided as an argument.
+		 *
+		 *   var schema = Joi.object().keys({ a: { b: Joi.number() }, c: { d: Joi.string() } });
+		 *   var requiredSchema = schema.requiredKeys('', 'a.b', 'c', 'c.d');
+		 *
+		 * Note that in this example '' means the current object, a is not required but b is, as well as c and d.
+		 */
+		requiredKeys(children: string): ObjectSchema;
+		requiredKeys(children: string[]): ObjectSchema;
+		requiredKeys(child:string, ...children: string[]): ObjectSchema;
+
+		/**
+		 * Sets the specified children to optional.
+		 *
+		 * @param children - can be a single string value, an array of string values, or each child provided as an argument.
+		 *
+		 * The behavior is exactly the same as requiredKeys.
+		 */
+		optionalKeys(children: string): ObjectSchema;
+		optionalKeys(children: string[]): ObjectSchema;
+		optionalKeys(child:string, ...children: string[]): ObjectSchema;
 	}
 
 	export interface BinarySchema extends AnySchema<BinarySchema> {
+		/**
+		 * Sets the string encoding format if a string input is converted to a buffer.
+		 */
+		encoding(encoding: string): BinarySchema;
+
 		/**
 		 * Specifies the minimum length of the buffer.
 		 */
@@ -388,17 +608,37 @@ declare module 'joi' {
 
 		/**
 		 * Specifies the oldest date allowed.
+		 * Notes: 'now' can be passed in lieu of date so as to always compare relatively to the current date,
+		 * allowing to explicitly ensure a date is either in the past or in the future.
+		 * It can also be a reference to another field.
 		 */
 		min(date: Date): DateSchema;
 		min(date: number): DateSchema;
 		min(date: string): DateSchema;
+		min(date: Reference): DateSchema;
 
 		/**
 		 * Specifies the latest date allowed.
+		 * Notes: 'now' can be passed in lieu of date so as to always compare relatively to the current date,
+		 * allowing to explicitly ensure a date is either in the past or in the future.
+		 * It can also be a reference to another field.
 		 */
 		max(date: Date): DateSchema;
 		max(date: number): DateSchema;
 		max(date: string): DateSchema;
+		max(date: Reference): DateSchema;
+
+		/**
+		 * Specifies the allowed date format:
+		 * @param format - string or array of strings that follow the moment.js format.
+		 */
+		format(format: string): DateSchema;
+		format(format: string[]): DateSchema;
+
+		/**
+		 * Requires the string value to be in valid ISO 8601 date format.
+		 */
+		iso(): DateSchema;
 	}
 
 	export interface FunctionSchema extends AnySchema<FunctionSchema> {
@@ -480,11 +720,15 @@ declare module 'joi' {
 
 	/**
 	 * Validates a value against a schema and throws if validation fails.
+	 *
+	 * @param value - the value to validate.
+	 * @param schema - the schema object.
+	 * @param message - optional message string prefix added in front of the error message. may also be an Error object.
 	 */
-	export function assert(value: any, schema: Schema): void;
+	export function assert(value: any, schema: Schema, message?: string | Error): void;
 
 	/**
 	 * Generates a reference to the value of the named key.
 	 */
-	export function ref(key:string, options?: ReferenceOptions): Reference;
+	export function ref(key: string, options?: ReferenceOptions): Reference;
 }
diff --git a/jquery.colorpicker/jquery.colorpicker.d.ts b/jquery.colorpicker/jquery.colorpicker.d.ts
index 683e28b96..5c89e4ed0 100644
--- a/jquery.colorpicker/jquery.colorpicker.d.ts
+++ b/jquery.colorpicker/jquery.colorpicker.d.ts
@@ -6,6 +6,15 @@
 /// <reference path="../jquery/jquery.d.ts" />
 
 interface JQueryColorpickerOptions {
+    // Events
+    // TODO: Figure out actual types.
+    cancel: Function,
+    close: Function,
+    init: Function,
+    select: Function,
+    ok: Function,
+    open: Function,
+
     alpha?: boolean;
     altAlpha?: boolean;
     altField?: string;
@@ -21,7 +30,7 @@ interface JQueryColorpickerOptions {
     closeOnOutside?: boolean;
     color?: string;
     colorFormat?: string;
-    dragggable?: boolean;
+    draggable?: boolean;
     duration?: string;
     hsv?: boolean;
     inline?: boolean;
diff --git a/jquery.contextMenu/jquery.contextMenu.d.ts.tscparams b/jquery.contextMenu/jquery.contextMenu.d.ts.tscparams
deleted file mode 100644
index 2f5856b19..000000000
--- a/jquery.contextMenu/jquery.contextMenu.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
---noImplicitAny
diff --git a/jquery.gridster/gridster.d.ts b/jquery.gridster/gridster.d.ts
index 53f26704e..e003f0ebc 100644
--- a/jquery.gridster/gridster.d.ts
+++ b/jquery.gridster/gridster.d.ts
@@ -184,6 +184,11 @@ interface Gridster {
 	**/
 	add_widget(html: HTMLElement, size_x?: number, size_y?: number, col?: number, row?: number): JQuery;
 
+	/**
+	* @see add_widget
+	**/
+	add_widget(html: JQuery, size_x?: number, size_y?: number, col?: number, row?: number): JQuery;
+
 	/**
 	* Change the size of a widget.
 	* @param $widget The jQuery wrapped HTMLElement that represents the widget is going to be resized.
@@ -208,6 +213,16 @@ interface Gridster {
 	**/
 	remove_widget(el: HTMLElement, callback: (el: HTMLElement) => void): Gridster;
 
+	/**
+	* @see remove_widget
+	**/
+	remove_widget(el: JQuery, silent?: boolean, callback?: (el: HTMLElement) => void): Gridster;
+
+	/**
+	* @see remove_widget
+	**/
+	remove_widget(el: JQuery, callback: (el: HTMLElement) => void): Gridster;
+
 	/**
 	* Returns a serialized array of the widgets in the grid.
 	* @param $widgets The collection of jQuery wrap ed HTMLElements you want to serialize.  If no argument is passed a l widgets will be serialized.
diff --git a/jquery.ui.layout/jquery.ui.layout.d.ts.tscparams b/jquery.ui.layout/jquery.ui.layout.d.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/jquery.ui.layout/jquery.ui.layout.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/katex/katex-tests.ts b/katex/katex-tests.ts
new file mode 100644
index 000000000..9829fcddf
--- /dev/null
+++ b/katex/katex-tests.ts
@@ -0,0 +1,18 @@
+/// <reference path="katex.d.ts" />
+
+import katexLib = require('katex');
+
+class KatexTest {
+	constructor() {
+		katexLib.render('My Latex String', document.createElement('div'));
+
+		try {
+			let options: katexLib.KatexOptions = { breakOnUnsupportedCmds: true };
+			let value: string = katexLib.renderToString('My Latex String', options);
+		} catch (error) {
+			if (error instanceof katexLib.ParseError) {
+				//do something with this error
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/katex/katex.d.ts b/katex/katex.d.ts
new file mode 100644
index 000000000..6d139ded1
--- /dev/null
+++ b/katex/katex.d.ts
@@ -0,0 +1,33 @@
+// Type definitions for KaTeX v.0.5.0
+// Project: http://khan.github.io/KaTeX/
+// Definitions by: Michael Randolph <https://github.com/mrand01>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "katex" {
+	interface KatexOptions {
+		displayMode?: boolean;
+		breakOnUnsupportedCmds?: boolean;
+		errorColor?: string;
+	}
+
+	class ParseError implements Error {
+		constructor(message: string, lexer: any, position: number);
+		name: string;
+		message: string;
+		position: number;
+	}
+	
+	/**
+	 * Renders a TeX expression into the specified DOM element
+	 * @param tex A TeX expression
+	 * @param element The DOM element to render into
+	 * @param options KaTeX options
+	 */
+	function render(tex: string, element: HTMLElement, options?:KatexOptions): void;
+	/**
+	 * Renders a TeX expression into an HTML string
+	 * @param tex A TeX expression
+	 * @param options KaTeX options
+	 */
+	function renderToString(tex: string, options?:KatexOptions): string;
+}
\ No newline at end of file
diff --git a/less/less-tests.ts.tscparams b/less/less-tests.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/less/less-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/less/less.d.ts.tscparams b/less/less.d.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/less/less.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index 14efc9c00..d36b5dfc4 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -89,6 +89,13 @@ class Dog {
 
 var result: any;
 
+// _.MapCache
+var testMapCache: _.MapCache;
+result = <(key: string) => boolean>testMapCache.delete;
+result = <(key: string) => any>testMapCache.get;
+result = <(key: string) => boolean>testMapCache.has;
+result = <(key: string, value: any) => _.Dictionary<any>>testMapCache.set;
+
 /*************
  * Chaining *
  *************/
@@ -354,10 +361,22 @@ result = <{ x: number; }[]>_([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }]).unique('x').v
 
 result = <number[]>_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
 
-result = <number[]>_.xor([1, 2, 3, 4, 5], [5, 2, 10]);
-result = <number[]>_.xor([1, 2, 3, 4, 5], [5, 2, 10], [4, 5, 6]);
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4, 5]).xor([5, 2, 10]);
-result = <_.LoDashArrayWrapper<number>>_([1, 2, 3, 4, 5]).xor([5, 2, 10], [4, 5, 6]);
+// _.xor
+var testXorArray: number[];
+var testXorList: _.List<number>;
+result = <number[]>_.xor<number>();
+result = <number[]>_.xor<number>(testXorArray);
+result = <number[]>_.xor<number>(testXorArray, testXorArray);
+result = <number[]>_.xor<number>(testXorArray, testXorArray, testXorArray);
+result = <number[]>_.xor<number>(testXorList);
+result = <number[]>_.xor<number>(testXorList, testXorList);
+result = <number[]>_.xor<number>(testXorList, testXorList, testXorList);
+result = <number[]>(_(testXorArray).xor().value());
+result = <number[]>(_(testXorArray).xor(testXorArray).value());
+result = <number[]>(_(testXorArray).xor(testXorArray, testXorArray).value());
+result = <number[]>(_(testXorList).xor().value());
+result = <number[]>(_(testXorList).xor(testXorList).value());
+result = <number[]>(_(testXorList).xor(testXorList, testXorList).value());
 
 result = <any[][]>_.zip(['moe', 'larry'], [30, 40], [true, false]);
 result = <any[][]>_.unzip(['moe', 'larry'], [30, 40], [true, false]);
@@ -909,17 +928,18 @@ var testFlowRightAddFn = (n: number, m: number) => n + m;
 result = <number>_.flowRight<(n: number, m: number) => number>(testFlowRightSquareFn, testFlowRightAddFn)(1, 2);
 result = <number>_(testFlowRightSquareFn).flowRight<(n: number, m: number) => number>(testFlowRightAddFn).value()(1, 2);
 
-var fibonacci = <Function>_.memoize(function (n: any): number {
-    return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
-});
-
-var data: { [index: string]: { name: string; age: number; } } = {
-    'moe': { 'name': 'moe', 'age': 40 },
-    'curly': { 'name': 'curly', 'age': 60 }
-};
-
-var stooge = _.memoize(function (name: string) { return data[name]; }, _.identity);
-stooge('curly');
+// _.memoize
+var testMemoizedFunction: _.MemoizedFunction;
+result = <_.MapCache>testMemoizedFunction.cache;
+interface TestMemoizedResultFn extends _.MemoizedFunction {
+    (...args: any[]): any;
+}
+var testMemoizeFn: (...args: any[]) => any;
+var testMemoizeResolverFn: (...args: any[]) => any;
+result = <TestMemoizedResultFn>_.memoize<TestMemoizedResultFn>(testMemoizeFn);
+result = <TestMemoizedResultFn>_.memoize<TestMemoizedResultFn>(testMemoizeFn, testMemoizeResolverFn);
+result = <TestMemoizedResultFn>(_(testMemoizeFn).memoize<TestMemoizedResultFn>().value());
+result = <TestMemoizedResultFn>(_(testMemoizeFn).memoize<TestMemoizedResultFn>(testMemoizeResolverFn).value());
 
 var returnedMemoize = _.throttle(function (a: any) { return a * 5; }, 5);
 returnedMemoize(4);
@@ -958,9 +978,10 @@ result = <TestNegateResult>_.negate<TestNegatePredicate, TestNegateResult>(testN
 result = <TestNegateResult>_(testNegatePredicate).negate().value();
 result = <TestNegateResult>_(testNegatePredicate).negate<TestNegateResult>().value();
 
-var initialize = _.once(function () { });
-initialize();
-initialize();
+// _.once
+result = <() => void>_.once<() => void>(function () {});
+result = <() => void>(_(function () {}).once().value());
+
 var returnedOnce = _.throttle(function (a: any) { return a * 5; }, 5);
 returnedOnce(4);
 
@@ -977,6 +998,16 @@ var optionsPartialRight = {
 
 defaultsDeep(optionsPartialRight, _.templateSettings);
 
+//_.rearg
+var testReargFn = (a: string, b: string, c: string) => [a, b, c];
+interface TestReargResultFn {
+    (b: string, c: string, a: string): string[];
+}
+result = <string[]>(_.rearg<TestReargResultFn>(testReargFn, 2, 0, 1))('b', 'c', 'a');
+result = <string[]>(_.rearg<TestReargResultFn>(testReargFn, [2, 0, 1]))('b', 'c', 'a');
+result = <string[]>(_(testReargFn).rearg<TestReargResultFn>(2, 0, 1).value())('b', 'c', 'a');
+result = <string[]>(_(testReargFn).rearg<TestReargResultFn>([2, 0, 1]).value())('b', 'c', 'a');
+
 //_.restParam
 var testRestParamFn = (a: string, b: string, c: number[]) => a + ' ' + b + ' ' + c.join(' ');
 interface testRestParamFunc {
@@ -989,6 +1020,14 @@ result = <string>(_.restParam<testRestParamResult, testRestParamFunc>(testRestPa
 result = <string>(_.restParam<testRestParamResult>(testRestParamFn, 2))('a', 'b', 1, 2, 3);
 result = <string>(_(testRestParamFn).restParam<testRestParamResult>(2).value())('a', 'b', 1, 2, 3);
 
+//_.spread
+var testSpreadFn = (who: string, what: string) => who + ' says ' + what;
+interface TestSpreadResultFn {
+    (args: string[]): string;
+}
+result = <string>(_.spread<TestSpreadResultFn>(testSpreadFn))(['fred', 'hello']);
+result = <string>(_(testSpreadFn).spread<TestSpreadResultFn>().value())(['fred', 'hello']);
+
 var throttled = _.throttle(function () { }, 100);
 jQuery(window).on('scroll', throttled);
 
@@ -1410,7 +1449,7 @@ result = <string>_.template('<% print("hello " + name); %>!', { 'name': 'larry'
 
 var listTemplate = '<% $.each(people, function(name) { %><li><%- name %></li><% }); %>';
 result = <string>_.template(listTemplate, { 'people': ['moe', 'larry'] }, { 'imports': { '$': jQuery } });
-result = <_.TemplateExecutor>_.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' });
+result = <_.TemplateExecutor>_.template('hello <%= name %>', null, /*sourceURL:*/ '/basic/greeting.jst');
 
 result = <_.TemplateExecutor>_.template('hi <%= data.name %>!', null, { 'variable': 'data' });
 result = <string>(<_.TemplateExecutor>result).source;
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index ea93f2e70..7c4111746 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -94,6 +94,40 @@ declare module _ {
         variable?: string;
     }
 
+    /**
+     * Creates a cache object to store key/value pairs.
+     */
+    interface MapCache {
+        /**
+         * Removes `key` and its value from the cache.
+         * @param key The key of the value to remove.
+         * @return Returns `true` if the entry was removed successfully, else `false`.
+         */
+        delete(key: string): boolean;
+
+        /**
+         * Gets the cached value for `key`.
+         * @param key The key of the value to get.
+         * @return Returns the cached value.
+         */
+        get(key: string): any;
+
+        /**
+         * Checks if a cached value for `key` exists.
+         * @param key The key of the entry to check.
+         * @return Returns `true` if an entry for `key` exists, else `false`.
+         */
+        has(key: string): boolean;
+
+        /**
+         * Sets `value` to `key` of the cache.
+         * @param key The key of the value to cache.
+         * @param value The value to cache.
+         * @return Returns the cache object.
+         */
+        set(key: string, value: any): _.Dictionary<any>;
+    }
+
     /**
     * An object used to flag environments features.
     **/
@@ -1868,33 +1902,25 @@ declare module _ {
     //_.xor
     interface LoDashStatic {
         /**
-        * Creates an array that is the symmetric difference of the provided arrays.
-        * @param array The array to process
-        * @param others The arrays of values to calculate the symmetric difference.
-        * @return Returns a new array of filtered values.
-        **/
-        xor<T>(
-            array: Array<T>,
-            ...others: Array<T>[]): T[];
-        /**
-        * @see _.xor
-        **/
-        xor<T>(
-            array: List<T>,
-            ...others: List<T>[]): T[];
+         * Creates an array of unique values that is the symmetric difference of the provided arrays.
+         * @param arrays The arrays to inspect.
+         * @return Returns the new array of values.
+         */
+        xor<T>(...arrays: List<T>[]): T[];
     }
 
     interface LoDashArrayWrapper<T> {
         /**
-        * @see _.xor
-        **/
-        xor(
-            ...others: Array<T>[]): LoDashArrayWrapper<T>;
+         * @see _.xor
+         */
+        xor(...arrays: T[][]): LoDashArrayWrapper<T>;
+    }
+
+    interface LoDashObjectWrapper<T> {
         /**
-        * @see _.xor
-        **/
-        xor(
-            ...others: List<T>[]): LoDashArrayWrapper<T>;
+         * @see _.xor
+         */
+        xor(...arrays: T[]): LoDashObjectWrapper<T>;
     }
 
     //_.zip
@@ -5534,20 +5560,30 @@ declare module _ {
     }
 
     //_.memoize
+    interface MemoizedFunction extends Function {
+        cache: MapCache;
+    }
+
     interface LoDashStatic {
         /**
-        * Creates a function that memoizes the result of func. If resolver is provided it will be
-        * used to determine the cache key for storing the result based on the arguments provided to
-        * the memoized function. By default, the first argument provided to the memoized function is
-        * used as the cache key. The func is executed with the this binding of the memoized function.
-        * The result cache is exposed as the cache property on the memoized function.
-        * @param func Computationally expensive function that will now memoized results.
-        * @param resolver Hash function for storing the result of `fn`.
-        * @return Returns the new memoizing function.
-        **/
-        memoize<T extends Function>(
-            func: T,
-            resolver?: Function): T;
+         * Creates a function that memoizes the result of func. If resolver is provided it determines the cache key for
+         * storing the result based on the arguments provided to the memoized function. By default, the first argument
+         * provided to the memoized function is coerced to a string and used as the cache key. The func is invoked with
+         * the this binding of the memoized function.
+         * @param func The function to have its output memoized.
+         * @param resolver The function to resolve the cache key.
+         * @return Returns the new memoizing function.
+         */
+        memoize<TResult extends MemoizedFunction>(
+            func: Function,
+            resolver?: Function): TResult;
+    }
+
+    interface LoDashObjectWrapper<T> {
+        /**
+         * @see _.memoize
+         */
+        memoize<TResult extends MemoizedFunction>(resolver?: Function): LoDashObjectWrapper<TResult>;
     }
 
     //_.modArgs
@@ -5616,15 +5652,22 @@ declare module _ {
     //_.once
     interface LoDashStatic {
         /**
-        * Creates a function that is restricted to execute func once. Repeat calls to the function
-        * will return the value of the first call. The func is executed with the this binding of the
-        * created function.
-        * @param func Function to only execute once.
-        * @return The new restricted function.
-        **/
+         * Creates a function that is restricted to invoking func once. Repeat calls to the function return the value
+         * of the first call. The func is invoked with the this binding and arguments of the created function.
+         * @param func The function to restrict.
+         * @return Returns the new restricted function.
+         */
+
         once<T extends Function>(func: T): T;
     }
 
+    interface LoDashObjectWrapper<T> {
+        /**
+         * @see _.once
+         */
+        once(): LoDashObjectWrapper<T>;
+    }
+
     //_.partial
     interface LoDashStatic {
         /**
@@ -5654,6 +5697,36 @@ declare module _ {
             ...args: any[]): Function;
     }
 
+    //_.rearg
+    interface LoDashStatic {
+        /**
+         * Creates a function that invokes func with arguments arranged according to the specified indexes where the
+         * argument value at the first index is provided as the first argument, the argument value at the second index
+         * is provided as the second argument, and so on.
+         * @param func The function to rearrange arguments for.
+         * @param indexes The arranged argument indexes, specified as individual indexes or arrays of indexes.
+         * @return Returns the new function.
+         */
+        rearg<TResult extends Function>(func: Function, indexes: number[]): TResult;
+
+        /**
+         * @see _.rearg
+         */
+        rearg<TResult extends Function>(func: Function, ...indexes: number[]): TResult;
+    }
+
+    interface LoDashObjectWrapper<T> {
+        /**
+         * @see _.rearg
+         */
+        rearg<TResult extends Function>(indexes: number[]): LoDashObjectWrapper<TResult>;
+
+        /**
+         * @see _.rearg
+         */
+        rearg<TResult extends Function>(...indexes: number[]): LoDashObjectWrapper<TResult>;
+    }
+
     //_.restParam
     interface LoDashStatic {
         /**
@@ -5678,6 +5751,25 @@ declare module _ {
         restParam<TResult extends Function>(start?: number): LoDashObjectWrapper<TResult>;
     }
 
+    //_.spread
+    interface LoDashStatic {
+        /**
+         * Creates a function that invokes func with the this binding of the created function and an array of arguments
+         * much like Function#apply.
+         * @param func The function to spread arguments over.
+         * @return Returns the new function.
+         */
+        spread<TResult extends Function>(func: Function): TResult;
+    }
+
+    interface LoDashObjectWrapper<T> {
+        /**
+         * @see _.spread
+         */
+        spread<TResult extends Function>(): LoDashObjectWrapper<TResult>;
+    }
+
+
     //_.throttle
     interface LoDashStatic {
         /**
diff --git a/loggly/loggly-tests.ts.tscparams b/loggly/loggly-tests.ts.tscparams
deleted file mode 100644
index 5f84b9777..000000000
--- a/loggly/loggly-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
---noImplicitAny --module commonjs --target es5
diff --git a/meteor/meteor.d.ts.tscparams b/meteor/meteor.d.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/meteor/meteor.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/metismenu/metismenu-tests.ts b/metismenu/metismenu-tests.ts
new file mode 100644
index 000000000..824beecbb
--- /dev/null
+++ b/metismenu/metismenu-tests.ts
@@ -0,0 +1,13 @@
+/// <reference path="../jquery/jquery.d.ts"/>
+/// <reference path="metismenu.d.ts"/>
+
+$('#menu').metisMenu();
+$('.metismenu').metisMenu({toggle: false});
+$('.test').metisMenu({
+    toggle: false,
+    doubleTapToGo: true,
+    activeClass: 'active',
+    collapseClass: 'collapse',
+    collapseInClass: 'in',
+    collapsingClass: 'collapsing'
+});
diff --git a/metismenu/metismenu.d.ts b/metismenu/metismenu.d.ts
new file mode 100644
index 000000000..a4dbdc0fd
--- /dev/null
+++ b/metismenu/metismenu.d.ts
@@ -0,0 +1,19 @@
+// Type definitions for metisMenu 2.0.3
+// Project: http://github.com/onokumus/metisMenu
+// Definitions by: onokums <https://github.com/onokumus/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../jquery/jquery.d.ts"/>
+
+interface MetisMenuOptions {
+    toggle?: boolean;
+    doubleTapToGo?: boolean;
+    activeClass?: string;
+    collapseClass?: string;
+    collapseInClass?: string;
+    collapsingClass?: string;
+}
+
+interface JQuery {
+    metisMenu(options?: MetisMenuOptions): JQuery;
+}
diff --git a/microsoft-live-connect/microsoft-live-connect-tests.ts b/microsoft-live-connect/microsoft-live-connect-tests.ts
index e6c1e2ad0..00f2208f0 100644
--- a/microsoft-live-connect/microsoft-live-connect-tests.ts
+++ b/microsoft-live-connect/microsoft-live-connect-tests.ts
@@ -467,7 +467,7 @@ var calendarCollection: Microsoft.Live.IObjectCollection<Microsoft.Live.ICalenda
 
 var newCalendar: Microsoft.Live.INewCalendar = {
     "name": "Summer Events",
-    "summary": "Things we are doing this summer."
+    "description": "Things we are doing this summer."
 };
 
 var newCalendarSub: Microsoft.Live.INewCalendarSubscription = {
diff --git a/mime/mime-tests.ts b/mime/mime-tests.ts
index 36f0e5c15..abfee0bd6 100644
--- a/mime/mime-tests.ts
+++ b/mime/mime-tests.ts
@@ -1,6 +1,6 @@
 /// <reference path="mime.d.ts" />
 
-import mime = require('mime');
+import * as mime from "mime";
 
 var str: string;
 var obj: Object;
diff --git a/modernizr/modernizr.d.ts b/modernizr/modernizr.d.ts
index 5827bbf9e..a9104fd22 100644
--- a/modernizr/modernizr.d.ts
+++ b/modernizr/modernizr.d.ts
@@ -96,9 +96,8 @@ interface ModernizrStatic {
     load(resourceObject: any): void;
     load(resourceString: string): void;
 
-    prefixed(): boolean;
-    prefixed(property: string): boolean;
-    prefixed(property: string, obj: any, element?: any): boolean;
+    prefixed(property: string): any;
+    prefixed(property: string, obj: any, element?: any): any;
 
     mq(mediaQuery: string): boolean;
 
diff --git a/moment/moment-node.d.ts b/moment/moment-node.d.ts
index fd0d59d68..3728f898f 100644
--- a/moment/moment-node.d.ts
+++ b/moment/moment-node.d.ts
@@ -7,28 +7,55 @@ declare module moment {
 
     interface MomentInput {
 
+        /** Year */
         years?: number;
+        /** Year */
+        year?: number;
+        /** Year */
         y?: number;
 
+        /** Month */
         months?: number;
+        /** Month */
+        month?: number;
+        /** Month */
         M?: number;
 
-        weeks?: number;
-        w?: number;
-
+        /** Day/Date */
         days?: number;
+        /** Day/Date */
+        day?: number;
+        /** Day/Date */
+        date?: number;
+        /** Day/Date */
         d?: number;
 
+        /** Hour */
         hours?: number;
+        /** Hour */
+        hour?: number;
+        /** Hour */
         h?: number;
 
+        /** Minute */
         minutes?: number;
+        /** Minute */
+        minute?: number;
+        /** Minute */
         m?: number;
 
+        /** Second */
         seconds?: number;
+        /** Second */
+        second?: number;
+        /** Second */
         s?: number;
 
+        /** Millisecond */
         milliseconds?: number;
+        /** Millisecond */
+        millisecond?: number;
+        /** Millisecond */
         ms?: number;
 
     }
diff --git a/node/node-tests.ts b/node/node-tests.ts
index fe63dc631..7978766eb 100644
--- a/node/node-tests.ts
+++ b/node/node-tests.ts
@@ -1,18 +1,17 @@
 /// <reference path="node.d.ts" />
-
-import assert = require("assert");
-import fs = require("fs");
-import events = require("events");
-import zlib = require("zlib");
-import url = require('url');
-import util = require("util");
-import crypto = require("crypto");
-import tls = require("tls");
-import http = require("http");
-import net = require("net");
-import dgram = require("dgram");
-import querystring = require('querystring');
-import path = require("path");
+import * as assert from "assert";
+import * as fs from "fs";
+import * as events from "events";
+import * as zlib from "zlib";
+import * as url from "url";
+import * as util from "util";
+import * as crypto from "crypto";
+import * as tls from "tls";
+import * as http from "http";
+import * as net from "net";
+import * as dgram from "dgram";
+import * as querystring from "querystring";
+import * as path from "path";
 
 assert(1 + 1 - 2 === 0, "The universe isn't how it should.");
 
diff --git a/node/node.d.ts b/node/node.d.ts
index d260c1966..1b661d8fa 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -422,9 +422,9 @@ declare module "events" {
 }
 
 declare module "http" {
-    import events = require("events");
-    import net = require("net");
-    import stream = require("stream");
+    import * as events from "events";
+    import * as net from "net";
+    import * as stream from "stream";
 
     export interface Server extends events.EventEmitter {
         listen(port: number, hostname?: string, backlog?: number, callback?: Function): Server;
@@ -568,8 +568,8 @@ declare module "http" {
 }
 
 declare module "cluster" {
-    import child  = require("child_process");
-    import events = require("events");
+    import * as child from "child_process";
+    import * as events from "events";
 
     export interface ClusterSettings {
         exec?: string;
@@ -608,7 +608,7 @@ declare module "cluster" {
 }
 
 declare module "zlib" {
-    import stream = require("stream");
+    import * as stream from "stream";
     export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; }
 
     export interface Gzip extends stream.Transform { }
@@ -693,9 +693,9 @@ declare module "os" {
 }
 
 declare module "https" {
-    import tls = require("tls");
-    import events = require("events");
-    import http = require("http");
+    import * as tls from "tls";
+    import * as events from "events";
+    import * as http from "http";
 
     export interface ServerOptions {
         pfx?: any;
@@ -759,8 +759,8 @@ declare module "punycode" {
 }
 
 declare module "repl" {
-    import stream = require("stream");
-    import events = require("events");
+    import * as stream from "stream";
+    import * as events from "events";
 
     export interface ReplOptions {
         prompt?: string;
@@ -777,8 +777,8 @@ declare module "repl" {
 }
 
 declare module "readline" {
-    import events = require("events");
-    import stream = require("stream");
+    import * as events from "events";
+    import * as stream from "stream";
 
     export interface ReadLine extends events.EventEmitter {
         setPrompt(prompt: string, length: number): void;
@@ -812,8 +812,8 @@ declare module "vm" {
 }
 
 declare module "child_process" {
-    import events = require("events");
-    import stream = require("stream");
+    import * as events from "events";
+    import * as stream from "stream";
 
     export interface ChildProcess extends events.EventEmitter {
         stdin:  stream.Writable;
@@ -939,7 +939,7 @@ declare module "dns" {
 }
 
 declare module "net" {
-    import stream = require("stream");
+    import * as stream from "stream";
 
     export interface Socket extends stream.Duplex {
         // Extended base methods
@@ -1007,7 +1007,7 @@ declare module "net" {
 }
 
 declare module "dgram" {
-    import events = require("events");
+    import * as events from "events";
 
     interface RemoteInfo {
         address: string;
@@ -1037,8 +1037,8 @@ declare module "dgram" {
 }
 
 declare module "fs" {
-    import stream = require("stream");
-    import events = require("events");
+    import * as stream from "stream";
+    import * as events from "events";
 
     interface Stats {
         isFile(): boolean;
@@ -1476,9 +1476,9 @@ declare module "string_decoder" {
 }
 
 declare module "tls" {
-    import crypto = require("crypto");
-    import net = require("net");
-    import stream = require("stream");
+    import * as crypto from "crypto";
+    import * as net from "net";
+    import * as stream from "stream";
 
     var CLIENT_RENEG_LIMIT: number;
     var CLIENT_RENEG_WINDOW: number;
@@ -1654,7 +1654,7 @@ declare module "crypto" {
 }
 
 declare module "stream" {
-    import events = require("events");
+    import * as events from "events";
 
     export interface Stream extends events.EventEmitter {
         pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
@@ -1819,7 +1819,7 @@ declare module "assert" {
 }
 
 declare module "tty" {
-    import net = require("net");
+    import * as net from "net";
 
     export function isatty(fd: number): boolean;
     export interface ReadStream extends net.Socket {
@@ -1833,7 +1833,7 @@ declare module "tty" {
 }
 
 declare module "domain" {
-    import events = require("events");
+    import * as events from "events";
 
     export class Domain extends events.EventEmitter {
         run(fn: Function): void;
diff --git a/nouislider/nouislider.d.ts b/nouislider/nouislider.d.ts
index 5b1700b23..e82418d97 100644
--- a/nouislider/nouislider.d.ts
+++ b/nouislider/nouislider.d.ts
@@ -82,7 +82,7 @@ interface noUiSliderOptions {
     animate?: boolean;
     /**
      * All values on the slider are part of a range. The range has a minimum and maximum value.
-     *
+     */
     behaviour?: string;
     /**
      * To format the slider output, noUiSlider offers a format option. 
diff --git a/passport-facebook-token/passport-facebook-token-tests.ts.tscparams b/passport-facebook-token/passport-facebook-token-tests.ts.tscparams
deleted file mode 100644
index 5f84b9777..000000000
--- a/passport-facebook-token/passport-facebook-token-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
---noImplicitAny --module commonjs --target es5
diff --git a/pdfkit/pdfkit-tests.ts b/pdfkit/pdfkit-tests.ts
index f60a00b1c..87263e932 100644
--- a/pdfkit/pdfkit-tests.ts
+++ b/pdfkit/pdfkit-tests.ts
@@ -24,7 +24,7 @@ doc.addPage({
 });
 
 doc.addPage({
-  margins: {
+  margin: {
     top: 50,
     bottom: 50,
     left: 72,
diff --git a/postal/postal-0.8.9.d.ts b/postal/postal-0.8.9.d.ts
new file mode 100644
index 000000000..0ef40c5d5
--- /dev/null
+++ b/postal/postal-0.8.9.d.ts
@@ -0,0 +1,71 @@
+// Type definitions for Postal v0.8.9
+// Project: https://github.com/postaljs/postal.js
+// Definitions by: Lokesh Peta <https://github.com/lokeshpeta/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../underscore/underscore.d.ts" />
+
+interface IConfiguration{
+	SYSTEM_CHANNEL: string;
+	DEFAULT_CHANNEL: string;
+	resolver: any;
+}
+
+interface ISubscriptionDefinition{
+	unsubscribe(): void;
+	subscribe(callback: (data: any, envelope: IEnvelope)=> void): void;
+	defer():ISubscriptionDefinition;
+	disposeAfter(maxCalls: number): ISubscriptionDefinition;
+	distinctUntilChanged(): ISubscriptionDefinition;
+	once(): ISubscriptionDefinition;
+	withConstraint(predicate: Function): ISubscriptionDefinition;
+	withConstraints(predicates: Array<Function>): ISubscriptionDefinition;
+	
+	withContext(context: any): ISubscriptionDefinition;
+	withDebounce(milliseconds: number, immediate: boolean ): ISubscriptionDefinition;
+	withDelay(milliseconds: number): ISubscriptionDefinition;
+	withThrottle(milliseconds: number): ISubscriptionDefinition;
+}
+
+interface IEnvelope{
+	topic: string;
+	data?: any;
+
+	/*Uses DEFAULT_CHANNEL if no channel is provided*/
+	channel?: string;
+
+	timeStamp?: string;
+}
+
+
+interface IChannelDefinition {
+	subscribe(topic: string): ISubscriptionDefinition;
+	subscribe(topic: string, callback: (data: any, envelope: IEnvelope)=> void): ISubscriptionDefinition;
+
+	publish(topic: string, data?: any): void;
+	publish(envelope: IEnvelope): void;
+
+	channel: string;
+}
+
+interface IPostalUtils{
+	getSubscribersFor(channel: string, tpc: any): any;
+	reset(): void;
+}
+
+interface IPostal {
+	channel(name?:string): IChannelDefinition;
+	
+	linkChannels(sources: IEnvelope | IEnvelope[], destinations:  IEnvelope | IEnvelope[]): ISubscriptionDefinition[];
+	
+	utils: IPostalUtils;
+
+	configuration: IConfiguration;
+}
+
+declare var postal: IPostal;
+
+declare module "postal" {
+    var postal: IPostal;
+    export = postal;
+}
\ No newline at end of file
diff --git a/postal/postal.d.ts b/postal/postal.d.ts
index 0ef40c5d5..e1bad48cc 100644
--- a/postal/postal.d.ts
+++ b/postal/postal.d.ts
@@ -1,33 +1,48 @@
-// Type definitions for Postal v0.8.9
+// Type definitions for Postal v1.0.6
 // Project: https://github.com/postaljs/postal.js
-// Definitions by: Lokesh Peta <https://github.com/lokeshpeta/>
+// Definitions by: Lokesh Peta <https://github.com/lokeshpeta/>, Paul Jolly <https://github.com/myitcv>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-/// <reference path="../underscore/underscore.d.ts" />
-
-interface IConfiguration{
+interface IConfiguration {
 	SYSTEM_CHANNEL: string;
 	DEFAULT_CHANNEL: string;
-	resolver: any;
+	resolver: IResolver;
 }
 
-interface ISubscriptionDefinition{
-	unsubscribe(): void;
-	subscribe(callback: (data: any, envelope: IEnvelope)=> void): void;
-	defer():ISubscriptionDefinition;
+interface IResolver {
+	compare(binding: string, topic: string, headerOptions: {}): boolean;
+	reset(): void;
+	purge(options?: {topic?: string, binding?: string, compact?: boolean}): void;
+}
+
+interface ICallback {
+	(data: any, envelope: IEnvelope): void
+}
+
+interface ISubscriptionDefinition {
+	channel: string;
+	topic: string;
+	callback: ICallback;
+
+	// after and before lack documentation
+
+	constraint(predicateFn: (data: any, envelope: IEnvelope) => boolean): ISubscriptionDefinition;
+	constraints(predicateFns: ((data: any, envelope: IEnvelope) => boolean)[]): ISubscriptionDefinition;
+	context(theContext: any): ISubscriptionDefinition;
+	debounce(interval: number): ISubscriptionDefinition;
+	defer(): ISubscriptionDefinition;
+	delay(waitTime: number): ISubscriptionDefinition;
 	disposeAfter(maxCalls: number): ISubscriptionDefinition;
+	distinct(): ISubscriptionDefinition;
 	distinctUntilChanged(): ISubscriptionDefinition;
+	logError(): ISubscriptionDefinition;
 	once(): ISubscriptionDefinition;
-	withConstraint(predicate: Function): ISubscriptionDefinition;
-	withConstraints(predicates: Array<Function>): ISubscriptionDefinition;
-	
-	withContext(context: any): ISubscriptionDefinition;
-	withDebounce(milliseconds: number, immediate: boolean ): ISubscriptionDefinition;
-	withDelay(milliseconds: number): ISubscriptionDefinition;
-	withThrottle(milliseconds: number): ISubscriptionDefinition;
+	throttle(interval: number): ISubscriptionDefinition;
+	subscribe(callback: ICallback): ISubscriptionDefinition;
+	unsubscribe(): void;
 }
 
-interface IEnvelope{
+interface IEnvelope {
 	topic: string;
 	data?: any;
 
@@ -39,26 +54,45 @@ interface IEnvelope{
 
 
 interface IChannelDefinition {
-	subscribe(topic: string): ISubscriptionDefinition;
-	subscribe(topic: string, callback: (data: any, envelope: IEnvelope)=> void): ISubscriptionDefinition;
+	subscribe(topic: string, callback: ICallback): ISubscriptionDefinition;
 
 	publish(topic: string, data?: any): void;
-	publish(envelope: IEnvelope): void;
 
 	channel: string;
 }
 
-interface IPostalUtils{
-	getSubscribersFor(channel: string, tpc: any): any;
-	reset(): void;
+interface ISourceArg {
+	topic: string;
+	channel?: string;
+}
+
+interface IDestinationArg {
+	topic: string | ((topic: string) => string);
+	channel?: string;
 }
 
 interface IPostal {
-	channel(name?:string): IChannelDefinition;
-	
-	linkChannels(sources: IEnvelope | IEnvelope[], destinations:  IEnvelope | IEnvelope[]): ISubscriptionDefinition[];
-	
-	utils: IPostalUtils;
+	subscriptions: {};
+	wiretaps: ICallback[];
+
+	addWireTap(callback: ICallback): () => void;
+
+	channel(name?: string): IChannelDefinition;
+
+	getSubscribersFor(): ISubscriptionDefinition[];
+	getSubscribersFor(options: {channel?: string, topic?: string, context?: any}): ISubscriptionDefinition[];
+	getSubscribersFor(predicateFn: (sub: ISubscriptionDefinition) => boolean): ISubscriptionDefinition[];
+
+	linkChannels(source: ISourceArg | ISourceArg[], destination: IDestinationArg | IDestinationArg[]): void;
+
+	publish(envelope: IEnvelope): void;
+
+	reset(): void;
+
+	subscribe(options: {channel?: string, topic: string, callback: ICallback}): ISubscriptionDefinition;
+	unsubscribe(sub: ISubscriptionDefinition): void;
+	unsubscribeFor(): void;
+	unsubscribeFor(options: {channel?: string, topic?: string, context?: any}): void;
 
 	configuration: IConfiguration;
 }
@@ -66,6 +100,7 @@ interface IPostal {
 declare var postal: IPostal;
 
 declare module "postal" {
-    var postal: IPostal;
-    export = postal;
-}
\ No newline at end of file
+	var postal: IPostal;
+	export = postal;
+}
+
diff --git a/qtip2/qtip2-tests.ts.tscparams b/qtip2/qtip2-tests.ts.tscparams
deleted file mode 100644
index 2280b0116..000000000
--- a/qtip2/qtip2-tests.ts.tscparams
+++ /dev/null
@@ -1,2 +0,0 @@
-
---noImplicitAny
\ No newline at end of file
diff --git a/react-dnd/react-dnd-tests.ts b/react-dnd/react-dnd-tests.ts
index 244144029..d270a041d 100644
--- a/react-dnd/react-dnd-tests.ts
+++ b/react-dnd/react-dnd-tests.ts
@@ -13,6 +13,7 @@ import DragSource = ReactDnd.DragSource;
 import DropTarget = ReactDnd.DropTarget;
 import DragDropContext = ReactDnd.DragDropContext;
 import HTML5Backend = require('react-dnd/modules/backends/HTML5');
+import TestBackend = require('react-dnd/modules/backends/Test');
 
 // Game Component
 // ----------------------------------------------------------------------
@@ -247,14 +248,18 @@ module Board {
         }
     }
 
-    var DndBoard = DragDropContext(HTML5Backend)(Board);
-    export var create = React.createFactory(DndBoard);
+    export var createWithHTMLBackend = React.createFactory(DragDropContext(HTML5Backend)(Board));
+    export var createWithTestBackend = React.createFactory(DragDropContext(TestBackend)(Board));
 }
 
-
 // Render the Board Component
 // ----------------------------------------------------------------------
 
-Board.create({
+Board.createWithHTMLBackend({
+    knightPosition: [0, 0]
+});
+
+
+Board.createWithTestBackend({
     knightPosition: [0, 0]
 });
diff --git a/react-dnd/react-dnd.d.ts b/react-dnd/react-dnd.d.ts
index 86eab01cd..d86af3b8b 100644
--- a/react-dnd/react-dnd.d.ts
+++ b/react-dnd/react-dnd.d.ts
@@ -170,3 +170,19 @@ declare module "react-dnd/modules/backends/HTML5" {
 
     export = HTML5Backend;
 }
+
+declare module "react-dnd/modules/backends/Test" {
+    class TestBackend {
+        setup(): void;
+        teardown(): void;
+        connectDragSource(): void;
+        connectDropTarget(): void;
+        simulateBeginDrag(sourceIds: __ReactDnd.Identifier[], options?: {}): void;
+        simulatePublishDragSource(): void;
+        simulateHover(targetIds: __ReactDnd.Identifier[], options?: {}): void;
+        simulateDrop(): void;
+        simulateEndDrag(): void;
+    }
+
+    export = TestBackend;
+}
diff --git a/react/react-addons-tests.ts b/react/react-addons-tests.ts
index 492fe4d81..6976d9959 100644
--- a/react/react-addons-tests.ts
+++ b/react/react-addons-tests.ts
@@ -84,6 +84,8 @@ class ModernComponent extends React.Component<Props, State>
         someOtherValue: React.PropTypes.string
     }
     
+    context: Context;
+    
     getChildContext() {
         return {
             someOtherValue: 'foo'
diff --git a/react/react-addons.d.ts b/react/react-addons.d.ts
index 37cde636d..d9915e502 100644
--- a/react/react-addons.d.ts
+++ b/react/react-addons.d.ts
@@ -137,7 +137,7 @@ declare module "react/addons" {
         forceUpdate(): void;
         props: P;
         state: S;
-        context: any;
+        context: {};
         refs: {
             [key: string]: Component<any, any>
         };
@@ -428,6 +428,8 @@ declare module "react/addons" {
         crossOrigin?: string;
         data?: string;
         dateTime?: string;
+        defaultChecked?: boolean;
+        defaultValue?: string;
         defer?: boolean;
         dir?: string;
         disabled?: boolean;
@@ -534,6 +536,7 @@ declare module "react/addons" {
         fy?: number | string;
         gradientTransform?: string;
         gradientUnits?: string;
+        height?: number | string;
         markerEnd?: string;
         markerMid?: string;
         markerStart?: string;
@@ -558,6 +561,7 @@ declare module "react/addons" {
         transform?: string;
         version?: string;
         viewBox?: string;
+        width?: number | string;
         x1?: number | string;
         x2?: number | string;
         x?: number | string;
@@ -1048,4 +1052,3 @@ declare module "react/addons" {
         identifiedTouch(identifier: number): Touch;
     }
 }
-
diff --git a/react/react-global.d.ts b/react/react-global.d.ts
index 4ba7266eb..f8b376355 100644
--- a/react/react-global.d.ts
+++ b/react/react-global.d.ts
@@ -139,7 +139,7 @@ declare module React {
         render(): JSX.Element;
         props: P;
         state: S;
-        context: any;
+        context: {};
         refs: {
             [key: string]: Component<any, any>
         };
@@ -430,6 +430,8 @@ declare module React {
         crossOrigin?: string;
         data?: string;
         dateTime?: string;
+        defaultChecked?: boolean;
+        defaultValue?: string;
         defer?: boolean;
         dir?: string;
         disabled?: boolean;
@@ -541,6 +543,7 @@ declare module React {
         fy?: number | string;
         gradientTransform?: string;
         gradientUnits?: string;
+        height?: number | string;
         markerEnd?: string;
         markerMid?: string;
         markerStart?: string;
@@ -565,6 +568,7 @@ declare module React {
         transform?: string;
         version?: string;
         viewBox?: string;
+        width?: number | string;
         x1?: number | string;
         x2?: number | string;
         x?: number | string;
diff --git a/react/react-tests.ts b/react/react-tests.ts
index 1fd2670de..a4d2c4f7a 100644
--- a/react/react-tests.ts
+++ b/react/react-tests.ts
@@ -82,6 +82,8 @@ class ModernComponent extends React.Component<Props, State>
         someOtherValue: React.PropTypes.string
     }
     
+    context: Context;
+    
     getChildContext() {
         return {
             someOtherValue: 'foo'
diff --git a/react/react.d.ts b/react/react.d.ts
index 0ed794f1e..218c6c94a 100644
--- a/react/react.d.ts
+++ b/react/react.d.ts
@@ -139,7 +139,7 @@ declare module __React {
         render(): JSX.Element;
         props: P;
         state: S;
-        context: any;
+        context: {};
         refs: {
             [key: string]: Component<any, any>
         };
@@ -430,6 +430,8 @@ declare module __React {
         crossOrigin?: string;
         data?: string;
         dateTime?: string;
+        defaultChecked?: boolean;
+        defaultValue?: string;
         defer?: boolean;
         dir?: string;
         disabled?: boolean;
@@ -541,6 +543,7 @@ declare module __React {
         fy?: number | string;
         gradientTransform?: string;
         gradientUnits?: string;
+        height?: number | string;
         markerEnd?: string;
         markerMid?: string;
         markerStart?: string;
@@ -565,6 +568,7 @@ declare module __React {
         transform?: string;
         version?: string;
         viewBox?: string;
+        width?: number | string;
         x1?: number | string;
         x2?: number | string;
         x?: number | string;
diff --git a/resemblejs/resemblejs-tests.ts b/resemblejs/resemblejs-tests.ts
index 163903fef..03140cb42 100644
--- a/resemblejs/resemblejs-tests.ts
+++ b/resemblejs/resemblejs-tests.ts
@@ -1,4 +1,4 @@
-/// <reference path="resemble.d.ts" />
+/// <reference path="resemblejs.d.ts" />
 
 resemble.outputSettings({
   errorColor: {
@@ -14,7 +14,7 @@ resemble.outputSettings({
 resemble("images/image.png").onComplete(function(data) {
   var r: number = data.red;
   var g: number = data.green;
-  var b: number = data.blue;  
+  var b: number = data.blue;
   var brightness: number = data.brightness;
 });
 
@@ -31,4 +31,3 @@ resemble("images/image2.png").compareTo("images/image2.png")
   var diffImageDataUrl: string = data.getImageDataUrl();
   var difference: number = data.misMatchPercentage;
 });
-
diff --git a/royalslider/royalslider-tests.ts b/royalslider/royalslider-tests.ts
index f79bd413b..6cafcb6d6 100644
--- a/royalslider/royalslider-tests.ts
+++ b/royalslider/royalslider-tests.ts
@@ -27,7 +27,7 @@ jQuery(document).ready(function () {
         fullscreen: {
             // fullscreen options go gere
             enabled: true,
-            native: true
+            nativeFS: true
         }
     });
 });
@@ -49,7 +49,7 @@ jQuery(document).ready(function () {
     $(".royalSlider").royalSlider({
         // general options go gere
         autoScaleSlider: true,
-        autoPlay: {
+        autoplay: {
             // autoplay options go gere
             enabled: true,
             pauseOnHover: true
diff --git a/sequelize/sequelize-tests-2.0.0.ts b/sequelize/sequelize-tests-2.0.0.ts
index b3a869a94..d35074e08 100644
--- a/sequelize/sequelize-tests-2.0.0.ts
+++ b/sequelize/sequelize-tests-2.0.0.ts
@@ -213,4 +213,215 @@ promiseMe = myModelInst.increment({});
 promiseMe = myModelInst.decrement({}, incrOpts);
 isBool = myModelInst.equal(myModelInst);
 isBool = myModelInst.equalsOneOf([myModelInst]);
-myModelPojo = myModelInst.toJSON();
\ No newline at end of file
+myModelPojo = myModelInst.toJSON();
+
+
+// data types test
+var types:any = Sequelize.STRING;
+types = Sequelize.STRING(12);
+types = Sequelize.STRING(12, true);
+types = Sequelize.STRING.BINARY;
+types = Sequelize.STRING(12).BINARY;
+types = Sequelize.STRING.BINARY(12);
+types = Sequelize.STRING({length:12, binary:true});
+types = Sequelize.STRING({length:12}).BINARY;
+
+types = Sequelize.CHAR;
+types = Sequelize.CHAR(12);
+types = Sequelize.CHAR(12, true);
+types = Sequelize.CHAR.BINARY;
+types = Sequelize.CHAR(12).BINARY;
+types = Sequelize.CHAR.BINARY(12);
+types = Sequelize.CHAR({length:12, binary:true});
+types = Sequelize.CHAR({length:12}).BINARY;
+
+types = Sequelize.TEXT;
+types = Sequelize.TEXT('tiny');
+types = Sequelize.TEXT({length:'tiny'});
+
+types = Sequelize.NUMBER;
+var numberOptions = {length:12, zerofill:true, decimals:1, precision:1, scale:1, unsigned:true};
+types = Sequelize.NUMBER(numberOptions);
+
+types = Sequelize.INTEGER;
+types = Sequelize.INTEGER.ZEROFILL;
+types = Sequelize.INTEGER.UNSIGNED;
+types = Sequelize.INTEGER.ZEROFILL.UNSIGNED;
+types = Sequelize.INTEGER.UNSIGNED.ZEROFILL;
+types = Sequelize.INTEGER(12);
+types = Sequelize.INTEGER(12).ZEROFILL;
+types = Sequelize.INTEGER(12).UNSIGNED;
+types = Sequelize.INTEGER(12).ZEROFILL.UNSIGNED;
+types = Sequelize.INTEGER(12).UNSIGNED.ZEROFILL;
+types = Sequelize.INTEGER(numberOptions);
+types = Sequelize.INTEGER(numberOptions).ZEROFILL;
+types = Sequelize.INTEGER(numberOptions).UNSIGNED;
+types = Sequelize.INTEGER(numberOptions).ZEROFILL.UNSIGNED;
+types = Sequelize.INTEGER(numberOptions).UNSIGNED.ZEROFILL;
+
+types = Sequelize.BIGINT;
+types = Sequelize.BIGINT.ZEROFILL;
+types = Sequelize.BIGINT.UNSIGNED;
+types = Sequelize.BIGINT.ZEROFILL.UNSIGNED;
+types = Sequelize.BIGINT.UNSIGNED.ZEROFILL;
+types = Sequelize.BIGINT(12);
+types = Sequelize.BIGINT(12).ZEROFILL;
+types = Sequelize.BIGINT(12).UNSIGNED;
+types = Sequelize.BIGINT(12).ZEROFILL.UNSIGNED;
+types = Sequelize.BIGINT(12).UNSIGNED.ZEROFILL;
+types = Sequelize.BIGINT(numberOptions);
+types = Sequelize.BIGINT(numberOptions).ZEROFILL;
+types = Sequelize.BIGINT(numberOptions).UNSIGNED;
+types = Sequelize.BIGINT(numberOptions).ZEROFILL.UNSIGNED;
+types = Sequelize.BIGINT(numberOptions).UNSIGNED.ZEROFILL;
+
+types = Sequelize.FLOAT;
+types = Sequelize.FLOAT.ZEROFILL;
+types = Sequelize.FLOAT.UNSIGNED;
+types = Sequelize.FLOAT.ZEROFILL.UNSIGNED;
+types = Sequelize.FLOAT.UNSIGNED.ZEROFILL;
+types = Sequelize.FLOAT(12);
+types = Sequelize.FLOAT(12).ZEROFILL;
+types = Sequelize.FLOAT(12).UNSIGNED;
+types = Sequelize.FLOAT(12).ZEROFILL.UNSIGNED;
+types = Sequelize.FLOAT(12).UNSIGNED.ZEROFILL;
+types = Sequelize.FLOAT(12,12);
+types = Sequelize.FLOAT(12,12).ZEROFILL;
+types = Sequelize.FLOAT(12,12).UNSIGNED;
+types = Sequelize.FLOAT(12,12).ZEROFILL.UNSIGNED;
+types = Sequelize.FLOAT(12,12).UNSIGNED.ZEROFILL;
+types = Sequelize.FLOAT(numberOptions);
+types = Sequelize.FLOAT(numberOptions).ZEROFILL;
+types = Sequelize.FLOAT(numberOptions).UNSIGNED;
+types = Sequelize.FLOAT(numberOptions).ZEROFILL.UNSIGNED;
+types = Sequelize.FLOAT(numberOptions).UNSIGNED.ZEROFILL;
+
+types = Sequelize.DOUBLE;
+types = Sequelize.DOUBLE.ZEROFILL;
+types = Sequelize.DOUBLE.UNSIGNED;
+types = Sequelize.DOUBLE.ZEROFILL.UNSIGNED;
+types = Sequelize.DOUBLE.UNSIGNED.ZEROFILL;
+types = Sequelize.DOUBLE(12);
+types = Sequelize.DOUBLE(12).ZEROFILL;
+types = Sequelize.DOUBLE(12).UNSIGNED;
+types = Sequelize.DOUBLE(12).ZEROFILL.UNSIGNED;
+types = Sequelize.DOUBLE(12).UNSIGNED.ZEROFILL;
+types = Sequelize.DOUBLE(12,12);
+types = Sequelize.DOUBLE(12,12).ZEROFILL;
+types = Sequelize.DOUBLE(12,12).UNSIGNED;
+types = Sequelize.DOUBLE(12,12).ZEROFILL.UNSIGNED;
+types = Sequelize.DOUBLE(12,12).UNSIGNED.ZEROFILL;
+types = Sequelize.DOUBLE(numberOptions);
+types = Sequelize.DOUBLE(numberOptions).ZEROFILL;
+types = Sequelize.DOUBLE(numberOptions).UNSIGNED;
+types = Sequelize.DOUBLE(numberOptions).ZEROFILL.UNSIGNED;
+types = Sequelize.DOUBLE(numberOptions).UNSIGNED.ZEROFILL;
+
+types = Sequelize.TIME;
+types = Sequelize.DATE;
+types = Sequelize.DATEONLY;
+types = Sequelize.BOOLEAN;
+types = Sequelize.NOW;
+
+types = Sequelize.BLOB;
+types = Sequelize.BLOB('tiny');
+types = Sequelize.BLOB({length:'tiny'});
+
+types = Sequelize.DECIMAL;
+types = Sequelize.DECIMAL.ZEROFILL;
+types = Sequelize.DECIMAL.UNSIGNED;
+types = Sequelize.DECIMAL.ZEROFILL.UNSIGNED;
+types = Sequelize.DECIMAL.UNSIGNED.ZEROFILL;
+types = Sequelize.DECIMAL(12,12);
+types = Sequelize.DECIMAL(12,12).ZEROFILL;
+types = Sequelize.DECIMAL(12,12).UNSIGNED;
+types = Sequelize.DECIMAL(12,12).ZEROFILL.UNSIGNED;
+types = Sequelize.DECIMAL(12,12).UNSIGNED.ZEROFILL;
+types = Sequelize.DECIMAL(numberOptions);
+types = Sequelize.DECIMAL(numberOptions).ZEROFILL;
+types = Sequelize.DECIMAL(numberOptions).UNSIGNED;
+types = Sequelize.DECIMAL(numberOptions).ZEROFILL.UNSIGNED;
+types = Sequelize.DECIMAL(numberOptions).UNSIGNED.ZEROFILL;
+
+types = Sequelize.NUMERIC;
+types = Sequelize.NUMERIC.ZEROFILL;
+types = Sequelize.NUMERIC.UNSIGNED;
+types = Sequelize.NUMERIC.ZEROFILL.UNSIGNED;
+types = Sequelize.NUMERIC.UNSIGNED.ZEROFILL;
+types = Sequelize.NUMERIC(12,12);
+types = Sequelize.NUMERIC(12,12).ZEROFILL;
+types = Sequelize.NUMERIC(12,12).UNSIGNED;
+types = Sequelize.NUMERIC(12,12).ZEROFILL.UNSIGNED;
+types = Sequelize.NUMERIC(12,12).UNSIGNED.ZEROFILL;
+types = Sequelize.NUMERIC(numberOptions);
+types = Sequelize.NUMERIC(numberOptions).ZEROFILL;
+types = Sequelize.NUMERIC(numberOptions).UNSIGNED;
+types = Sequelize.NUMERIC(numberOptions).ZEROFILL.UNSIGNED;
+types = Sequelize.NUMERIC(numberOptions).UNSIGNED.ZEROFILL;
+
+types = Sequelize.UUID;
+types = Sequelize.UUIDV1;
+types = Sequelize.UUIDV4;
+types = Sequelize.HSTORE;
+types = Sequelize.JSON;
+types = Sequelize.JSONB;
+types = Sequelize.VIRTUAL;
+
+types = Sequelize.ARRAY(Sequelize.INTEGER(12));
+types = Sequelize.ARRAY({type: Sequelize.BLOB});
+var obj = {};
+var isbool:boolean = types.is(obj, obj);
+
+types = Sequelize.NONE;
+types = Sequelize.ENUM("one", "two", 'three');
+
+types = Sequelize.RANGE(Sequelize.INTEGER(12));
+types = Sequelize.RANGE({subtype: Sequelize.BLOB});
+
+types = Sequelize.REAL;
+types = Sequelize.REAL.ZEROFILL;
+types = Sequelize.REAL.UNSIGNED;
+types = Sequelize.REAL.ZEROFILL.UNSIGNED;
+types = Sequelize.REAL.UNSIGNED.ZEROFILL;
+types = Sequelize.REAL(12,12);
+types = Sequelize.REAL(12,12).ZEROFILL;
+types = Sequelize.REAL(12,12).UNSIGNED;
+types = Sequelize.REAL(12,12).ZEROFILL.UNSIGNED;
+types = Sequelize.REAL(12,12).UNSIGNED.ZEROFILL;
+types = Sequelize.REAL(numberOptions);
+types = Sequelize.REAL(numberOptions).ZEROFILL;
+types = Sequelize.REAL(numberOptions).UNSIGNED;
+types = Sequelize.REAL(numberOptions).ZEROFILL.UNSIGNED;
+types = Sequelize.REAL(numberOptions).UNSIGNED.ZEROFILL;
+
+types = Sequelize.DOUBLE;
+types = Sequelize.DOUBLE.ZEROFILL;
+types = Sequelize.DOUBLE.UNSIGNED;
+types = Sequelize.DOUBLE.ZEROFILL.UNSIGNED;
+types = Sequelize.DOUBLE.UNSIGNED.ZEROFILL;
+types = Sequelize.DOUBLE(12,12);
+types = Sequelize.DOUBLE(12,12).ZEROFILL;
+types = Sequelize.DOUBLE(12,12).UNSIGNED;
+types = Sequelize.DOUBLE(12,12).ZEROFILL.UNSIGNED;
+types = Sequelize.DOUBLE(12,12).UNSIGNED.ZEROFILL;
+types = Sequelize.DOUBLE(numberOptions);
+types = Sequelize.DOUBLE(numberOptions).ZEROFILL;
+types = Sequelize.DOUBLE(numberOptions).UNSIGNED;
+types = Sequelize.DOUBLE(numberOptions).ZEROFILL.UNSIGNED;
+types = Sequelize.DOUBLE(numberOptions).UNSIGNED.ZEROFILL;
+
+types = Sequelize["DOUBLE PRECISION"];
+types = Sequelize["DOUBLE PRECISION"].ZEROFILL;
+types = Sequelize["DOUBLE PRECISION"].UNSIGNED;
+types = Sequelize["DOUBLE PRECISION"].ZEROFILL.UNSIGNED;
+types = Sequelize["DOUBLE PRECISION"].UNSIGNED.ZEROFILL;
+types = Sequelize["DOUBLE PRECISION"](12,12);
+types = Sequelize["DOUBLE PRECISION"](12,12).ZEROFILL;
+types = Sequelize["DOUBLE PRECISION"](12,12).UNSIGNED;
+types = Sequelize["DOUBLE PRECISION"](12,12).ZEROFILL.UNSIGNED;
+types = Sequelize["DOUBLE PRECISION"](12,12).UNSIGNED.ZEROFILL;
+types = Sequelize["DOUBLE PRECISION"](numberOptions);
+types = Sequelize["DOUBLE PRECISION"](numberOptions).ZEROFILL;
+types = Sequelize["DOUBLE PRECISION"](numberOptions).UNSIGNED;
+types = Sequelize["DOUBLE PRECISION"](numberOptions).ZEROFILL.UNSIGNED;
+types = Sequelize["DOUBLE PRECISION"](numberOptions).UNSIGNED.ZEROFILL;
\ No newline at end of file
diff --git a/serve-static/serve-static-tests.ts b/serve-static/serve-static-tests.ts
index 36d2761cd..9813794a6 100644
--- a/serve-static/serve-static-tests.ts
+++ b/serve-static/serve-static-tests.ts
@@ -1,7 +1,7 @@
 /// <reference path="serve-static.d.ts" />
 
-import express = require('express');
-import serveStatic = require('serve-static');
+import * as express from 'express';
+import * as serveStatic from 'serve-static';
 var app = express();
 
 app.use(serveStatic('/1'));
diff --git a/serve-static/serve-static.d.ts b/serve-static/serve-static.d.ts
index cbf9406d7..ef59fa2bc 100644
--- a/serve-static/serve-static.d.ts
+++ b/serve-static/serve-static.d.ts
@@ -5,8 +5,8 @@
 
 /* =================== USAGE ===================
 
-    import serveStatic = require('serve-static');
-    app.use(serveStatic('public/ftp', {'index': ['default.html', 'default.htm']}))
+    import * as serveStatic from "serve-static";
+    app.use(serveStatic("public/ftp", {"index": ["default.html", "default.htm"]}))
 
  =============================================== */
 
@@ -14,7 +14,7 @@
 /// <reference path="../mime/mime.d.ts" />
 
 declare module "serve-static" {
-    import express = require('express');
+    import * as express from "express";
     
     /**
      * Create a new middleware function to serve files from within a given root directory. 
@@ -76,7 +76,7 @@ declare module "serve-static" {
         setHeaders?: (res: express.Response, path: string, stat: any) => any;
     }): express.Handler;
 
-    import m = require('mime');
+    import * as m from "mime";
 
     module serveStatic {
         var mime: typeof m;
diff --git a/sharepoint/SharePoint.d.ts b/sharepoint/SharePoint.d.ts
index fef652dd3..24bea641a 100644
--- a/sharepoint/SharePoint.d.ts
+++ b/sharepoint/SharePoint.d.ts
@@ -6507,7 +6507,6 @@ declare module SP {
             static getTaxonomySession(context: SP.ClientContext): TaxonomySession;
             get_offlineTermStoreNames(): string[];
             get_termStores(): TermStoreCollection;
-            getTerms(termLabel: string, trimUnavailable: boolean): TermCollection;
             getTerms(labelMatchInformation: LabelMatchInformation): TermCollection;
             updateCache(): void;
             getTerm(guid: SP.Guid): Term;
diff --git a/smoothie/smoothie.d.ts b/smoothie/smoothie.d.ts
index 714590f84..e01ab34d5 100644
--- a/smoothie/smoothie.d.ts
+++ b/smoothie/smoothie.d.ts
@@ -18,7 +18,7 @@ declare module "smoothie"
 
     export interface ITimeSeriesPresentationOptions
     {
-        stokeStyle?: string;
+        strokeStyle?: string;
         fillStyle?: string;
         lineWidth?: number;
     }
@@ -73,7 +73,7 @@ declare module "smoothie"
         /** The pixel width of grid lines. */
         lineWidth?: number;
         /** Colour of grid lines. */
-        stokeStyle?: string;
+        strokeStyle?: string;
         /** Distance between vertical grid lines. */
         millisPerLine?: number;
         /** Controls whether grid lines are 1px sharp, or softened. */
diff --git a/snake-case/snake-case-tests.ts b/snake-case/snake-case-tests.ts
new file mode 100644
index 000000000..e8d6db7bc
--- /dev/null
+++ b/snake-case/snake-case-tests.ts
@@ -0,0 +1,9 @@
+/// <reference path="snake-case.d.ts" />
+
+import camelCase = require('snake-case');
+
+console.log(camelCase('string')); 	  // => "string"
+console.log(camelCase('camelCase'));	  // => "camel_case"
+console.log(camelCase('sentence case'));  // => "sentence_case"
+
+console.log(camelCase('MY STRING', 'tr')); // => "my_strıng" 
diff --git a/snake-case/snake-case.d.ts b/snake-case/snake-case.d.ts
new file mode 100644
index 000000000..96db37535
--- /dev/null
+++ b/snake-case/snake-case.d.ts
@@ -0,0 +1,9 @@
+// Type definitions for snake-case
+// Project: https://github.com/blakeembrey/snake-case
+// Definitions by: Sam Saint-Pettersen <https://github.com/stpettersens>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "snake-case" {
+	function snakeCase(string: string, locale?: string): string;
+	export = snakeCase;
+}
diff --git a/stripe/stripe.d.ts.tscparams b/stripe/stripe.d.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/stripe/stripe.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/threejs/three-trackballcontrols.d.ts b/threejs/three-trackballcontrols.d.ts
index e969bcb5e..17f45ec91 100644
--- a/threejs/three-trackballcontrols.d.ts
+++ b/threejs/three-trackballcontrols.d.ts
@@ -28,6 +28,10 @@ declare module THREE {
         maxDistance:number;
         keys:number[];
 
+        position0: THREE.Vector3;
+        target0: THREE.Vector3;
+        up0: THREE.Vector3;
+
         update():void;
         reset():void;
         checkDistances():void;
@@ -38,4 +42,4 @@ declare module THREE {
         handleResize():void;
         handleEvent(event: any):void;
     }
-}
+}
\ No newline at end of file
diff --git a/threejs/three-transformcontrols.d.ts b/threejs/three-transformcontrols.d.ts
new file mode 100644
index 000000000..5be96cd03
--- /dev/null
+++ b/threejs/three-transformcontrols.d.ts
@@ -0,0 +1,23 @@
+// Type definitions for three.js (TransformControls.js)
+// Project: https://github.com/mrdoob/three.js/blob/master/examples/js/controls/TransformControls.js
+// Definitions by: Stefan Profanter <https://github.com/Pro>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="./three.d.ts" />
+
+declare module THREE {
+	class TransformControls extends Object3D {
+		constructor(object:Camera, domElement?:HTMLElement);
+
+		object: Object3D;
+
+		update():void;
+		detach(object: Object3D): void;
+		attach(object: Object3D): void;
+		setMode(mode: string): void;
+		setSnap(snap: any): void;
+		setSize(size:number):void;
+		setSpace(space:string):void;
+
+	}
+}
diff --git a/threejs/three.d.ts b/threejs/three.d.ts
index d87541145..826d6332f 100644
--- a/threejs/three.d.ts
+++ b/threejs/three.d.ts
@@ -5672,7 +5672,7 @@ declare module THREE {
     }
 
     export class BoundingBoxHelper extends Mesh {
-        constructor(object: Object3D, hex?: number);
+        constructor(object?: Object3D, hex?: number);
 
         object: Object3D;
         box: Box3;
diff --git a/titanium/titanium-tests.ts.tscparams b/titanium/titanium-tests.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/titanium/titanium-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/twix/twix.d.ts b/twix/twix.d.ts
index e82df73be..4c52fbc79 100644
--- a/twix/twix.d.ts
+++ b/twix/twix.d.ts
@@ -9,33 +9,33 @@ declare module moment {
     interface Moment {
         twix(date: Date): Twix;
         twix(date: Date, allDay: boolean): Twix;
-        twix(date: Date, options: TwixFormatOptions): Twix;
-        twix(date: Date, format: string, options: TwixFormatOptions): Twix;
+        twix(date: Date, options: TwixParseAndFormatOptions): Twix;
+        twix(date: Date, format: string, options: TwixParseAndFormatOptions): Twix;
 
         twix(date: Moment): Twix;
         twix(date: Moment, allDay: boolean): Twix;
-        twix(date: Moment, options: TwixFormatOptions): Twix;
-        twix(date: Moment, format: string, options: TwixFormatOptions): Twix;
+        twix(date: Moment, options: TwixParseAndFormatOptions): Twix;
+        twix(date: Moment, format: string, options: TwixParseAndFormatOptions): Twix;
 
         twix(date: MomentInput): Twix;
         twix(date: MomentInput, allDay: boolean): Twix;
-        twix(date: MomentInput, options: TwixFormatOptions): Twix;
-        twix(date: MomentInput, format: string, options: TwixFormatOptions): Twix;
+        twix(date: MomentInput, options: TwixParseAndFormatOptions): Twix;
+        twix(date: MomentInput, format: string, options: TwixParseAndFormatOptions): Twix;
 
         twix(date: number): Twix;
         twix(date: number, allDay: boolean): Twix;
-        twix(date: number, options: TwixFormatOptions): Twix;
-        twix(date: number, format: string, options: TwixFormatOptions): Twix;
+        twix(date: number, options: TwixParseAndFormatOptions): Twix;
+        twix(date: number, format: string, options: TwixParseAndFormatOptions): Twix;
 
         twix(date: number[]): Twix;
         twix(date: number[], allDay: boolean): Twix;
-        twix(date: number[], options: TwixFormatOptions): Twix;
-        twix(date: number[], format: string, options: TwixFormatOptions): Twix;
+        twix(date: number[], options: TwixParseAndFormatOptions): Twix;
+        twix(date: number[], format: string, options: TwixParseAndFormatOptions): Twix;
 
         twix(date: string): Twix;
         twix(date: string, allDay: boolean): Twix;
-        twix(date: string, options: TwixFormatOptions): Twix;
-        twix(date: string, format: string, options: TwixFormatOptions): Twix;
+        twix(date: string, options: TwixParseAndFormatOptions): Twix;
+        twix(date: string, format: string, options: TwixParseAndFormatOptions): Twix;
     }
 
     interface MomentStatic {
@@ -63,6 +63,10 @@ declare module moment {
         lastNightEndsAt?: number;
     }
 
+    interface TwixParseAndFormatOptions extends TwixFormatOptions {
+        parseStrict?: boolean;
+    }
+
     interface TwixSimpleFormatOptions {
         allDay?: string;
         template?: (left: any, right: any) => any;
diff --git a/ui-grid/ui-grid.d.ts b/ui-grid/ui-grid.d.ts
index 15c65e50d..896a2d60e 100644
--- a/ui-grid/ui-grid.d.ts
+++ b/ui-grid/ui-grid.d.ts
@@ -112,7 +112,7 @@ declare module uiGrid {
         }
         scrollbars: {
             NEVER: number;
-            ALWAYS: number;            
+            ALWAYS: number;
         }
     }
     export interface IGridInstance {
@@ -247,7 +247,7 @@ declare module uiGrid {
         clearAllFilters(refreshRows?: boolean, clearConditions?: boolean, clearFlags?: boolean): ng.IPromise<Array<IGridRow>>;
         clearRowInvisible(rowEntity: any): void;
         getVisibleRows(grid: IGridInstance): Array<IGridRow>;
-        handleWindowResize(): void;       
+        handleWindowResize(): void;
         notifiyDataChange(type: string): void;
         refreshRows(): ng.IPromise<boolean>;
         registerColumnsProcessor(processorFunction: IColumnProcessor, priority: number): void;
@@ -257,23 +257,23 @@ declare module uiGrid {
         scrollToIfNecessary(gridRow: IGridRow, gridCol: IGridColumn): void;
         setRowInvisible(rowEntity: any): void;
         sortHandleNulls(a: any,b: any): number;
-        queueGridRefresh(): void;         
+        queueGridRefresh(): void;
         queueRefresh(): void;
         on: {
             sortChanged: (scope: ng.IScope, handler: (grid: IGridInstance, sortColumns: Array<IColumnDef>) => void) => void;
-            columnVisiblityChanged: (scope: ng.IScope, handler: (grid: IGridColumn) => void) => void;            
+            columnVisibilityChanged: (scope: ng.IScope, handler: (grid: IGridColumn) => void) => void;
             canvasHeightChanged: (scope: ng.IScope, handler: (oldHeight: number, newHeight: number) => void) => void;
-            
+
             /**
-             * filterChangedis raised after the filter is changed. The nature of the watch expression doesn't allow notification 
+             * filterChangedis raised after the filter is changed. The nature of the watch expression doesn't allow notification
              * of what changed, so the receiver of this event will need to re-extract the filter conditions from the columns.
              * http://ui-grid.info/docs/#/api/ui.grid.core.api:PublicApi
              */
             filterChanged: (scope: ng.IScope, handler: () => void) => void;
-            rowsRendered: (scope: ng.IScope, handler: () => void) => void;            
+            rowsRendered: (scope: ng.IScope, handler: () => void) => void;
             rowsVisibleChanged: (scope: ng.IScope, handler: () => void) => void;
             scrollBegin: (scope: ng.IScope, handler: () => void) => void;
-            scrollEnd: (scope: ng.IScope, handler: () => void) => void;            
+            scrollEnd: (scope: ng.IScope, handler: () => void) => void;
         }
     }
     export interface IGridSelectionApi {
@@ -291,7 +291,7 @@ declare module uiGrid {
         getSelectAllState: () => boolean;
         on: {
             rowSelectionChanged: (scope: ng.IScope, handler: (row: IGridRow, event?: Event) => void) => void;
-            rowSelectionChangedBatch: (scope: ng.IScope, handler: (row: Array<IGridRow>, event?: Event) => void) => void;    
+            rowSelectionChangedBatch: (scope: ng.IScope, handler: (row: Array<IGridRow>, event?: Event) => void) => void;
         }
     }
     export interface IGridPaginationApi {
@@ -303,18 +303,23 @@ declare module uiGrid {
         on: {
             paginationChanged: (scope: ng.IScope, handler: (newPage: number, pageSize: number) => void) => void;
         }
-    }    
+    }
     export interface IGridRowEditApi {
         flushDirtyRows(grid?: IGridInstance): ng.IPromise<boolean>;
         getDirtyRows(grid?: IGridInstance): Array<IGridRow>;
-        getErrorRows(grid?: IGridInstance): Array<IGridRow>;   
+        getErrorRows(grid?: IGridInstance): Array<IGridRow>;
         setRowsClean(dataRows: Array<any>):  Array<any>;
         setRowsDirty(dataRows: Array<any>): Array<any>;
-        setSavePromise(rowEntity: Object, savePromise: ng.IPromise<any>): void; 
+        setSavePromise(rowEntity: Object, savePromise: ng.IPromise<any>): void;
         on: {
-            saveRow: (scope: ng.IScope, handler: (rowEntity: Array<any>) => void) => void
+            saveRow: (scope: ng.IScope, handler: (rowEntity: Array<any>) => void) => void;
         }
-    } 
+    }
+    export interface IGridRowResizableApi {
+        on: {
+            columnSizeChanged: (scope: ng.IScope, handler: (coldDef: IColumnDef) => void) => void;
+        }
+    }
 
     export interface IGridApiConstructor {
         new (grid: IGridInstance): IGridApi;
@@ -375,25 +380,30 @@ declare module uiGrid {
         core: IGridCoreApi;
 
         /**
-         * Selection api         
-         */         
+         * Selection api
+         */
         selection: IGridSelectionApi;
 
-        
+
         /**
-         * Pagination api         
+         * Pagination api
          */
         pagination: IGridPaginationApi;
-       
-     
+
+
         /**
-         * Grid Row Edit Api         
-         */      
+         * Grid Row Edit Api
+         */
         rowEdit: IGridRowEditApi;
-        
+
+        /**
+         * Grid row resizable Api
+         */
+        colResizable: IGridRowResizableApi;
+
         /**
          * A grid instance is made available in the gridApi.
-         */         
+         */
         grid: IGridInstance;
     }
     export interface IGridRowConstructor {
@@ -522,6 +532,8 @@ declare module uiGrid {
     }
 
     export interface IGridColumn {
+        /** Column definition */
+        colDef: uiGrid.IColumnDef;
         /**
          * Column name that will be shown in the header.
          * If displayName is not provided then one is generated using the name.
@@ -540,9 +552,11 @@ declare module uiGrid {
         filters?: Array<IFilterOptions>;
         name?: string;
         /** Sort on this column */
-        sort?: ISortInfo
+        sort?: ISortInfo;
         /** Algorithm to use for sorting this column. Takes 'a' and 'b' parameters like any normal sorting function. */
         sortingAlgorithm?: (a: any, b: any) => number;
+        /** Column width */
+        width: number;
         /**
          * Initializes a column
          * @param colDef the column def to associate with this column
diff --git a/underscore/underscore-tests.ts b/underscore/underscore-tests.ts
index d530a4334..f469d3bea 100644
--- a/underscore/underscore-tests.ts
+++ b/underscore/underscore-tests.ts
@@ -291,17 +291,18 @@ _.result(object, 'stuff');
 var compiled = _.template("hello: <%= name %>");
 compiled({ name: 'moe' });
 var list2 = "<% _.each(people, function(name) { %> <li><%= name %></li> <% }); %>";
-_.template(list2, { people: ['moe', 'curly', 'larry'] });
+_.template(list2)({ people: ['moe', 'curly', 'larry'] });
 var template = _.template("<b><%- value %></b>");
 template({ value: '<script>' });
 var compiled2 = _.template("<% print('Hello ' + epithet); %>");
 compiled2({ epithet: "stooge" });
+var oldTemplateSettings = _.templateSettings;
 _.templateSettings = {
 	interpolate: /\{\{(.+?)\}\}/g
 };
 var template2 = _.template("Hello {{ name }}!");
 template2({ name: "Mustache" });
-_.template("Using 'with': <%= data.answer %>", { variable: 'data' });
+_.template("Using 'with': <%= data.answer %>", oldTemplateSettings)({ variable: 'data' });
 
 
 _(['test', 'test']).pick(['test2', 'test2']);
diff --git a/underscore/underscore.d.ts b/underscore/underscore.d.ts
index 4842224c9..4aed7a855 100644
--- a/underscore/underscore.d.ts
+++ b/underscore/underscore.d.ts
@@ -2833,7 +2833,7 @@ interface _Chain<T> {
 	* Wrapped type `any[]`.
 	* @see _.partition
 	**/
-	partition(iterator: _.ListIterator<T, boolean>, context?: any): _Chain<T[][]>;
+	partition(iterator: _.ListIterator<T, boolean>, context?: any): _Chain<T[]>;
 
 	/**
 	* Wrapped type `any[][]`.
diff --git a/vexflow/vexflow-tests.ts b/vexflow/vexflow-tests.ts
new file mode 100644
index 000000000..351ad2ee8
--- /dev/null
+++ b/vexflow/vexflow-tests.ts
@@ -0,0 +1,88 @@
+/// <reference path="vexflow.d.ts" />
+
+var canvas = document.getElementById("canvas");
+var renderer = new Vex.Flow.Renderer(canvas, Vex.Flow.Renderer.Backends.CANVAS);
+var ctx = renderer.getContext();
+
+// Add a treble clef and time signature
+var stave = new Vex.Flow.Stave(10, 0, 550);
+stave.setContext(ctx).
+    addClef("treble").
+    addKeySignature("A").
+    addTimeSignature("4/4");
+
+// Dotted eighth E##, sixteenth Eb, half D, quarter Cm#5
+var notes1 = [
+    new Vex.Flow.StaveNote({keys: ["e##/5"], duration: "8d"}).
+        addAccidental(0, new Vex.Flow.Accidental("##")).
+        addDotToAll(),
+    new Vex.Flow.StaveNote({keys: ["eb/5"], duration: "16"}).
+        addAccidental(0, new Vex.Flow.Accidental("b")),
+    new Vex.Flow.StaveNote({keys: ["d/5"], duration: "h"}),
+    new Vex.Flow.StaveNote({keys: ["c/5", "eb/5", "g#/5"], duration: "q"}).
+        addAccidental(1, new Vex.Flow.Accidental("b")).
+        addAccidental(2, new Vex.Flow.Accidental("#"))
+];
+
+// Create a beam for the first two notes
+var beam = new Vex.Flow.Beam(notes1.slice(0, 2));
+
+// Add a grace note to the half D
+var gracenote = new Vex.Flow.GraceNote({keys: ["e/5"], duration: "16", slash: true});
+notes1[2].addModifier(0, new Vex.Flow.GraceNoteGroup([gracenote], true).beamNotes());
+
+// Color the chord
+notes1[3].setStyle({fillStyle: "blue", strokeStyle: "blue", stemStyle: "blue"});
+
+// Create a voice in 4/4 and add notes
+var voice1 = new Vex.Flow.Voice({
+    num_beats: 4,
+    beat_value: 4,
+    resolution: Vex.Flow.RESOLUTION
+}).addTickables(notes1);
+
+// Create a second voice with just one whole note
+var voice2 = new Vex.Flow.Voice(Vex.Flow.TIME4_4).
+    addTickables([new Vex.Flow.StaveNote({keys: ["c/4"], duration: "w"})]);
+
+// Format and justify the notes to 550 pixels
+var formatter = new Vex.Flow.Formatter().
+    joinVoices([voice1, voice2]).format([voice1, voice2], 550);
+
+// Render stave
+stave.draw();
+
+// Render voices
+voice1.draw(ctx, stave);
+voice2.draw(ctx, stave);
+
+// Render beam
+beam.setContext(ctx).draw();
+
+// Create and draw a tablature stave
+var tabstave = new Vex.Flow.TabStave(10, 200, 550);
+tabstave.addTabGlyph();
+tabstave.setContext(ctx).draw();
+
+// Create some TabNotes
+var notes = [
+    // A single note
+    new Vex.Flow.TabNote({
+        positions: [{str: 3, fret: 7}],
+        duration: "q"}),
+
+    // A chord with the note on the 3rd string bent
+    new Vex.Flow.TabNote({
+        positions: [{str: 2, fret: 10}, {str: 3, fret: 9}],
+        duration: "q"}).
+        addModifier(new Vex.Flow.Bend("Full"), 1),
+
+    // A single note with a harsh vibrato
+    new Vex.Flow.TabNote({
+        positions: [{str: 2, fret: 5}],
+        duration: "h"}).
+        addModifier(new Vex.Flow.Vibrato().setHarsh(true).setVibratoWidth(70), 0)
+];
+
+// Format ad draw the notes
+Vex.Flow.Formatter.FormatAndDraw(ctx, tabstave, notes);
\ No newline at end of file
diff --git a/vexflow/vexflow.d.ts b/vexflow/vexflow.d.ts
new file mode 100644
index 000000000..1822c0c67
--- /dev/null
+++ b/vexflow/vexflow.d.ts
@@ -0,0 +1,1413 @@
+// Type definitions for VexFlow v1.2.27
+// Project: http://vexflow.com
+// Definitions by: Roman Quiring <https://github.com/rquiring>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+//inconsistent namespace: this is a helper funtion from tables.js and should not pollute the global namespace!
+declare function sanitizeDuration(duration : string) : string; 
+
+declare module Vex {
+    
+    function L(block : string, args : any[]) : void;
+    function Merge<T extends Object>(destination : T, source : Object) : T;
+    function Min(a : number, b : number) : number;
+    function Max(a : number, b : number) : number;
+    function RoundN(x : number, n : number) : number;
+    function MidLine(a : number, b : number) : number;
+    function SortAndUnique<T extends any[]>(arr : T, cmp : Function, eq : Function) : T;
+    function Contains(a : any[], obj : any) : boolean;
+    function getCanvasContext(canvas_sel : string) : CanvasRenderingContext2D;
+    function drawDot(ctx : IRenderContext, x : number, y : number, color? : string) : void;
+    function BM(s : number, f : Function) : void;
+    function Inherit<T extends Object>(child : T, parent : Object, object : Object) : T;
+    
+    class RuntimeError {
+        constructor(code : string, message : string);
+    }
+    
+    class RERR {
+        constructor(code : string, message : string);
+    }
+    
+    /**
+     * Helper interface for handling the different rendering contexts (i.e. CanvasContext, RaphaelContext, SVGContext). Not part of VexFlow!
+     */
+    interface IRenderContext {
+        clear() : void;
+        setFont(family : string, size : number, weight? : number) : IRenderContext;
+        setRawFont(font : string) : IRenderContext;
+        setFillStyle(style : string) : IRenderContext;
+        setBackgroundFillStyle(style : string) : IRenderContext;
+        setStrokeStyle(style : string) : IRenderContext;
+        setShadowColor(color : string) : IRenderContext;
+        setShadowBlur(blur : string) : IRenderContext;
+        setLineWidth(width : number) : IRenderContext;
+        setLineCap(cap_type : string) : IRenderContext;
+        setLineDash(dash : string) : IRenderContext;
+        scale(x : number, y : number) : IRenderContext;
+        resize(width : number, height : number) : IRenderContext;
+        fillRect(x : number, y : number, width : number, height : number) : IRenderContext;
+        clearRect(x : number, y : number, width : number, height : number) : IRenderContext;
+        beginPath() : IRenderContext;
+        moveTo(x : number, y : number) : IRenderContext;
+        lineTo(x : number, y : number) : IRenderContext;
+        bezierCurveToTo(x1 : number, y1 : number, x2 : number, y2 : number, x : number, y : number) : IRenderContext;
+        quadraticCurveToTo(x1 : number, y1 : number, x2 : number, y2 : number) : void;
+        arc(x : number, y : number, radius : number, startAngle : number, endAngle : number, antiClockwise : boolean) : IRenderContext;
+        glow() : IRenderContext;
+        fill() : IRenderContext;
+        stroke() : IRenderContext;
+        closePath() : IRenderContext;
+        fillText(text : string, x : number, y : number) : IRenderContext;
+        save() : IRenderContext;
+        restore() : IRenderContext;
+        
+        /**
+         * canvas returns TextMetrics, SVG returns SVGRect, Raphael returns {width : number, height : number}. Only width is used throughout VexFlow.
+         */
+        measureText(text : string) : {width : number};
+    }
+    
+    /**
+     * Helper interface for handling the Vex.Flow.Font object in Vex.Flow.Glyph. Not part of VexFlow!
+     */
+    interface IFont {
+        glyphs : {x_min : number, x_max : number, ha : number, o : string[]}[];
+        cssFontWeight : string;
+        ascender : number;
+        underlinePosition : number;
+        cssFontStyle : string;
+        boundingBox : {yMin : number, xMin : number, yMax : number, xMax : number};
+        resolution : number;
+        descender : number;
+        familyName : string;
+        lineHeight : number;
+        underlineThickness : number;
+        
+        /**
+         * This property is missing in vexflow_font.js, but present in gonville_original.js and gonville_all.js.
+         */
+        original_font_information? : {postscript_name : string, version_string : string, vendor_url : string, full_font_name : string, font_family_name : string, copyright : string, description : string, trademark : string, designer : string, designer_url : string, unique_font_identifier : string, license_url : string, license_description : string, manufacturer_name : string, font_sub_family_name : string};
+    }
+    
+    module Flow {
+        
+        const RESOLUTION : number;
+        
+        // from tables.js:
+        const STEM_WIDTH : number;
+        const STEM_HEIGHT : number;
+        const STAVE_LINE_THICKNESS : number;
+        const TIME4_4 : {num_beats : number, beat_value : number, resolution : number};
+        const unicode : {[name : string] : string}; //inconsistent API: this should be private and have a wrapper function like the other tables
+        function clefProperties(clef : string) : {line_shift : number};
+        function keyProperties(key : string, clef : string, params : {octave_shift? : number}) : {key : string, octave : number, line : number, int_value : number, accidental : string, code : number, stroke : number, shift_right : number, displaced : boolean};
+        function integerToNote(integer : number) : string;
+        function tabToGlyph(fret : string) : {text : string, code : number, width : number, shift_y : number};
+        function textWidth(text : string) : number;
+        function articulationCodes(artic : string) : {code : string, width : number, shift_right : number, shift_up : number, shift_down : number, between_lines : boolean};
+        function accidentalCodes(acc : string) : {code : string, width : number, gracenote_width : number, shift_right : number, shift_down : number};
+        function ornamentCodes(acc : string) : {code : string, shift_right : number, shift_up : number, shift_down : number, width : number};
+        function keySignature(spec : string) : {type: string, line: number}[];
+        function parseNoteDurationString(durationString : string) : {duration : string, dots : number, type : string};
+        function parseNoteData(noteData : {duration : string, dots : number, type : string}) : {duration : string, type : string, dots : number, ticks : number};
+        function durationToFraction(duration : string) : Fraction;
+        function durationToNumber(duration : string) : number;
+        function durationToTicks(duration : string) : number;
+        function durationToGlyph(duration : string, type : string) : {head_width : number, stem : boolean, stem_offset : number, flag : boolean, stem_up_extension : number, stem_down_extension : number, gracenote_stem_up_extension : number, gracenote_stem_down_extension : number, tabnote_stem_up_extension : number, tabnote_stem_down_extension : number, dot_shiftY : number, line_above : number, line_below : number, code_head? : string, rest? : boolean, position? : string};
+        
+        // from glyph.js:
+        function renderGlyph(ctx : IRenderContext, x_pos : number, y_pos : number, point : number, val : string, nocache : boolean) : void;
+        
+        // from vexflow_font.js / gonville_original.js / gonville_all.js
+        var Font : {
+            glyphs : {x_min : number, x_max : number, ha : number, o : string[]}[];
+            cssFontWeight : string;
+            ascender : number;
+            underlinePosition : number;
+            cssFontStyle : string;
+            boundingBox : {yMin : number, xMin : number, yMax : number, xMax : number};
+            resolution : number;
+            descender : number;
+            familyName : string;
+            lineHeight : number;
+            underlineThickness : number;
+            
+            //inconsistent member : this is missing in vexflow_font.js, but present in gonville_original.js and gonville_all.js
+            original_font_information : {postscript_name : string, version_string : string, vendor_url : string, full_font_name : string, font_family_name : string, copyright : string, description : string, trademark : string, designer : string, designer_url : string, unique_font_identifier : string, license_url : string, license_description : string, manufacturer_name : string, font_sub_family_name : string};
+        }
+        
+        module Accidental {
+            const CATEGORY : string;
+        }
+        
+        class Accidental extends Modifier {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes
+            setNote(note : Note) : Modifier;
+            
+            constructor(type : string);
+            static DEBUG : boolean;
+            static format(accidentals : Accidental[], state : {left_shift : number, right_shift : number, text_line : number}) : void;
+            setNote(note : StaveNote) : void;
+            setAsCautionary() : Accidental;
+            draw() : void;
+            static applyAccidentals(voices : Voice[], keySignature? : string) : void;
+        }
+        
+        export module Annotation {
+            const enum Justify {LEFT, CENTER, RIGHT, CENTER_STEM}
+            const enum VerticalJustify {TOP, CENTER, BOTTOM, CENTER_STEM}
+            const CATEGORY : string;
+        }
+        
+        class Annotation extends Modifier {
+            constructor(text : string);
+            static DEBUG : boolean;
+            static format(annotations : Annotation[], state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
+            setTextLine(line : number) : Annotation;
+            setFont(family : string, size : number, weight : string) : Annotation;
+            setVerticalJustification(just : Annotation.VerticalJustify) : Annotation;
+            getJustification() : Annotation.Justify;
+            setJustification(justification : Annotation.Justify) : Annotation;
+            draw() : void;
+        }
+        
+        module Articulation {
+            const CATEGORY : string;
+        }
+        
+        class Articulation extends Modifier {
+            constructor(type : string);
+            static DEBUG : boolean;
+            static format(articulations : Articulation[], state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
+            draw() : void;
+        }
+        
+        class BarNote extends Note {
+            static DEBUG : boolean;
+            getType() : Barline.type;
+            setType(type : Barline.type) : BarNote;
+            getBoundingBox() : BoundingBox;
+            addToModifierContext() : BarNote;
+            preFormat() : BarNote;
+            draw() : void;
+        }
+        
+        export module Barline {
+            const enum type {SINGLE, DOUBLE, END, REPEAT_BEGIN, REPEAT_END, REPEAT_BOTH, NONE}
+        }
+        
+        class Barline extends StaveModifier {
+            constructor(type : Barline.type, x : number);
+            getCategory() : string;
+            setX(x : number) : Barline;
+            draw(stave : Stave, x_shift? : number) : void;
+            drawVerticalBar(stave : Stave, x : number, double_bar? : boolean) : void;
+            drawVerticalEndBar(stave : Stave, x : number) : void;
+            drawRepeatBar(stave : Stave, x : number, begin : boolean) : void;
+        }
+        
+        class Beam {
+            constructor(notes : StemmableNote[], auto_stem? : boolean);
+            setContext(context : IRenderContext) : Beam;
+            getNotes() : StemmableNote[];
+            getBeamCount() : number;
+            breakSecondaryAt(indices : number[]) : Beam;
+            getSlopeY() : number;
+            calculateSlope() : void;
+            applyStemExtensions() : void;
+            getBeamLines(duration : string) : {start : number, end : number}[];
+            drawStems() : void;
+            drawBeamLines() : void;
+            preFormat() : Beam;
+            postFormat() : Beam;
+            draw() : boolean;
+            calculateStemDirection(notes : Note) : number;
+            static getDefaultBeamGroups(time_sig : string) : Fraction[];
+            static applyAndGetBeams(voice : Voice, stem_direction : number, groups : Fraction[]) : Beam[];
+            static generateBeams(notes : StemmableNote[], config? : {groups? : Fraction[], stem_direction? : number, beam_rests? : boolean, beam_middle_only? : boolean, show_stemlets? : boolean, maintain_stem_directions? : boolean}) : Beam[];
+        }
+        
+        module Bend {
+            const CATEGORY : string;
+        }
+        
+        class Bend extends Modifier {
+            constructor(text : string, release? : boolean, phrase? : {type : number, text : string, width : number}[]);
+            static UP : number;
+            static DOWN : number;
+            static format(bends : Bend[], state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
+            setXShift(value : number) : void;
+            setFont(font : string) : Bend;
+            getText() : string;
+            updateWidth() : Bend;
+            draw() : void;
+        }
+        
+        class BoundingBox {
+            constructor(x : number, y : number, w : number, h : number);
+            static copy(that : BoundingBox) : BoundingBox;
+            getX() : number;
+            getY() : number;
+            getW() : number;
+            getH() : number;
+            setX(x : number) : BoundingBox;
+            setY(y : number) : BoundingBox;
+            setW(w : number) : BoundingBox;
+            setH(h : number) : BoundingBox;
+            move(x : number, y : number) : void;
+            clone() : BoundingBox;
+            mergeWith(boundingBox : BoundingBox, ctx? : IRenderContext) : BoundingBox;
+            draw(ctx : IRenderContext, x : number, y : number) : void;
+        }
+        
+        class CanvasContext implements IRenderContext {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes or type inconsistencies mentioned below are fixed
+            setLineDash(dash : string) : CanvasContext;
+            scale(x : number, y : number) : CanvasContext;
+            resize(width : number, height : number) : CanvasContext;
+            fillRect(x : number, y : number, width : number, height : number) : CanvasContext;
+            clearRect(x : number, y : number, width : number, height : number) : CanvasContext;
+            beginPath() : CanvasContext;
+            moveTo(x : number, y : number) : CanvasContext;
+            lineTo(x : number, y : number) : CanvasContext;
+            bezierCurveToTo(x1 : number, y1 : number, x2 : number, y2 : number, x : number, y : number) : CanvasContext;
+            quadraticCurveToTo(x1 : number, y1 : number, x2 : number, y2 : number) : CanvasContext;
+            arc(x : number, y : number, radius : number, startAngle : number, endAngle : number, antiClockwise : boolean) : CanvasContext;
+            glow() : CanvasContext;
+            fill() : CanvasContext;
+            stroke() : CanvasContext;
+            closePath() : CanvasContext;
+            fillText(text : string, x : number, y : number) : CanvasContext;
+            save() : CanvasContext;
+            restore() : CanvasContext;
+            
+            constructor(context : CanvasRenderingContext2D);
+            static WIDTH : number;
+            static HEIGHT : number;
+            clear() : void;
+            setFont(family : string, size : number, weight? : number) : CanvasContext;
+            setRawFont(font : string) : CanvasContext;
+            setFillStyle(style : string) : CanvasContext;
+            setBackgroundFillStyle(style : string) : CanvasContext;
+            setStrokeStyle(style : string) : CanvasContext;
+            setShadowColor(style : string) : CanvasContext; //inconsistent name: style -> color
+            setShadowBlur(blur : string) : CanvasContext;
+            setLineWidth(width : number) : CanvasContext;
+            setLineCap(cap_type : string) : CanvasContext;
+            
+            //inconsistent type: void -> CanvasContext
+            setLineDash(dash : string) : void;
+            scale(x : number, y : number) : void;
+            resize(width : number, height : number) : void;
+            fillRect(x : number, y : number, width : number, height : number) : void;
+            clearRect(x : number, y : number, width : number, height : number) : void;
+            beginPath() : void;
+            moveTo(x : number, y : number) : void;
+            lineTo(x : number, y : number) : void;
+            bezierCurveToTo(x1 : number, y1 : number, x2 : number, y2 : number, x : number, y : number) : void;
+            quadraticCurveToTo(x1 : number, y1 : number, x : number, y : number) : void; //inconsistent name: x -> x2, y -> y2
+            arc(x : number, y : number, radius : number, startAngle : number, endAngle : number, antiClockwise : boolean) : void;
+            glow() : void;
+            fill() : void;
+            stroke() : void;
+            closePath() : void;
+            measureText(text : string) : TextMetrics;
+            fillText(text : string, x : number, y : number) : void;
+            save() : void;
+            restore() : void;
+        }
+        
+        class Clef extends StaveModifier {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes
+            addModifier() : void;
+            addEndModifier() : void;
+            
+            constructor(clef : string, size? : string, annotation? : string);
+            static DEBUG : boolean;
+            addModifier(stave : Stave) : void;
+            addEndModifier(stave : Stave) : void;
+        }
+        
+        class ClefNote extends Note {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes
+            setStave(stave : Stave) : Note;
+            
+            constructor(clef : string, size? : string, annotation? : string);
+            setClef(clef : string, size? : string, annotation? : string) : ClefNote;
+            getClef() : string;
+            setStave(stave : Stave) : void;
+            getBoundingBox() : BoundingBox;
+            addToModifierContext() : ClefNote;
+            getCategory() : string;
+            preFormat() : ClefNote;
+            draw() : void;
+        }
+        
+        class Crescendo extends Note {
+            constructor(note_struct : {duration : number, line? : number});
+            static DEBUG : boolean;
+            setLine(line : number) : Crescendo;
+            setHeight(height : number) : Crescendo;
+            setDecrescendo(decresc : boolean) : Crescendo;
+            preFormat() : Crescendo;
+            draw() : void;
+        }
+        
+        export module Curve {
+            const enum Position {NEAR_HEAD, NEAR_TOP}
+        }
+        
+        class Curve {
+            constructor(from : Note, to : Note, options? : {spacing? : number, thickness? : number, x_shift? : number, y_shift : number, position : Curve.Position, invert : boolean, cps? : {x : number, y : number}[]});
+            static DEBUG : boolean;
+            setContext(context : IRenderContext) : Curve;
+            setNotes(from : Note, to : Note) : Curve;
+            isPartial() : boolean;
+            renderCurve(params : {first_x : number, first_y : number, last_x : number, last_y : number, direction : number}) : void;
+            draw() : boolean;
+        }
+        
+        module Dot {
+            const CATEGORY : string;
+        }
+        
+        class Dot extends Modifier {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes or type inconsistencies mentioned below are fixed
+            setNote(note : Note) : Dot;
+            
+            static format(dots : number, state : {left_shift : number, right_shift : number, text_line : number}) : void;
+            setNote(note : Note) : void; //inconsistent type: void -> Dot
+            setDotShiftY(y : number) : Dot;
+            draw() : void;
+        }
+        
+        class Formatter {
+            static DEBUG : boolean;
+            static FormatAndDraw(ctx : IRenderContext, stave : Stave, notes : Note[], params? : {auto_beam : boolean, align_rests : boolean}) : BoundingBox; 
+            static FormatAndDraw(ctx : IRenderContext, stave : Stave, notes : Note[], params? : boolean) : BoundingBox;
+            static FormatAndDrawTab(ctx : IRenderContext, tabstave : TabStave, stave : Stave, tabnotes : TabNote[], notes : Note[], autobeam? : boolean, params? : {auto_beam : boolean, align_rests : boolean}) : void;
+            static FormatAndDrawTab(ctx : IRenderContext, tabstave : TabStave, stave : Stave, tabnotes : TabNote[], notes : Note[], autobeam? : boolean, params? : boolean) : void;
+            static AlignRestsToNotes(notes : Note[], align_all_notes? : boolean, align_tuplets? : boolean) : Formatter;
+            alignRests(voices : Voice[], align_all_notes : boolean) : void;
+            preCalculateMinTotalWidth(voices : Voice[]) : number;
+            getMinTotalWidth() : number;
+            createModifierContexts(voices : Voice[]) : ModifierContext[];
+            createTickContexts(voices : Voice[]) : TickContext[];
+            preFormat(justifyWidth? : number, rendering_context? : IRenderContext, voices? : Voice[], stave? : Stave) : void;
+            postFormat() : Formatter;
+            joinVoices(voices : Voice[]) : Formatter;
+            format(voices : Voice[], justifyWidth : number, options? : {align_rests? : boolean, context : IRenderContext}) : Formatter;
+            formatToStave(voices : Voice[], stave : Stave, options? : {align_rests? : boolean, context : IRenderContext}) : Formatter;
+        }
+        
+        class Fraction {
+            constructor(numerator : number, denominator : number);
+            static GCD(a : number, b : number) : number;
+            static LCM(a : number, b : number) : number;
+            static LCMM(a : number, b : number) : number;
+            set(numerator : number, denominator : number) : Fraction;
+            value() : number;
+            simplify() : Fraction;
+            add(param1 : Fraction, param2 : Fraction) : Fraction;
+            add(param1 : number, param2 : number) : Fraction;
+            subtract(param1 : Fraction, param2 : Fraction) : Fraction;
+            subtract(param1 : number, param2 : number) : Fraction;
+            multiply(param1 : Fraction, param2 : Fraction) : Fraction;
+            multiply(param1 : number, param2 : number) : Fraction;
+            divide(param1 : Fraction, param2 : Fraction) : Fraction;
+            divide(param1 : number, param2 : number) : Fraction;
+            equals(compare : Fraction) : boolean;
+            greaterThan(compare : Fraction) : boolean;
+            greaterThanEquals(compare : Fraction) : boolean;
+            lessThan(compare : Fraction) : boolean;
+            lessThanEquals(compare : Fraction) : boolean;
+            clone() : Fraction;
+            copy(copy : Fraction) : Fraction;
+            quotient() : number;
+            fraction() : number;
+            abs() : Fraction;
+            toString() : string;
+            toSimplifiedString() : string;
+            toMixedString() : string;
+            parse(str : string) : Fraction;
+        }
+        
+        module FretHandFinger {
+            const CATEGORY : string;
+        }
+        
+        class FretHandFinger extends Modifier {
+            constructor(number : number);
+            static format(nums : FretHandFinger[], state : {left_shift : number, right_shift : number, text_line : number}) : void;
+            getNote() : Note;
+            setNote(note : Note) : FretHandFinger;
+            getIndex() : number;
+            setIndex(index : number) : FretHandFinger;
+            getPosition() : Modifier.Position;
+            setPosition(position : Modifier.Position) : FretHandFinger;
+            setFretHandFinger(number : number) : FretHandFinger;
+            setOffsetX(x : number) : FretHandFinger;
+            setOffsetY(y : number) : FretHandFinger;
+            draw() : void;
+        }
+        
+        class GhostNote extends StemmableNote {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes or type inconsistencies mentioned below are fixed
+            setStave(stave : Stave) : Note;
+            
+            constructor(duration : string);
+            constructor(note_struct : {type? : string, dots? : number, duration : string}); //inconsistent name : init struct is called 'duration', should be 'params'/'options' (may be string or Object)
+            isRest() : boolean;
+            setStave(stave : Stave) : void; //inconsistent type: void -> GhostNote
+            addToModifierContext() : GhostNote;
+            preFormat() : GhostNote;
+            draw() : void;
+        }
+        
+        class Glyph {
+            constructor(code : string, point : number, options? : {cache? : boolean, font? : IFont});
+            setOptions(options : {cache? : boolean, font? : IFont}) : void;
+            setStave(stave : Stave) : Glyph;
+            setXShift(x_shift : number) : Glyph;
+            setYShift(y_shift : number) : Glyph;
+            setContext(context : IRenderContext) : Glyph;
+            getContext() : IRenderContext;
+            reset() : void;
+            setWidth(width : number) : Glyph;
+            getMetrics() : {x_min : number, x_max : number, width : number, height : number};
+            render(ctx : IRenderContext, x_pos : number, y_pos : number) : void;
+            renderToStave(x : number) : void;
+            static loadMetrics(font : IFont, code : string, cache : boolean) : {x_min : number, x_max : number, ha : number, outline : number[]};
+            static renderOutline(ctx : IRenderContext, outline : number[], scale : number, x_pos : number, y_pos : number) : void;
+        }
+        
+        class GraceNote extends StaveNote {
+            constructor(note_struct : {slash? : boolean, type? : string, dots? : number, duration : string, clef? : string, keys : string[], octave_shift? : number, auto_stem? : boolean, stem_direction? : number});
+            getStemExtension() : number;
+            getCategory() : string;
+            draw() : void;
+        }
+        
+        module GraceNoteGroup {
+            const CATEGORY : string;
+        }
+        
+        class GraceNoteGroup extends Modifier {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes or type inconsistencies mentioned below are fixed
+            setWidth(width : number) : Modifier;
+            setNote(note : StaveNote) : Modifier;
+            
+            constructor(grace_notes : GraceNote[], show_slur? : boolean); //inconsistent name: 'show_slur' is called 'config', suggesting object (is boolean)
+            static DEBUG : boolean;
+            static format(gracenote_groups : GraceNoteGroup[], state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
+            preFormat() : void;
+            beamNotes() : GraceNoteGroup;
+            setNote(note : Note) : void; //inconsistent type: void -> GraceNoteGroup
+            setWidth(width : number) : void; //inconsistent type: void -> GraceNoteGroup
+            getWidth() : number;
+            setXShift(x_shift : number) : void;
+            draw() : void;
+        }
+        
+        class KeyManager {
+            constructor(key : string);
+            setKey(key : string) : KeyManager;
+            getKey() : string;
+            reset() : KeyManager;
+            getAccidental(key : string) : {note : string, accidental : string};
+            selectNote(note : string) : {note : string, accidental : string, change : boolean};
+        }
+        
+        class KeySignature extends StaveModifier {
+             //TODO remove the following lines once TypeScript allows subclass overrides with type changes
+            addModifier() : void;
+            
+            constructor(key_spec : string);
+            addAccToStave(stave : Stave, acc : {type : string, line : number}, next? : {type : string, line : number}) : void;
+            cancelKey(spec : string) : KeySignature;
+            addModifier(stave : Stave) : KeySignature;
+            addToStave(stave : Stave, firstGlyph? : boolean) : KeySignature;
+            convertAccLines(clef : string, type : string) : void;
+        }
+        
+        export module Modifier {
+            const enum Position {LEFT, RIGHT, ABOVE, BELOW}
+            const CATEGORY : string
+        }
+        
+        class Modifier {
+            static DEBUG : boolean;
+            getCategory() : string;
+            getWidth() : number;
+            setWidth(width : number) : Modifier;
+            getNote() : Note;
+            setNote(note : Note) : Modifier;
+            getIndex() : number;
+            setIndex(index : number) : Modifier;
+            getContext() : IRenderContext;
+            setContext(context : IRenderContext) : Modifier;
+            getModifierContext() : ModifierContext;
+            setModifierContext(c : ModifierContext) : Modifier;
+            getPosition() : Modifier.Position;
+            setPosition(position : Modifier.Position) : Modifier;
+            setTextLine(line : number) : Modifier;
+            setYShift(y : number) : Modifier;
+            setXShift(x : number) : void; //inconsistent type: void -> Modifier
+            draw() : void;
+        }
+        
+        class ModifierContext {
+            static DEBUG : boolean;
+            addModifier(modifier : Modifier) : ModifierContext;
+            getModifiers(type : string) : Modifier[];
+            getWidth() : number;
+            getExtraLeftPx() : number;
+            getExtraRightPx() : number;
+            getState() : {left_shift : number, right_shift : number, text_line : number};
+            getMetrics() : {width : number, spacing : number, extra_left_px : number, extra_right_px : number};
+            preFormat() : void;
+            postFormat() : void;
+        }
+        
+        module Music {
+            const NUM_TONES : number;
+            const roots : string[];
+            const root_values : number[];
+            const root_indices : {[root : string] : number};
+            const canonical_notes : string[];
+            const diatonic_intervals : string[];
+            const diatonic_accidentals : {[diatonic_interval : string] : {note : number, accidental : number}};
+            const intervals : {[interval : string] : number};
+            const scales : {[scale : string] : number[]};
+            const accidentals : string[];
+            const noteValues : {[value : string] : {root_index : number, int_val : number}};
+        }
+        
+        class Music {
+            isValidNoteValue(note : number) : boolean;
+            isValidIntervalValue(interval : number) : boolean;
+            getNoteParts(noteString : string) : {root : string, accidental : string};
+            getKeyParts(noteString : string) : {root : string, accidental : string, type : string};
+            getNoteValue(noteString : string) : number;
+            getIntervalValue(intervalString : string) : number;
+            getCanonicalNoteName(noteValue : number) : string;
+            getCanonicalIntervalName(intervalValue : number) : string;
+            getRelativeNoteValue(noteValue : number, intervalValue : number, direction? : number) : number;
+            getRelativeNoteName(root : string, noteValue : number) : string;
+            getScaleTones(key : string, intervals : number[]) : number;
+            getIntervalBetween(note1 : number, note2 : number, direction? : number) : number;
+            createScaleMap(keySignature : string) : {[rootName : string] : string};
+        }
+        
+        module Note {
+            const CATEGORY : string;
+        }
+        
+        class Note implements Tickable {
+            //from tickable interface:
+            getTicks() : Fraction;
+            getCenterXShift() : number;
+            isCenterAligned() : boolean;
+            setCenterAlignment(align_center : boolean) : Note;
+            getTuplet() : Tuplet;
+            setTuplet(tuplet : Tuplet) : Note;
+            addToModifierContext(mc : ModifierContext) : void;
+            preFormat() : void;
+            postFormat() : Note;
+            getIntrinsicTicks() : Fraction;
+            setIntrinsicTicks(intrinsicTicks : Fraction) : void;
+            getTickMultiplier() : Fraction;
+            applyTickMultiplier(numerator : number, denominator : number) : void;
+            setDuration(duration : Fraction) : void;
+            
+            constructor(note_struct : {type? : string, dots? : number, duration : string});
+            getPlayNote() : any;
+            setPlayNote(note : any) : Note;
+            isRest() : boolean;
+            addStroke(index : number, stroke : Stroke) : Note;
+            getStave() : Stave;
+            setStave(stave : Stave) : Note;
+            getCategory() : string;
+            setContext(context : IRenderContext) : Note;
+            getExtraLeftPx() : number;
+            getExtraRightPx() : number;
+            setExtraLeftPx(x : number) : Note;
+            setExtraRightPx(x : number) : Note;
+            shouldIgnoreTicks() : boolean;
+            getLineNumber() : number;
+            getLineForRest() : number;
+            getGlyph() : Glyph;
+            setYs(ys : number[]) : Note;
+            getYs() : number[];
+            getYForTopText(text_line : number) : number;
+            getBoundingBox() : BoundingBox;
+            getVoice() : Voice;
+            setVoice(voice : Voice) : Note;
+            getTickContext() : TickContext;
+            setTickContext(tc : TickContext) : Note;
+            getDuration() : string;
+            isDotted() : boolean;
+            hasStem() : boolean;
+            getDots() : number;
+            getNoteType() : string;
+            setBeam() : Note;
+            setModifierContext(mc : ModifierContext) : Note;
+            addModifier(modifier : Modifier, index? : number) : Note;
+            getModifierStartXY() : {x : number, y : number};
+            getMetrics() : {width : number, noteWidth : number, left_shift : number, modLeftPx : number, modRightPx : number, extraLeftPx : number, extraRightPx : number};
+            setWidth(width : number) : void;
+            getWidth() : number;
+            setXShift(x : number) : Note;
+            getX() : number;
+            getAbsoluteX() : number;
+            setPreFormatted(value : boolean) : void;
+        }
+        
+        class NoteHead extends Note {
+            constructor(head_options : {x? : number, y? : number, note_type? : string, duration : string, displaced? : boolean, stem_direction? : number, line : number, x_shift : number, custom_glyph_code? : string, style? : string, slashed? : boolean, glyph_font_scale? : number});
+            static DEBUG : boolean;
+            getCategory() : string;
+            setContext(context : IRenderContext) : NoteHead;
+            getWidth() : number;
+            isDisplaced() : boolean;
+            getStyle() : {shadowColor? : string, shadowBlur? : string, fillStyle? : string, strokeStyle? : string};
+            setStyle(style : {shadowColor? : string, shadowBlur? : string, fillStyle? : string, strokeStyle? : string}) : NoteHead;
+            getGlyph() : Glyph;
+            setX(x : number) : NoteHead;
+            getY() : number;
+            setY(y : number) : NoteHead;
+            getLine() : number;
+            setLine(line : number) : NoteHead;
+            getAbsoluteX() : number;
+            getBoundingBox() : BoundingBox;
+            applyStyle(context : IRenderContext) : NoteHead;
+            setStave(stave : Stave) : NoteHead;
+            preFormat() : NoteHead;
+            draw() : void;
+        }
+        
+        module Ornament {
+            const CATEGORY : string;
+        }
+        
+        class Ornament extends Modifier {
+            constructor(type : string);
+            static DEBUG : boolean;
+            static format(ornaments : Ornament[], state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
+            setDelayed(delayed : boolean) : Ornament;
+            setUpperAccidental(acc : string) : Ornament;
+            setLowerAccidental(acc : string) : Ornament;
+            draw() : void;
+        }
+        
+        export module PedalMarking {
+            const enum Styles {TEXT, BRACKET, MIXED}
+            const GLYPHS : {[name : string] : {code : string, x_shift : number, y_shift : number}};
+        }
+        
+        class PedalMarking {
+            constructor(notes : Note[]); //inconsistent name: 'notes' is called 'type', suggesting string (is Note[])
+            static DEBUG : boolean;
+            static createSustain(notes : Note[]) : PedalMarking;
+            static createSostenuto(notes : Note[]) : PedalMarking;
+            static createUnaCorda(notes : Note[]) : PedalMarking;
+            setCustomText(depress? : string, release? : string) : PedalMarking;
+            setStyle(style : PedalMarking.Styles) : PedalMarking;
+            setLine(line : number) : PedalMarking;
+            setContext(context : IRenderContext) : PedalMarking;
+            drawBracketed() : void;
+            drawText() : void;
+            draw() : void;
+        }
+        
+        class RaphaelContext implements IRenderContext {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes or type inconsistencies mentioned below are fixed
+            setLineWidth(width : number) : RaphaelContext;
+            glow() : RaphaelContext;
+            
+            constructor(element : HTMLElement);
+            setFont(family : string, size : number, weight? : number) : RaphaelContext;
+            setRawFont(font : string) : RaphaelContext;
+            setFillStyle(style : string) : RaphaelContext;
+            setBackgroundFillStyle(style : string) : RaphaelContext;
+            setStrokeStyle(style : string) : RaphaelContext;
+            setShadowColor(style : string) : RaphaelContext; //inconsistent name: style -> color
+            setShadowBlur(blur : string) : RaphaelContext;
+            setLineWidth(width : number) : void; //inconsistent type: void -> RaphaelContext
+            setLineDash(dash : string) : RaphaelContext;
+            setLineCap(cap_type : string) : RaphaelContext;
+            scale(x : number, y : number) : RaphaelContext;
+            clear() : void;
+            resize(width : number, height : number) : RaphaelContext;
+            setViewBox(viewBox : string) : void;
+            rect(x : number, y : number, width : number, height : number) : void;
+            fillRect(x : number, y : number, width : number, height : number) : RaphaelContext;
+            clearRect(x : number, y : number, width : number, height : number) : RaphaelContext;
+            beginPath() : RaphaelContext;
+            moveTo(x : number, y : number) : RaphaelContext;
+            lineTo(x : number, y : number) : RaphaelContext;
+            bezierCurveToTo(x1 : number, y1 : number, x2 : number, y2 : number, x : number, y : number) : RaphaelContext;
+            quadraticCurveToTo(x1 : number, y1 : number, x : number, y : number) : RaphaelContext; //inconsistent name: x, y -> x2, y2
+            arc(x : number, y : number, radius : number, startAngle : number, endAngle : number, antiClockwise : boolean) : RaphaelContext;
+            glow() : {width : number, fill : boolean, opacity : number, offsetx : number, offsety : number, color : string}; //inconsistent type : Object -> RaphaelContext
+            fill() : RaphaelContext;
+            stroke() : RaphaelContext;
+            closePath() : RaphaelContext;
+            measureText(text : string) : {width : number, height : number};
+            fillText(text : string, x : number, y : number) : RaphaelContext;
+            save() : RaphaelContext;
+            restore() : RaphaelContext;
+        }
+        
+        export module Renderer {
+            const enum Backends {CANVAS, RAPHAEL, SVG, VML}
+            const enum LineEndType {NONE, UP, DOWN}
+        }
+        
+        class Renderer {
+            constructor(sel : HTMLElement, backend : Renderer.Backends)
+            static USE_CANVAS_PROXY : boolean;
+            static buildContext(sel : HTMLElement, backend : Renderer.Backends, width? : number, height? : number, background? : string) : IRenderContext;
+            static getCanvasContext(sel : HTMLElement, backend : Renderer.Backends, width? : number, height? : number, background? : string) : CanvasContext;
+            static getRaphaelContext(sel : HTMLElement, backend : Renderer.Backends, width? : number, height? : number, background? : string) : RaphaelContext;
+            static getSVGContext(sel : HTMLElement, backend : Renderer.Backends, width? : number, height? : number, background? : string) : SVGContext;
+            static bolsterCanvasContext(ctx : CanvasRenderingContext2D) : CanvasContext;
+            static drawDashedLine(context : IRenderContext, fromX : number, fromY : number, toX : number, toY : number, dashPattern : number[]) : void;
+            resize(width : number, height : number) : Renderer;
+            getContext() : IRenderContext;
+        }
+        
+        export module Repetition {
+            const enum type {NONE, CODA_LEFT, CODA_RIGHT, SEGNO_LEFT, SEGNO_RIGHT, DC, DC_AL_CODA, DC_AL_FINE, DS, DS_AL_CODA, DS_AL_FINE, FINE}
+        }
+        
+        class Repetition extends StaveModifier {
+            constructor(type : Repetition.type, x : number, y_shift : number);
+            getCategory() : string;
+            setShiftX(x : number) : Repetition;
+            setShiftY(y : number) : Repetition;
+            draw(stave : Stave, x : number) : Repetition;
+            drawCodaFixed(stave : Stave, x : number) : Repetition;
+            drawSignoFixed(stave : Stave, x : number) : Repetition; //inconsistent name: drawSignoFixed -> drawSegnoFixed
+            drawSymbolText(stave : Stave, x : number, text : string, draw_coda : boolean) : Repetition;
+        }
+        
+        class Stave {
+            constructor(x : number, y : number, width : number, options? : {vertical_bar_width? : number, glyph_spacing_px? : number, num_lines? : number, fill_style? : string, spacing_between_lines_px? : number, space_above_staff_ln? : number, space_below_staff_ln? : number, top_text_position? : number});
+            resetLines() : void;
+            setNoteStartX(x : number) : Stave;
+            getNoteStartX() : number;
+            getNoteEndX() : number;
+            getTieStartX() : number;
+            getTieEndX() : number;
+            setContext(context : IRenderContext) : Stave;
+            getContext() : IRenderContext;
+            getX() : number;
+            getNumLines() : number;
+            setY(y : number) : Stave;
+            setWidth(width : number) : Stave;
+            getWidth() : number;
+            setMeasure(measure : number) : Stave;
+            setBegBarType(type : Barline.type) : Stave;
+            setEndBarType(type : Barline.type) : Stave;
+            getModifierXShift(index : number) : number;
+            setRepetitionTypeLeft(type : Repetition.type, y : number) : Stave;
+            setRepetitionTypeRight(type : Repetition.type, y : number) : Stave;
+            setVoltaType(type : Volta.type, number_t : number, y : number) : Stave;
+            setSection(section : string, y : number) : Stave;
+            setTempo(tempo : {name? : string, duration : string, dots : number, bpm : number}, y : number) : Stave;
+            setText(text : string, position : Modifier.Position, options? : {shift_x? : number, shift_y? : number, justification? : TextNote.Justification}) : Stave;
+            getHeight() : number;
+            getSpacingBetweenLines() : number;
+            getBoundingBix() : BoundingBox;
+            getBottomY() : number;
+            getBottomLineY() : number;
+            getYForLine(line : number) : number;
+            getYForTopText(line? : number) : number;
+            getYForBottomText(line? : number) : number;
+            getYForNote(line? : number) : number;
+            getYForGlyphs() : number;
+            addGlyph(glypg : Glyph) : Stave;
+            addEndGlyph(glypg : Glyph) : Stave;
+            addModifier(modifier : StaveModifier) : Stave;
+            addEndModifier(modifier : StaveModifier) : Stave;
+            addKeySignature(keySpec : string) : Stave;
+            addClef(clef : string, size? : string, annotation? : string) : Stave;
+            addEndClef(clef : string, size? : string, annotation? : string) : Stave;
+            addTimeSignature(timeSpec : string, customPadding? : number) : void; //inconsistent type: void -> Stave
+            addTrebleGlyph() : Stave;
+            draw() : void;
+            drawVertical(x : number, isDouble : boolean) : void;
+            drawVerticalFixed(x : number, isDouble : boolean) : void;
+            drawVerticalBar(x : number) : void;
+            drawVerticalBarFixed(x : number) : void;
+            getConfigForLines() : {visible : boolean}[];
+            setConfigForLine(line_number : number, line_config : {visible : boolean}) : Stave;
+            setConfigForLines(lines_configuration : {visible : boolean}[]) : Stave;
+        }
+        
+        export module StaveConnector {
+            const enum type {SINGLE_RIGHT, SINGLE_LEFT, SINGLE, DOUBLE, BRACE, BRACKET, BOLD_DOUBLE_LEFT, BOLD_DOUBLE_RIGHT, THIN_DOUBLE}
+        }
+        
+        class StaveConnector {
+            constructor(top_stave : Stave, bottom_stave : Stave);
+            setContext(ctx : IRenderContext) : StaveConnector;
+            setType(type : StaveConnector.type) : StaveConnector;
+            setText(text : string, text_options? : {shift_x? : number, shift_y? : number}) : StaveConnector;
+            setFont(font : {family? : string, size? : number, weight? : string}) : void; //inconsistent type: void -> StaveConnector
+            setXShift(x_shift : number) : StaveConnector;
+            draw() : void;
+            drawBoldDoubleLine(ctx : Object, type : StaveConnector.type, topX : number, topY : number, botY : number) : void;
+        }
+        
+        export module StaveHairpin {
+            const enum type {CRESC, DECRESC}
+        }
+        
+        class StaveHairpin {
+            constructor(notes : {first_note : Note, last_note : Note}, type : StaveHairpin.type);
+            static FormatByTicksAndDraw(ctx : IRenderContext, formatter : Formatter, notes : {first_note : Note, last_note : Note}, type : StaveHairpin.type, position : Modifier.Position, options? : {height : number, y_shift : number, left_shift_ticks : number, right_shift_ticks : number}) : void;
+            setContext(context : IRenderContext) : StaveHairpin;
+            setPosition(position : Modifier.Position) : StaveHairpin;
+            setRenderOptions(options : {height? : number, y_shift : number, left_shift_px : number, right_shift_px : number}) : StaveHairpin;
+            setNotes(notes : {first_note : Note, last_note : Note}) : StaveHairpin;
+            renderHairpin(params : {first_x : number, last_x : number, first_y : number, last_y : number, staff_height : number}) : void;
+            draw() : boolean;
+        }
+        
+        export module StaveLine {
+            const enum TextVerticalPosition {TOP, BOTTOM}
+            const enum TextJustification {LEFT, CENTER, RIGHT}
+        }
+        
+        class StaveLine {
+            constructor(notes : {first_note: Note, last_note: Note, first_indices : number[], last_indices : number[]});
+            setContext(context : Object) : StaveLine;
+            setFont(font : {family : string, size : number, weight : string}) : StaveLine;
+            setText(text : string) : StaveLine;
+            setNotes(notes : {first_note: Note, last_note: Note, first_indices? : number[], last_indices? : number[]}) : StaveLine;
+            applyLineStyle() : void;
+            applyFontStyle() : void;
+            draw() : StaveLine;
+            
+            //inconsistent API: this should be set via an options object in the constructor
+            render_options : {padding_left : number, padding_right : number, line_width : number, line_dash : number[], rounded_end : boolean, color : string, draw_start_arrow : boolean, draw_end_arrow : boolean, arrowhead_length : number, arrowhead_angle : number, text_position_vertical : StaveLine.TextVerticalPosition, text_justification : StaveLine.TextJustification};
+        }
+        
+        class StaveModifier {
+            getCategory() : string;
+            makeSpacer(padding : number) : {getContext: Function, setStave: Function, renderToStave: Function, getMetrics: Function};
+            placeGlyphOnLine(glyph : Glyph, stave : Stave, line : number) : void;
+            setPadding(padding : number) : void;
+            addToStave(stave : Stave, firstGlyph : boolean) : StaveModifier;
+            addToStaveEnd(stave : Stave, firstGlyph : boolean) : StaveModifier;
+            addModifier() : void;
+            addEndModifier() : void;
+        }
+        
+        module StaveNote {
+            const STEM_UP : number;
+            const STEM_DOWN : number;
+            const CATEGORY : string;
+        }
+        
+        class StaveNote extends StemmableNote {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes and/or inconsistencies mentioned below are fixed
+            buildStem() : StemmableNote;            
+            setStave(stave : Stave) : Note;
+            addModifier(modifier : Modifier, index? : number) : Note;
+            getModifierStartXY() : {x : number, y : number};
+            getDots() : number;
+
+            constructor(note_struct : {type? : string, dots? : number, duration : string, clef? : string, keys : string[], octave_shift? : number, auto_stem? : boolean, stem_direction? : number});
+            static DEBUG : boolean;
+            static format(notes : StaveNote[] , state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
+            static formatByY(notes : StaveNote[] , state : {left_shift : number, right_shift : number, text_line : number}) : void;
+            static postFormat(notes : StaveNote[]) : boolean;
+            buildStem() : void; //inconsistent type: void -> StaveNote
+            buildNoteHeads() : void;
+            autoStem() : void;
+            calculateKeyProps() : void;
+            getBoundingBox() : BoundingBox;
+            getLineNumber() : number;
+            isRest() : boolean;
+            isChord() : boolean;
+            hasStem() : boolean;
+            getYForTopText(text_line : number) : number;
+            getYForBottomText(text_line : number) : number;
+            setStave(stave : Stave) : StaveNote;
+            getKeys() : string[];
+            getKeyProps() : {key : string, octave : number, line : number, int_value : number, accidental : string, code : number, stroke : number, shift_right : number, displaced : boolean}[];
+            isDisplaced() : boolean;
+            setNoteDisplaced(displaced : boolean) : StaveNote;
+            getTieRightX() : number;
+            getTieLeftX() : number;
+            getLineForRest() : number;
+            getModifierStartXY(position : Modifier.Position, index : number) : {x : number, y : number};
+            setStyle(style : {shadowColor? : string, shadowBlur? : string, fillStyle? : string, strokeStyle? : string}) : void; // inconsistent type: void -> StaveNote
+            setKeyStyle(index : number, style : {shadowColor? : string, shadowBlur? : string, fillStyle? : string, strokeStyle? : string}) : StaveNote;
+            setKeyLine(index : number, line : number) : StaveNote;
+            getKeyLine(index : number) : number;
+            addToModifierContext(mContext : ModifierContext) : StaveNote;
+            addModifier(index : number, modifier : Modifier) : StaveNote;
+            addAccidental(index : number, accidental : Accidental) : StaveNote;
+            addArticulation(index : number, articulation : Articulation) : StaveNote;
+            addAnnotation(index : number, annotation : Annotation) : StaveNote;
+            addDot(index : number) : StaveNote;
+            addDotToAll() : StaveNote;
+            getAccidentals() : Accidental[];
+            getDots() : Dot[];
+            getVoiceShiftWidth() : number;
+            calcExtraPx() : void;
+            preFormat() : void;
+            getNoteHeadBounds() : {y_top: number, y_bottom: number, highest_line: number, lowest_line: number};
+            getNoteHeadBeginX() : number;
+            getNoteHeadEndX() : number;
+            drawLedgerLines() : void;
+            drawModifiers() : void;
+            drawFlag() : void;
+            drawNoteHeads() : void;
+            drawStem(struct : {x_begin? : number, x_end? : number, y_top? : number, y_bottom? : number, y_extend? : number, stem_extension? : number, stem_direction? : number}) : void;
+            draw() : void;
+        }
+        
+        class StaveSection extends Modifier {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes
+            draw() : void;
+            
+            constructor(section : string, x : number, shift_y : number);
+            getCategory() : string;
+            setStaveSection(section : string) : StaveSection;
+            setShiftX(x : number) : StaveSection;
+            setShiftY(y : number) : StaveSection;
+            draw(stave : Stave, shift_x : number) : StaveSection;
+        }
+        
+        class StaveTempo extends StaveModifier {
+            constructor(tempo : {name? : string, duration : string, dots : number, bpm : number}, x : number, shift_y : number);
+            getCategory() : string;
+            setTempo(tempo : {name? : string, duration : string, dots : number, bpm : number}) : StaveTempo;
+            setShiftX(x : number) : StaveTempo;
+            setShiftY(y : number) : StaveTempo;
+            draw(stave : Stave, shift_x : number) : StaveTempo;
+        }
+        
+        class StaveText extends Modifier {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes
+            draw() : void;
+            
+            constructor(text : string, position : Modifier.Position, options? : {shift_x? : number, shift_y? : number, justification? : TextNote.Justification});
+            getCategory() : string;
+            setStaveText(text : string) : StaveText;
+            setShiftX(x : number) : StaveText;
+            setShiftY(y : number) : StaveText;
+            setFont(font : {family? : string, size? : number, weight? : number}) : void;
+            setText(text : string) : void;
+            draw(stave : Stave) : StaveText;
+        }
+        
+        class StaveTie {
+            constructor(notes : {first_note: Note, last_note: Note, first_indices : number[], last_indices : number[]}, text? : string);
+            setContext(context : IRenderContext) : StaveTie;
+            setFont(font : {family : string, size : number, weight : string}) : StaveTie;
+            setNotes(notes : {first_note: Note, last_note: Note, first_indices : number[], last_indices : number[]}) : StaveTie;
+            isPartial() : boolean;
+            renderTie(params : {first_ys : number[], last_ys : number[], last_x_px : number, first_x_px : number, direction : number}) : void;
+            renderText(first_x_px : number, last_x_px : number) : void;
+            draw() : boolean;
+        }
+        
+        module Stem {
+            const UP : number;
+            const DOWN : number;
+        }
+        
+        class Stem {
+            constructor(options : {x_begin? : number, x_end? : number, y_top? : number, y_bottom? : number, y_extend? : number, stem_extension? : number, stem_direction? : number});
+            static DEBUG : boolean;
+            setNoteHeadXBounds(x_begin : number, x_end : number) : Stem;
+            setDirection(direction : number) : void;
+            setExtension(extension : number) : void;
+            setYBounds(y_top : number, y_bottom : number) : void;
+            getCategory() : string;
+            setContext(context : IRenderContext) : Stem;
+            getHeight() : number;
+            getBoundingBox() : BoundingBox;
+            getExtents() : {topY : number, baseY : number};
+            setStyle(style : {shadowColor? : string, shadowBlur? : string, fillStyle? : string, strokeStyle? : string}) : void;
+            getStyle() : {shadowColor? : string, shadowBlur? : string, fillStyle? : string, strokeStyle? : string};
+            applyStyle(context : IRenderContext) : Stem;
+            draw() : void;
+            
+            //inconsistent API: this should be set via the options object in the constructor
+            hide : boolean;
+        }
+        
+        class StemmableNote extends Note {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes
+            setBeam() : Note;
+            
+            constructor(note_struct : {type? : string, dots? : number, duration : string});
+            static DEBUG : boolean;
+            getStem() : Stem;
+            setStem(stem : Stem) : StemmableNote;
+            buildStem() : StemmableNote;
+            getStemLength() : number;
+            getBeamCount() : number;
+            getStemMinumumLength() : number; //inconsistent name: getStemMinumumLength -> getStemMinimumLength
+            getStemDirection() : number;
+            setStemDirection(direction : number) : StemmableNote;
+            getStemX() : number;
+            getCenterGlyphX() : number;
+            getStemExtension() : number;
+            setStemLength() : number;
+            getStemExtents() : {topY : number, baseY : number};
+            setBeam(beam : Beam) : StemmableNote;
+            getYForTopText(text_line : number) : number;
+            getYForBottomText(text_line : number) : number;
+            postFormat() : StemmableNote;
+            drawStem(stem_struct : {x_begin? : number, x_end? : number, y_top? : number, y_bottom? : number, y_extend? : number, stem_extension? : number, stem_direction? : number}) : void;
+        }
+        
+        module StringNumber {
+            const CATEGORY : string;
+        }
+        
+        class StringNumber extends Modifier {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes
+            setNote(note : Note) : StringNumber;
+            
+            constructor(number : number);
+            static format(nums : StringNumber[], state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
+            getNote()  : Note;
+            setNote(note : StemmableNote) : StringNumber;
+            getIndex() : number;
+            setIndex(index : number) : StringNumber;
+            setLineEndType(leg : Renderer.LineEndType) : StringNumber;
+            getPosition() : Modifier.Position;
+            setPosition(position : Modifier.Position) : StringNumber;
+            setStringNumber(number : number) : StringNumber;
+            setOffsetX(x : number) : StringNumber;
+            setOffsetY(y : number) : StringNumber;
+            setLastNote(note : StemmableNote) : StringNumber;
+            setDashed(dashed : boolean) : StringNumber;
+            draw() : void;
+        }
+        
+        export module Stroke {
+            const enum Type {BRUSH_DOWN, BRUSH_UP, ROLL_DOWN, ROLL_UP, RASQUEDO_DOWN, RASQUEDO_UP}
+            const CATEGORY : string;
+        }
+        
+        class Stroke extends Modifier {
+            constructor(type : Stroke.Type, options : {all_voices? : boolean});
+            static format(strokes : Stroke[], state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
+            getPosition() : Modifier.Position;
+            addEndNote(note : Note) : Stroke;
+            draw() : void;
+        }
+        
+        class SVGContext implements IRenderContext {
+            constructor(element : HTMLElement);
+            iePolyfill() : boolean;
+            setFont(family : string, size : number, weight? : number) : SVGContext;
+            setRawFont(font : string) : SVGContext;
+            setFillStyle(style : string) : SVGContext;
+            setBackgroundFillStyle(style : string) : SVGContext;
+            setStrokeStyle(style : string) : SVGContext;
+            setShadowColor(style : string) : SVGContext; //inconsistent name: style -> color
+            setShadowBlur(blur : string) : SVGContext;
+            setLineWidth(width : number) : SVGContext;
+            setLineDash(dash : string) : SVGContext;
+            setLineCap(cap_type : string) : SVGContext;
+            resize(width : number, height : number) : SVGContext;
+            scale(x : number, y : number) : SVGContext;
+            setViewBox(xMin : number, yMin : number, width : number, height : number) : void;
+            clear() : void;
+            rect(x : number, y : number, width : number, height : number) : SVGContext;
+            fillRect(x : number, y : number, width : number, height : number) : SVGContext;
+            clearRect(x : number, y : number, width : number, height : number) : SVGContext;
+            beginPath() : SVGContext;
+            moveTo(x : number, y : number) : SVGContext;
+            lineTo(x : number, y : number) : SVGContext;
+            bezierCurveToTo(x1 : number, y1 : number, x2 : number, y2 : number, x : number, y : number) : SVGContext;
+            quadraticCurveToTo(x1 : number, y1 : number, x : number, y : number) : SVGContext; //inconsistent: x, y -> x2, y2
+            arc(x : number, y : number, radius : number, startAngle : number, endAngle : number, antiClockwise : boolean) : SVGContext;
+            closePath() : SVGContext;
+            glow() : SVGContext;
+            fill() : SVGContext;
+            stroke() : SVGContext;
+            measureText(text : string) : SVGRect;
+            ieMeasureTextFix(bbox : SVGRect, text : string) : {x : number, y : number, width : number, height : number};
+            fillText(text : string, x : number, y : number) : SVGContext;
+            save() : SVGContext;
+            restore() : SVGContext;
+        }
+        
+        class TabNote extends StemmableNote {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes
+            setStave(stave : Stave) : Note;
+            getModifierStartXY() : {x : number, y : number};
+            
+            constructor(tab_struct : {positions : {str : number, fret : number}[], type? : string, dots? : number, duration : string, stem_direction? : boolean}, draw_stem? : boolean);
+            getCategory() : string;
+            setGhost(ghost : boolean) : TabNote;
+            hasStem() : boolean;
+            getStemExtension() : number;
+            addDot() : TabNote;
+            updateWidth() : void;
+            setStave(stave : Stave) : TabNote;
+            getPositions() : {str : number, fret : number}[];
+            addToModifierContext(mc : ModifierContext) : TabNote;
+            getTieRightX() : number;
+            getTieLeftX() : number;
+            getModifierStartXY(position : Modifier.Position, index : number) : {x : number, y : number};
+            getLineForRest() : number;
+            preFormat() : void;
+            getStemX() : number;
+            getStemY() : number;
+            getStemExtents() : {topY : number, baseY : number};
+            drawFlag() : void;
+            drawModifiers() : void;
+            drawStemThrough() : void;
+            draw() : void;
+        }
+        
+        module TabSlide {
+            const SLIDE_UP : number;
+            const SLIDE_DOWN : number;
+        }
+        
+        class TabSlide extends TabTie {
+            constructor(notes : {first_note: Note, last_note: Note, first_indices : number[], last_indices : number[]}, direction? : number);
+            static createSlideUp(notes : {first_note: Note, last_note: Note, first_indices : number[], last_indices : number[]}) : TabSlide;
+            static createSlideDown(notes : {first_note: Note, last_note: Note, first_indices : number[], last_indices : number[]}) : TabSlide;
+            renderTie(params : {first_ys : number[], last_ys : number[], last_x_px : number, first_x_px : number, direction : number}) : void;
+        }
+        
+        class TabStave extends Stave {
+            constructor(x : number, y : number, width : number, options? : {vertical_bar_width? : number, glyph_spacing_px? : number, num_lines? : number, fill_style? : string, spacing_between_lines_px? : number, space_above_staff_ln? : number, space_below_staff_ln? : number, top_text_position? : number});
+            getYForGlyphs() : number;
+            addTabGlyph() : TabStave;
+        }
+        
+        class TabTie extends StaveTie {
+            constructor(notes : {first_note: Note, last_note: Note, first_indices : number[], last_indices : number[]}, text? : string);
+            createHammeron(notes : {first_note: Note, last_note: Note, first_indices : number[], last_indices : number[]}) : TabTie;
+            createPulloff(notes : {first_note: Note, last_note: Note, first_indices : number[], last_indices : number[]}) : TabTie;
+            draw() : boolean;
+        }
+        
+        export module TextBracket {
+            const enum Positions {TOP, BOTTOM}
+        }
+        
+        class TextBracket {
+            constructor(bracket_data : {start : Note, stop : Note, text? : string, superscript? : string, position? : TextBracket.Positions});
+            static DEBUG : boolean;
+            applyStyle(context : IRenderContext) : TextBracket;
+            setDashed(dashed : boolean, dash? : number[]) : TextBracket;
+            setFont(font : {family : string, size : number, weight : string}) : TextBracket;
+            setContext(context : IRenderContext) : TextBracket;
+            setLine(line : number) : TextBracket;
+            draw() : void;
+        }
+        
+        class TextDynamics extends Note {
+            constructor(text_struct : {duration : string, text : string, line? : number});
+            static DEBUG : boolean;
+            setLine(line : number) : TextDynamics;
+            preFormat() : TextDynamics;
+            draw() : void;
+        }
+        
+        export module TextNote {
+            const enum Justification {LEFT, CENTER, RIGHT}
+            const GLYPHS : {[name : string] : {code : string, point : number, x_shift : number, y_shift : number}}
+        }
+
+        class TextNote extends Note {
+            constructor(text_struct : {duration : string, text? : string, superscript? : boolean, subscript? : boolean, glyph? : string, font? : {family : string, size : number, weight : string}, line? : number, smooth? : boolean, ignore_ticks? : boolean});
+            setJustification(just : TextNote.Justification) : TextNote;
+            setLine(line : number) : TextNote;
+            preFormat() : void;
+            draw() : void;
+        }
+        
+        interface Tickable {
+            setContext(context : IRenderContext) : void;
+            getBoundingBox() : BoundingBox;
+            getTicks() : Fraction;
+            shouldIgnoreTicks() : boolean;
+            getWidth() : number;
+            setXShift(x : number) : Tickable;
+            getCenterXShift() : number;
+            isCenterAligned() : boolean;
+            setCenterAlignment(align_center : boolean) : Tickable;
+            getVoice() : Voice;
+            setVoice(voice : Voice) : void;
+            getTuplet() : Tuplet;
+            setTuplet(tuplet : Tuplet) : Tickable;
+            addToModifierContext(mc : ModifierContext) : void;
+            addModifier(mod : Modifier) : Tickable;
+            setTickContext(tc : TickContext) : void;
+            preFormat() : void;
+            postFormat() : Tickable;
+            getIntrinsicTicks() : Fraction;
+            setIntrinsicTicks(intrinsicTicks : Fraction) : void;
+            getTickMultiplier() : Fraction;
+            applyTickMultiplier(numerator : number, denominator : number) : void;
+            setDuration(duration : Fraction) : void;
+        }
+        
+        class TickContext {
+            setContext(context : IRenderContext) : void;
+            getContext() : IRenderContext;
+            shouldIgnoreTicks() : boolean;
+            getWidth() : number;
+            getX() : number;
+            setX(x : number) : TickContext;
+            getPixelsUsed() : number;
+            setPixelsUsed(pixelsUsed : number) : TickContext;
+            setPadding(padding : number) : TickContext;
+            getMaxTicks() : number;
+            getMinTicks() : number;
+            getTickables() : Tickable[];
+            getCenterAlignedTickables() : Tickable[];
+            getMetrics() : {width : number, notePx : number, extraLeftPx : number, extraRightPx : number};
+            getCurrentTick() : Fraction;
+            setCurrentTick(tick : Fraction) : void;
+            getExtraPx() : {left: number, right: number, extraLeft : number, extraRight : number};
+            addTickable(tickable : Tickable) : TickContext;
+            preFormat() : TickContext;
+            postFormat() : TickContext;
+            static getNextContext(tContext : TickContext) : TickContext;
+        }
+        
+        module TimeSignature {
+            const glyphs : {[name : string] : {code : string, point : number, line : number}};
+        }
+        
+        class TimeSignature extends StaveModifier {
+             //TODO remove the following lines once TypeScript allows subclass overrides with type changes
+            addModifier() : void;
+            addEndModifier() : void;
+            
+            constructor(timeSpec : string, customPadding? : number);
+            parseTimeSpec(timeSpec : string) : {num : number, glyph : Glyph};
+            makeTimeSignatureGlyph(topNums : number[], botNums : number[]) : Glyph;
+            getTimeSig() : {num : number, glyph : Glyph};
+            addModifier(stave : Stave) : void;
+            addEndModifier(stave : Stave) : void;
+        }
+        
+        class TimeSigNote extends Note {
+            //TODO remove the following lines once TypeScript allows subclass overrides with type changes or type inconsistencies mentioned below are fixed
+            setStave(stave : Stave) : Note;
+
+            constructor(timeSpec : string, customPadding : number);
+            setStave(stave : Stave) : void; //inconsistent type: void -> TimeSignote
+            getBoundingBox() : BoundingBox;
+            addToModifierContext() : TimeSigNote;
+            preFormat() : TimeSigNote;
+            draw() : void;
+        }
+        
+        class Tremolo extends Modifier {
+            constructor(num : number);
+            getCategory() : string;
+            draw() : void;
+        }
+        
+        module Tuning {
+            const names : {[name : string] : string};
+        }
+        
+        class Tuning {
+            constructor(tuningString? : string);
+            noteToInteger(noteString : string) : number;
+            setTuning(tuningString : string) : void;
+            getValueForString(stringNum : string) : number;
+            getValueForFret(fretNum : string, stringNum : string) : number;
+            getNoteForFret(fretNum : string, stringNum : string) : string; 
+        }
+        
+        module Tuplet {
+            const LOCATION_TOP : number;
+            const LOCATION_BOTTOM : number;            
+        }
+        
+        class Tuplet {
+            constructor(notes : StaveNote[], options : {num_notes? : number, beats_occupied? : number});
+            attach() : void;
+            detach() : void;
+            setContext(context : IRenderContext) : Tuplet;
+            setBracketed(bracketed : boolean) : Tuplet;
+            setRatioed(ratioed : boolean) : Tuplet;
+            setTupletLocation(location : number) : Tuplet;
+            getNotes() : StaveNote[];
+            getNoteCount() : number;
+            getBeatsOccupied() : number;
+            setBeatsOccupied(beats : number) : void;
+            resolveGlyphs() : void;
+            draw() : void;
+        }
+        
+        module Vibrato {
+            const CATEGORY : string;
+        }
+        
+        class Vibrato extends Modifier {
+            static format(vibratos : Vibrato[], state : {left_shift : number, right_shift : number, text_line : number}, context : ModifierContext) : boolean;
+            setHarsh(harsh : boolean) : Vibrato;
+            setVibratoWidth(width : number) : Vibrato;
+            draw() : void;            
+        }
+        
+        export module Voice {
+            const enum Mode {STRICT, SOFT, FULL}
+        }
+        
+        class Voice {
+            constructor(time : {num_beats? : number, beat_value? : number, resolution? : number});
+            getTotalTicks() : Fraction;
+            getTicksUsed() : Fraction;
+            getLargestTickWidth() : number;
+            getSmallestTickCount() : Fraction;
+            getTickables() : Tickable[];
+            getMode() : number;
+            setMode(mode : number) : Voice;
+            getResolutionMultiplier() : number;
+            getActualResolution() : number;
+            setStave(stave : Stave) : Voice;
+            getBoundingBox() : BoundingBox;
+            getVoiceGroup() : VoiceGroup;
+            setVoiceGroup(g : VoiceGroup) : Voice;
+            setStrict(strict : boolean) : Voice;
+            isComplete() : boolean;
+            addTickable(tickable : Tickable) : Voice;
+            addTickables(tickables : Tickable[]) : Voice;
+            preFormat() : Voice;
+            draw(context : IRenderContext, stave? : Stave) : void;
+        }
+        
+        class VoiceGroup {
+            getVoices() : Voice[];
+            getModifierContexts() : ModifierContext[];
+            addVoice(voice : Voice) : void;
+        }
+        
+        export module Volta {
+            const enum type {NONE, BEGIN, MID, END, BEGIN_END}
+        }
+        
+        class Volta extends StaveModifier {
+            constructor(type : Volta.type, number : number, x : number, y_shift : number);
+            getCategory() : string;
+            setShiftY(y : number) : Volta;
+            draw(stave : Stave, x : number) : Volta;
+        }
+    }
+}
\ No newline at end of file
diff --git a/vue/vue-tests.ts b/vue/vue-tests.ts
index 540f9f5ba..297379bbb 100644
--- a/vue/vue-tests.ts
+++ b/vue/vue-tests.ts
@@ -17,7 +17,7 @@ module myapp {
       });
       this.methods = {
         action: this.action
-      }
+      };
     }
     action(): void {
       console.log("action");
@@ -27,3 +27,7 @@ module myapp {
 
 var app = new myapp.Application();
 app.$mount("#main");
+
+var AppConstructor = Vue.extend({});
+var extendedApp = new AppConstructor();
+app.$mount("#main");
diff --git a/vue/vue.d.ts b/vue/vue.d.ts
index 25fcc4277..109f81762 100644
--- a/vue/vue.d.ts
+++ b/vue/vue.d.ts
@@ -120,7 +120,7 @@ declare module vuejs {
      * http://vuejs.org/api/global-api.html
      */
     static config: VueConfig;
-    static extend(options: {}): Vue;
+    static extend(options: {}): typeof Vue;
     static directive(id: string, definition?: {}): void;
     static directive(id: string, definition?: VueCallback): void;
     static filter(id: string, definition?: FilterCallback): void;
@@ -168,4 +168,4 @@ import Vue = vuejs.Vue;
 declare module "vue" {
     import vue = vuejs.Vue;
     export = vue;
-}
\ No newline at end of file
+}
diff --git a/webfontloader/webfontloader-tests.ts.tscparams b/webfontloader/webfontloader-tests.ts.tscparams
deleted file mode 100644
index 4169d3605..000000000
--- a/webfontloader/webfontloader-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
---noImplicitAny --module commonjs --target es5
\ No newline at end of file
diff --git a/youtube/youtube.d.ts.tscparams b/youtube/youtube.d.ts.tscparams
deleted file mode 100644
index d3f5a12fa..000000000
--- a/youtube/youtube.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-