diff --git a/angular2/angular2-tests.ts.tscparams b/angular2/angular2-tests.ts.tscparams
index cfedaf198..3f0863ac6 100644
--- a/angular2/angular2-tests.ts.tscparams
+++ b/angular2/angular2-tests.ts.tscparams
@@ -1 +1 @@
---experimentalDecorators --target ES5
\ No newline at end of file
+--experimentalDecorators --noImplicitAny --target ES5
diff --git a/angular2/angular2.d.ts b/angular2/angular2.d.ts
index 0c7b8609e..15d7f1461 100644
--- a/angular2/angular2.d.ts
+++ b/angular2/angular2.d.ts
@@ -41,23 +41,23 @@ declare module ng {
 
   /**
    * Declare reusable UI building blocks for an application.
-   * 
+   *
    * Each Angular component requires a single `@Component` and at least one `@View` annotation. The
    * `@Component`
    * annotation specifies when a component is instantiated, and which properties and hostListeners it
    * binds to.
-   * 
+   *
    * When a component is instantiated, Angular
    * - creates a shadow DOM for the component.
    * - loads the selected template into the shadow DOM.
    * - creates all the injectable objects configured with `bindings` and `viewBindings`.
-   * 
+   *
    * All template expressions and statements are then evaluated against the component instance.
-   * 
+   *
    * For details on the `@View` annotation, see {@link ViewMetadata}.
-   * 
+   *
    * ## Example
-   * 
+   *
    * ```
    * @Component({
    *   selector: 'greet'
@@ -67,7 +67,7 @@ declare module ng {
    * })
    * class Greet {
    *   name: string;
-   * 
+   *
    *   constructor() {
    *     this.name = 'World';
    *   }
@@ -75,47 +75,47 @@ declare module ng {
    * ```
    */
   class ComponentMetadata extends DirectiveMetadata {
-    
+
 
     /**
      * Defines the used change detection strategy.
-     * 
+     *
      * When a component is instantiated, Angular creates a change detector, which is responsible for
      * propagating
      * the component's bindings.
-     * 
+     *
      * 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: [
@@ -128,30 +128,30 @@ declare module ng {
      * })
      * class HelloWorld {
      * }
-     * 
+     *
      * ```
      */
      viewBindings: List<any>;
   }
-  
+
 
   /**
    * Directives allow you to attach behavior to elements in the DOM.
-   * 
+   *
    * {@link DirectiveMetadata}s with an embedded view are called {@link ComponentMetadata}s.
-   * 
+   *
    * A directive consists of a single directive annotation and a controller class. When the
    * directive's `selector` matches
    * elements in the DOM, the following steps occur:
-   * 
+   *
    * 1. For each directive, the `ElementInjector` attempts to resolve the directive's constructor
    * arguments.
    * 2. Angular instantiates directives for each matched element using `ElementInjector` in a
    * depth-first order,
    *    as declared in the HTML.
-   * 
+   *
    * ## Understanding How Injection Works
-   * 
+   *
    * There are three stages of injection resolution.
    * - *Pre-existing Injectors*:
    *   - The terminal {@link Injector} cannot resolve dependencies. It either throws an error or, if
@@ -165,24 +165,24 @@ declare module ng {
    * - *Element Injectors*: Each component instance has a Shadow DOM. Within the Shadow DOM each
    * element has an `ElementInjector`
    *     which follow the same parent-child hierarchy as the DOM elements themselves.
-   * 
+   *
    * When a template is instantiated, it also must instantiate the corresponding directives in a
    * depth-first order. The
    * current `ElementInjector` resolves the constructor dependencies for each directive.
-   * 
+   *
    * Angular then resolves dependencies as follows, according to the order in which they appear in the
    * {@link ViewMetadata}:
-   * 
+   *
    * 1. Dependencies on the current element
    * 2. Dependencies on element injectors and their parents until it encounters a Shadow DOM boundary
    * 3. Dependencies on component injectors and their parents until it encounters the root component
    * 4. Dependencies on pre-existing injectors
-   * 
-   * 
+   *
+   *
    * The `ElementInjector` can inject other directives, element-specific special objects, or it can
    * delegate to the parent
    * injector.
-   * 
+   *
    * To inject other directives, declare the constructor parameter as:
    * - `directive:DirectiveType`: a directive on the current element only
    * - `@Host() directive:DirectiveType`: any directive that matches the type between the current
@@ -192,21 +192,21 @@ declare module ng {
    * directives.
    * - `@QueryDescendants(DirectiveType) query:QueryList<DirectiveType>`: A live collection of any
    * child directives.
-   * 
+   *
    * To inject element-specific special objects, declare the constructor parameter as:
    * - `element: ElementRef` to obtain a reference to logical element in the view.
    * - `viewContainer: ViewContainerRef` to control child template instantiation, for
    * {@link DirectiveMetadata} directives only
    * - `bindingPropagation: BindingPropagation` to control change detection in a more granular way.
-   * 
+   *
    * ## Example
-   * 
+   *
    * The following example demonstrates how dependency injection resolves constructor arguments in
    * practice.
-   * 
-   * 
+   *
+   *
    * Assume this HTML template:
-   * 
+   *
    * ```
    * <div dependency="1">
    *   <div dependency="2">
@@ -219,14 +219,14 @@ declare module ng {
    *   </div>
    * </div>
    * ```
-   * 
+   *
    * With the following `dependency` decorator and `SomeService` injectable class.
-   * 
+   *
    * ```
    * @Injectable()
    * class SomeService {
    * }
-   * 
+   *
    * @Directive({
    *   selector: '[dependency]',
    *   properties: [
@@ -237,15 +237,15 @@ declare module ng {
    *   id:string;
    * }
    * ```
-   * 
+   *
    * Let's step through the different ways in which `MyDirective` could be declared...
-   * 
-   * 
+   *
+   *
    * ### No injection
-   * 
+   *
    * Here the constructor is declared with no arguments, therefore nothing is injected into
    * `MyDirective`.
-   * 
+   *
    * ```
    * @Directive({ selector: '[my-directive]' })
    * class MyDirective {
@@ -253,15 +253,15 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * This directive would be instantiated with no dependencies.
-   * 
-   * 
+   *
+   *
    * ### Component-level injection
-   * 
+   *
    * Directives can inject any injectable instance from the closest component injector or any of its
    * parents.
-   * 
+   *
    * Here, the constructor declares a parameter, `someService`, and injects the `SomeService` type
    * from the parent
    * component's injector.
@@ -272,14 +272,14 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * This directive would be instantiated with a dependency on `SomeService`.
-   * 
-   * 
+   *
+   *
    * ### Injecting a directive from the current element
-   * 
+   *
    * Directives can inject other directives declared on the current element.
-   * 
+   *
    * ```
    * @Directive({ selector: '[my-directive]' })
    * class MyDirective {
@@ -290,9 +290,9 @@ declare module ng {
    * ```
    * This directive would be instantiated with `Dependency` declared at the same element, in this case
    * `dependency="3"`.
-   * 
+   *
    * ### Injecting a directive from any ancestor elements
-   * 
+   *
    * Directives can inject other directives declared on any ancestor element (in the current Shadow
    * DOM), i.e. on the current element, the
    * parent element, or its parents.
@@ -304,23 +304,23 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * `@Host` checks the current element, the parent, as well as its parents recursively. If
    * `dependency="2"` didn't
    * exist on the direct parent, this injection would
    * have returned
    * `dependency="1"`.
-   * 
-   * 
+   *
+   *
    * ### Injecting a live collection of direct child directives
-   * 
-   * 
+   *
+   *
    * A directive can also query for other child directives. Since parent directives are instantiated
    * before child directives, a directive can't simply inject the list of child directives. Instead,
    * the directive injects a {@link QueryList}, which updates its contents as children are added,
    * removed, or moved by a directive that uses a {@link ViewContainerRef} such as a `ng-for`, an
    * `ng-if`, or an `ng-switch`.
-   * 
+   *
    * ```
    * @Directive({ selector: '[my-directive]' })
    * class MyDirective {
@@ -328,15 +328,15 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * This directive would be instantiated with a {@link QueryList} which contains `Dependency` 4 and
    * 6. Here, `Dependency` 5 would not be included, because it is not a direct child.
-   * 
+   *
    * ### Injecting a live collection of descendant directives
-   * 
+   *
    * By passing the descendant flag to `@Query` above, we can include the children of the child
    * elements.
-   * 
+   *
    * ```
    * @Directive({ selector: '[my-directive]' })
    * class MyDirective {
@@ -344,18 +344,18 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * This directive would be instantiated with a Query which would contain `Dependency` 4, 5 and 6.
-   * 
+   *
    * ### Optional injection
-   * 
+   *
    * The normal behavior of directives is to return an error when a specified dependency cannot be
    * resolved. If you
    * would like to inject `null` on unresolved dependency instead, you can annotate that dependency
    * with `@Optional()`.
    * This explicitly permits the author of a template to treat some of the surrounding directives as
    * optional.
-   * 
+   *
    * ```
    * @Directive({ selector: '[my-directive]' })
    * class MyDirective {
@@ -363,15 +363,15 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * This directive would be instantiated with a `Dependency` directive found on the current element.
    * If none can be
    * found, the injector supplies `null` instead of throwing an error.
-   * 
+   *
    * ## Example
-   * 
+   *
    * Here we use a decorator directive to simply define basic tool-tip behavior.
-   * 
+   *
    * ```
    * @Directive({
    *   selector: '[tooltip]',
@@ -387,16 +387,16 @@ declare module ng {
    *   text:string;
    *   overlay:Overlay; // NOT YET IMPLEMENTED
    *   overlayManager:OverlayManager; // NOT YET IMPLEMENTED
-   * 
+   *
    *   constructor(overlayManager:OverlayManager) {
    *     this.overlay = overlay;
    *   }
-   * 
+   *
    *   onMouseEnter() {
    *     // exact signature to be determined
    *     this.overlay = this.overlayManager.open(text, ...);
    *   }
-   * 
+   *
    *   onMouseLeave() {
    *     this.overlay.close();
    *     this.overlay = null;
@@ -406,39 +406,39 @@ declare module ng {
    * In our HTML template, we can then add this behavior to a `<div>` or any other element with the
    * `tooltip` selector,
    * like so:
-   * 
+   *
    * ```
    * <div tooltip="some text here"></div>
    * ```
-   * 
+   *
    * Directives can also control the instantiation, destruction, and positioning of inline template
    * elements:
-   * 
+   *
    * A directive uses a {@link ViewContainerRef} to instantiate, insert, move, and destroy views at
    * runtime.
    * The {@link ViewContainerRef} is created as a result of `<template>` element, and represents a
    * location in the current view
    * where these actions are performed.
-   * 
+   *
    * Views are always created as children of the current {@link ViewMetadata}, and as siblings of the
    * `<template>` element. Thus a
    * directive in a child view cannot inject the directive that created it.
-   * 
+   *
    * Since directives that create views via ViewContainers are common in Angular, and using the full
    * `<template>` element syntax is wordy, Angular
    * also supports a shorthand notation: `<li *foo="bar">` and `<li template="foo: bar">` are
    * equivalent.
-   * 
+   *
    * Thus,
-   * 
+   *
    * ```
    * <ul>
    *   <li *foo="bar" title="text"></li>
    * </ul>
    * ```
-   * 
+   *
    * Expands in use to:
-   * 
+   *
    * ```
    * <ul>
    *   <template [foo]="bar">
@@ -446,18 +446,18 @@ declare module ng {
    *   </template>
    * </ul>
    * ```
-   * 
+   *
    * Notice that although the shorthand places `*foo="bar"` within the `<li>` element, the binding for
    * the directive
    * controller is correctly instantiated on the `<template>` element rather than the `<li>` element.
-   * 
-   * 
+   *
+   *
    * ## Example
-   * 
+   *
    * Let's suppose we want to implement the `unless` behavior, to conditionally include a template.
-   * 
+   *
    * Here is a simple directive that triggers on an `unless` selector:
-   * 
+   *
    * ```
    * @Directive({
    *   selector: '[unless]',
@@ -467,13 +467,13 @@ declare module ng {
    *   viewContainer: ViewContainerRef;
    *   templateRef: TemplateRef;
    *   prevCondition: boolean;
-   * 
+   *
    *   constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef) {
    *     this.viewContainer = viewContainer;
    *     this.templateRef = templateRef;
    *     this.prevCondition = null;
    *   }
-   * 
+   *
    *   set unless(newCondition) {
    *     if (newCondition && (isBlank(this.prevCondition) || !this.prevCondition)) {
    *       this.prevCondition = true;
@@ -485,17 +485,17 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * We can then use this `unless` selector in a template:
    * ```
    * <ul>
    *   <li *unless="expr"></li>
    * </ul>
    * ```
-   * 
+   *
    * Once the directive instantiates the child view, the shorthand notation for the template expands
    * and the result is:
-   * 
+   *
    * ```
    * <ul>
    *   <template [unless]="exp">
@@ -504,66 +504,66 @@ declare module ng {
    *   <li></li>
    * </ul>
    * ```
-   * 
+   *
    * Note also that although the `<li></li>` template still exists inside the `<template></template>`,
    * the instantiated
    * view occurs on the second `<li></li>` which is a sibling to the `<template>` element.
    */
   class DirectiveMetadata extends InjectableMetadata {
-    
+
 
     /**
      * The CSS selector that triggers the instantiation of a directive.
-     * 
+     *
      * Angular only allows directives to trigger on CSS selectors that do not cross element
      * boundaries.
-     * 
+     *
      * `selector` may be declared as one of the following:
-     * 
+     *
      * - `element-name`: select by element name.
      * - `.class`: select by class name.
      * - `[attribute]`: select by attribute name.
      * - `[attribute=value]`: select by attribute name and value.
      * - `:not(sub_selector)`: select only if the element does not match the `sub_selector`.
      * - `selector1, selector2`: select if either `selector1` or `selector2` matches.
-     * 
-     * 
+     *
+     *
      * ## Example
-     * 
+     *
      * Suppose we have a directive with an `input[type=text]` selector.
-     * 
+     *
      * And the following HTML:
-     * 
+     *
      * ```html
      * <form>
      *   <input type="text">
      *   <input type="radio">
      * <form>
      * ```
-     * 
+     *
      * The directive would only be instantiated on the `<input type="text">` element.
      */
      selector: string;
-    
+
 
     /**
      * Enumerates the set of properties that accept data binding for a directive.
-     * 
+     *
      * The `properties` property defines a set of `directiveProperty` to `bindingProperty`
      * configuration:
-     * 
+     *
      * - `directiveProperty` specifies the component property where the value is written.
      * - `bindingProperty` specifies the DOM property where the value is read from.
-     * 
+     *
      * You can include a {@link PipeMetadata} when specifying a `bindingProperty` to allow for data
      * transformation and structural change detection of the value. These pipes will be evaluated in
      * the context of this component.
-     * 
+     *
      * ## Syntax
-     * 
+     *
      * There is no need to specify both `directiveProperty` and `bindingProperty` when they both have
      * the same value.
-     * 
+     *
      * ```
      * @Directive({
      *   properties: [
@@ -574,13 +574,13 @@ declare module ng {
      *   ]
      * }
      * ```
-     * 
-     * 
+     *
+     *
      * ## Basic Property Binding
-     * 
+     *
      * We can easily build a simple `Tooltip` directive that exposes a `tooltip` property, which can
      * be used in templates with standard Angular syntax. For example:
-     * 
+     *
      * ```
      * @Directive({
      *   selector: '[tooltip]',
@@ -594,65 +594,65 @@ declare module ng {
      *   }
      * }
      * ```
-     * 
+     *
      * We can then bind to the `tooltip' property as either an expression (`someExpression`) or as a
      * string literal, as shown in the HTML template below:
-     * 
+     *
      * ```html
      * <div [tooltip]="someExpression">...</div>
      * <div tooltip="Some Text">...</div>
      * ```
-     * 
+     *
      * Whenever the `someExpression` expression changes, the `properties` declaration instructs
      * Angular to update the `Tooltip`'s `text` property.
-     * 
+     *
      * ### Bindings With Pipes
-     * 
+     *
      * You can use pipes in bindings, as follows:
-     * 
+     *
      * ```html
      * <div [class-set]="someExpression | somePipe">
      * ```
      */
      properties: List<string>;
-    
+
 
     /**
      * 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');
      *   }
@@ -660,31 +660,31 @@ declare module ng {
      * ```
      */
      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: {
@@ -694,13 +694,13 @@ declare module ng {
      *   }
      * }
      * ```
-     * 
+     *
      * ## Basic Event Binding:
-     * 
+     *
      * Suppose you want to write a directive that reacts to `change` events in the DOM and on
      * `resize` events in window.
      * You would define the event binding as follows:
-     * 
+     *
      * ```
      * @Directive({
      *   selector: 'input',
@@ -718,13 +718,13 @@ declare module ng {
      *   }
      * }
      * ```
-     * 
+     *
      * ## Properties
-     * 
+     *
      * Specifies which DOM properties a directives updates.
-     * 
+     *
      * ## Syntax
-     * 
+     *
      * ```
      * @Directive({
      *   selector: 'input',
@@ -736,17 +736,17 @@ declare module ng {
      *   value:string;
      * }
      * ```
-     * 
+     *
      * In this example the prop property of the host element is updated with the expression value
      * every time it changes.
-     * 
+     *
      * ## Attributes
-     * 
+     *
      * Specifies static attributes that should be propagated to a host element. Attributes specified
      * in `hostAttributes` are propagated only if a given attribute is not present on a host element.
-     * 
+     *
      * ## Syntax
-     * 
+     *
      * ```
      * @Directive({
      *   selector: '[my-button]',
@@ -757,16 +757,16 @@ declare module ng {
      * class MyButton {
      * }
      * ```
-     * 
+     *
      * In this example using `my-button` directive (ex.: `<div my-button></div>`) on a host element
      * (here: `<div>` ) will ensure that this element will get the "button" role.
-     * 
+     *
      * ## Actions
-     * 
+     *
      * Specifies which DOM methods a directive can invoke.
-     * 
+     *
      * ## Syntax
-     * 
+     *
      * ```
      * @Directive({
      *   selector: 'input',
@@ -778,47 +778,47 @@ declare module ng {
      *   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: [
@@ -827,7 +827,7 @@ declare module ng {
      * })
      * class HelloWorld {
      *   greeter:Greeter;
-     * 
+     *
      *   constructor(greeter:Greeter) {
      *     this.greeter = greeter;
      *   }
@@ -835,13 +835,13 @@ declare module ng {
      * ```
      */
      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',
@@ -849,7 +849,7 @@ declare module ng {
      * })
      * class ChildDir {
      * }
-     * 
+     *
      * @Component({
      *   selector: 'main',
      * })
@@ -859,18 +859,18 @@ declare module ng {
      * })
      * class MainComponent {
      * }
-     * 
+     *
      * ```
      */
      exportAs: string;
   }
-  
+
 
   /**
    * Declare reusable pipe function.
-   * 
+   *
    * ## Example
-   * 
+   *
    * ```
    * @Pipe({
    *   name: 'lowercase'
@@ -881,10 +881,10 @@ declare module ng {
    * ```
    */
   class PipeMetadata extends InjectableMetadata {
-    
+
      name: string;
   }
-  
+
 
   /**
    * Lifecycle events are guaranteed to be called in the following order:
@@ -894,13 +894,13 @@ declare module ng {
    * - `onAllChangesDone`
    */
   enum LifecycleEvent {
-    
+
 
     /**
      * Notify a directive whenever a {@link ViewMetadata} that contains it is destroyed.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```
      * @Directive({
      *   ...,
@@ -914,18 +914,18 @@ declare module ng {
      * ```
      */
      onDestroy,
-    
+
 
     /**
      * Notify a directive when any of its bindings have changed.
-     * 
+     *
      * This method is called right after the directive's bindings have been checked,
      * and before any of its children's bindings have been checked.
-     * 
+     *
      * It is invoked only if at least one of the directive's bindings has changed.
-     * 
+     *
      * ## Example:
-     * 
+     *
      * ```
      * @Directive({
      *   selector: '[class-set]',
@@ -951,18 +951,18 @@ declare module ng {
      *  ```
      */
      onChange,
-    
+
 
     /**
      * Notify a directive when it has been checked.
-     * 
+     *
      * This method is called right after the directive's bindings have been checked,
      * and before any of its children's bindings have been checked.
-     * 
+     *
      * It is invoked every time even when none of the directive's bindings has changed.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```
      * @Directive({
      *   selector: '[class-set]',
@@ -975,18 +975,18 @@ declare module ng {
      *  ```
      */
      onCheck,
-    
+
 
     /**
      * Notify a directive when it has been checked the first itme.
-     * 
+     *
      * This method is called right after the directive's bindings have been checked,
      * and before any of its children's bindings have been checked.
-     * 
+     *
      * It is invoked only once.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```
      * @Directive({
      *   selector: '[class-set]',
@@ -999,45 +999,45 @@ declare module ng {
      *  ```
      */
      onInit,
-    
+
 
     /**
      * Notify a directive when the bindings of all its children have been checked (whether they have
      * changed or not).
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```
      * @Directive({
      *   selector: '[class-set]',
      *   lifecycle: [LifecycleEvent.onAllChangesDone]
      * })
      * class ClassSet {
-     * 
+     *
      *   onAllChangesDone() {
      *   }
-     * 
+     *
      * }
      *  ```
      */
      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 ComponentMetadata}.
-   * 
+   *
    * ## Example
-   * 
+   *
    * ```
    * @Component({
    *   selector: 'greet'
@@ -1048,7 +1048,7 @@ declare module ng {
    * })
    * class Greet {
    *   name: string;
-   * 
+   *
    *   constructor() {
    *     this.name = 'World';
    *   }
@@ -1056,43 +1056,43 @@ declare module ng {
    * ```
    */
   class ViewMetadata {
-    
+
 
     /**
      * Specifies a template URL for an angular component.
-     * 
+     *
      * NOTE: either `templateUrl` or `template` should be used, but not both.
      */
      templateUrl: string;
-    
+
 
     /**
      * Specifies an inline template for an angular component.
-     * 
+     *
      * NOTE: either `templateUrl` or `template` should be used, but not both.
      */
      template: string;
-    
+
 
     /**
      * Specifies stylesheet URLs for an angular component.
      */
      styleUrls: List<string>;
-    
+
 
     /**
      * 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'
@@ -1109,9 +1109,9 @@ declare module ng {
      * ```
      */
      directives: List<Type | any | List<any>>;
-    
+
      pipes: List<Type | any | List<any>>;
-    
+
 
     /**
      * Specify how the template and the styles should be encapsulated.
@@ -1121,70 +1121,70 @@ declare module ng {
      */
      encapsulation: ViewEncapsulation;
   }
-  
+
 
   /**
    * How the template and styles of a view should be encapsulated.
    */
   enum ViewEncapsulation {
-    
+
 
     /**
      * Emulate scoping of styles by preprocessing the style rules
      * and adding additional attributes to elements. This is the default.
      */
      EMULATED,
-    
+
 
     /**
      * Uses the native mechanism of the renderer. For the DOM this means creating a ShadowRoot.
      */
      NATIVE,
-    
+
 
     /**
      * Don't scope the template nor the styles.
      */
      NONE
   }
-  
+
 
   /**
    * Specifies that a {@link QueryList} should be injected.
-   * 
+   *
    * See {@link QueryList} for usage and example.
    */
   class QueryMetadata extends DependencyMetadata {
-    
+
      descendants: boolean;
-    
+
      isViewQuery: any;
-    
+
      selector: any;
-    
+
      isVarBindingQuery: boolean;
-    
+
      varBindings: 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'
@@ -1197,29 +1197,29 @@ declare module ng {
    * ```
    */
   class AttributeMetadata extends DependencyMetadata {
-    
+
      attributeName: string;
-    
+
      token: any;
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * {@link AttributeMetadata} factory function.
    */
   var Attribute : AttributeFactory ;
-  
+
 
   /**
    * {@link AttributeMetadata} factory for creating annotations, decorators or DSL.
-   * 
+   *
    * ## Example as TypeScript Decorator
-   * 
+   *
    * ```
    * import {Attribute, Component, View} from "angular2/angular2";
-   * 
+   *
    * @Component({...})
    * @View({...})
    * class MyComponent {
@@ -1228,9 +1228,9 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * ## Example as ES5 DSL
-   * 
+   *
    * ```
    * var MyComponent = ng
    *   .Component({...})
@@ -1241,14 +1241,14 @@ declare module ng {
    *     }]
    *   })
    * ```
-   * 
+   *
    * ## Example as ES5 annotation
-   * 
+   *
    * ```
    * var MyComponent = function(title) {
    *   ...
    * };
-   * 
+   *
    * MyComponent.annotations = [
    *   new ng.Component({...}),
    *   new ng.View({...})
@@ -1259,28 +1259,28 @@ declare module ng {
    * ```
    */
   interface AttributeFactory {
-    
+
      new(name: string): AttributeMetadata;
-  
-    
+
+
      (name: string): TypeDecorator;
-  
+
   }
-  
+
 
   /**
    * {@link ComponentMetadata} factory function.
    */
   var Component : ComponentFactory ;
-  
+
 
   /**
    * Interface for the {@link ComponentMetadata} decorator function.
-   * 
+   *
    * See {@link ComponentFactory}.
    */
   interface ComponentDecorator extends TypeDecorator {
-    
+
 
     /**
      * Chain {@link ViewMetadata} annotation.
@@ -1295,16 +1295,16 @@ declare module ng {
     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 {
@@ -1313,9 +1313,9 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * ## Example as ES5 DSL
-   * 
+   *
    * ```
    * var MyComponent = ng
    *   .Component({...})
@@ -1326,14 +1326,14 @@ declare module ng {
    *     }
    *   })
    * ```
-   * 
+   *
    * ## Example as ES5 annotation
-   * 
+   *
    * ```
    * var MyComponent = function() {
    *   ...
    * };
-   * 
+   *
    * MyComponent.annotations = [
    *   new ng.Component({...}),
    *   new ng.View({...})
@@ -1341,7 +1341,7 @@ declare module ng {
    * ```
    */
   interface ComponentFactory {
-    
+
      new(obj: {
     selector?: string,
     properties?: List<string>,
@@ -1354,8 +1354,8 @@ declare module ng {
     viewBindings?: List<any>,
     changeDetection?: string,
   }): ComponentMetadata;
-  
-    
+
+
      (obj: {
     selector?: string,
     properties?: List<string>,
@@ -1367,34 +1367,36 @@ declare module ng {
     compileChildren?: boolean,
     viewBindings?: List<any>,
     changeDetection?: string,
+    // NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
+    injectables?: any[]
   }): ComponentDecorator;
-  
+
   }
-  
+
 
   /**
    * {@link DirectiveMetadata} factory function.
    */
   var Directive : DirectiveFactory ;
-  
+
 
   /**
    * Interface for the {@link DirectiveMetadata} decorator function.
-   * 
+   *
    * See {@link DirectiveFactory}.
    */
   interface DirectiveDecorator extends TypeDecorator {
   }
-  
+
 
   /**
    * {@link DirectiveMetadata} factory for creating annotations, decorators or DSL.
-   * 
+   *
    * ## Example as TypeScript Decorator
-   * 
+   *
    * ```
    * import {Directive} from "angular2/angular2";
-   * 
+   *
    * @Directive({...})
    * class MyDirective {
    *   constructor() {
@@ -1402,9 +1404,9 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * ## Example as ES5 DSL
-   * 
+   *
    * ```
    * var MyDirective = ng
    *   .Directive({...})
@@ -1414,50 +1416,52 @@ declare module ng {
    *     }
    *   })
    * ```
-   * 
+   *
    * ## Example as ES5 annotation
-   * 
+   *
    * ```
    * var MyDirective = function() {
    *   ...
    * };
-   * 
+   *
    * MyDirective.annotations = [
    *   new ng.Directive({...})
    * ]
    * ```
    */
   interface DirectiveFactory {
-    
+
      new(obj: {
     selector?: string, properties?: List<string>, events?: List<string>,
         host?: StringMap<string, string>, lifecycle?: List<LifecycleEvent>, bindings?: List<any>,
         exportAs?: string, compileChildren?: boolean;
   }): DirectiveMetadata;
-  
-    
+
+
      (obj: {
     selector?: string, properties?: List<string>, events?: List<string>,
         host?: StringMap<string, string>, lifecycle?: List<LifecycleEvent>, bindings?: List<any>,
         exportAs?: string, compileChildren?: boolean;
+        // NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590 
+        hostListeners?: any;
   }): DirectiveDecorator;
-  
+
   }
-  
+
 
   /**
    * {@link ViewMetadata} factory function.
    */
   var View : ViewFactory ;
-  
+
 
   /**
    * Interface for the {@link ViewMetadata} decorator function.
-   * 
+   *
    * See {@link ViewFactory}.
    */
   interface ViewDecorator extends TypeDecorator {
-    
+
 
     /**
      * Chain {@link ViewMetadata} annotation.
@@ -1472,16 +1476,16 @@ declare module ng {
     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 {
@@ -1490,9 +1494,9 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * ## Example as ES5 DSL
-   * 
+   *
    * ```
    * var MyComponent = ng
    *   .Component({...})
@@ -1503,14 +1507,14 @@ declare module ng {
    *     }
    *   })
    * ```
-   * 
+   *
    * ## Example as ES5 annotation
-   * 
+   *
    * ```
    * var MyComponent = function() {
    *   ...
    * };
-   * 
+   *
    * MyComponent.annotations = [
    *   new ng.Component({...}),
    *   new ng.View({...})
@@ -1518,7 +1522,7 @@ declare module ng {
    * ```
    */
   interface ViewFactory {
-    
+
      new(obj: {
     templateUrl?: string,
     template?: string,
@@ -1527,8 +1531,8 @@ declare module ng {
     styles?: List<string>,
     styleUrls?: List<string>,
   }): ViewMetadata;
-  
-    
+
+
      (obj: {
     templateUrl?: string,
     template?: string,
@@ -1537,24 +1541,24 @@ declare module ng {
     styles?: List<string>,
     styleUrls?: List<string>,
   }): ViewDecorator;
-  
+
   }
-  
+
 
   /**
    * {@link QueryMetadata} factory function.
    */
   var Query : QueryFactory ;
-  
+
 
   /**
    * {@link QueryMetadata} factory for creating annotations, decorators or DSL.
-   * 
+   *
    * ## Example as TypeScript Decorator
-   * 
+   *
    * ```
    * import {Query, QueryList, Component, View} from "angular2/angular2";
-   * 
+   *
    * @Component({...})
    * @View({...})
    * class MyComponent {
@@ -1563,9 +1567,9 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * ## Example as ES5 DSL
-   * 
+   *
    * ```
    * var MyComponent = ng
    *   .Component({...})
@@ -1576,14 +1580,14 @@ declare module ng {
    *     }]
    *   })
    * ```
-   * 
+   *
    * ## Example as ES5 annotation
-   * 
+   *
    * ```
    * var MyComponent = function(queryList) {
    *   ...
    * };
-   * 
+   *
    * MyComponent.annotations = [
    *   new ng.Component({...}),
    *   new ng.View({...})
@@ -1594,56 +1598,56 @@ declare module ng {
    * ```
    */
   interface QueryFactory {
-    
+
      new(selector: Type | string, {descendants}?: {descendants?: boolean}): QueryMetadata;
-  
-    
+
+
      (selector: Type | string, {descendants}?: {descendants?: boolean}): ParameterDecorator;
-  
+
   }
-  
+
 
   /**
    * {@link di/ViewQueryMetadata} factory function.
    */
   var ViewQuery : QueryFactory ;
-  
+
 
   /**
    * {@link PipeMetadata} factory function.
    */
   var Pipe : PipeFactory ;
-  
+
 
   /**
    * {@link PipeMetadata} factory for creating decorators.
-   * 
+   *
    * ## Example as TypeScript Decorator
-   * 
+   *
    * ```
    * import {Pipe} from "angular2/angular2";
-   * 
+   *
    * @Pipe({...})
    * class MyPipe {
    *   constructor() {
    *     ...
    *   }
-   * 
+   *
    *   transform(v, args) {}
    * }
    * ```
    */
   interface PipeFactory {
-    
+
      new(obj: {
     name: string,
   }): any;
-  
-    
+
+
      (obj: {name: string}): any;
-  
+
   }
-  
+
 
   /**
    * Defines lifecycle method
@@ -1651,96 +1655,96 @@ declare module ng {
    * 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) {
@@ -1748,9 +1752,9 @@ declare module ng {
    *   }];
    * });
    * ```
-   * 
+   *
    * is equivalent to ES6:
-   * 
+   *
    * ```
    * class MyService {
    *   constructor(name: string, @Query() queryList: QueryList) {
@@ -1758,16 +1762,16 @@ declare module ng {
    *   }
    * }
    * ```
-   * 
+   *
    * ## Example with inheritance
-   * 
+   *
    * ```
    * var Shape = ng.Class({
    *   constructor: (color) {
    *     this.color = color;
    *   }
    * });
-   * 
+   *
    * var Square = ng.Class({
    *   extends: Shape,
    *   constructor: function(color, size) {
@@ -1778,49 +1782,49 @@ declare module ng {
    * ```
    */
   function Class(clsDef: ClassDefinition) : Type ;
-  
+
 
   /**
    * Declares the interface to be used with {@link Class}.
    */
   interface ClassDefinition {
-    
+
 
     /**
      * Optional argument for specifying the superclass.
      */
      extends?: Type;
-    
+
 
     /**
      * Required constructor function for a class.
-     * 
+     *
      * The function may be optionally wrapped in an `Array`, in which case additional parameter
      * annotations may be specified.
      * The number of arguments and the number of parameter annotations must match.
-     * 
+     *
      * See {@link Class} for example of usage.
      */
      constructor: (Function | Array<any>);
   }
-  
+
 
   /**
    * An interface implemented by all Angular type decorators, which allows them to be used as ES7
    * decorators as well as
    * Angular DSL syntax.
-   * 
+   *
    * DSL syntax:
-   * 
+   *
    * ```
    * var MyClass = ng
    *   .Component({...})
    *   .View({...})
    *   .Class({...});
    * ```
-   * 
+   *
    * ES7 syntax:
-   * 
+   *
    * ```
    * @ng.Component({...})
    * @ng.View({...})
@@ -1828,187 +1832,187 @@ declare module ng {
    * ```
    */
   interface TypeDecorator {
-    
+
 
     /**
      * Invoke as ES7 decorator.
      */
      <T extends Type>(type: T): T;
-  
-    
+
+
 
     /**
      * Storage for the accumulated annotations so far used by the DSL syntax.
-     * 
+     *
      * Used by {@link Class} to annotate the generated class.
      */
      annotations: Array<any>;
-    
+
 
     /**
      * Generate a class from the definition and annotate it with {@link TypeDecorator#annotations}.
      */
      Class(obj: ClassDefinition): Type;
   }
-  
+
 
   /**
    * CHECK_ONCE means that after calling detectChanges the mode of the change detector
    * will become CHECKED.
    */
   const CHECK_ONCE : string ;
-  
+
 
   /**
    * 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;
-    
+
      ref: ChangeDetectorRef;
-    
+
      addChild(cd: ChangeDetector): void;
-    
+
      addShadowDomChild(cd: ChangeDetector): void;
-    
+
      removeChild(cd: ChangeDetector): void;
-    
+
      removeShadowDomChild(cd: ChangeDetector): void;
-    
+
      remove(): void;
-    
+
      hydrate(context: any, locals: Locals, directives: any, pipes: any): void;
-    
+
      dehydrate(): void;
-    
+
      markPathToRootAsCheckOnce(): void;
-    
+
      handleEvent(eventName: string, elIndex: number, locals: Locals): void;
-    
+
      detectChanges(): void;
-    
+
      checkNoChanges(): void;
   }
-  
+
   class Locals {
-    
+
      parent: Locals;
-    
+
      current: Map<any, any>;
-    
+
      contains(name: string): boolean;
-    
+
      get(name: string): any;
-    
+
      set(name: string, value: any): void;
-    
+
      clearValues(): void;
   }
-  
+
 
   /**
    * Controls change detection.
-   * 
+   *
    * {@link ChangeDetectorRef} allows requesting checks for detectors that rely on observables. It
    * also allows detaching and attaching change detector subtrees.
    */
   interface ChangeDetectorRef {
-    
+
 
     /**
      * Request to check all ON_PUSH ancestors.
      */
      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 PipeMetadata} transformation has changed even though the
    * reference
    * has not changed.
-   * 
+   *
    * The wrapped value will be unwrapped by change detection, and the unwrapped value will be stored.
-   * 
+   *
    * Example:
-   * 
+   *
    * ```
    * if (this._latestValue === this._latestReturnedValue) {
    *    return this._latestReturnedValue;
@@ -2019,18 +2023,18 @@ declare module ng {
    * ```
    */
   class WrappedValue {
-    
+
      static wrap(value: any): WrappedValue;
-    
+
      wrapped: any;
   }
-  
+
 
   /**
    * An interface which all pipes must implement.
-   * 
+   *
    * #Example
-   * 
+   *
    * ```
    * class DoublePipe implements PipeTransform {
    *  transform(value, args = []) {
@@ -2040,24 +2044,24 @@ declare module ng {
    * ```
    */
   interface PipeTransform {
-    
+
      transform(value: any, args: List<any>): any;
   }
-  
+
 
   /**
    * An interface that stateful pipes should implement.
-   * 
+   *
    * #Example
-   * 
+   *
    * ```
    * class StatefulPipe implements PipeTransform, PipeOnDestroy {
    *  connection;
-   * 
+   *
    *  onDestroy() {
    *    this.connection.release();
    *  }
-   * 
+   *
    *  transform(value, args = []) {
    *    this.connection = createConnection();
    *    // ...
@@ -2067,30 +2071,30 @@ declare module ng {
    * ```
    */
   interface PipeOnDestroy {
-    
+
      onDestroy(): void;
   }
-  
+
 
   /**
    * A repository of different iterable diffing strategies used by NgFor, NgClass, and others.
    */
   class IterableDiffers {
-    
+
      static create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers;
-    
+
 
     /**
      * Takes an array of {@link IterableDifferFactory} and returns a binding used to extend the
      * inherited {@link IterableDiffers} instance with the provided factories and return a new
      * {@link IterableDiffers} instance.
-     * 
+     *
      * The following example shows how to extend an existing list of factories,
      * which will only be applied to the injector for this component and its children.
      * This step is all that's required to make a new {@link IterableDiffer} available.
-     * 
+     *
      * # Example
-     * 
+     *
      * ```
      * @Component({
      *   viewBindings: [
@@ -2100,50 +2104,50 @@ declare module ng {
      * ```
      */
      static extend(factories: IterableDifferFactory[]): Binding;
-    
+
      factories: IterableDifferFactory[];
-    
+
      find(iterable: Object): IterableDifferFactory;
   }
-  
+
   interface IterableDiffer {
-    
+
      diff(object: Object): any;
-    
+
      onDestroy(): void;
   }
-  
+
 
   /**
    * Provides a factory for {@link IterableDiffer}.
    */
   interface IterableDifferFactory {
-    
+
      supports(objects: Object): boolean;
-    
+
      create(cdRef: ChangeDetectorRef): IterableDiffer;
   }
-  
+
 
   /**
    * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.
    */
   class KeyValueDiffers {
-    
+
      static create(factories: KeyValueDifferFactory[], parent?: KeyValueDiffers): KeyValueDiffers;
-    
+
 
     /**
      * Takes an array of {@link KeyValueDifferFactory} and returns a binding used to extend the
      * inherited {@link KeyValueDiffers} instance with the provided factories and return a new
      * {@link KeyValueDiffers} instance.
-     * 
+     *
      * The following example shows how to extend an existing list of factories,
      * which will only be applied to the injector for this component and its children.
      * This step is all that's required to make a new {@link KeyValueDiffer} available.
-     * 
+     *
      * # Example
-     * 
+     *
      * ```
      * @Component({
      *   viewBindings: [
@@ -2153,61 +2157,61 @@ declare module ng {
      * ```
      */
      static extend(factories: KeyValueDifferFactory[]): Binding;
-    
+
      factories: KeyValueDifferFactory[];
-    
+
      find(kv: Object): KeyValueDifferFactory;
   }
-  
+
   interface KeyValueDiffer {
-    
+
      diff(object: Object): void;
-    
+
      onDestroy(): void;
   }
-  
+
 
   /**
    * Provides a factory for {@link KeyValueDiffer}.
    */
   interface KeyValueDifferFactory {
-    
+
      supports(objects: Object): boolean;
-    
+
      create(cdRef: ChangeDetectorRef): KeyValueDiffer;
   }
-  
+
 
   /**
    * An opaque token representing the application root type in the {@link Injector}.
-   * 
+   *
    * ```
    * @Component(...)
    * @View(...)
    * class MyApp {
    *   ...
    * }
-   * 
+   *
    * bootstrap(MyApp).then((appRef:ApplicationRef) {
    *   expect(appRef.injector.get(appComponentTypeToken)).toEqual(MyApp);
    * });
-   * 
+   *
    * ```
    */
   const APP_COMPONENT : OpaqueToken ;
-  
+
 
   /**
    * Bootstrapping for Angular applications.
-   * 
+   *
    * You instantiate an Angular application by explicitly specifying a component to use as the root
    * component for your
    * application via the `bootstrap()` method.
-   * 
+   *
    * ## Simple Example
-   * 
+   *
    * Assuming this `index.html`:
-   * 
+   *
    * ```html
    * <html>
    *   <!-- load Angular script tags here. -->
@@ -2216,7 +2220,7 @@ declare module ng {
    *   </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
@@ -2226,9 +2230,9 @@ declare module ng {
    * 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'
@@ -2238,21 +2242,21 @@ declare module ng {
    * })
    * 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.
@@ -2266,15 +2270,15 @@ declare module ng {
    *  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
@@ -2282,10 +2286,10 @@ declare module ng {
    * `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
@@ -2293,10 +2297,10 @@ declare module ng {
    * 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
@@ -2305,12 +2309,12 @@ declare module ng {
    * 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`
@@ -2320,87 +2324,87 @@ declare module ng {
    * to override default injection behavior.
    * - `errorReporter`: `function(exception:any, stackTrace:string)` a default error reporter for
    * unhandled exceptions.
-   * 
+   *
    * Returns a `Promise` of {@link ApplicationRef}.
    */
   function bootstrap(appComponentType: /*Type*/ any, componentInjectableBindings?: List<Type | Binding | List<any>>) : Promise<ApplicationRef> ;
-  
+
 
   /**
    * Runtime representation of a type.
-   * 
+   *
    * In JavaScript a Type is a constructor function.
    */
   interface Type extends Function {
-    
+
      new(args: any): any;
-  
+
   }
-  
+
 
   /**
    * Represents a Angular's representation of an Application.
-   * 
+   *
    * `ApplicationRef` represents a running application instance. Use it to retrieve the host
    * component, injector,
    * or dispose of an application.
    */
   interface ApplicationRef {
-    
+
 
     /**
      * Returns the current {@link ComponentMetadata} type.
      */
      hostComponentType: Type;
-    
+
 
     /**
      * Returns the current {@link ComponentMetadata} instance.
      */
      hostComponent: any;
-    
+
 
     /**
      * Dispose (un-load) the application.
      */
      dispose(): void;
-    
+
 
     /**
      * Returns the root application {@link Injector}.
      */
      injector: Injector;
   }
-  
+
 
   /**
    * Specifies app root url for the application.
-   * 
+   *
    * Used by the {@link Compiler} when resolving HTML and CSS template URLs.
-   * 
+   *
    * This interface can be overridden by the application developer to create custom behavior.
-   * 
+   *
    * See {@link Compiler}
    */
   class AppRootUrl {
-    
+
 
     /**
      * Returns the base URL of the currently running application.
      */
      value: any;
   }
-  
+
 
   /**
    * Used by the {@link Compiler} when resolving HTML and CSS template URLs.
-   * 
+   *
    * This interface can be overridden by the application developer to create custom behavior.
-   * 
+   *
    * See {@link Compiler}
    */
   class UrlResolver {
-    
+
 
     /**
      * Resolves the `url` given the `baseUrl`:
@@ -2409,24 +2413,24 @@ declare module ng {
      * `baseUrl` and `url`,
      * - if `url` is absolute (it has a scheme: 'http://', 'https://' or start with '/'), the `url` is
      * returned as is (ignoring the `baseUrl`)
-     * 
+     *
      * @param {string} baseUrl
      * @param {string} url
      * @returns {string} the resolved URL
      */
      resolve(baseUrl: string, url: string): string;
   }
-  
+
 
   /**
    * Resolve a `Type` from a {@link ComponentMetadata} into a URL.
-   * 
+   *
    * This interface can be overridden by the application developer to create custom behavior.
-   * 
+   *
    * See {@link Compiler}
    */
   class ComponentUrlMapper {
-    
+
 
     /**
      * Returns the base URL to the component source file.
@@ -2436,39 +2440,39 @@ declare module ng {
      */
      getUrl(component: Type): string;
   }
-  
+
 
   /**
    * Resolve a `Type` for {@link DirectiveMetadata}.
-   * 
+   *
    * This interface can be overridden by the application developer to create custom behavior.
-   * 
+   *
    * See {@link Compiler}
    */
   class DirectiveResolver {
-    
+
 
     /**
      * Return {@link DirectiveMetadata} for a given `Type`.
      */
      resolve(type: Type): DirectiveMetadata;
   }
-  
+
 
   /**
    * ## URL Resolution
-   * 
+   *
    * ```
    * var appRootUrl: AppRootUrl = ...;
    * var componentUrlMapper: ComponentUrlMapper = ...;
    * var urlResolver: UrlResolver = ...;
-   * 
+   *
    * var componentType: Type = ...;
    * var componentAnnotation: ComponentAnnotation = ...;
    * var viewAnnotation: ViewAnnotation = ...;
-   * 
+   *
    * // Resolving a URL
-   * 
+   *
    * var url = viewAnnotation.templateUrl;
    * var componentUrl = componentUrlMapper.getUrl(componentType);
    * var componentResolvedUrl = urlResolver.resolve(appRootUrl.value, componentUrl);
@@ -2476,10 +2480,10 @@ declare module ng {
    * ```
    */
   interface Compiler {
-    
+
      compileInHost(componentTypeOrBinding: Type | Binding): Promise<ProtoViewRef>;
   }
-  
+
 
   /**
    * Entry point for creating, moving views in the view hierarchy and destroying views.
@@ -2487,58 +2491,58 @@ declare module ng {
    * in AppViewManagerUtils and the Renderer, so unit tests get simpler.
    */
   interface AppViewManager {
-    
+
 
     /**
      * Returns a {@link ViewContainerRef} at the {@link ElementRef} location.
      */
      getViewContainer(location: ElementRef): ViewContainerRef;
-    
+
 
     /**
      * Return the first child element of the host element view.
      */
      getHostElement(hostViewRef: HostViewRef): ElementRef;
-    
+
 
     /**
      * Returns an ElementRef for the element with the given variable name
      * in the current view.
-     * 
+     *
      * - `hostLocation`: {@link ElementRef} of any element in the View which defines the scope of
      *   search.
      * - `variableName`: Name of the variable to locate.
      * - Returns {@link ElementRef} of the found element or null. (Throws if not found.)
      */
      getNamedElementInComponentView(hostLocation: ElementRef, variableName: string): ElementRef;
-    
+
 
     /**
      * Returns the component instance for a given element.
-     * 
+     *
      * The component is the execution context as seen by an expression at that {@link ElementRef}
      * location.
      */
      getComponent(hostLocation: ElementRef): any;
-    
+
 
     /**
      * Load component view into existing element.
-     * 
+     *
      * Use this if a host element is already in the DOM and it is necessary to upgrade
      * the element into Angular component by attaching a view but reusing the existing element.
-     * 
+     *
      * - `hostProtoViewRef`: {@link ProtoViewRef} Proto view to use in creating a view for this
      *   component.
      * - `overrideSelector`: (optional) selector to use in locating the existing element to load
      *   the view into. If not specified use the selector in the component definition of the
      *   `hostProtoView`.
      * - injector: {@link Injector} to use as parent injector for the view.
-     * 
+     *
      * See {@link AppViewManager#destroyRootHostView}.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```
      * @ng.Component({
      *   selector: 'child-component'
@@ -2547,9 +2551,9 @@ declare module ng {
      *   template: 'Child'
      * })
      * class ChildComponent {
-     * 
+     *
      * }
-     * 
+     *
      * @ng.Component({
      *   selector: 'my-app'
      * })
@@ -2560,103 +2564,103 @@ declare module ng {
      * })
      * class MyApp {
      *   viewRef: ng.ViewRef;
-     * 
+     *
      *   constructor(public appViewManager: ng.AppViewManager, compiler: ng.Compiler) {
      *     compiler.compileInHost(ChildComponent).then((protoView: ng.ProtoViewRef) => {
      *       this.viewRef = appViewManager.createRootHostView(protoView, 'some-component', null);
      *     })
      *   }
-     * 
+     *
      *   onDestroy() {
      *     this.appViewManager.destroyRootHostView(this.viewRef);
      *     this.viewRef = null;
      *   }
      * }
-     * 
+     *
      * ng.bootstrap(MyApp);
      * ```
      */
      createRootHostView(hostProtoViewRef: ProtoViewRef, overrideSelector: string, injector: Injector): HostViewRef;
-    
+
 
     /**
      * Remove the View created with {@link AppViewManager#createRootHostView}.
      */
      destroyRootHostView(hostViewRef: HostViewRef): void;
-    
+
 
     /**
      * See {@link AppViewManager#destroyViewInContainer}.
      */
      createEmbeddedViewInContainer(viewContainerLocation: ElementRef, atIndex: number, templateRef: TemplateRef): ViewRef;
-    
+
 
     /**
      * See {@link AppViewManager#destroyViewInContainer}.
      */
      createHostViewInContainer(viewContainerLocation: ElementRef, atIndex: number, protoViewRef: ProtoViewRef, imperativelyCreatedInjector: ResolvedBinding[]): HostViewRef;
-    
+
 
     /**
      * See {@link AppViewManager#createViewInContainer}.
      */
      destroyViewInContainer(viewContainerLocation: ElementRef, atIndex: number): void;
-    
+
 
     /**
      * See {@link AppViewManager#detachViewInContainer}.
      */
      attachViewInContainer(viewContainerLocation: ElementRef, atIndex: number, viewRef: ViewRef): ViewRef;
-    
+
 
     /**
      * See {@link AppViewManager#attachViewInContainer}.
      */
      detachViewInContainer(viewContainerLocation: ElementRef, atIndex: number): ViewRef;
   }
-  
+
 
   /**
    * An iterable and observable live list of components in the DOM.
-   * 
+   *
    * A QueryList contains a live list of child directives in the DOM of a directive.
    * The directives are kept in depth-first pre-order traversal of the DOM.
-   * 
+   *
    * The `QueryList` is iterable, therefore it can be used in both javascript code with `for..of` loop
    * as well as in template with `*ng-for="of"` directive.
-   * 
+   *
    * QueryList is updated as part of the change-detection cycle of a directive. Since change detection
    * happens after construction of a directive, QueryList will always be empty when observed in the
    * constructor.
-   * 
-   * 
+   *
+   *
    * NOTE: In the future this class will implement an `Observable` interface. For now it uses a plain
    * list of observable callbacks.
-   * 
+   *
    * # Example:
-   * 
+   *
    * Assume that `<tabs>` component would like to get a list its children which are `<pane>`
    * components as shown in this example:
-   * 
+   *
    * ```html
    * <tabs>
    *   <pane title="Overview">...</pane>
    *   <pane *ng-for="#o of objects" [title]="o.title">{{o.text}}</pane>
    * </tabs>
    * ```
-   * 
+   *
    * In the above example the list of `<tabs>` elements needs to get a list of `<pane>` elements so
    * that it could render tabs with the correct titles and in the correct order.
-   * 
+   *
    * A possible solution would be for a `<pane>` to inject `<tabs>` component and then register itself
    * with `<tabs>` component's on `hydrate` and deregister on `dehydrate` event. While a reasonable
    * approach, this would only work partialy since `*ng-for` could rearrange the list of `<pane>`
    * components which would not be reported to `<tabs>` component and thus the list of `<pane>`
    * components would be out of sync with respect to the list of `<pane>` elements.
-   * 
+   *
    * A preferred solution is to inject a `QueryList` which is a live list of directives in the
    * component`s light DOM.
-   * 
+   *
    * ```javascript
    * @Component({
    *   selector: 'tabs'
@@ -2671,12 +2675,12 @@ declare module ng {
    * })
    * class Tabs {
    *   panes: QueryList<Pane>
-   * 
+   *
    *   constructor(@Query(Pane) panes:QueryList<Pane>) {
    *     this.panes = panes;
    *   }
    * }
-   * 
+   *
    * @Component({
    *   selector: 'pane',
    *   properties: ['title']
@@ -2688,50 +2692,50 @@ declare module ng {
    * ```
    */
   class QueryList<T> {
-    
+
      reset(newList: List<T>): void;
-    
+
      add(obj: T): void;
-    
+
      fireCallbacks(): void;
-    
+
      onChange(callback: () => void): void;
-    
+
      removeCallback(callback: () => void): void;
-    
+
      toString(): string;
-    
+
      length: number;
-    
+
      first: T;
-    
+
      last: T;
-    
+
      map<U>(fn: (item: T) => U): U[];
   }
-  
+
 
   /**
    * Service for dynamically loading a Component into an arbitrary position in the internal Angular
    * application tree.
    */
   class DynamicComponentLoader {
-    
+
 
     /**
      * Loads a root component that is placed at the first element that matches the component's
      * selector.
-     * 
+     *
      * - `typeOrBinding` `Type` \ {@link Binding} - representing the component to load.
      * - `overrideSelector` (optional) selector to load the component at (or use
      *   `@Component.selector`) The selector can be anywhere (i.e. outside the current component.)
      * - `injector` {@link Injector} - optional injector to use for the component.
-     * 
+     *
      * The loaded component receives injection normally as a hosted view.
-     * 
-     * 
+     *
+     *
      * ## Example
-     * 
+     *
      * ```
      * @ng.Component({
      *   selector: 'child-component'
@@ -2741,9 +2745,9 @@ declare module ng {
      * })
      * class ChildComponent {
      * }
-     * 
-     * 
-     * 
+     *
+     *
+     *
      * @ng.Component({
      *   selector: 'my-app'
      * })
@@ -2757,12 +2761,12 @@ declare module ng {
      *     dynamicComponentLoader.loadAsRoot(ChildComponent, '#child', injector);
      *   }
      * }
-     * 
+     *
      * ng.bootstrap(MyApp);
      * ```
-     * 
+     *
      * Resulting DOM:
-     * 
+     *
      * ```
      * <my-app>
      *   Parent (
@@ -2774,16 +2778,16 @@ declare module ng {
      * ```
      */
      loadAsRoot(typeOrBinding: Type | Binding, overrideSelector: string, injector: Injector): Promise<ComponentRef>;
-    
+
 
     /**
      * Loads a component into the component view of the provided ElementRef next to the element
      * with the given name.
-     * 
+     *
      * The loaded component receives injection normally as a hosted view.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```
      * @ng.Component({
      *   selector: 'child-component'
@@ -2793,8 +2797,8 @@ declare module ng {
      * })
      * class ChildComponent {
      * }
-     * 
-     * 
+     *
+     *
      * @ng.Component({
      *   selector: 'my-app'
      * })
@@ -2808,12 +2812,12 @@ declare module ng {
      *     dynamicComponentLoader.loadIntoLocation(ChildComponent, elementRef, 'child');
      *   }
      * }
-     * 
+     *
      * ng.bootstrap(MyApp);
      * ```
-     * 
+     *
      * Resulting DOM:
-     * 
+     *
      * ```
      * <my-app>
      *    Parent (
@@ -2824,16 +2828,16 @@ declare module ng {
      * ```
      */
      loadIntoLocation(typeOrBinding: Type | Binding, hostLocation: ElementRef, anchorName: string, bindings?: ResolvedBinding[]): Promise<ComponentRef>;
-    
+
 
     /**
      * Loads a component next to the provided ElementRef.
-     * 
+     *
      * The loaded component receives injection normally as a hosted view.
-     * 
-     * 
+     *
+     *
      * ## Example
-     * 
+     *
      * ```
      * @ng.Component({
      *   selector: 'child-component'
@@ -2843,8 +2847,8 @@ declare module ng {
      * })
      * class ChildComponent {
      * }
-     * 
-     * 
+     *
+     *
      * @ng.Component({
      *   selector: 'my-app'
      * })
@@ -2856,12 +2860,12 @@ declare module ng {
      *     dynamicComponentLoader.loadIntoLocation(ChildComponent, elementRef, 'child');
      *   }
      * }
-     * 
+     *
      * ng.bootstrap(MyApp);
      * ```
-     * 
+     *
      * Resulting DOM:
-     * 
+     *
      * ```
      * <my-app>Parent</my-app>
      * <child-component>Child</child-component>
@@ -2869,46 +2873,46 @@ declare module ng {
      */
      loadNextToLocation(typeOrBinding: Type | Binding, location: ElementRef, bindings?: ResolvedBinding[]): Promise<ComponentRef>;
   }
-  
+
 
   /**
    * Provides access to explicitly trigger change detection in an application.
-   * 
+   *
    * By default, `Zone` triggers change detection in Angular on each virtual machine (VM) turn. When
    * testing, or in some
    * limited application use cases, a developer can also trigger change detection with the
    * `lifecycle.tick()` method.
-   * 
+   *
    * Each Angular application has a single `LifeCycle` instance.
-   * 
+   *
    * # Example
-   * 
+   *
    * This is a contrived example, since the bootstrap automatically runs inside of the `Zone`, which
    * invokes
    * `lifecycle.tick()` on your behalf.
-   * 
+   *
    * ```javascript
    * bootstrap(MyApp).then((ref:ComponentRef) => {
    *   var lifeCycle = ref.injector.get(LifeCycle);
    *   var myApp = ref.instance;
-   * 
+   *
    *   ref.doSomething();
    *   lifecycle.tick();
    * });
    * ```
    */
   class LifeCycle {
-    
+
 
     /**
      * @private
      */
      registerWith(zone: NgZone, changeDetector?: ChangeDetector): void;
-    
+
 
     /**
      * Invoke this method to explicitly process change detection and its side-effects.
-     * 
+     *
      *  In development mode, `tick()` also performs a second change detection cycle to ensure that no
      * further
      *  changes are detected. If additional changes are picked up during this second cycle, bindings
@@ -2922,105 +2926,105 @@ declare module ng {
      */
      tick(): void;
   }
-  
+
 
   /**
    * Reference to the element.
-   * 
+   *
    * Represents an opaque reference to the underlying element. The element is a DOM ELement in
    * a Browser, but may represent other types on other rendering platforms. In the browser the
    * `ElementRef` can be sent to the web-worker. Web Workers can not have references to the
    * DOM Elements.
    */
   class ElementRef implements RenderElementRef {
-    
+
 
     /**
      * Reference to the {@link ViewRef} where the `ElementRef` is inside of.
      */
      parentView: ViewRef;
-    
+
 
     /**
      * Index of the element inside the {@link ViewRef}.
-     * 
+     *
      * This is used internally by the Angular framework to locate elements.
      */
      boundElementIndex: number;
-    
+
 
     /**
      * Index of the element inside the `RenderViewRef`.
-     * 
+     *
      * This is used internally by the Angular framework to locate elements.
      */
      renderBoundElementIndex: number;
-    
+
      renderView: RenderViewRef;
-    
+
 
     /**
      * Returns the native Element implementation.
-     * 
+     *
      * In the browser this represents the DOM Element.
-     * 
+     *
      * The `nativeElement` can be used as an escape hatch when direct DOM manipulation is needed. Use
      * this with caution, as it creates tight coupling between your application and the Browser, which
      * will not work in WebWorkers.
-     * 
+     *
      * NOTE: This method will return null in the webworker scenario!
      */
      nativeElement: any;
   }
-  
+
 
   /**
    * Reference to a template within a component.
-   * 
+   *
    * Represents an opaque reference to the underlying template that can
    * be instantiated using the {@link ViewContainerRef}.
    */
   class TemplateRef {
-    
+
 
     /**
      * The location of the template
      */
      elementRef: ElementRef;
-    
+
      protoViewRef: ProtoViewRef;
-    
+
 
     /**
      * Whether this template has a local variable with the given name
      */
      hasLocal(name: string): boolean;
   }
-  
+
 
   /**
    * A reference to an Angular View.
-   * 
+   *
    * A View is a fundamental building block of Application UI. A View is the smallest set of
    * elements which are created and destroyed together. A View can change properties on the elements
    * within the view, but it can not change the structure of those elements.
-   * 
+   *
    * To change structure of the elements, the Views can contain zero or more {@link ViewContainerRef}s
    * which allow the views to be nested.
-   * 
+   *
    * ## Example
-   * 
+   *
    * Given this template
-   * 
+   *
    * ```
    * Count: {{items.length}}
    * <ul>
    *   <li *ng-for="var item of items">{{item}}</li>
    * </ul>
    * ```
-   * 
+   *
    * The above example we have two {@link ProtoViewRef}s:
-   * 
+   *
    * Outter {@link ProtoViewRef}:
    * ```
    * Count: {{items.length}}
@@ -3028,16 +3032,16 @@ declare module ng {
    *   <template ng-for var-item [ng-for-of]="items"></template>
    * </ul>
    * ```
-   * 
+   *
    * Inner {@link ProtoViewRef}:
    * ```
    *   <li>{{item}}</li>
    * ```
-   * 
+   *
    * Notice that the original template is broken down into two separate {@link ProtoViewRef}s.
-   * 
+   *
    * The outter/inner {@link ProtoViewRef}s are then assembled into views like so:
-   * 
+   *
    * ```
    * <!-- ViewRef: outer-0 -->
    * Count: 2
@@ -3050,55 +3054,55 @@ declare module ng {
    * ```
    */
   interface ViewRef extends HostViewRef {
-    
+
 
     /**
      * Return `RenderViewRef`
      */
      render: RenderViewRef;
-    
+
 
     /**
      * Return `RenderFragmentRef`
      */
      renderFragment: RenderFragmentRef;
-    
+
 
     /**
      * Set local variable in a view.
-     * 
+     *
      * - `contextName` - Name of the local variable in a view.
      * - `value` - Value for the local variable in a view.
      */
      setLocal(contextName: string, value: any): void;
   }
-  
+
   interface HostViewRef {
   }
-  
+
 
   /**
    * A reference to an Angular ProtoView.
-   * 
+   *
    * A ProtoView is a reference to a template for easy creation of views.
    * (See {@link AppViewManager#createViewInContainer `AppViewManager#createViewInContainer`} and
    * {@link AppViewManager#createRootHostView `AppViewManager#createRootHostView`}).
-   * 
+   *
    * A `ProtoView` is a factory for creating `View`s.
-   * 
+   *
    * ## Example
-   * 
+   *
    * Given this template
-   * 
+   *
    * ```
    * Count: {{items.length}}
    * <ul>
    *   <li *ng-for="var item of items">{{item}}</li>
    * </ul>
    * ```
-   * 
+   *
    * The above example we have two {@link ProtoViewRef}s:
-   * 
+   *
    * Outter {@link ProtoViewRef}:
    * ```
    * Count: {{items.length}}
@@ -3106,53 +3110,53 @@ declare module ng {
    *   <template ng-for var-item [ng-for-of]="items"></template>
    * </ul>
    * ```
-   * 
+   *
    * Inner {@link ProtoViewRef}:
    * ```
    *   <li>{{item}}</li>
    * ```
-   * 
+   *
    * Notice that the original template is broken down into two separate {@link ProtoViewRef}s.
    */
   interface ProtoViewRef {
   }
-  
+
 
   /**
    * A location where {@link ViewRef}s can be attached.
-   * 
+   *
    * A `ViewContainerRef` represents a location in a {@link ViewRef} where other child
    * {@link ViewRef}s can be inserted. Adding and removing views is the only way of structurally
    * changing the rendered DOM of the application.
    */
   interface ViewContainerRef {
-    
+
      viewManager: AppViewManager;
-    
+
      element: ElementRef;
-    
+
 
     /**
      * Remove all {@link ViewRef}s at current location.
      */
      clear(): void;
-    
+
 
     /**
      * Return a {@link ViewRef} at specific index.
      */
      get(index: number): ViewRef;
-    
+
 
     /**
      * Returns number of {@link ViewRef}s currently attached at this location.
      */
      length: number;
-    
+
 
     /**
      * Create and insert a {@link ViewRef} into the view-container.
-     * 
+     *
      * - `protoViewRef` (optional) {@link ProtoViewRef} - The `ProtoView` to use for creating
      *   `View` to be inserted at this location. If `ViewContainer` is created at a location
      *   of inline template, then `protoViewRef` is the `ProtoView` of the template.
@@ -3161,38 +3165,38 @@ declare module ng {
      *   {@link ElementRef} location. (Or current context if unspecified.)
      * - `bindings` (optional) Array of {@link ResolvedBinding} - Used for configuring
      *   `ElementInjector`.
-     * 
+     *
      * Returns newly created {@link ViewRef}.
      */
      createEmbeddedView(templateRef: TemplateRef, atIndex?: number): ViewRef;
-    
+
      createHostView(protoViewRef?: ProtoViewRef, atIndex?: number, dynamicallyCreatedBindings?: ResolvedBinding[]): HostViewRef;
-    
+
 
     /**
      * Insert a {@link ViewRef} at specefic index.
-     * 
+     *
      * The index is location at which the {@link ViewRef} should be attached. If omitted it is
      * inserted at the end.
-     * 
+     *
      * Returns the inserted {@link ViewRef}.
      */
      insert(viewRef: ViewRef, atIndex?: number): ViewRef;
-    
+
 
     /**
      * Return the index of already inserted {@link ViewRef}.
      */
      indexOf(viewRef: ViewRef): number;
-    
+
 
     /**
      * Remove a {@link ViewRef} at specific index.
-     * 
+     *
      * If the index is omitted last {@link ViewRef} is removed.
      */
      remove(atIndex?: number): void;
-    
+
 
     /**
      * The method can be used together with insert to implement a view move, i.e.
@@ -3200,77 +3204,77 @@ declare module ng {
      */
      detach(atIndex?: number): ViewRef;
   }
-  
+
 
   /**
    * Angular's reference to a component instance.
-   * 
+   *
    * `ComponentRef` represents a component instance lifecycle and meta information.
    */
   interface ComponentRef {
-    
+
 
     /**
      * Location of the component host element.
      */
      location: ElementRef;
-    
+
 
     /**
      * Instance of component.
      */
      instance: any;
-    
+
 
     /**
      * Returns the host {@link ViewRef}.
      */
      hostView: HostViewRef;
-    
+
 
     /**
      * Dispose of the component instance.
      */
      dispose(): void;
   }
-  
+
 
   /**
    * A wrapper around zones that lets you schedule tasks after it has executed a task.
-   * 
+   *
    * The wrapper maintains an "inner" and an "mount" `Zone`. The application code will executes
    * in the "inner" zone unless `runOutsideAngular` is explicitely called.
-   * 
+   *
    * A typical application will create a singleton `NgZone`. The outer `Zone` is a fork of the root
    * `Zone`. The default `onTurnDone` runs the Angular change detection.
    */
   class NgZone {
-    
+
 
     /**
      * Sets the zone hook that is called just before Angular event turn starts.
      * It is called once per browser event.
      */
      overrideOnTurnStart(onTurnStartFn: Function): void;
-    
+
 
     /**
      * Sets the zone hook that is called immediately after Angular processes
      * all pending microtasks.
      */
      overrideOnTurnDone(onTurnDoneFn: Function): void;
-    
+
 
     /**
      * Sets the zone hook that is called immediately after the last turn in
      * an event completes. At this point Angular will no longer attempt to
      * sync the UI. Any changes to the data model will not be reflected in the
      * DOM. `onEventDoneFn` is executed outside Angular zone.
-     * 
+     *
      * This hook is useful for validating application state (e.g. in a test).
      */
      overrideOnEventDone(onEventDoneFn: Function, opt_waitForAsync: boolean): void;
-    
+
 
     /**
      * Sets the zone hook that is called when an error is uncaught in the
@@ -3278,17 +3282,17 @@ declare module ng {
      * the stack trace.
      */
      overrideOnErrorHandler(errorHandlingFn: Function): void;
-    
+
 
     /**
      * Runs `fn` in the inner zone and returns whatever it returns.
-     * 
+     *
      * In a typical app where the inner zone is the Angular zone, this allows one to make use of the
      * Angular's auto digest mechanism.
-     * 
+     *
      * ```
      * var zone: NgZone = [ref to the application zone];
-     * 
+     *
      * zone.run(() => {
      *   // the change detection will run after this function and the microtasks it enqueues have
      * executed.
@@ -3296,17 +3300,17 @@ declare module ng {
      * ```
      */
      run(fn: () => any): any;
-    
+
 
     /**
      * Runs `fn` in the outer zone and returns whatever it returns.
-     * 
+     *
      * In a typical app where the inner zone is the Angular zone, this allows one to escape Angular's
      * auto-digest mechanism.
-     * 
+     *
      * ```
      * var zone: NgZone = [ref to the application zone];
-     * 
+     *
      * zone.runOutsideAngular(() => {
      *   element.onClick(() => {
      *     // Clicking on the element would not trigger the change detection
@@ -3316,36 +3320,36 @@ declare module ng {
      */
      runOutsideAngular(fn: () => any): any;
   }
-  
+
   class Observable {
-    
+
      observer(generator: any): Object;
   }
-  
+
 
   /**
    * Use Rx.Observable but provides an adapter to make it work as specified here:
    * https://github.com/jhusain/observable-spec
-   * 
+   *
    * Once a reference implementation of the spec is available, switch to it.
    */
   class EventEmitter extends Observable {
-    
+
      observer(generator: any): Rx.IDisposable;
-    
+
      toRx(): Rx.Observable<any>;
-    
+
      next(value: any): void;
-    
+
      throw(error: any): void;
-    
+
      return(value?: any): void;
   }
-  
+
 
   /**
    * A parameter metadata that specifies a dependency.
-   * 
+   *
    * ```
    * class AComponent {
    *   constructor(@Inject(MyService) aService:MyService) {}
@@ -3353,17 +3357,17 @@ declare module ng {
    * ```
    */
   class InjectMetadata {
-    
+
      token: any;
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * A parameter metadata that marks a dependency as optional. {@link Injector} provides `null` if
    * the dependency is not found.
-   * 
+   *
    * ```
    * class AComponent {
    *   constructor(@Optional() aService:MyService) {
@@ -3373,66 +3377,66 @@ declare module ng {
    * ```
    */
   class OptionalMetadata {
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * A marker metadata that marks a class as available to `Injector` for creation. Used by tooling
    * for generating constructor stubs.
-   * 
+   *
    * ```
    * class NeedsService {
    *   constructor(svc:UsefulService) {}
    * }
-   * 
+   *
    * @Injectable
    * class UsefulService {}
    * ```
    */
   class InjectableMetadata {
   }
-  
+
 
   /**
    * Specifies that an injector should retrieve a dependency from itself.
-   * 
+   *
    * ## Example
-   * 
+   *
    * ```
    * class Dependency {
    * }
-   * 
+   *
    * class NeedsDependency {
    *   constructor(public @Self() dependency:Dependency) {}
    * }
-   * 
+   *
    * var inj = Injector.resolveAndCreate([Dependency, NeedsDependency]);
    * var nd = inj.get(NeedsDependency);
    * expect(nd.dependency).toBeAnInstanceOf(Dependency);
    * ```
    */
   class SelfMetadata {
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * Specifies that an injector should retrieve a dependency from any injector until reaching the
    * closest host.
-   * 
+   *
    * ## Example
-   * 
+   *
    * ```
    * class Dependency {
    * }
-   * 
+   *
    * class NeedsDependency {
    *   constructor(public @Host() dependency:Dependency) {}
    * }
-   * 
+   *
    * var parent = Injector.resolveAndCreate([
    *   bind(Dependency).toClass(HostDependency)
    * ]);
@@ -3443,27 +3447,27 @@ declare module ng {
    * ```
    */
   class HostMetadata {
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * Specifies that the dependency resolution should start from the parent injector.
-   * 
+   *
    * ## Example
-   * 
-   * 
+   *
+   *
    * ```
    * class Service {}
-   * 
+   *
    * class ParentService implements Service {
    * }
-   * 
+   *
    * class ChildService implements Service {
    *   constructor(public @SkipSelf() parentService:Service) {}
    * }
-   * 
+   *
    * var parent = Injector.resolveAndCreate([
    *   bind(Service).toClass(ParentService)
    * ]);
@@ -3476,115 +3480,115 @@ declare module ng {
    * ```
    */
   class SkipSelfMetadata {
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * `DependencyMetadata is used by the framework to extend DI.
-   * 
+   *
    * Only metadata implementing `DependencyMetadata` are added to the list of dependency
    * properties.
-   * 
+   *
    * For example:
-   * 
+   *
    * ```
    * class Exclude extends DependencyMetadata {}
    * class NotDependencyProperty {}
-   * 
+   *
    * class AComponent {
    *   constructor(@Exclude @NotDependencyProperty aService:AService) {}
    * }
    * ```
-   * 
+   *
    * will create the following dependency:
-   * 
+   *
    * ```
    * new Dependency(Key.get(AService), [new Exclude()])
    * ```
-   * 
+   *
    * The framework can use `new Exclude()` to handle the `aService` dependency
    * in a specific way.
    */
   class DependencyMetadata {
-    
+
      token: any;
   }
-  
+
 
   /**
    * Allows to refer to references which are not yet defined.
-   * 
+   *
    * This situation arises when the key which we need te refer to for the purposes of DI is declared,
    * but not yet defined.
-   * 
+   *
    * ## Example:
-   * 
+   *
    * ```
    * class Door {
    *   // Incorrect way to refer to a reference which is defined later.
    *   // This fails because `Lock` is undefined at this point.
    *   constructor(lock:Lock) { }
-   * 
+   *
    *   // Correct way to refer to a reference which is defined later.
    *   // The reference needs to be captured in a closure.
    *   constructor(@Inject(forwardRef(() => Lock)) lock:Lock) { }
    * }
-   * 
+   *
    * // Only at this point the lock is defined.
    * class Lock {
    * }
    * ```
    */
   function forwardRef(forwardRefFn: ForwardRefFn) : Type ;
-  
+
 
   /**
    * Lazily retrieve the reference value.
-   * 
+   *
    * See: {@link forwardRef}
    */
   function resolveForwardRef(type: any) : any ;
-  
+
   interface ForwardRefFn {
-    
+
      (): any;
-  
+
   }
-  
+
 
   /**
    * A dependency injection container used for resolving dependencies.
-   * 
+   *
    * An `Injector` is a replacement for a `new` operator, which can automatically resolve the
    * constructor dependencies.
    * In typical use, application code asks for the dependencies in the constructor and they are
    * resolved by the `Injector`.
-   * 
+   *
    * ## Example:
-   * 
+   *
    * Suppose that we want to inject an `Engine` into class `Car`, we would define it like this:
-   * 
+   *
    * ```javascript
    * class Engine {
    * }
-   * 
+   *
    * class Car {
    *   constructor(@Inject(Engine) engine) {
    *   }
    * }
-   * 
+   *
    * ```
-   * 
+   *
    * Next we need to write the code that creates and instantiates the `Injector`. We then ask for the
    * `root` object, `Car`, so that the `Injector` can recursively build all of that object's
    * dependencies.
-   * 
+   *
    * ```javascript
    * main() {
    *   var injector = Injector.resolveAndCreate([Car, Engine]);
-   * 
+   *
    *   // Get a reference to the `root` object, which will recursively instantiate the tree.
    *   var car = injector.get(Car);
    * }
@@ -3593,18 +3597,18 @@ declare module ng {
    * resolve all of the object's dependencies automatically.
    */
   class Injector {
-    
+
 
     /**
      * Turns a list of binding definitions into an internal resolved list of resolved bindings.
-     * 
+     *
      * A resolution is a process of flattening multiple nested lists and converting individual
      * bindings into a list of {@link ResolvedBinding}s. The resolution can be cached by `resolve`
      * for the {@link Injector} for performance-sensitive code.
-     * 
+     *
      * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
      * recursive list of more bindings.
-     * 
+     *
      * The returned list is sparse, indexed by `id` for the {@link Key}. It is generally not useful to
      * application code
      * other than for passing it to {@link Injector} functions that require resolved binding lists,
@@ -3612,207 +3616,207 @@ declare module ng {
      * `fromResolvedBindings` and `createChildFromResolved`.
      */
      static resolve(bindings: List<Type | Binding | List<any>>): List<ResolvedBinding>;
-    
+
 
     /**
      * Resolves bindings and creates an injector based on those bindings. This function is slower than
      * the corresponding `fromResolvedBindings` because it needs to resolve bindings first. See
      * `resolve`
      * for the {@link Injector}.
-     * 
+     *
      * Prefer `fromResolvedBindings` in performance-critical code that creates lots of injectors.
-     * 
+     *
      * @param `bindings` can be a list of `Type`, {@link Binding}, {@link ResolvedBinding}, or a
      * recursive list of more
      * bindings.
      * @param `depProvider`
      */
      static resolveAndCreate(bindings: List<Type | Binding | List<any>>, depProvider?: DependencyProvider): Injector;
-    
+
 
     /**
      * Creates an injector from previously resolved bindings. This bypasses resolution and flattening.
      * This API is the recommended way to construct injectors in performance-sensitive parts.
-     * 
+     *
      * @param `bindings` A sparse list of {@link ResolvedBinding}s. See `resolve` for the
      * {@link Injector}.
      * @param `depProvider`
      */
      static fromResolvedBindings(bindings: List<ResolvedBinding>, depProvider?: DependencyProvider): Injector;
-    
+
 
     /**
      * 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;
-    
+
 
     /**
      * Resolves a binding and instantiates an object in the context of the injector.
-     * 
+     *
      * @param `binding`: either a type or a binding.
      * @returns an object created using binding.
      */
      resolveAndInstantiate(binding: Type | Binding): any;
-    
+
 
     /**
      * Instantiates an object using a resolved bindin in the context of the injector.
-     * 
+     *
      * @param `binding`: a resolved binding
      * @returns an object created using binding.
      */
      instantiateResolved(binding: ResolvedBinding): any;
-    
+
      displayName: string;
-    
+
      toString(): string;
   }
-  
+
   class ProtoInjector {
-    
+
      numberOfBindings: number;
-    
+
      getBindingAtIndex(index: number): any;
   }
-  
+
   class BindingWithVisibility {
-    
+
      binding: ResolvedBinding;
-    
+
      visibility: Visibility;
-    
+
      getKeyId(): number;
   }
-  
+
 
   /**
    * Used to provide dependencies that cannot be easily expressed as bindings.
    */
   interface DependencyProvider {
-    
+
      getDependency(injector: Injector, binding: ResolvedBinding, dependency: Dependency): any;
   }
-  
+
   enum Visibility {
-    
+
      Public,
-    
+
      Private,
-    
+
      PublicAndPrivate
   }
-  
+
   const UNDEFINED : Object ;
-  
+
 
   /**
    * Describes how_ the {@link Injector} should instantiate a given token.
-   * 
+   *
    * See {@link bind}.
-   * 
+   *
    * ## Example
-   * 
+   *
    * ```javascript
    * var injector = Injector.resolveAndCreate([
    *   new Binding(String, { toValue: 'Hello' })
    * ]);
-   * 
+   *
    * expect(injector.get(String)).toEqual('Hello');
    * ```
    */
   class Binding {
-    
+
 
     /**
      * Token used when retrieving this binding. Usually the `Type`.
      */
      token: any;
-    
+
 
     /**
      * Binds an interface to an implementation / subclass.
-     * 
+     *
      * ## Example
-     * 
+     *
      * Becuse `toAlias` and `toClass` are often confused, the example contains both use cases for easy
      * comparison.
-     * 
+     *
      * ```javascript
-     * 
+     *
      * class Vehicle {}
-     * 
+     *
      * class Car extends Vehicle {}
-     * 
+     *
      * var injectorClass = Injector.resolveAndCreate([
      *   Car,
      *   new Binding(Vehicle, { toClass: Car })
@@ -3821,50 +3825,50 @@ declare module ng {
      *   Car,
      *   new Binding(Vehicle, { toAlias: Car })
      * ]);
-     * 
+     *
      * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
      * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
-     * 
+     *
      * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
      * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
      * ```
      */
      toClass: Type;
-    
+
 
     /**
      * Binds a key to a value.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```javascript
      * var injector = Injector.resolveAndCreate([
      *   new Binding(String, { toValue: 'Hello' })
      * ]);
-     * 
+     *
      * expect(injector.get(String)).toEqual('Hello');
      * ```
      */
      toValue: any;
-    
+
 
     /**
      * Binds a key to the alias for an existing key.
-     * 
+     *
      * An alias means that {@link Injector} returns the same instance as if the alias token was used.
      * This is in contrast to `toClass` where a separate instance of `toClass` is returned.
-     * 
+     *
      * ## Example
-     * 
+     *
      * Becuse `toAlias` and `toClass` are often confused the example contains both use cases for easy
      * comparison.
-     * 
+     *
      * ```javascript
-     * 
+     *
      * class Vehicle {}
-     * 
+     *
      * class Car extends Vehicle {}
-     * 
+     *
      * var injectorAlias = Injector.resolveAndCreate([
      *   Car,
      *   new Binding(Vehicle, { toAlias: Car })
@@ -3873,88 +3877,88 @@ declare module ng {
      *   Car,
      *   new Binding(Vehicle, { toClass: Car })
      * ]);
-     * 
+     *
      * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
      * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
-     * 
+     *
      * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
      * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
      * ```
      */
      toAlias: any;
-    
+
 
     /**
      * Binds a key to a function which computes the value.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```javascript
      * var injector = Injector.resolveAndCreate([
      *   new Binding(Number, { toFactory: () => { return 1+2; }}),
      *   new Binding(String, { toFactory: (value) => { return "Value: " + value; },
      *                         dependencies: [Number] })
      * ]);
-     * 
+     *
      * expect(injector.get(Number)).toEqual(3);
      * expect(injector.get(String)).toEqual('Value: 3');
      * ```
      */
      toFactory: Function;
-    
+
 
     /**
      * Used in conjunction with `toFactory` and specifies a set of dependencies
      * (as `token`s) which should be injected into the factory function.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```javascript
      * var injector = Injector.resolveAndCreate([
      *   new Binding(Number, { toFactory: () => { return 1+2; }}),
      *   new Binding(String, { toFactory: (value) => { return "Value: " + value; },
      *                         dependencies: [Number] })
      * ]);
-     * 
+     *
      * expect(injector.get(Number)).toEqual(3);
      * expect(injector.get(String)).toEqual('Value: 3');
      * ```
      */
      dependencies: List<any>;
-    
+
 
     /**
      * Converts the {@link Binding} into {@link ResolvedBinding}.
-     * 
+     *
      * {@link Injector} internally only uses {@link ResolvedBinding}, {@link Binding} contains
      * convenience binding syntax.
      */
      resolve(): ResolvedBinding;
   }
-  
+
 
   /**
    * Helper class for the {@link bind} function.
    */
   class BindingBuilder {
-    
+
      token: any;
-    
+
 
     /**
      * Binds an interface to an implementation / subclass.
-     * 
+     *
      * ## Example
-     * 
+     *
      * Because `toAlias` and `toClass` are often confused, the example contains both use cases for
      * easy comparison.
-     * 
+     *
      * ```javascript
-     * 
+     *
      * class Vehicle {}
-     * 
+     *
      * class Car extends Vehicle {}
-     * 
+     *
      * var injectorClass = Injector.resolveAndCreate([
      *   Car,
      *   bind(Vehicle).toClass(Car)
@@ -3963,50 +3967,50 @@ declare module ng {
      *   Car,
      *   bind(Vehicle).toAlias(Car)
      * ]);
-     * 
+     *
      * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
      * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
-     * 
+     *
      * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
      * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
      * ```
      */
      toClass(type: Type): Binding;
-    
+
 
     /**
      * Binds a key to a value.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```javascript
      * var injector = Injector.resolveAndCreate([
      *   bind(String).toValue('Hello')
      * ]);
-     * 
+     *
      * expect(injector.get(String)).toEqual('Hello');
      * ```
      */
      toValue(value: any): Binding;
-    
+
 
     /**
      * Binds a key to the alias for an existing key.
-     * 
+     *
      * An alias means that we will return the same instance as if the alias token was used. (This is
      * in contrast to `toClass` where a separate instance of `toClass` will be returned.)
-     * 
+     *
      * ## Example
-     * 
+     *
      * Becuse `toAlias` and `toClass` are often confused, the example contains both use cases for easy
      * comparison.
-     * 
+     *
      * ```javascript
-     * 
+     *
      * class Vehicle {}
-     * 
+     *
      * class Car extends Vehicle {}
-     * 
+     *
      * var injectorAlias = Injector.resolveAndCreate([
      *   Car,
      *   bind(Vehicle).toAlias(Car)
@@ -4015,151 +4019,151 @@ declare module ng {
      *   Car,
      *   bind(Vehicle).toClass(Car)
      * ]);
-     * 
+     *
      * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
      * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
-     * 
+     *
      * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
      * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
      * ```
      */
      toAlias(aliasToken: /*Type*/ any): Binding;
-    
+
 
     /**
      * Binds a key to a function which computes the value.
-     * 
+     *
      * ## Example
-     * 
+     *
      * ```javascript
      * var injector = Injector.resolveAndCreate([
      *   bind(Number).toFactory(() => { return 1+2; }),
      *   bind(String).toFactory((v) => { return "Value: " + v; }, [Number])
      * ]);
-     * 
+     *
      * expect(injector.get(Number)).toEqual(3);
      * expect(injector.get(String)).toEqual('Value: 3');
      * ```
      */
      toFactory(factoryFunction: Function, dependencies?: List<any>): Binding;
   }
-  
+
 
   /**
    * 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 {
-    
+
      static fromKey(key: Key): 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.
    */
   class Key {
-    
+
 
     /**
      * Retrieves a `Key` for a token.
      */
      static get(token: Object): Key;
-    
+
 
     /**
      * @returns the number of keys registered in the system.
      */
      static numberOfKeys: number;
-    
+
      token: Object;
-    
+
      id: number;
-    
+
      displayName: string;
   }
-  
+
 
   /**
    * @private
    */
   class KeyRegistry {
-    
+
      get(token: Object): Key;
-    
+
      numberOfKeys: number;
   }
-  
+
 
   /**
    * Type literals is a Dart-only feature. This is here only so we can x-compile
    * to multiple languages.
    */
   class TypeLiteral {
-    
+
      type: any;
   }
-  
+
 
   /**
    * Thrown when trying to retrieve a dependency by `Key` from {@link Injector}, but the
@@ -4167,36 +4171,36 @@ declare module ng {
    */
   class NoBindingError extends AbstractBindingError {
   }
-  
+
 
   /**
    * Base class for all errors arising from misconfigured bindings.
    */
   class AbstractBindingError extends BaseException {
-    
+
      name: string;
-    
+
      message: string;
-    
+
      keys: List<Key>;
-    
+
      injectors: List<Injector>;
-    
+
      constructResolvingMessage: Function;
-    
+
      addKey(injector: Injector, key: Key): void;
-    
+
      context: any;
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * Thrown when dependencies form a cycle.
-   * 
+   *
    * ## Example:
-   * 
+   *
    * ```javascript
    * class A {
    *   constructor(b:B) {}
@@ -4205,195 +4209,195 @@ declare module ng {
    *   constructor(a:A) {}
    * }
    * ```
-   * 
+   *
    * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.
    */
   class CyclicDependencyError extends AbstractBindingError {
   }
-  
+
 
   /**
    * Thrown when a constructing type returns with an Error.
-   * 
+   *
    * The `InstantiationError` class contains the original error plus the dependency graph which caused
    * this object to be instantiated.
    */
   class InstantiationError extends AbstractBindingError {
-    
+
      causeKey: Key;
   }
-  
+
 
   /**
    * Thrown when an object other then {@link Binding} (or `Type`) is passed to {@link Injector}
    * creation.
    */
   class InvalidBindingError extends BaseException {
-    
+
      message: string;
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * Thrown when the class has no annotation information.
-   * 
+   *
    * Lack of annotation information prevents the {@link Injector} from determining which dependencies
    * need to be injected into the constructor.
    */
   class NoAnnotationError extends BaseException {
-    
+
      name: string;
-    
+
      message: string;
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * Thrown when getting an object by index.
    */
   class OutOfBoundsError extends BaseException {
-    
+
      message: string;
-    
+
      toString(): string;
   }
-  
+
   class OpaqueToken {
-    
+
      toString(): string;
   }
-  
+
 
   /**
    * Factory for creating {@link InjectMetadata}.
    */
   interface InjectFactory {
-    
+
      new(token: any): InjectMetadata;
-  
-    
+
+
      (token: any): any;
-  
+
   }
-  
+
 
   /**
    * Factory for creating {@link OptionalMetadata}.
    */
   interface OptionalFactory {
-    
+
      new(): OptionalMetadata;
-  
-    
+
+
      (): any;
-  
+
   }
-  
+
 
   /**
    * Factory for creating {@link InjectableMetadata}.
    */
   interface InjectableFactory {
-    
+
      new(): InjectableMetadata;
-  
-    
+
+
      (): any;
-  
+
   }
-  
+
 
   /**
    * Factory for creating {@link SelfMetadata}.
    */
   interface SelfFactory {
-    
+
      new(): SelfMetadata;
-  
-    
+
+
      (): any;
-  
+
   }
-  
+
 
   /**
    * Factory for creating {@link HostMetadata}.
    */
   interface HostFactory {
-    
+
      new(): HostMetadata;
-  
-    
+
+
      (): any;
-  
+
   }
-  
+
 
   /**
    * Factory for creating {@link SkipSelfMetadata}.
    */
   interface SkipSelfFactory {
-    
+
      new(): SkipSelfMetadata;
-  
-    
+
+
      (): any;
-  
+
   }
-  
+
 
   /**
    * Factory for creating {@link InjectMetadata}.
    */
   var Inject : InjectFactory ;
-  
+
 
   /**
    * Factory for creating {@link OptionalMetadata}.
    */
   var Optional : OptionalFactory ;
-  
+
 
   /**
    * Factory for creating {@link InjectableMetadata}.
    */
   var Injectable : InjectableFactory ;
-  
+
 
   /**
    * Factory for creating {@link SelfMetadata}.
    */
   var Self : SelfFactory ;
-  
+
 
   /**
    * Factory for creating {@link HostMetadata}.
    */
   var Host : HostFactory ;
-  
+
 
   /**
    * Factory for creating {@link SkipSelfMetadata}.
    */
   var SkipSelf : SkipSelfFactory ;
-  
+
 
   /**
    * A collection of the Angular core directives that are likely to be used in each and every Angular
    * application.
-   * 
+   *
    * This collection can be used to quickly enumerate all the built-in directives in the `@View`
    * annotation. For example,
    * instead of writing:
-   * 
+   *
    * ```
    * import {NgClass, NgIf, NgFor, NgSwitch, NgSwitchWhen, NgSwitchDefault} from 'angular2/angular2';
    * import {OtherDirective} from 'myDirectives';
-   * 
+   *
    * @Component({
    *  selector: 'my-component'
    * })
@@ -4406,11 +4410,11 @@ declare module ng {
    * }
    * ```
    * one could import all the core directives at once:
-   * 
+   *
    * ```
    * import {CORE_DIRECTIVES} from 'angular2/angular2';
    * import {OtherDirective} from 'myDirectives';
-   * 
+   *
    * @Component({
    *  selector: 'my-component'
    * })
@@ -4424,11 +4428,11 @@ declare module ng {
    * ```
    */
   const CORE_DIRECTIVES : 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
@@ -4437,9 +4441,9 @@ declare module ng {
    * are interpreted as {boolean} expression. If a given expression
    * evaluates to {true} a corresponding CSS class is added - otherwise
    * it is removed.
-   * 
+   *
    * # Example:
-   * 
+   *
    * ```
    * <div class="message" [ng-class]="{error: errorCount > 0}">
    *     Please check errors.
@@ -4447,33 +4451,33 @@ declare module ng {
    * ```
    */
   class NgClass {
-    
+
      initialClasses: any;
-    
+
      rawClass: any;
-    
+
      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">
@@ -4481,48 +4485,48 @@ declare module ng {
    *   </li>
    * </ul>
    * ```
-   * 
+   *
    * # Syntax
-   * 
+   *
    * - `<li *ng-for="#item of items; #i = index">...</li>`
    * - `<li template="ng-for #item of items; #i = index">...</li>`
    * - `<template ng-for #item [ng-for-of]="items" #i="index"><li>...</li></template>`
    */
   class NgFor {
-    
+
      static bulkRemove(tuples: List<RecordViewTuple>, viewContainer: ViewContainerRef): List<RecordViewTuple>;
-    
+
      static bulkInsert(tuples: List<RecordViewTuple>, viewContainer: ViewContainerRef, templateRef: TemplateRef): List<RecordViewTuple>;
-    
+
      viewContainer: ViewContainerRef;
-    
+
      templateRef: TemplateRef;
-    
+
      iterableDiffers: IterableDiffers;
-    
+
      cdr: ChangeDetectorRef;
-    
+
      ngForOf: any;
-    
+
      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
@@ -4530,27 +4534,27 @@ declare module ng {
    *   {{errorCount}} errors detected
    * </div>
    * ```
-   * 
+   *
    * # Syntax
-   * 
+   *
    * - `<div *ng-if="condition">...</div>`
    * - `<div template="ng-if condition">...</div>`
    * - `<template [ng-if]="condition"><div>...</div></template>`
    */
   class NgIf {
-    
+
      ngIf: any;
   }
-  
+
 
   /**
    * The `NgNonBindable` directive tells Angular not to compile or bind the contents of the current
    * DOM element. This is useful if the element contains what appears to be Angular directives and
    * bindings but which should be ignored by Angular. This could be the case if you have a site that
    * displays snippets of code, for instance.
-   * 
+   *
    * Example:
-   * 
+   *
    * ```
    * <div>Normal: {{1 + 2}}</div> // output "Normal: 3"
    * <div ng-non-bindable>Ignored: {{1 + 2}}</div> // output "Ignored: {{1 + 2}}"
@@ -4558,50 +4562,50 @@ declare module ng {
    */
   class NgNonBindable {
   }
-  
+
 
   /**
    * Adds or removes styles based on an {expression}.
-   * 
+   *
    * When the expression assigned to `ng-style` evaluates to an object, the corresponding element
    * styles are updated. Style names to update are taken from the object keys and values - from the
    * corresponding object values.
-   * 
+   *
    * # Example:
-   * 
+   *
    * ```
    * <div [ng-style]="{'text-align': alignExp}"></div>
    * ```
-   * 
+   *
    * In the above example the `text-align` style will be updated based on the `alignExp` value
    * changes.
-   * 
+   *
    * # Syntax
-   * 
+   *
    * - `<div [ng-style]="{'text-align': alignExp}"></div>`
    * - `<div [ng-style]="styleExp"></div>`
    */
   class NgStyle {
-    
+
      rawStyle: any;
-    
+
      onCheck(): void;
   }
-  
+
   class SwitchView {
-    
+
      create(): void;
-    
+
      destroy(): void;
   }
-  
+
 
   /**
    * The `NgSwitch` directive is used to conditionally swap DOM structure on your template based on a
    * scope expression.
    * Elements within `NgSwitch` but without `NgSwitchWhen` or `NgSwitchDefault` directives will be
    * preserved at the location as specified in the template.
-   * 
+   *
    * `NgSwitch` simply chooses nested elements and makes them visible based on which element matches
    * the value obtained from the evaluated expression. In other words, you define a container element
    * (where you place the directive), place an expression on the **`[ng-switch]="..."` attribute**),
@@ -4610,9 +4614,9 @@ declare module ng {
    * The when attribute is used to inform NgSwitch which element to display when the expression is
    * evaluated. If a matching expression is not found via a when attribute then an element with the
    * default attribute is displayed.
-   * 
+   *
    * # Example:
-   * 
+   *
    * ```
    * <ANY [ng-switch]="expression">
    *   <template [ng-switch-when]="whenExpression1">...</template>
@@ -4622,115 +4626,115 @@ declare module ng {
    * ```
    */
   class NgSwitch {
-    
+
      ngSwitch: any;
   }
-  
+
 
   /**
    * Defines a case statement as an expression.
-   * 
+   *
    * If multiple `NgSwitchWhen` match the `NgSwitch` value, all of them are displayed.
-   * 
+   *
    * Example:
-   * 
+   *
    * ```
    * // match against a context variable
    * <template [ng-switch-when]="contextVariable">...</template>
-   * 
+   *
    * // match against a constant string
    * <template ng-switch-when="stringValue">...</template>
    * ```
    */
   class NgSwitchWhen {
-    
+
      ngSwitchWhen: any;
   }
-  
+
 
   /**
    * Defines a default case statement.
-   * 
+   *
    * Default case statements are displayed when no `NgSwitchWhen` match the `ng-switch` value.
-   * 
+   *
    * Example:
-   * 
+   *
    * ```
    * <template ng-switch-default>...</template>
    * ```
    */
   class NgSwitchDefault {
   }
-  
+
 
   /**
    * Omitting from external API doc as this is really an abstract internal concept.
    */
   class AbstractControl {
-    
+
      validator: Function;
-    
+
      value: any;
-    
+
      status: string;
-    
+
      valid: boolean;
-    
+
      errors: StringMap<string, any>;
-    
+
      pristine: boolean;
-    
+
      dirty: boolean;
-    
+
      touched: boolean;
-    
+
      untouched: boolean;
-    
+
      valueChanges: Observable;
-    
+
      markAsTouched(): void;
-    
+
      markAsDirty({onlySelf}?: {onlySelf?: boolean}): void;
-    
+
      setParent(parent: ControlGroup | ControlArray): void;
-    
+
      updateValidity({onlySelf}?: {onlySelf?: boolean}): void;
-    
+
      updateValueAndValidity({onlySelf, emitEvent}?: {onlySelf?: boolean, emitEvent?: boolean}): void;
-    
+
      find(path: List<string | number>| string): AbstractControl;
-    
+
      getError(errorCode: string, path?: List<string>): any;
-    
+
      hasError(errorCode: string, path?: List<string>): boolean;
   }
-  
+
 
   /**
    * Defines a part of a form that cannot be divided into other controls.
-   * 
+   *
    * `Control` is one of the three fundamental building blocks used to define forms in Angular, along
    * with
    * {@link ControlGroup} and {@link ControlArray}.
    */
   class Control extends AbstractControl {
-    
+
      updateValue(value: any, {onlySelf, emitEvent, emitModelToViewChange}?:
                   {onlySelf?: boolean, emitEvent?: boolean, emitModelToViewChange?: boolean}): void;
-    
+
      registerOnChange(fn: Function): void;
   }
-  
+
 
   /**
    * Defines a part of a form, of fixed length, that can contain other controls.
-   * 
+   *
    * A ControlGroup aggregates the values and errors of each {@link Control} in the group. Thus, if
    * one of the controls
    * in a group is invalid, the entire group is invalid. Similarly, if a control changes its value,
    * the entire group
    * changes as well.
-   * 
+   *
    * `ControlGroup` is one of the three fundamental building blocks used to define forms in Angular,
    * along with
    * {@link Control} and {@link ControlArray}. {@link ControlArray} can also contain other controls,
@@ -4738,118 +4742,118 @@ declare module ng {
    * length.
    */
   class ControlGroup extends AbstractControl {
-    
+
      controls: StringMap<string, AbstractControl>;
-    
+
      addControl(name: string, c: AbstractControl): void;
-    
+
      removeControl(name: string): void;
-    
+
      include(controlName: string): void;
-    
+
      exclude(controlName: string): void;
-    
+
      contains(controlName: string): boolean;
   }
-  
+
 
   /**
    * Defines a part of a form, of variable length, that can contain other controls.
-   * 
+   *
    * A `ControlArray` aggregates the values and errors of each {@link Control} in the group. Thus, if
    * one of the controls
    * in a group is invalid, the entire group is invalid. Similarly, if a control changes its value,
    * the entire group
    * changes as well.
-   * 
+   *
    * `ControlArray` is one of the three fundamental building blocks used to define forms in Angular,
    * along with {@link Control} and {@link ControlGroup}. {@link ControlGroup} can also contain
    * other controls, but is of fixed length.
    */
   class ControlArray extends AbstractControl {
-    
+
      controls: List<AbstractControl>;
-    
+
      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({
@@ -4858,9 +4862,9 @@ declare module ng {
    *              <form #f="form" (submit)='onLogIn(f.value)'>
    *                Login <input type='text' ng-control='login' #l="form">
    *                <div *ng-if="!l.valid">Login is invalid</div>
-   * 
+   *
    *                Password <input type='password' ng-control='password'>
-   * 
+   *
    *                <button type='submit'>Log in!</button>
    *              </form>
    *      `})
@@ -4870,9 +4874,9 @@ declare module ng {
    *  }
    * }
    *  ```
-   * 
+   *
    * We can also use ng-model to bind a domain model to the form.
-   * 
+   *
    *  ```
    * @Component({selector: "login-comp"})
    * @View({
@@ -4887,7 +4891,7 @@ declare module ng {
    *      `})
    * class LoginComp {
    *  credentials: {login:string, password:string};
-   * 
+   *
    *  onLogIn() {
    *    // this.credentials.login === "some login"
    *    // this.credentials.password === "some password"
@@ -4896,42 +4900,42 @@ declare module ng {
    *  ```
    */
   class NgControlName extends NgControl {
-    
+
      update: any;
-    
+
      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({
@@ -4940,16 +4944,16 @@ declare module ng {
    *      })
    * class LoginComp {
    *  loginControl:Control;
-   * 
+   *
    *  constructor() {
    *    this.loginControl = new Control('');
    *  }
    * }
-   * 
+   *
    *  ```
-   * 
+   *
    * We can also use ng-model to bind a domain model to the form.
-   * 
+   *
    *  ```
    * @Component({selector: "login-comp"})
    * @View({
@@ -4959,7 +4963,7 @@ declare module ng {
    * class LoginComp {
    *  loginControl:Control;
    *  login:string;
-   * 
+   *
    *  constructor() {
    *    this.loginControl = new Control('');
    *  }
@@ -4967,32 +4971,32 @@ declare module ng {
    *  ```
    */
   class NgFormControl extends NgControl {
-    
+
      form: Control;
-    
+
      update: any;
-    
+
      model: any;
-    
+
      viewModel: any;
-    
+
      ngValidators: QueryList<NgValidator>;
-    
+
      onChange(c: StringMap<string, any>): void;
-    
+
      path: List<string>;
-    
+
      control: Control;
-    
+
      validator: Function;
-    
+
      viewToModelUpdate(newValue: any): void;
   }
-  
+
 
   /**
    * Binds a domain model to the form.
-   * 
+   *
    * # Example
    *  ```
    * @Component({selector: "search-comp"})
@@ -5007,56 +5011,56 @@ declare module ng {
    *  ```
    */
   class NgModel extends NgControl {
-    
+
      update: any;
-    
+
      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({
@@ -5068,7 +5072,7 @@ declare module ng {
    *                  Password <input type='password' ng-control='password'>
    *                </div>
    *                <div *ng-if="!credentials.valid">Credentials are invalid</div>
-   * 
+   *
    *                <div ng-control-group='personal'>
    *                  Name <input type='text' ng-control='name'>
    *                </div>
@@ -5081,32 +5085,32 @@ declare module ng {
    *    //  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({
@@ -5119,23 +5123,23 @@ declare module ng {
    *      })
    * class LoginComp {
    *  loginForm:ControlGroup;
-   * 
+   *
    *  constructor() {
    *    this.loginForm = new ControlGroup({
    *      login: new Control(""),
    *      password: new Control("")
    *    });
    *  }
-   * 
+   *
    *  onLogin() {
    *    // this.loginForm.value
    *  }
    * }
-   * 
+   *
    *  ```
-   * 
+   *
    * We can also use ng-model to bind a domain model to the form.
-   * 
+   *
    *  ```
    * @Component({selector: "login-comp"})
    * @View({
@@ -5149,14 +5153,14 @@ declare module ng {
    * class LoginComp {
    *  credentials:{login:string, password:string}
    *  loginForm:ControlGroup;
-   * 
+   *
    *  constructor() {
    *    this.loginForm = new ControlGroup({
    *      login: new Control(""),
    *      password: new Control("")
    *    });
    *  }
-   * 
+   *
    *  onLogin() {
    *    // this.credentials.login === 'some login'
    *    // this.credentials.password === 'some password'
@@ -5165,44 +5169,44 @@ declare module ng {
    *  ```
    */
   class NgFormModel extends ControlContainer implements Form {
-    
+
      form: ControlGroup;
-    
+
      directives: List<NgControl>;
-    
+
      ngSubmit: any;
-    
+
      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({
@@ -5214,7 +5218,7 @@ declare module ng {
    *                  Password <input type='password' ng-control='password'>
    *                </div>
    *                <div *ng-if="!credentials.valid">Credentials are invalid</div>
-   * 
+   *
    *                <div ng-control-group='personal'>
    *                  Name <input type='text' ng-control='name'>
    *                </div>
@@ -5227,142 +5231,142 @@ declare module ng {
    *    //  credentials: {login: 'some login', password: 'some password'}}
    *  }
    * }
-   * 
+   *
    *  ```
    */
   class NgForm extends ControlContainer implements Form {
-    
+
      form: ControlGroup;
-    
+
      ngSubmit: any;
-    
+
      formDirective: Form;
-    
+
      control: ControlGroup;
-    
+
      path: List<string>;
-    
+
      controls: StringMap<string, AbstractControl>;
-    
+
      addControl(dir: NgControl): void;
-    
+
      getControl(dir: NgControl): Control;
-    
+
      removeControl(dir: NgControl): void;
-    
+
      addControlGroup(dir: NgControlGroup): void;
-    
+
      removeControlGroup(dir: NgControlGroup): void;
-    
+
      getControlGroup(dir: NgControlGroup): ControlGroup;
-    
+
      updateModel(dir: NgControl, value: any): void;
-    
+
      onSubmit(): boolean;
   }
-  
+
 
   /**
    * A bridge between a control and a native element.
-   * 
+   *
    * Please see {@link DefaultValueAccessor} for more information.
    */
   interface ControlValueAccessor {
-    
+
      writeValue(obj: any): void;
-    
+
      registerOnChange(fn: any): void;
-    
+
      registerOnTouched(fn: any): void;
   }
-  
+
 
   /**
    * The default accessor for writing a value and listening to changes that is used by the
    * {@link NgModel}, {@link NgFormControl}, and {@link NgControlName} directives.
-   * 
+   *
    *  # Example
    *  ```
    *  <input type="text" [(ng-model)]="searchQuery">
    *  ```
    */
   class DefaultValueAccessor implements ControlValueAccessor {
-    
+
      cd: NgControl;
-    
+
      onChange: any;
-    
+
      onTouched: any;
-    
+
      renderer: Renderer;
-    
+
      elementRef: ElementRef;
-    
+
      writeValue(value: any): void;
-    
+
      ngClassUntouched: boolean;
-    
+
      ngClassTouched: boolean;
-    
+
      ngClassPristine: boolean;
-    
+
      ngClassDirty: boolean;
-    
+
      ngClassValid: boolean;
-    
+
      ngClassInvalid: boolean;
-    
+
      registerOnChange(fn: (_: any) => void): void;
-    
+
      registerOnTouched(fn: () => void): void;
   }
-  
+
 
   /**
    * The accessor for writing a value and listening to changes on a checkbox input element.
-   * 
+   *
    *  # Example
    *  ```
    *  <input type="checkbox" [ng-control]="rememberLogin">
    *  ```
    */
   class CheckboxControlValueAccessor implements ControlValueAccessor {
-    
+
      cd: NgControl;
-    
+
      onChange: any;
-    
+
      onTouched: any;
-    
+
      renderer: Renderer;
-    
+
      elementRef: ElementRef;
-    
+
      writeValue(value: any): void;
-    
+
      ngClassUntouched: boolean;
-    
+
      ngClassTouched: boolean;
-    
+
      ngClassPristine: boolean;
-    
+
      ngClassDirty: boolean;
-    
+
      ngClassValid: boolean;
-    
+
      ngClassInvalid: boolean;
-    
+
      registerOnChange(fn: (_: any) => {}): void;
-    
+
      registerOnTouched(fn: () => {}): void;
   }
-  
+
 
   /**
    * Marks <option> as dynamic, so Angular can be notified when options change.
-   * 
+   *
    * #Example:
-   * 
+   *
    * ```
    * <select ng-control="city">
    *   <option *ng-for="#c of cities" [value]="c"></option>
@@ -5371,95 +5375,95 @@ declare module ng {
    */
   class NgSelectOption {
   }
-  
+
 
   /**
    * The accessor for writing a value and listening to changes on a select element.
    */
   class SelectControlValueAccessor implements ControlValueAccessor {
-    
+
      cd: NgControl;
-    
+
      value: string;
-    
+
      onChange: any;
-    
+
      onTouched: any;
-    
+
      renderer: Renderer;
-    
+
      elementRef: ElementRef;
-    
+
      writeValue(value: any): void;
-    
+
      ngClassUntouched: boolean;
-    
+
      ngClassTouched: boolean;
-    
+
      ngClassPristine: boolean;
-    
+
      ngClassDirty: boolean;
-    
+
      ngClassValid: boolean;
-    
+
      ngClassInvalid: boolean;
-    
+
      registerOnChange(fn: () => any): void;
-    
+
      registerOnTouched(fn: () => any): void;
   }
-  
+
 
   /**
    * A list of all the form directives used as part of a `@View` annotation.
-   * 
+   *
    *  This is a shorthand for importing them each individually.
    */
   const FORM_DIRECTIVES : List<Type> ;
-  
+
 
   /**
    * Provides a set of validators used by form controls.
-   * 
+   *
    * # Example
-   * 
+   *
    * ```
    * var loginControl = new Control("", Validators.required)
    * ```
    */
   class Validators {
-    
+
      static required(c:Control): StringMap<string, boolean>;
-    
+
      static nullValidator(c: any): StringMap<string, boolean>;
-    
+
      static compose(validators: List<Function>): Function;
-    
+
      static group(c:ControlGroup): StringMap<string, boolean>;
-    
+
      static array(c:ControlArray): StringMap<string, boolean>;
   }
-  
+
   class NgValidator {
-    
+
      validator: Function;
   }
-  
+
   class NgRequiredValidator extends NgValidator {
-    
+
      validator: Function;
   }
-  
+
 
   /**
    * Creates a form object from a user-specified configuration.
-   * 
+   *
    * # Example
-   * 
+   *
    * ```
    * import {Component, View, bootstrap} from 'angular2/angular2';
    * import {FormBuilder, Validators, FORM_DIRECTIVES, ControlGroup} from 'angular2/forms';
-   * 
+   *
    * @Component({
    *   selector: 'login-comp',
    *   viewBindings: [
@@ -5470,7 +5474,7 @@ declare module ng {
    *   template: `
    *     <form [control-group]="loginForm">
    *       Login <input control="login">
-   * 
+   *
    *       <div control-group="passwordRetry">
    *         Password <input type="password" control="password">
    *         Confirm password <input type="password" control="passwordConfirmation">
@@ -5483,11 +5487,11 @@ declare module ng {
    * })
    * class LoginComp {
    *   loginForm: ControlGroup;
-   * 
+   *
    *   constructor(builder: FormBuilder) {
    *     this.loginForm = builder.group({
    *       login: ["", Validators.required],
-   * 
+   *
    *       passwordRetry: builder.group({
    *         password: ["", Validators.required],
    *         passwordConfirmation: ["", Validators.required]
@@ -5495,43 +5499,43 @@ declare module ng {
    *     });
    *   }
    * }
-   * 
+   *
    * bootstrap(LoginComp)
    * ```
-   * 
+   *
    * This example creates a {@link ControlGroup} that consists of a `login` {@link Control}, and a
    * nested
    * {@link ControlGroup} that defines a `password` and a `passwordConfirmation` {@link Control}:
-   * 
+   *
    * ```
    *  var loginForm = builder.group({
    *    login: ["", Validators.required],
-   * 
+   *
    *    passwordRetry: builder.group({
    *      password: ["", Validators.required],
    *      passwordConfirmation: ["", Validators.required]
    *    })
    *  });
-   * 
+   *
    *  ```
    */
   class FormBuilder {
-    
+
      group(controlsConfig: StringMap<string, any>, extra?: StringMap<string, any>): ControlGroup;
-    
+
      control(value: Object, validator?: Function): Control;
-    
+
      array(controlsConfig: List<any>, validator?: Function): ControlArray;
   }
-  
+
   const FORM_BINDINGS : List<Type> ;
-  
+
   class RenderDirectiveMetadata {
-    
+
      static DIRECTIVE_TYPE: any;
-    
+
      static COMPONENT_TYPE: any;
-    
+
      static create({id, selector, compileChildren, events, host, properties, readAttributes, type,
                  callOnDestroy, callOnChange, callOnCheck, callOnInit, callOnAllChangesDone,
                  changeDetection, exportAs}: {
@@ -5551,87 +5555,87 @@ declare module ng {
     changeDetection?: string,
     exportAs?: string
   }): RenderDirectiveMetadata;
-    
+
      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.
@@ -5640,15 +5644,15 @@ declare module ng {
      */
      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
@@ -5656,7 +5660,7 @@ declare module ng {
      * @return {RenderViewWithFragments} the created view including fragments
      */
      createRootHostView(hostProtoViewRef: RenderProtoViewRef, fragmentCount: number, hostElementSelector: string): RenderViewWithFragments;
-    
+
 
     /**
      * Creates a regular view out of the given ProtoView.
@@ -5664,187 +5668,187 @@ declare module ng {
      * synchronously even when dealing with webworkers!
      */
      createView(protoViewRef: RenderProtoViewRef, fragmentCount: number): RenderViewWithFragments;
-    
+
 
     /**
      * Destroys the given view after it has been dehydrated and detached
      */
      destroyView(viewRef: RenderViewRef): void;
-    
+
 
     /**
      * Attaches a fragment after another fragment.
      */
      attachFragmentAfterFragment(previousFragmentRef: RenderFragmentRef, fragmentRef: RenderFragmentRef): void;
-    
+
 
     /**
      * Attaches a fragment after an element.
      */
      attachFragmentAfterElement(elementRef: RenderElementRef, fragmentRef: RenderFragmentRef): void;
-    
+
 
     /**
      * Detaches a fragment.
      */
      detachFragment(fragmentRef: RenderFragmentRef): void;
-    
+
 
     /**
      * Hydrates a view after it has been attached. Hydration/dehydration is used for reusing views
      * inside of the view pool.
      */
      hydrateView(viewRef: RenderViewRef): void;
-    
+
 
     /**
      * Dehydrates a view after it has been attached. Hydration/dehydration is used for reusing views
      * inside of the view pool.
      */
      dehydrateView(viewRef: RenderViewRef): void;
-    
+
 
     /**
      * Returns the native element at the given location.
      * Attention: In a WebWorker scenario, this should always return null!
      */
      getNativeElementSync(location: RenderElementRef): any;
-    
+
 
     /**
      * Sets a property on an element.
      */
      setElementProperty(location: RenderElementRef, propertyName: string, propertyValue: any): void;
-    
+
 
     /**
      * Sets an attribute on an element.
      */
      setElementAttribute(location: RenderElementRef, attributeName: string, attributeValue: string): void;
-    
+
 
     /**
      * Sets a class on an element.
      */
      setElementClass(location: RenderElementRef, className: string, isAdd: boolean): void;
-    
+
 
     /**
      * Sets a style on an element.
      */
      setElementStyle(location: RenderElementRef, styleName: string, styleValue: string): void;
-    
+
 
     /**
      * Calls a method on an element.
      */
      invokeElementMethod(location: RenderElementRef, methodName: string, args: List<any>): void;
-    
+
 
     /**
      * Sets the value of a text node.
      */
      setText(viewRef: RenderViewRef, textNodeIndex: number, text: string): void;
-    
+
 
     /**
      * Sets the dispatcher for all events of the given view
      */
      setEventDispatcher(viewRef: RenderViewRef, dispatcher: RenderEventDispatcher): void;
   }
-  
+
 
   /**
    * Abstract reference to the element which can be marshaled across web-worker boundary.
-   * 
+   *
    * This interface is used by the Renderer API.
    */
   interface RenderElementRef {
-    
+
 
     /**
      * Reference to the `RenderViewRef` where the `RenderElementRef` is inside of.
      */
      renderView: RenderViewRef;
-    
+
 
     /**
      * Index of the element inside the `RenderViewRef`.
-     * 
+     *
      * This is used internally by the Angular framework to locate elements.
      */
      renderBoundElementIndex: number;
   }
-  
+
   class RenderViewRef {
   }
-  
+
   class RenderProtoViewRef {
   }
-  
+
   class RenderFragmentRef {
   }
-  
+
   class RenderViewWithFragments {
-    
+
      viewRef: RenderViewRef;
-    
+
      fragmentRefs: RenderFragmentRef[];
   }
-  
+
   class ViewDefinition {
-    
+
      componentId: string;
-    
+
      templateAbsUrl: string;
-    
+
      template: string;
-    
+
      directives: List<RenderDirectiveMetadata>;
-    
+
      styleAbsUrls: List<string>;
-    
+
      styles: List<string>;
-    
+
      encapsulation: ViewEncapsulation;
   }
-  
+
   const DOCUMENT : OpaqueToken ;
-  
+
 
   /**
    * A unique id (string) for an angular application.
    */
   const APP_ID : OpaqueToken ;
-  
+
 
   /**
    * Defines when a compiled template should be stored as a string
    * rather than keeping its Nodes to preserve memory.
    */
   const MAX_IN_MEMORY_ELEMENTS_PER_TEMPLATE : OpaqueToken ;
-  
+
 
   /**
    * Create trace scope.
-   * 
+   *
    * Scopes must be strictly nested and are analogous to stack frames, but
    * do not have to follow the stack frames. Instead it is recommended that they follow logical
    * nesting. You may want to use
    * [Event
    * Signatures](http://google.github.io/tracing-framework/instrumenting-code.html#custom-events)
    * as they are defined in WTF.
-   * 
+   *
    * Used to mark scope entry. The return value is used to leave the scope.
-   * 
+   *
    *     final myScope = wtfCreateScope('MyClass#myMethod(ascii someVal)');
-   * 
+   *
    *     someMethod() {
    *        var s = myScope('Foo'); // 'Foo' gets stored in tracing UI
    *        // DO SOME WORK HERE
    *        return wtfLeave(s, 123); // Return value 123
    *     }
-   * 
+   *
    * Note, adding try-finally block around the work to ensure that `wtfLeave` gets called can
    * negatively impact the performance of your application. For this reason we recommend that
    * you don't add them to ensure that `wtfLeave` gets called. In production `wtfLeave` is a noop and
@@ -5854,24 +5858,24 @@ declare module ng {
    * an exception is expected during normal execution while profiling.
    */
   var wtfCreateScope : WtfScopeFn ;
-  
+
 
   /**
    * Used to mark end of Scope.
-   * 
+   *
    * - `scope` to end.
    * - `returnValue` (optional) to be passed to the WTF.
-   * 
+   *
    * Returns the `returnValue for easy chaining.
    */
   var wtfLeave : <T>(scope: any, returnValue?: T) => T ;
-  
+
 
   /**
    * Used to mark Async start. Async are similar to scope but they don't have to be strictly nested.
    * The return value is used in the call to [endAsync]. Async ranges only work if WTF has been
    * enabled.
-   * 
+   *
    *     someMethod() {
    *        var s = wtfStartTimeRange('HTTP:GET', 'some.url');
    *        var future = new Future.delay(5).then((_) {
@@ -5880,7 +5884,7 @@ declare module ng {
    *     }
    */
   var wtfStartTimeRange : (rangeType: string, action: string) => any ;
-  
+
 
   /**
    * Ends a async time range operation.
@@ -5888,33 +5892,31 @@ declare module ng {
    * enabled.
    */
   var wtfEndTimeRange : (range: any) => void ;
-  
+
   interface WtfScopeFn {
-    
+
      (arg0?: any, arg1?: any): any;
-  
+
   }
-  
+
   var ChangeDetectorRef: InjectableReference;
-  
+
   var ApplicationRef: InjectableReference;
-  
+
   var Compiler: InjectableReference;
-  
+
   var AppViewManager: InjectableReference;
-  
+
   var ViewRef: InjectableReference;
-  
+
   var ProtoViewRef: InjectableReference;
-  
+
   var ViewContainerRef: InjectableReference;
-  
+
   var ComponentRef: InjectableReference;
-  
+
 }
 
 declare module "angular2/angular2" {
   export = ng;
 }
-
-
diff --git a/async/asyncamd-tests.ts b/async/asyncamd-tests.ts
index 4618a67bf..fc1c25460 100644
--- a/async/asyncamd-tests.ts
+++ b/async/asyncamd-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./async.d.ts" />
+
 import async = require("async");
 
-async.map(["a", "b", "c"], (item, cb) => cb(null, [item.toUpperCase()]), (err, results) => { });
\ No newline at end of file
+async.map(["a", "b", "c"], (item, cb) => cb(null, [item.toUpperCase()]), (err, results) => { });
diff --git a/bowser/bowser-tests.ts b/bowser/bowser-tests.ts
index 07d9f18cb..600618765 100644
--- a/bowser/bowser-tests.ts
+++ b/bowser/bowser-tests.ts
@@ -1,7 +1,9 @@
+/// <reference path="./bowser.d.ts" />
+
 import Bowser = require('bowser');
 
 Bowser.msedge === true;
 Bowser.test(['msie']) === true;
 Bowser.a === Bowser.c;
 Bowser.osversion > 10;
-Bowser.osversion === '10.1A';
\ No newline at end of file
+Bowser.osversion === '10.1A';
diff --git a/breeze/breeze-tests.ts b/breeze/breeze-tests.ts
index f309462af..1f9c87dfa 100644
--- a/breeze/breeze-tests.ts
+++ b/breeze/breeze-tests.ts
@@ -11,7 +11,7 @@ function test_dataType() {
     var x = typ.parentEnum === <breeze.core.IEnum> breeze.DataType;
     var isFalse = breeze.DataType.contains(breeze.DataType.Double);
     var dt = breeze.DataType.fromName("Decimal");
-    
+
 }
 
 function test_dataProperty() {
@@ -33,7 +33,7 @@ function test_dataService() {
     var em = new breeze.EntityManager({
         dataService: ds
     });
-    
+
 }
 
 function test_entityAspect() {
@@ -69,7 +69,7 @@ function test_entityAspect() {
         var errorsAdded = validationChangeArgs.added;
         var errorsCleared = validationChangeArgs.removed;
     });
-    
+
 }
 
 function test_entityKey() {
@@ -132,7 +132,7 @@ function test_entityManager() {
         serviceName: "breeze/NorthwindIBModel",
         metadataStore: metadataStore
     });
-    
+
     return new breeze.QueryOptions({
         mergeStrategy: null,
         fetchStrategy: this.fetchStrategy
@@ -157,7 +157,7 @@ function test_entityManager() {
 
     var cust2 = em1.createEntity("Customer", { companyName: "foo" });
     var cust3 = em1.createEntity("foo", { xxx: 3 }, breeze.EntityState.Added);
-    
+
     em1.attachEntity(cust1, breeze.EntityState.Added);
     em1.clear();
     var em2 = em1.createEmptyCopy();
@@ -246,7 +246,7 @@ function test_entityManager() {
     var custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     if (em1.hasChanges([custType, orderType])) { };
-    
+
     var bundle = em1.exportEntities();
     window.localStorage.setItem("myEntityManager", bundle);
     var bundleFromStorage = window.localStorage.getItem("myEntityManager");
@@ -434,7 +434,7 @@ function test_entityState() {
     return es === breeze.EntityState.Unchanged;
     var es = anEntity.entityAspect.entityState;
     return es.isUnchangedOrModified();
-    
+
     return es === breeze.EntityState.Unchanged || es === breeze.EntityState.Modified;
 }
 
@@ -443,12 +443,14 @@ function test_entityType() {
     var myEntityType: breeze.EntityType;
     var dataProperty1: breeze.DataProperty, dataProperty2: breeze.DataProperty, navigationProperty1: breeze.DataProperty;
     var em1: breeze.EntityManager;
+    /* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
     var entityManager = new breeze.EntityType({
         metadataStore: myMetadataStore,
         serviceName: "breeze/NorthwindIBModel",
         name: "person",
         namespace: "myAppNamespace"
     });
+     */
     myEntityType.addProperty(dataProperty1);
     myEntityType.addProperty(dataProperty2);
     myEntityType.addProperty(navigationProperty1);
@@ -759,9 +761,11 @@ function test_validator() {
     orderType = <breeze.EntityType> em1.metadataStore.getEntityType("Order");
     var orderDateProperty = orderType.getProperty("OrderDate");
     orderDateProperty.validators.push(breeze.Validator.date());
+    /* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
     var v0 = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" });
     v0.validate("adasdfasdf");
     var errMessage = v0.getMessage();
+     */
     custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
     var customerIdProperty = custType.getProperty("CustomerID");
     customerIdProperty.validators.push(breeze.Validator.guid());
@@ -788,6 +792,7 @@ function test_validator() {
     regionProperty.validators.push(breeze.Validator.string());
     custType = <breeze.EntityType> em1.metadataStore.getEntityType("Customer");
      regionProperty = custType.getProperty("Region");
+    /* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
     regionProperty.validators.push(breeze.Validator.stringLength({ minLength: 2, maxLength: 5 }));
     var validator = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" });
     var result = validator.validate("asdf");
@@ -796,6 +801,7 @@ function test_validator() {
     var errMsg = result.errorMessage;
     var context = result.context;
     var sameValidator = result.validator;
+     */
     var valFn = function (v: any) {
         if (v == null) return true;
         return (v.substr(0,2) === "US");
diff --git a/cheerio/cheerio-tests.ts b/cheerio/cheerio-tests.ts
index c41939a30..2f7b9f948 100644
--- a/cheerio/cheerio-tests.ts
+++ b/cheerio/cheerio-tests.ts
@@ -29,7 +29,7 @@ $ = cheerio.load(html, {
     normalizeWhitespace: true,
     xmlMode: true,
     decodeEntities: true,
-    lowercaseTags: true,
+    lowerCaseTags: true,
     lowerCaseAttributeNames: true,
     recognizeCDATA: true,
     recognizeSelfClosing: true
diff --git a/clone/clone-tests.ts b/clone/clone-tests.ts
index 6a25fb7c3..8cb0681fd 100644
--- a/clone/clone-tests.ts
+++ b/clone/clone-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./clone.d.ts" />
+
 import clone = require("clone");
 
 var original = {
diff --git a/connect-slashes/connect-slashes-tests.ts b/connect-slashes/connect-slashes-tests.ts
index 6fc66bbc0..f4c8ac965 100644
--- a/connect-slashes/connect-slashes-tests.ts
+++ b/connect-slashes/connect-slashes-tests.ts
@@ -1,4 +1,4 @@
-/// <reference path="../express/express.d.ts"/>
+/// <reference path="./connect-slashes.d.ts"/>
 
 import express = require('express');
 import slashes = require('connect-slashes');
diff --git a/contextjs/contextjs-tests.ts b/contextjs/contextjs-tests.ts
index 0b0d55d09..abfc643ef 100644
--- a/contextjs/contextjs-tests.ts
+++ b/contextjs/contextjs-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./contextjs.d.ts" />
+
 import context = require("contextjs");
 
 context.init();
diff --git a/convert-source-map/convert-source-map-tests.ts b/convert-source-map/convert-source-map-tests.ts
index a89cfb712..1701e0065 100644
--- a/convert-source-map/convert-source-map-tests.ts
+++ b/convert-source-map/convert-source-map-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./convert-source-map.d.ts" />
+
 import convert = require("convert-source-map");
 
 var json = convert
@@ -10,4 +12,4 @@ var modified = convert
 	.toJSON();
 
 console.log(json);
-console.log(modified);
\ No newline at end of file
+console.log(modified);
diff --git a/core-js/core-js.d.ts b/core-js/core-js.d.ts
index 476ab9916..9c492e433 100644
--- a/core-js/core-js.d.ts
+++ b/core-js/core-js.d.ts
@@ -22,13 +22,13 @@ declare type PropertyKey = string | number | symbol;
 
 // #############################################################################################
 // ECMAScript 6: Object & Function
-// Modules: es6.object.assign, es6.object.is, es6.object.set-prototype-of, 
+// Modules: es6.object.assign, es6.object.is, es6.object.set-prototype-of,
 //          es6.object.to-string, es6.function.name and es6.function.has-instance.
 // #############################################################################################
- 
+
 interface ObjectConstructor {
     /**
-      * Copy the values of all of the enumerable own properties from one or more source objects to a 
+      * Copy the values of all of the enumerable own properties from one or more source objects to a
       * target object. Returns the target object.
       * @param target The target object to copy to.
       * @param sources One or more source objects to copy properties from.
@@ -57,10 +57,10 @@ interface Function {
       */
     name: string;
 
-    /** 
-      * Determines if a constructor object recognizes an object as one of the 
+    /**
+      * Determines if a constructor object recognizes an object as one of the
       * constructor’s instances.
-      * @param value The object to test. 
+      * @param value The object to test.
       */
     [Symbol.hasInstance](value: any): boolean;
 }
@@ -71,30 +71,25 @@ interface Function {
 //          and es6.array.find-index
 // #############################################################################################
 
-interface ArrayLike<T> {
-    length: number;
-    [n: number]: T;
-}
-
 interface Array<T> {
-    /** 
-      * Returns the value of the first element in the array where predicate is true, and undefined 
+    /**
+      * Returns the value of the first element in the array where predicate is true, and undefined
       * otherwise.
-      * @param predicate find calls predicate once for each element of the array, in ascending 
-      * order, until it finds one where predicate returns true. If such an element is found, find 
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
       * immediately returns that element value. Otherwise, find returns undefined.
-      * @param thisArg If provided, it will be used as the this value for each invocation of 
+      * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
     find(predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): T;
 
-    /** 
-      * Returns the index of the first element in the array where predicate is true, and undefined 
+    /**
+      * Returns the index of the first element in the array where predicate is true, and undefined
       * otherwise.
-      * @param predicate find calls predicate once for each element of the array, in ascending 
-      * order, until it finds one where predicate returns true. If such an element is found, find 
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
       * immediately returns that element value. Otherwise, find returns undefined.
-      * @param thisArg If provided, it will be used as the this value for each invocation of 
+      * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
     findIndex(predicate: (value: T) => boolean, thisArg?: any): number;
@@ -102,21 +97,21 @@ interface Array<T> {
     /**
       * Returns the this object after filling the section identified by start and end with value
       * @param value value to fill array section with
-      * @param start index to start filling the array at. If start is negative, it is treated as 
-      * length+start where length is the length of the array. 
-      * @param end index to stop filling the array at. If end is negative, it is treated as 
+      * @param start index to start filling the array at. If start is negative, it is treated as
+      * length+start where length is the length of the array.
+      * @param end index to stop filling the array at. If end is negative, it is treated as
       * length+end.
       */
     fill(value: T, start?: number, end?: number): T[];
 
-    /** 
+    /**
       * Returns the this object after copying a section of the array identified by start and end
       * to the same array starting at position target
-      * @param target If target is negative, it is treated as length+target where length is the 
-      * length of the array. 
-      * @param start If start is negative, it is treated as length+start. If end is negative, it 
+      * @param target If target is negative, it is treated as length+target where length is the
+      * length of the array.
+      * @param start If start is negative, it is treated as length+start. If end is negative, it
       * is treated as length+end.
-      * @param end If not specified, length of the this object is used as its default value. 
+      * @param end If not specified, length of the this object is used as its default value.
       */
     copyWithin(target: number, start: number, end?: number): T[];
 
@@ -161,47 +156,47 @@ interface ArrayConstructor {
 
 // #############################################################################################
 // ECMAScript 6: String & RegExp
-// Modules: es6.string.from-code-point, es6.string.raw, es6.string.code-point-at, 
-//          es6.string.ends-with, es6.string.includes, es6.string.repeat, 
+// Modules: es6.string.from-code-point, es6.string.raw, es6.string.code-point-at,
+//          es6.string.ends-with, es6.string.includes, es6.string.repeat,
 //          es6.string.starts-with, and es6.regexp
 // #############################################################################################
 
 interface String {
     /**
-      * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point 
-      * value of the UTF-16 encoded code point starting at the string element at position pos in 
-      * the String resulting from converting this object to a String. 
-      * If there is no element at that position, the result is undefined. 
+      * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point
+      * value of the UTF-16 encoded code point starting at the string element at position pos in
+      * the String resulting from converting this object to a String.
+      * If there is no element at that position, the result is undefined.
       * If a valid UTF-16 surrogate pair does not begin at pos, the result is the code unit at pos.
       */
     codePointAt(pos: number): number;
 
     /**
-      * Returns true if searchString appears as a substring of the result of converting this 
-      * object to a String, at one or more positions that are 
+      * Returns true if searchString appears as a substring of the result of converting this
+      * object to a String, at one or more positions that are
       * greater than or equal to position; otherwise, returns false.
-      * @param searchString search string 
+      * @param searchString search string
       * @param position If position is undefined, 0 is assumed, so as to search all of the String.
       */
     includes(searchString: string, position?: number): boolean;
 
     /**
-      * Returns true if the sequence of elements of searchString converted to a String is the 
-      * same as the corresponding elements of this object (converted to a String) starting at 
+      * Returns true if the sequence of elements of searchString converted to a String is the
+      * same as the corresponding elements of this object (converted to a String) starting at
       * endPosition – length(this). Otherwise returns false.
       */
     endsWith(searchString: string, endPosition?: number): boolean;
 
     /**
-      * Returns a String value that is made from count copies appended together. If count is 0, 
+      * Returns a String value that is made from count copies appended together. If count is 0,
       * T is the empty String is returned.
       * @param count number of copies to append
       */
     repeat(count: number): string;
 
     /**
-      * Returns true if the sequence of elements of searchString converted to a String is the 
-      * same as the corresponding elements of this object (converted to a String) starting at 
+      * Returns true if the sequence of elements of searchString converted to a String is the
+      * same as the corresponding elements of this object (converted to a String) starting at
       * position. Otherwise returns false.
       */
     startsWith(searchString: string, position?: number): boolean;
@@ -216,7 +211,7 @@ interface StringConstructor {
 
     /**
       * String.raw is intended for use as a tag function of a Tagged Template String. When called
-      * as such the first argument will be a well formed template call site object and the rest 
+      * as such the first argument will be a well formed template call site object and the rest
       * parameter will contain the substitution values.
       * @param template A well-formed template string call site representation.
       * @param substitutions A set of substitution values.
@@ -248,14 +243,14 @@ interface RegExp {
 interface NumberConstructor {
     /**
       * The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1
-      * that is representable as a Number value, which is approximately: 
+      * that is representable as a Number value, which is approximately:
       * 2.2204460492503130808472633361816 x 10‍−‍16.
       */
     EPSILON: number;
 
     /**
       * Returns true if passed value is finite.
-      * Unlike the global isFininte, Number.isFinite doesn't forcibly convert the parameter to a 
+      * Unlike the global isFininte, Number.isFinite doesn't forcibly convert the parameter to a
       * number. Only finite values of the type number, result in true.
       * @param number A numeric value.
       */
@@ -268,7 +263,7 @@ interface NumberConstructor {
     isInteger(number: number): boolean;
 
     /**
-      * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a 
+      * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a
       * number). Unlike the global isNaN(), Number.isNaN() doesn't forcefully convert the parameter
       * to a number. Only values of the type number, that are also NaN, result in true.
       * @param number A numeric value.
@@ -281,30 +276,30 @@ interface NumberConstructor {
       */
     isSafeInteger(number: number): boolean;
 
-    /** 
-      * The value of the largest integer n such that n and n + 1 are both exactly representable as 
-      * a Number value. 
+    /**
+      * The value of the largest integer n such that n and n + 1 are both exactly representable as
+      * a Number value.
       * The value of Number.MIN_SAFE_INTEGER is 9007199254740991 2^53 − 1.
       */
     MAX_SAFE_INTEGER: number;
 
-    /** 
-      * The value of the smallest integer n such that n and n − 1 are both exactly representable as 
-      * a Number value. 
+    /**
+      * The value of the smallest integer n such that n and n − 1 are both exactly representable as
+      * a Number value.
       * The value of Number.MIN_SAFE_INTEGER is −9007199254740991 (−(2^53 − 1)).
       */
     MIN_SAFE_INTEGER: number;
 
     /**
-      * Converts a string to a floating-point number. 
-      * @param string A string that contains a floating-point number. 
+      * Converts a string to a floating-point number.
+      * @param string A string that contains a floating-point number.
       */
     parseFloat(string: string): number;
 
     /**
       * Converts A string to an integer.
       * @param s A string to convert into a number.
-      * @param radix A value between 2 and 36 that specifies the base of the number in numString. 
+      * @param radix A value between 2 and 36 that specifies the base of the number in numString.
       * If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal.
       * All other strings are considered decimal.
       */
@@ -350,7 +345,7 @@ interface Math {
     log1p(x: number): number;
 
     /**
-      * Returns the result of (e^x - 1) of x (e raised to the power of x, where e is the base of 
+      * Returns the result of (e^x - 1) of x (e raised to the power of x, where e is the base of
       * the natural logarithms).
       * @param x A numeric expression.
       */
@@ -436,8 +431,8 @@ interface Symbol {
 }
 
 interface SymbolConstructor {
-    /** 
-      * A reference to the prototype. 
+    /**
+      * A reference to the prototype.
       */
     prototype: Symbol;
 
@@ -448,14 +443,14 @@ interface SymbolConstructor {
     (description?: string|number): symbol;
 
     /**
-      * Returns a Symbol object from the global symbol registry matching the given key if found. 
+      * Returns a Symbol object from the global symbol registry matching the given key if found.
       * Otherwise, returns a new symbol with this key.
       * @param key key to search for.
       */
     for(key: string): symbol;
 
     /**
-      * Returns a key from the global symbol registry matching the given Symbol if found. 
+      * Returns a key from the global symbol registry matching the given Symbol if found.
       * Otherwise, returns a undefined.
       * @param sym Symbol to find the key for.
       */
@@ -463,72 +458,72 @@ interface SymbolConstructor {
 
     // Well-known Symbols
 
-    /** 
-      * A method that determines if a constructor object recognizes an object as one of the 
-      * constructor’s instances. Called by the semantics of the instanceof operator. 
+    /**
+      * A method that determines if a constructor object recognizes an object as one of the
+      * constructor’s instances. Called by the semantics of the instanceof operator.
       */
     hasInstance: symbol;
 
-    /** 
+    /**
       * A Boolean value that if true indicates that an object should flatten to its array elements
       * by Array.prototype.concat.
       */
     isConcatSpreadable: symbol;
 
-    /** 
-      * A method that returns the default iterator for an object. Called by the semantics of the 
+    /**
+      * A method that returns the default iterator for an object. Called by the semantics of the
       * for-of statement.
       */
     iterator: symbol;
 
     /**
-      * A regular expression method that matches the regular expression against a string. Called 
-      * by the String.prototype.match method. 
+      * A regular expression method that matches the regular expression against a string. Called
+      * by the String.prototype.match method.
       */
     match: symbol;
 
-    /** 
-      * A regular expression method that replaces matched substrings of a string. Called by the 
+    /**
+      * A regular expression method that replaces matched substrings of a string. Called by the
       * String.prototype.replace method.
       */
     replace: symbol;
 
     /**
-      * A regular expression method that returns the index within a string that matches the 
+      * A regular expression method that returns the index within a string that matches the
       * regular expression. Called by the String.prototype.search method.
       */
     search: symbol;
 
-    /** 
-      * A function valued property that is the constructor function that is used to create 
+    /**
+      * A function valued property that is the constructor function that is used to create
       * derived objects.
       */
     species: symbol;
 
     /**
-      * A regular expression method that splits a string at the indices that match the regular 
+      * A regular expression method that splits a string at the indices that match the regular
       * expression. Called by the String.prototype.split method.
       */
     split: symbol;
 
-    /** 
+    /**
       * A method that converts an object to a corresponding primitive value.Called by the ToPrimitive
       * abstract operation.
       */
     toPrimitive: symbol;
 
-    /** 
+    /**
       * A String value that is used in the creation of the default string description of an object.
       * Called by the built-in method Object.prototype.toString.
       */
     toStringTag: symbol;
 
-    /** 
-      * An Object whose own property names are property names that are excluded from the with 
+    /**
+      * An Object whose own property names are property names that are excluded from the with
       * environment bindings of the associated objects.
       */
     unscopables: symbol;
-    
+
     /**
       * Non-standard. Use simple mode for core-js symbols. See https://github.com/zloirock/core-js/#caveats-when-using-symbol-polyfill
       */
@@ -544,12 +539,12 @@ declare var Symbol: SymbolConstructor;
 
 interface Object {
     /**
-      * Determines whether an object has a property with the specified name. 
+      * Determines whether an object has a property with the specified name.
       * @param v A property name.
       */
     hasOwnProperty(v: PropertyKey): boolean;
 
-    /** 
+    /**
       * Determines whether a specified property is enumerable.
       * @param v A property name.
       */
@@ -564,17 +559,17 @@ interface ObjectConstructor {
     getOwnPropertySymbols(o: any): symbol[];
 
     /**
-      * Gets the own property descriptor of the specified object. 
-      * An own property descriptor is one that is defined directly on the object and is not 
-      * inherited from the object's prototype. 
+      * Gets the own property descriptor of the specified object.
+      * An own property descriptor is one that is defined directly on the object and is not
+      * inherited from the object's prototype.
       * @param o Object that contains the property.
       * @param p Name of the property.
     */
     getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
 
     /**
-      * Adds a property to an object, or modifies attributes of an existing property. 
-      * @param o Object on which to add or modify the property. This can be a native JavaScript 
+      * Adds a property to an object, or modifies attributes of an existing property.
+      * @param o Object on which to add or modify the property. This can be a native JavaScript
       * object (that is, a user-defined object or a built in object) or a DOM object.
       * @param p The property name.
       * @param attributes Descriptor for the property. It can be for a data property or an accessor
@@ -693,17 +688,17 @@ interface Array<T> {
     /** Iterator */
     [Symbol.iterator](): IterableIterator<T>;
 
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIterator<[number, T]>;
 
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIterator<number>;
 
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIterator<T>;
@@ -776,21 +771,21 @@ interface Promise<T> {
 }
 
 interface PromiseConstructor {
-    /** 
-      * A reference to the prototype. 
+    /**
+      * A reference to the prototype.
       */
     prototype: Promise<any>;
 
     /**
      * Creates a new Promise.
-     * @param executor A callback used to initialize the promise. This callback is passed two arguments: 
-     * a resolve callback used resolve the promise with a value or the result of another promise, 
+     * @param executor A callback used to initialize the promise. This callback is passed two arguments:
+     * a resolve callback used resolve the promise with a value or the result of another promise,
      * and a reject callback used to reject the promise with a provided reason or error.
      */
     new <T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
 
     /**
-     * Creates a Promise that is resolved with an array of results when all of the provided Promises 
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
      * resolve, or rejected when any Promise is rejected.
      * @param values An array of Promises.
      * @returns A new Promise.
@@ -798,7 +793,7 @@ interface PromiseConstructor {
     all<T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>;
 
     /**
-     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved 
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
      * or rejected.
      * @param values An array of Promises.
      * @returns A new Promise.
@@ -859,7 +854,7 @@ declare module Reflect {
 
 // #############################################################################################
 // ECMAScript 7
-// Modules: es7.array.includes, es7.string.at, es7.string.lpad, es7.string.rpad, 
+// Modules: es7.array.includes, es7.string.at, es7.string.lpad, es7.string.rpad,
 //          es7.object.to-array, es7.object.get-own-property-descriptors, es7.regexp.escape,
 //          es7.map.to-json, and es7.set.to-json
 // #############################################################################################
@@ -918,14 +913,14 @@ interface ArrayConstructor {
       */
     join<T>(array: ArrayLike<T>, separator?: string): string;
     /**
-      * Reverses the elements in an Array. 
+      * Reverses the elements in an Array.
       */
     reverse<T>(array: ArrayLike<T>): T[];
     /**
       * Removes the first element from an array and returns it.
       */
     shift<T>(array: ArrayLike<T>): T;
-    /** 
+    /**
       * Returns a section of an array.
       * @param start The beginning of the specified portion of the array.
       * @param end The end of the specified portion of the array.
@@ -988,21 +983,21 @@ interface ArrayConstructor {
 
     /**
       * Performs the specified action for each element in an array.
-      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. 
+      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
     forEach<T>(array: ArrayLike<T>, callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
 
     /**
       * Calls a defined callback function on each element of an array, and returns an array that contains the results.
-      * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. 
+      * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
     map<T, U>(array: ArrayLike<T>, callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
 
     /**
-      * Returns the elements of an array that meet the condition specified in a callback function. 
-      * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array. 
+      * Returns the elements of an array that meet the condition specified in a callback function.
+      * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array.
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
     filter<T>(array: ArrayLike<T>, callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];
@@ -1021,53 +1016,53 @@ interface ArrayConstructor {
       */
     reduce<T>(array: ArrayLike<T>, callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
 
-    /** 
+    /**
       * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
-      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. 
+      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
       * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
       */
     reduceRight<T, U>(array: ArrayLike<T>, callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
 
-    /** 
+    /**
       * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
-      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. 
+      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
       * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
       */
     reduceRight<T>(array: ArrayLike<T>, callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
 
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
 
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys<T>(array: ArrayLike<T>): IterableIterator<number>;
 
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values<T>(array: ArrayLike<T>): IterableIterator<T>;
 
-    /** 
-      * Returns the value of the first element in the array where predicate is true, and undefined 
+    /**
+      * Returns the value of the first element in the array where predicate is true, and undefined
       * otherwise.
-      * @param predicate find calls predicate once for each element of the array, in ascending 
-      * order, until it finds one where predicate returns true. If such an element is found, find 
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
       * immediately returns that element value. Otherwise, find returns undefined.
-      * @param thisArg If provided, it will be used as the this value for each invocation of 
+      * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
     find<T>(array: ArrayLike<T>, predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): T;
 
-    /** 
-      * Returns the index of the first element in the array where predicate is true, and undefined 
+    /**
+      * Returns the index of the first element in the array where predicate is true, and undefined
       * otherwise.
-      * @param predicate find calls predicate once for each element of the array, in ascending 
-      * order, until it finds one where predicate returns true. If such an element is found, find 
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
       * immediately returns that element value. Otherwise, find returns undefined.
-      * @param thisArg If provided, it will be used as the this value for each invocation of 
+      * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
     findIndex<T>(array: ArrayLike<T>, predicate: (value: T) => boolean, thisArg?: any): number;
@@ -1075,21 +1070,21 @@ interface ArrayConstructor {
     /**
       * Returns the this object after filling the section identified by start and end with value
       * @param value value to fill array section with
-      * @param start index to start filling the array at. If start is negative, it is treated as 
-      * length+start where length is the length of the array. 
-      * @param end index to stop filling the array at. If end is negative, it is treated as 
+      * @param start index to start filling the array at. If start is negative, it is treated as
+      * length+start where length is the length of the array.
+      * @param end index to stop filling the array at. If end is negative, it is treated as
       * length+end.
       */
     fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
 
-    /** 
+    /**
       * Returns the this object after copying a section of the array identified by start and end
       * to the same array starting at position target
-      * @param target If target is negative, it is treated as length+target where length is the 
-      * length of the array. 
-      * @param start If start is negative, it is treated as length+start. If end is negative, it 
+      * @param target If target is negative, it is treated as length+target where length is the
+      * length of the array.
+      * @param start If start is negative, it is treated as length+start. If end is negative, it
       * is treated as length+end.
-      * @param end If not specified, length of the this object is used as its default value. 
+      * @param end If not specified, length of the this object is used as its default value.
       */
     copyWithin<T>(array: ArrayLike<T>, target: number, start: number, end?: number): T[];
 
@@ -1113,7 +1108,7 @@ interface ObjectConstructor {
       * Non-standard.
       */
     classof(value: any): string;
-    
+
     /**
       * Non-standard.
       */
@@ -1477,13 +1472,13 @@ declare module core {
 }
 
 declare module "core-js" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/shim" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/core" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/core/$for" {
     import $for = core.$for;
@@ -2149,10 +2144,10 @@ declare module "core-js/fn/symbol/unscopables" {
     export = unscopables;
 }
 declare module "core-js/es5" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/es6" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/es6/array" {
     var Array: typeof core.Array;
@@ -2211,7 +2206,7 @@ declare module "core-js/es6/weak-set" {
     export = WeakSet;
 }
 declare module "core-js/es7" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/es7/array" {
     var Array: typeof core.Array;
@@ -2238,32 +2233,32 @@ declare module "core-js/es7/string" {
     export = String;
 }
 declare module "core-js/js" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/js/array" {
     var Array: typeof core.Array;
     export = Array;
 }
 declare module "core-js/web" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/web/dom" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/web/immediate" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/web/timers" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/shim" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/core" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/core/$for" {
     import $for = core.$for;
@@ -2928,10 +2923,10 @@ declare module "core-js/libary/fn/symbol/unscopables" {
     export = unscopables;
 }
 declare module "core-js/libary/es5" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/es6" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/es6/array" {
     var Array: typeof core.Array;
@@ -2990,7 +2985,7 @@ declare module "core-js/libary/es6/weak-set" {
     export = WeakSet;
 }
 declare module "core-js/libary/es7" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/es7/array" {
     var Array: typeof core.Array;
@@ -3017,21 +3012,21 @@ declare module "core-js/libary/es7/string" {
     export = String;
 }
 declare module "core-js/libary/js" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/js/array" {
     var Array: typeof core.Array;
     export = Array;
 }
 declare module "core-js/libary/web" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/web/dom" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/web/immediate" {
-    export = core; 
+    export = core;
 }
 declare module "core-js/libary/web/timers" {
-    export = core; 
+    export = core;
 }
diff --git a/devextreme/dx.devextreme.d.ts b/devextreme/dx.devextreme.d.ts
index ac0639b0a..00f2d340b 100644
--- a/devextreme/dx.devextreme.d.ts
+++ b/devextreme/dx.devextreme.d.ts
@@ -1869,7 +1869,7 @@ declare module DevExpress.ui {
     /** A container widget used to arrange inner elements. */
     export class dxBox extends CollectionWidget {
         constructor(element: JQuery, options?: dxBoxOptions);
-        constructor(element: Element, options?: dxBoxOptions);    
+        constructor(element: Element, options?: dxBoxOptions);
     }
     export interface dxResponsiveBoxOptions extends CollectionWidgetOptions {
         /** Specifies the collection of rows for the grid used to position layout elements. */
@@ -3041,7 +3041,7 @@ declare module DevExpress.ui {
         lookup?: {
             /** Specifies whether or not a user can nullify values of a lookup column. */
             allowClearing?: boolean;
-            /** 
+            /**
              * Specifies the data source providing data for a lookup column.
              */
             dataSource?: any;
@@ -3076,6 +3076,9 @@ declare module DevExpress.ui {
         showInColumnChooser?: boolean;
         /** Specifies the identifier of the column. */
         name?: string;
+        // NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
+        text?: string;
+        value?: any;
     }
     export interface dxDataGridOptions extends WidgetOptions {
         /** Specifies whether the outer borders of the grid are visible or not. */
@@ -3171,7 +3174,7 @@ declare module DevExpress.ui {
                 cancel?: string;
             }
         };
-        /** 
+        /**
          * An array of grid columns.
          */
         columns?: dxDataGridColumn[];
@@ -3271,7 +3274,7 @@ declare module DevExpress.ui {
             autoExpandAll?: boolean;
             /** Specifies the message displayed in a group row when the corresponding group is continued from the previous page. */
             groupContinuedMessage?: string;
-            /** 
+            /**
              * Specifies the message displayed in a group row when the corresponding group continues on the next page.
              */
             groupContinuesMessage?: string;
@@ -3653,7 +3656,7 @@ declare module DevExpress.ui {
         removeRow(rowIndex: number): void;
         /** Saves changes made in a grid. */
         saveEditData(): void;
-        /** 
+        /**
          * Searches grid records by a search string.
          */
         searchByText(text: string): void;
@@ -5385,7 +5388,7 @@ declare module DevExpress.viz.charts {
         /** Specifies whether a single series or multiple series can be selected in the chart. */
         seriesSelectionMode?: string;
         /** Specifies how the chart must behave when series point labels overlap. */
-        resolveLabelOverlapping?: string; 
+        resolveLabelOverlapping?: string;
     }
     export interface Legend extends AdvancedLegend {
         /** Specifies whether the legend is located outside or inside the chart's plot. */
@@ -5580,7 +5583,7 @@ declare module DevExpress.viz.charts {
         onLegendClick?: any;
         legendClick?: any;
         /** Specifies how the chart must behave when series point labels overlap. */
-        resolveLabelOverlapping?: string; 
+        resolveLabelOverlapping?: string;
     }
     /** A circular chart widget for HTML JS applications. */
     export class dxPieChart extends BaseChart {
@@ -5952,7 +5955,7 @@ declare module DevExpress.viz.rangeSelector {
         behavior?: {
             /** Indicates whether or not you can swap sliders. */
             allowSlidersSwap?: boolean;
-            /** 
+            /**
 Indicates whether or not animation is enabled.
  */
             animationEnabled?: boolean;
@@ -6067,7 +6070,7 @@ Indicates whether or not animation is enabled.
             maxRange?: any;
             /** Specifies the number of minor ticks between neighboring major ticks. */
             minorTickCount?: number;
-            /** 
+            /**
 Specifies an interval between minor ticks.
  */
             minorTickInterval?: any;
diff --git a/dragula/dragula-amd-tests.ts b/dragula/dragula-amd-tests.ts
index 99cb5e043..0dcca91e2 100644
--- a/dragula/dragula-amd-tests.ts
+++ b/dragula/dragula-amd-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./dragula.d.ts" />
+
 import dragula = require("dragula");
 
 // containers
diff --git a/es6-shim/es6-shim.d.ts b/es6-shim/es6-shim.d.ts
index cff5a9b7e..30621b372 100644
--- a/es6-shim/es6-shim.d.ts
+++ b/es6-shim/es6-shim.d.ts
@@ -12,7 +12,7 @@ interface IteratorResult<T> {
 
 interface IterableShim<T> {
     /**
-      * Shim for an ES6 iterable. Not intended for direct use by user code. 
+      * Shim for an ES6 iterable. Not intended for direct use by user code.
       */
     "_es6-shim iterator_"(): Iterator<T>;
 }
@@ -39,7 +39,7 @@ interface StringConstructor {
 
     /**
       * String.raw is intended for use as a tag function of a Tagged Template String. When called
-      * as such the first argument will be a well formed template call site object and the rest 
+      * as such the first argument will be a well formed template call site object and the rest
       * parameter will contain the substitution values.
       * @param template A well-formed template string call site representation.
       * @param substitutions A set of substitution values.
@@ -49,40 +49,40 @@ interface StringConstructor {
 
 interface String {
     /**
-      * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point 
-      * value of the UTF-16 encoded code point starting at the string element at position pos in 
-      * the String resulting from converting this object to a String. 
-      * If there is no element at that position, the result is undefined. 
+      * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point
+      * value of the UTF-16 encoded code point starting at the string element at position pos in
+      * the String resulting from converting this object to a String.
+      * If there is no element at that position, the result is undefined.
       * If a valid UTF-16 surrogate pair does not begin at pos, the result is the code unit at pos.
       */
     codePointAt(pos: number): number;
 
     /**
-      * Returns true if searchString appears as a substring of the result of converting this 
-      * object to a String, at one or more positions that are 
+      * Returns true if searchString appears as a substring of the result of converting this
+      * object to a String, at one or more positions that are
       * greater than or equal to position; otherwise, returns false.
-      * @param searchString search string 
+      * @param searchString search string
       * @param position If position is undefined, 0 is assumed, so as to search all of the String.
       */
     includes(searchString: string, position?: number): boolean;
 
     /**
-      * Returns true if the sequence of elements of searchString converted to a String is the 
-      * same as the corresponding elements of this object (converted to a String) starting at 
+      * Returns true if the sequence of elements of searchString converted to a String is the
+      * same as the corresponding elements of this object (converted to a String) starting at
       * endPosition – length(this). Otherwise returns false.
       */
     endsWith(searchString: string, endPosition?: number): boolean;
 
     /**
-      * Returns a String value that is made from count copies appended together. If count is 0, 
+      * Returns a String value that is made from count copies appended together. If count is 0,
       * T is the empty String is returned.
       * @param count number of copies to append
       */
     repeat(count: number): string;
 
     /**
-      * Returns true if the sequence of elements of searchString converted to a String is the 
-      * same as the corresponding elements of this object (converted to a String) starting at 
+      * Returns true if the sequence of elements of searchString converted to a String is the
+      * same as the corresponding elements of this object (converted to a String) starting at
       * position. Otherwise returns false.
       */
     startsWith(searchString: string, position?: number): boolean;
@@ -130,19 +130,14 @@ interface String {
     sub(): string;
 
     /** Returns a <sup> HTML element */
-    sup(): string;    
+    sup(): string;
 
     /**
-      * Shim for an ES6 iterable. Not intended for direct use by user code. 
+      * Shim for an ES6 iterable. Not intended for direct use by user code.
       */
     "_es6-shim iterator_"(): IterableIteratorShim<string>;
 }
 
-interface ArrayLike<T> {
-    length: number;
-    [n: number]: T;
-}
-
 interface ArrayConstructor {
     /**
       * Creates an array from an array-like object.
@@ -180,24 +175,24 @@ interface ArrayConstructor {
 }
 
 interface Array<T> {
-    /** 
-      * Returns the value of the first element in the array where predicate is true, and undefined 
+    /**
+      * Returns the value of the first element in the array where predicate is true, and undefined
       * otherwise.
-      * @param predicate find calls predicate once for each element of the array, in ascending 
-      * order, until it finds one where predicate returns true. If such an element is found, find 
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
       * immediately returns that element value. Otherwise, find returns undefined.
-      * @param thisArg If provided, it will be used as the this value for each invocation of 
+      * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
     find(predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): T;
 
-    /** 
-      * Returns the index of the first element in the array where predicate is true, and undefined 
+    /**
+      * Returns the index of the first element in the array where predicate is true, and undefined
       * otherwise.
-      * @param predicate find calls predicate once for each element of the array, in ascending 
-      * order, until it finds one where predicate returns true. If such an element is found, find 
+      * @param predicate find calls predicate once for each element of the array, in ascending
+      * order, until it finds one where predicate returns true. If such an element is found, find
       * immediately returns that element value. Otherwise, find returns undefined.
-      * @param thisArg If provided, it will be used as the this value for each invocation of 
+      * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
     findIndex(predicate: (value: T) => boolean, thisArg?: any): number;
@@ -205,41 +200,41 @@ interface Array<T> {
     /**
       * Returns the this object after filling the section identified by start and end with value
       * @param value value to fill array section with
-      * @param start index to start filling the array at. If start is negative, it is treated as 
-      * length+start where length is the length of the array. 
-      * @param end index to stop filling the array at. If end is negative, it is treated as 
+      * @param start index to start filling the array at. If start is negative, it is treated as
+      * length+start where length is the length of the array.
+      * @param end index to stop filling the array at. If end is negative, it is treated as
       * length+end.
       */
     fill(value: T, start?: number, end?: number): T[];
 
-    /** 
+    /**
       * Returns the this object after copying a section of the array identified by start and end
       * to the same array starting at position target
-      * @param target If target is negative, it is treated as length+target where length is the 
-      * length of the array. 
-      * @param start If start is negative, it is treated as length+start. If end is negative, it 
+      * @param target If target is negative, it is treated as length+target where length is the
+      * length of the array.
+      * @param start If start is negative, it is treated as length+start. If end is negative, it
       * is treated as length+end.
-      * @param end If not specified, length of the this object is used as its default value. 
+      * @param end If not specified, length of the this object is used as its default value.
       */
     copyWithin(target: number, start: number, end?: number): T[];
 
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIteratorShim<[number, T]>;
 
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIteratorShim<number>;
 
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIteratorShim<T>;
 
     /**
-      * Shim for an ES6 iterable. Not intended for direct use by user code. 
+      * Shim for an ES6 iterable. Not intended for direct use by user code.
       */
     "_es6-shim iterator_"(): IterableIteratorShim<T>;
 }
@@ -247,14 +242,14 @@ interface Array<T> {
 interface NumberConstructor {
     /**
       * The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1
-      * that is representable as a Number value, which is approximately: 
+      * that is representable as a Number value, which is approximately:
       * 2.2204460492503130808472633361816 x 10‍−‍16.
       */
     EPSILON: number;
 
     /**
       * Returns true if passed value is finite.
-      * Unlike the global isFininte, Number.isFinite doesn't forcibly convert the parameter to a 
+      * Unlike the global isFininte, Number.isFinite doesn't forcibly convert the parameter to a
       * number. Only finite values of the type number, result in true.
       * @param number A numeric value.
       */
@@ -267,7 +262,7 @@ interface NumberConstructor {
     isInteger(number: number): boolean;
 
     /**
-      * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a 
+      * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a
       * number). Unlike the global isNaN(), Number.isNaN() doesn't forcefully convert the parameter
       * to a number. Only values of the type number, that are also NaN, result in true.
       * @param number A numeric value.
@@ -280,30 +275,30 @@ interface NumberConstructor {
       */
     isSafeInteger(number: number): boolean;
 
-    /** 
-      * The value of the largest integer n such that n and n + 1 are both exactly representable as 
-      * a Number value. 
+    /**
+      * The value of the largest integer n such that n and n + 1 are both exactly representable as
+      * a Number value.
       * The value of Number.MIN_SAFE_INTEGER is 9007199254740991 2^53 − 1.
       */
     MAX_SAFE_INTEGER: number;
 
-    /** 
-      * The value of the smallest integer n such that n and n − 1 are both exactly representable as 
-      * a Number value. 
+    /**
+      * The value of the smallest integer n such that n and n − 1 are both exactly representable as
+      * a Number value.
       * The value of Number.MIN_SAFE_INTEGER is −9007199254740991 (−(2^53 − 1)).
       */
     MIN_SAFE_INTEGER: number;
 
     /**
-      * Converts a string to a floating-point number. 
-      * @param string A string that contains a floating-point number. 
+      * Converts a string to a floating-point number.
+      * @param string A string that contains a floating-point number.
       */
     parseFloat(string: string): number;
 
     /**
       * Converts A string to an integer.
       * @param s A string to convert into a number.
-      * @param radix A value between 2 and 36 that specifies the base of the number in numString. 
+      * @param radix A value between 2 and 36 that specifies the base of the number in numString.
       * If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal.
       * All other strings are considered decimal.
       */
@@ -312,7 +307,7 @@ interface NumberConstructor {
 
 interface ObjectConstructor {
     /**
-      * Copy the values of all of the enumerable own properties from one or more source objects to a 
+      * Copy the values of all of the enumerable own properties from one or more source objects to a
       * target object. Returns the target object.
       * @param target The target object to copy to.
       * @param sources One or more source objects to copy properties from.
@@ -390,7 +385,7 @@ interface Math {
     log1p(x: number): number;
 
     /**
-      * Returns the result of (e^x - 1) of x (e raised to the power of x, where e is the base of 
+      * Returns the result of (e^x - 1) of x (e raised to the power of x, where e is the base of
       * the natural logarithms).
       * @param x A numeric expression.
       */
@@ -497,21 +492,21 @@ interface Promise<T> {
 }
 
 interface PromiseConstructor {
-    /** 
-      * A reference to the prototype. 
+    /**
+      * A reference to the prototype.
       */
     prototype: Promise<any>;
 
     /**
      * Creates a new Promise.
-     * @param executor A callback used to initialize the promise. This callback is passed two arguments: 
-     * a resolve callback used resolve the promise with a value or the result of another promise, 
+     * @param executor A callback used to initialize the promise. This callback is passed two arguments:
+     * a resolve callback used resolve the promise with a value or the result of another promise,
      * and a reject callback used to reject the promise with a provided reason or error.
      */
     new <T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
 
     /**
-     * Creates a Promise that is resolved with an array of results when all of the provided Promises 
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
      * resolve, or rejected when any Promise is rejected.
      * @param values An array of Promises.
      * @returns A new Promise.
@@ -519,7 +514,7 @@ interface PromiseConstructor {
     all<T>(values: IterableShim<T | PromiseLike<T>>): Promise<T[]>;
 
     /**
-     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved 
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
      * or rejected.
      * @param values An array of Promises.
      * @returns A new Promise.
@@ -670,4 +665,4 @@ declare module "es6-shim" {
         function set(target: any, propertyKey: PropertyKey, value: any, receiver?: any): boolean;
         function setPrototypeOf(target: any, proto: any): boolean;
     }
-}
\ No newline at end of file
+}
diff --git a/fhir/fhir-tests.ts b/fhir/fhir-tests.disabled.ts
similarity index 100%
rename from fhir/fhir-tests.ts
rename to fhir/fhir-tests.disabled.ts
diff --git a/highcharts-ng/highcharts-ng-tests.ts b/highcharts-ng/highcharts-ng-tests.ts
index 5f05b3373..493d0f94f 100644
--- a/highcharts-ng/highcharts-ng-tests.ts
+++ b/highcharts-ng/highcharts-ng-tests.ts
@@ -37,4 +37,4 @@ class AppController {
     }
 }
 
-app.controller("AppController", AppController);
\ No newline at end of file
+app.controller("AppController", AppController);
diff --git a/highcharts-ng/highcharts-ng.d.ts b/highcharts-ng/highcharts-ng.d.ts
index d0a340559..dd15fd476 100644
--- a/highcharts-ng/highcharts-ng.d.ts
+++ b/highcharts-ng/highcharts-ng.d.ts
@@ -6,11 +6,11 @@
 /// <reference path="../highcharts/highcharts.d.ts" />
 
 interface HighChartsNGConfig {
-    options: HighchartsChartOptions;
+    options: HighchartsOptions;
     //The below properties are watched separately for changes.
 
     //Series object (optional) - a list of series using normal highcharts series options.
-    series?: number[]|[number, number][]| HighchartsDataPoint[];
+    series?: number[]|[number, number][]| HighchartsDataPoint[] | {data:number[];}[];
     //Title configuration (optional)
     title?: {
         text?: string;
@@ -40,4 +40,4 @@ interface HighChartsNGConfig {
 interface HighChartsNGChart extends HighChartsNGConfig {
     //This is a simple way to access all the Highcharts API that is not currently managed by this directive.
     getHighcharts(): HighchartsChartObject;
-}
\ No newline at end of file
+}
diff --git a/highcharts/highcharts.d.ts b/highcharts/highcharts.d.ts
index 2341f8769..f654b9749 100644
--- a/highcharts/highcharts.d.ts
+++ b/highcharts/highcharts.d.ts
@@ -249,7 +249,7 @@ interface HighchartsCSSObject {
     fontWeight?: string;
     left?: string;
     opacity?: number;
-    padding?: string;
+    padding?: string | number;
     position?: string;
     top?: string;
 }
diff --git a/i18n-node/i18n-node.d.ts b/i18n-node/i18n-node.d.ts
index 348c2f268..79dda8b75 100644
--- a/i18n-node/i18n-node.d.ts
+++ b/i18n-node/i18n-node.d.ts
@@ -22,29 +22,34 @@ declare module i18n {
          */
         directory?: string;
 
-        /** 
+        /**
          * whether to write new locale information to disk
          * @default true
          */
         updateFiles?: boolean;
 
-        /** 
+        /**
          * What to use as the indentation unit
          * @default "\t"
          */
         indent?: string;
 
-        /** 
+        /**
          * Setting extension of json files (you might want to set this to '.js' according to webtranslateit)
          * @default ".json"
          */
         extension?: string;
 
-        /** 
+        /**
          * Enable object notation
          * @default false
          */
         objectNotation?: boolean;
+
+        /**
+         * json files prefix
+         */
+        prefix?: string;
     }
     export interface TranslateOptions {
         phrase: string;
diff --git a/i18next/i18next.d.ts b/i18next/i18next.d.ts
index feb6658c8..38d91b603 100644
--- a/i18next/i18next.d.ts
+++ b/i18next/i18next.d.ts
@@ -19,6 +19,12 @@ interface IResourceStoreKey {
 
 interface I18nTranslateOptions extends I18nextOptions {
     defaultValue?: any; // normally a string
+    // NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
+    toAdd?: any;
+    child?: any;
+    sprintf?: any;
+    count?: any;
+    context?: any;
 }
 
 interface I18nextOptions {
@@ -66,6 +72,9 @@ interface I18nextOptions {
     cookieName?: string;                    // Default value: 'i18next'
 
     postProcess?: string;                   // Default value: undefined
+
+    // NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
+    replace?: any;
 }
 
 interface I18nextStatic {
diff --git a/js-data-http/js-data-http-tests.ts b/js-data-http/js-data-http-tests.ts
index d7c07d654..00457d714 100644
--- a/js-data-http/js-data-http-tests.ts
+++ b/js-data-http/js-data-http-tests.ts
@@ -28,7 +28,7 @@ ADocument.inject({ id: 5, author: 'John' });
 ADocument.inject({ id: 6, author: 'John' });
 
 // bypass the data store
-adapter.updateAll(ADocument, { author: 'Johnny' }, { author: 'John' }).then(function (documents) {
+adapter.updateAll<{ id?: number; author: string; }>(ADocument, { author: 'Johnny' }, { author: 'John' }).then(function (documents) {
     documents[0]; // { id: 5, author: 'Johnny' }
 
     // The updated documents have NOT been injected into the data store because we bypassed the data store
@@ -37,7 +37,7 @@ adapter.updateAll(ADocument, { author: 'Johnny' }, { author: 'John' }).then(func
 });
 
 // Normally you would just go through the data store
-ADocument.updateAll({ author: 'Johnny' }, { author: 'John' }).then(function (documents) {
+ADocument.updateAll<{ id?: number; author: string; }>({ author: 'Johnny' }, { author: 'John' }).then(function (documents) {
     documents[0]; // { id: 5, author: 'Johnny' }
 
     // the updated documents have been injected into the data store
@@ -164,4 +164,4 @@ ADocument.create({ author: 'John' }).then(function (document:any) {
 
     // the new document has been injected into the data store
     ADocument.get(document.id); // { id: 5, author: 'John' }
-});
\ No newline at end of file
+});
diff --git a/js-data/js-data.d.ts b/js-data/js-data.d.ts
index e17c4ae0d..604b70e6c 100644
--- a/js-data/js-data.d.ts
+++ b/js-data/js-data.d.ts
@@ -153,7 +153,7 @@ declare module JSData {
         findAll<T>(params?:DSFilterParams, options?:DSAdapterOperationConfiguration):JSDataPromise<Array<T>>;
         loadRelations<T>(idOrInstance:string | number | Object, relations:string | Array<string>, options?:DSAdapterOperationConfiguration):JSDataPromise<T>;
         update<T>(id:string | number, attrs:Object, options?:DSSaveConfiguration):JSDataPromise<T>;
-        updateAll<T>(attrs:Object, params?:DSFilterParams, options?:DSAdapterOperationConfiguration):JSDataPromise<Array<T>>;
+        updateAll<T>(attrs:Object, params?:DSFilterParams & T, options?:DSAdapterOperationConfiguration):JSDataPromise<Array<T>>;
         reap(resourceNametions?:DSConfiguration):JSDataPromise<any>;
         refresh<T>(id:string | number, options?:DSAdapterOperationConfiguration):JSDataPromise<T>;
         save<T>(id:string | number, options?:DSSaveConfiguration):JSDataPromise<T>;
@@ -283,7 +283,7 @@ declare module JSData {
 
         update<T>(config:DSResourceDefinition<T>, id:string | number, attrs:Object, options?:DSConfiguration):JSDataPromise<T>;
 
-        updateAll<T>(config:DSResourceDefinition<T>, attrs:Object, params?:DSFilterParams, options?:DSConfiguration):JSDataPromise<T>;
+        updateAll<T>(config:DSResourceDefinition<T>, attrs:Object, params?:DSFilterParams & T, options?:DSConfiguration):JSDataPromise<T[]>;
     }
 }
 
@@ -297,4 +297,4 @@ declare var JSData:{
 declare module 'js-data' {
 
     export = JSData;
-}
\ No newline at end of file
+}
diff --git a/jsdom/jsdom-tests.ts b/jsdom/jsdom-tests.ts
index 504f1f064..1f0d04a0b 100644
--- a/jsdom/jsdom-tests.ts
+++ b/jsdom/jsdom-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./jsdom.d.ts" />
+
 import jsdom = require("jsdom");
 
 jsdom.defaultDocumentFeatures.FetchExternalResources = ["img"];
diff --git a/knockout/knockoutamd-tests.ts b/knockout/knockoutamd-tests.ts
index dd2124b70..447da840e 100644
--- a/knockout/knockoutamd-tests.ts
+++ b/knockout/knockoutamd-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./knockout.d.ts" />
+
 import ko = require("knockout");
 
 var myArray = ko.observableArray([1, 2, 3]);
@@ -6,4 +8,4 @@ class MyViewModel {
 	name = ko.observable("Jeff");
 }
 
-ko.applyBindings(new MyViewModel());
\ No newline at end of file
+ko.applyBindings(new MyViewModel());
diff --git a/leapmotionTS/LeapMotionTS-tests.ts b/leapmotionTS/LeapMotionTS-tests.ts
index c6db49c3e..ac392941e 100755
--- a/leapmotionTS/LeapMotionTS-tests.ts
+++ b/leapmotionTS/LeapMotionTS-tests.ts
@@ -1,6 +1,4 @@
-/// <reference path="LeapMotionTS.d.ts" />
-
-import Leap = require('LeapMotionTS');
+import Leap = require('./LeapMotionTS');
 
 var controller: Leap.Controller = new Leap.Controller();
 controller.addEventListener(Leap.LeapEvent.LEAPMOTION_FRAME, (event: Leap.LeapEvent) => {
diff --git a/mailparser/mailparser-tests.ts b/mailparser/mailparser-tests.ts
index 51d562788..b7df9adb4 100644
--- a/mailparser/mailparser-tests.ts
+++ b/mailparser/mailparser-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./mailparser.d.ts" />
+
 import mailparser_mod = require("mailparser");
 import MailParser = mailparser_mod.MailParser;
 import ParsedMail = mailparser_mod.ParsedMail;
@@ -12,25 +14,25 @@ mailparser.on("headers", function(headers){
 });
 
 mailparser.on("end", function(mail){
-    mail; // object structure for parsed e-mail 
+    mail; // object structure for parsed e-mail
 });
-    
+
 
 // Decode a simple e-mail
 // This example decodes an e-mail from a string
- 
+
 var email = "From: 'Sender Name' <sender@example.com>\r\n"+
             "To: 'Receiver Name' <receiver@example.com>\r\n"+
             "Subject: Hello world!\r\n"+
             "\r\n"+
             "How are you today?";
-    // setup an event listener when the parsing finishes 
+    // setup an event listener when the parsing finishes
 mailparser.on("end", function(mail_object){
-    console.log("From:", mail_object.from); //[{address:'sender@example.com',name:'Sender Name'}] 
-    console.log("Subject:", mail_object.subject); // Hello world! 
-    console.log("Text body:", mail_object.text); // How are you today? 
+    console.log("From:", mail_object.from); //[{address:'sender@example.com',name:'Sender Name'}]
+    console.log("Subject:", mail_object.subject); // Hello world!
+    console.log("Text body:", mail_object.text); // How are you today?
 });
-    // send the email source to the parser 
+    // send the email source to the parser
 mailparser.write(email);
 mailparser.end();
 
@@ -42,7 +44,7 @@ import fs = require("fs");
 mailparser.on("end", function(mail_object){
     console.log("Subject:", mail_object.subject);
 });
- 
+
 fs.createReadStream("email.eml").pipe(mailparser);
 
 
@@ -63,7 +65,3 @@ mp.on("attachment", function(attachment, mail){
     var output = fs.createWriteStream(attachment.generatedFileName);
     attachment.stream.pipe(output);
 });
-
-
-
-
diff --git a/mariasql/mariasql-tests.ts b/mariasql/mariasql-tests.ts
index 76819feba..c3ab5c848 100644
--- a/mariasql/mariasql-tests.ts
+++ b/mariasql/mariasql-tests.ts
@@ -1,7 +1,8 @@
 // These are the examples from the node-mariasql README transposed to TypeScript
 // https://github.com/mscdex/node-mariasql
 
-/// <reference path="../node/node-0.10.d.ts" />
+/// <reference path="./mariasql.d.ts" />
+/// <reference path="../node/node.d.ts" />
 
 // Example 1 - SHOW DATABASES
 import util = require('util');
@@ -198,4 +199,4 @@ c.end();
  Query #3 finished successfully
  Done with all queries
  Client closed
- */
\ No newline at end of file
+ */
diff --git a/node-imap/imap-tests.ts b/node-imap/imap-tests.ts
index 61f4b2e0c..3c124ca46 100644
--- a/node-imap/imap-tests.ts
+++ b/node-imap/imap-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./imap.d.ts" />
+
 import Imap = require('imap');
 var inspect = require('util').inspect;
 
diff --git a/node-polyglot/node-polyglot-tests.ts b/node-polyglot/node-polyglot-tests.ts
index fee07d79e..249be9577 100644
--- a/node-polyglot/node-polyglot-tests.ts
+++ b/node-polyglot/node-polyglot-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./node-polyglot.d.ts" />
+
 import Polyglot = require("node-polyglot");
 
 function instantiatePolyglot(): void {
diff --git a/npm-shrinkwrap.json b/npm-shrinkwrap.json
index d332a49ef..3458cb8a6 100644
--- a/npm-shrinkwrap.json
+++ b/npm-shrinkwrap.json
@@ -28,9 +28,9 @@
                   "resolved": "https://registry.npmjs.org/hoek/-/hoek-2.14.0.tgz"
                 },
                 "topo": {
-                  "version": "1.0.2",
+                  "version": "1.0.3",
                   "from": "topo@>=1.0.0 <2.0.0",
-                  "resolved": "https://registry.npmjs.org/topo/-/topo-1.0.2.tgz"
+                  "resolved": "https://registry.npmjs.org/topo/-/topo-1.0.3.tgz"
                 },
                 "isemail": {
                   "version": "1.1.1",
@@ -38,9 +38,9 @@
                   "resolved": "https://registry.npmjs.org/isemail/-/isemail-1.1.1.tgz"
                 },
                 "moment": {
-                  "version": "2.10.3",
+                  "version": "2.10.6",
                   "from": "moment@>=2.0.0 <3.0.0",
-                  "resolved": "https://registry.npmjs.org/moment/-/moment-2.10.3.tgz"
+                  "resolved": "https://registry.npmjs.org/moment/-/moment-2.10.6.tgz"
                 }
               }
             },
@@ -103,9 +103,9 @@
                   "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
                 },
                 "minimatch": {
-                  "version": "2.0.9",
+                  "version": "2.0.10",
                   "from": "minimatch@>=2.0.1 <3.0.0",
-                  "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-2.0.9.tgz",
+                  "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-2.0.10.tgz",
                   "dependencies": {
                     "brace-expansion": {
                       "version": "1.1.0",
@@ -170,9 +170,9 @@
               "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
             },
             "minimatch": {
-              "version": "2.0.9",
+              "version": "2.0.10",
               "from": "minimatch@>=2.0.1 <3.0.0",
-              "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-2.0.9.tgz",
+              "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-2.0.10.tgz",
               "dependencies": {
                 "brace-expansion": {
                   "version": "1.1.0",
@@ -208,9 +208,9 @@
           }
         },
         "lazy.js": {
-          "version": "0.4.0",
+          "version": "0.4.2",
           "from": "lazy.js@>=0.4.0 <0.5.0",
-          "resolved": "https://registry.npmjs.org/lazy.js/-/lazy.js-0.4.0.tgz"
+          "resolved": "https://registry.npmjs.org/lazy.js/-/lazy.js-0.4.2.tgz"
         },
         "manticore": {
           "version": "0.2.4",
@@ -305,9 +305,9 @@
       }
     },
     "typescript": {
-      "version": "1.5.3",
-      "from": "typescript@1.5.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-1.5.3.tgz"
+      "version": "1.6.0-beta",
+      "from": "typescript@1.6.0-beta",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-1.6.0-beta.tgz"
     }
   }
 }
diff --git a/package.json b/package.json
index 2c5b834ed..e82eb15b0 100644
--- a/package.json
+++ b/package.json
@@ -36,6 +36,6 @@
   },
   "devDependencies": {
     "definition-tester": "0.2.0",
-    "typescript": "1.5.3"
+    "typescript": "1.6.0-beta"
   }
 }
diff --git a/papaparse/papaparse-tests.ts b/papaparse/papaparse-tests.ts
index 14cc40bb3..8ae3f9167 100644
--- a/papaparse/papaparse-tests.ts
+++ b/papaparse/papaparse-tests.ts
@@ -12,14 +12,14 @@ res.errors[0].code;
 Papa.parse("3,3,3", {
 	delimiter: ';',
 	comments: false,
-	
+
 	step: function(results, p) {
 		p.abort();
 		results.data.length;
 	}
 });
 
-var file = new File();
+var file = new File(null, null, null);
 
 Papa.parse(file, {
 	complete: function(a, b) {
@@ -52,4 +52,4 @@ Papa.LocalChunkSize;
 var parser = new Papa.Parser({})
 parser.getCharIndex();
 parser.abort();
-parser.parse("", 0, false);
\ No newline at end of file
+parser.parse("", 0, false);
diff --git a/passport-facebook/passport-facebook-tests.ts b/passport-facebook/passport-facebook-tests.ts
index b35770479..8accf57c0 100644
--- a/passport-facebook/passport-facebook-tests.ts
+++ b/passport-facebook/passport-facebook-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./passport-facebook.d.ts" />
+
 /**
  * Created by jcabresos on 4/19/2014.
  */
@@ -22,4 +24,4 @@ passport.use(new facebook.Strategy({
              done(null, user);
          });
     })
-);
\ No newline at end of file
+);
diff --git a/passport-google-oauth/passport-google-oauth-tests.ts b/passport-google-oauth/passport-google-oauth-tests.ts
index 60fad97b4..ef7a4e9ef 100644
--- a/passport-google-oauth/passport-google-oauth-tests.ts
+++ b/passport-google-oauth/passport-google-oauth-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./passport-google-oauth.d.ts" />
+
 /**
  * Created by jcabresos on 4/19/2014.
  */
diff --git a/passport-local/passport-local-tests.ts b/passport-local/passport-local-tests.ts
index 873dc609b..68056db49 100644
--- a/passport-local/passport-local-tests.ts
+++ b/passport-local/passport-local-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./passport-local.d.ts" />
+
 /**
  * Created by Maxime LUCE <https://github.com/SomaticIT>.
  */
diff --git a/passport-strategy/passport-strategy-tests.ts b/passport-strategy/passport-strategy-tests.ts
index e9c6fd604..ad5a9a38d 100644
--- a/passport-strategy/passport-strategy-tests.ts
+++ b/passport-strategy/passport-strategy-tests.ts
@@ -1,3 +1,4 @@
+/// <reference path="./passport-strategy.d.ts" />
 
 import express = require('express');
 import passport = require('passport-strategy');
diff --git a/passport-twitter/passport-twitter-tests.ts b/passport-twitter/passport-twitter-tests.ts
index ae644dfa2..f7d539f16 100644
--- a/passport-twitter/passport-twitter-tests.ts
+++ b/passport-twitter/passport-twitter-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./passport-twitter.d.ts" />
+
 /**
  * Created by jcabresos on 4/19/2014.
  */
diff --git a/phantom/phantom-tests.ts b/phantom/phantom-tests.ts
index bd12a5e6e..d18168827 100644
--- a/phantom/phantom-tests.ts
+++ b/phantom/phantom-tests.ts
@@ -117,7 +117,7 @@ phantom.create((ph) => {
       var finishedFunc = (result: any) => {
         ph.exit();
       };
-      page.evaluate(someFunc, finishedFunc, 'div', {wahtt: 111});
+      page.evaluate<string, {wahtt: number;}, void>(someFunc, finishedFunc, 'div', {wahtt: 111});
     });
   });
 
@@ -164,5 +164,3 @@ phantom.create((ph) => {
     });
   });
 });
-
-
diff --git a/physijs/tests/jenga.ts b/physijs/tests/jenga.ts
index e2eeecc94..77b9c6cd6 100644
--- a/physijs/tests/jenga.ts
+++ b/physijs/tests/jenga.ts
@@ -85,7 +85,7 @@ initScene = function() {
 
     // Materials
     table_material = Physijs.createMaterial(
-        new THREE.MeshLambertMaterial({ map: THREE.ImageUtils.loadTexture( 'images/wood.jpg' ), ambient: 0xFFFFFF }),
+        new THREE.MeshLambertMaterial({ map: THREE.ImageUtils.loadTexture( 'images/wood.jpg' ) }),
         .9, // high friction
         .2 // low restitution
     );
@@ -93,7 +93,7 @@ initScene = function() {
     table_material.map.repeat.set( 5, 5 );
 
     block_material = Physijs.createMaterial(
-        new THREE.MeshLambertMaterial({ map: THREE.ImageUtils.loadTexture( 'images/plywood.jpg' ), ambient: 0xFFFFFF }),
+        new THREE.MeshLambertMaterial({ map: THREE.ImageUtils.loadTexture( 'images/plywood.jpg' ) }),
         .4, // medium friction
         .4 // medium restitution
     );
diff --git a/project-oxford/project-oxford-tests.ts b/project-oxford/project-oxford-tests.ts
index 3d662d504..896d407b8 100644
--- a/project-oxford/project-oxford-tests.ts
+++ b/project-oxford/project-oxford-tests.ts
@@ -16,7 +16,7 @@ var billFaces = <string[]>[];
 var personGroupId = "uuid.v4()";
 var personGroupId2 = "uuid.v4()";
 var billPersonId: string;
- 
+
 describe('Project Oxford Face API Test', function () {
     afterEach(function() {
         // delay after each test to prevent throttling
@@ -82,7 +82,7 @@ describe('Project Oxford Face API Test', function () {
             });
         });
     });
-    
+
     describe('#similar()', function () {
         it('detects similar faces', function (done) {
             var detects = <any>[];
@@ -148,7 +148,7 @@ describe('Project Oxford Face API Test', function () {
             });
         });
     });
-    
+
     describe('#PersonGroup', function () {
         before(function(done) {
             this.timeout(5000);
@@ -199,7 +199,7 @@ describe('Project Oxford Face API Test', function () {
                 done();
             });
         });
-        
+
         it('updates a PersonGroup', function (done) {
             client.face.personGroup.update(personGroupId, 'po-node-test-group2', 'test-data2').then(function (response) {
                 assert.ok(true, "void response expected");;
@@ -364,7 +364,7 @@ describe('Project Oxford Vision API Test', function () {
     before(function() {
         // ensure the output directory exists
         if(!fs.existsSync('./test/output')){
-            fs.mkdirSync('./test/output', 0766);
+            fs.mkdirSync('./test/output', parseInt("0766", 8));
         }
     });
 
@@ -417,7 +417,7 @@ describe('Project Oxford Vision API Test', function () {
             done();
         });
     });
-    
+
     it('creates a thumbnail for a local image', function (done) {
         this.timeout(10000);
         client.vision.thumbnail({
@@ -449,7 +449,7 @@ describe('Project Oxford Vision API Test', function () {
             done();
         });
     });
-    
+
     it('runs OCR on a local image', function (done) {
         this.timeout(10000);
         client.vision.ocr({
@@ -477,4 +477,4 @@ describe('Project Oxford Vision API Test', function () {
             done();
         });
     });
-});
\ No newline at end of file
+});
diff --git a/promise-pool/promise-pool-tests.ts b/promise-pool/promise-pool-tests.ts
index 4f3bd40de..a9cc160be 100644
--- a/promise-pool/promise-pool-tests.ts
+++ b/promise-pool/promise-pool-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./promise-pool.d.ts" />
+
 import Q = require('q');
 import promisePool = require('promise-pool');
 
@@ -44,4 +46,4 @@ function onProgress(progress: promisePool.IProgress) {
     progress.fulfilled == 0;
     progress.total == 0;
     progress.index == 0;
-}
\ No newline at end of file
+}
diff --git a/protobufjs/protobufjs-tests.ts b/protobufjs/protobufjs-tests.ts
index 8cf52b274..f20efec3c 100644
--- a/protobufjs/protobufjs-tests.ts
+++ b/protobufjs/protobufjs-tests.ts
@@ -15,51 +15,51 @@ function testProtoBufJs() {
     assert.ok("loadProto" in ProtoBuf, "ProtoBuf should contain property loadProto");
     assert.ok("loadProtoFile" in ProtoBuf, "ProtoBuf should contain property loadProtoFile");
     assert.ok("newBuilder" in ProtoBuf, "ProtoBuf should contain property newBuilder");
-    
+
     var jsonProto: ProtoBuf.ProtoBuilder = ProtoBuf.loadJson(readFileSync("test.json",
         {"encoding": "utf8"}));
     assertIsProtoBuilder(jsonProto, "loadJson");
-    
+
     var jsonFileProto: ProtoBuf.ProtoBuilder = ProtoBuf.loadJsonFile("test.json");
     assertIsProtoBuilder(jsonFileProto, "loadJsonFile");
-    
+
     ProtoBuf.loadJsonFile("test.json", (error: any, builder: ProtoBuf.ProtoBuilder) => {
         assertIsProtoBuilder(builder, "loadJsonFile callback");
       });
-      
+
     var proto: ProtoBuf.ProtoBuilder = ProtoBuf.loadProto(readFileSync("test.proto",
         {"encoding": "utf8"}));
     assertIsProtoBuilder(proto, "loadProto");
-    
+
     var protoFile: ProtoBuf.ProtoBuilder = ProtoBuf.loadProtoFile("test.proto");
     assertIsProtoBuilder(protoFile, "loadProtoFile");
-    
+
     ProtoBuf.loadProtoFile("test.proto", (error: any, builder: ProtoBuf.ProtoBuilder) => {
         assertIsProtoBuilder(builder, "loadProtoFile callback");
       });
-      
+
      var newBuilder: ProtoBuf.ProtoBuilder = ProtoBuf.newBuilder();
      assertIsProtoBuilder(newBuilder, "newBuilder");
-     
+
      assertIsNamespace(protoFile.ns, "protoFile.ns");
      assertIsNamespace(protoFile.ptr, "protoFile.ptr");
-     
+
      assertIsProtoBuf(protoFile.build(), "protoFile.build()");
      assertIsProtoBuf(protoFile.result, "protoFile.result");
-     
+
      assertIsProtoBuilder(protoFile.create(), "protoFile.create()");
      assertIsProtoBuilder(protoFile.define("js"), "protoFile.define()");
-     
+
      assertIsT(protoFile.lookup(), "protoFile.lookup()");
 }
 
 function testBuilderJs() {
     var Builder: ProtoBuf.Builder = ProtoBuf.Builder;
     assertIsBuilder(Builder, "Builder");
-    
+
     var newBuilder: ProtoBuf.ProtoBuilder = new ProtoBuf.Builder();
     assertIsProtoBuilder(newBuilder, "new Builder()");
-    
+
     var Message: ProtoBuf.Message = Builder.Message;
     var Service: ProtoBuf.Service = Builder.Service;
 }
@@ -104,13 +104,13 @@ function assertIsBuilder(b: ProtoBuf.Builder, name: string) {
 }
 
 function assertIsProtoBuf(pb: ProtoBuf.ProtoBuf, name: string) {
-    for (var package in pb) {
-        if (pb.hasOwnProperty(package)) {
-            for (var property in pb[package]) {
-                if (typeof pb[package][property] == typeof Object
-                      && pb[package].hasOwnProperty(property)) {
-                    assertIsMetaMessage(pb[package][property],
-                        name + "." + package + "." + property);
+    for (var pkg in pb) {
+        if (pb.hasOwnProperty(pkg)) {
+            for (var property in pb[pkg]) {
+                if (typeof pb[pkg][property] == typeof Object
+                      && pb[pkg].hasOwnProperty(property)) {
+                    assertIsMetaMessage(pb[pkg][property],
+                        name + "." + pkg + "." + property);
                 }
             }
         }
@@ -127,7 +127,7 @@ function assertIsMetaMessage(mm: ProtoBuf.MetaMessage, name: string) {
 function assertIsDotProto(dp: ProtoBuf.DotProto, name: string) {
     assert.ok("Parser" in dp, name + " should contain property Parser");
     assert.ok("Tokenizer" in dp, name + " should contain property Tokenizer");
-    
+
     assertIsParser(new dp.Parser(readFileSync("test.proto", {"encoding": "utf8"})),
         name + ".Parser");
     assertIsTokenizer(new dp.Tokenizer(readFileSync("test.proto", {"encoding": "utf8"})),
@@ -138,7 +138,7 @@ function assertIsParser(p: ProtoBuf.Parser, name: string) {
     assert.ok("tn" in p, name + " should contain property tn");
     assert.ok("parse" in p, name + " should contain property parse");
     assert.ok("toString" in p, name + " should contain property toString");
-    
+
     assertIsTokenizer(p.tn, name + ".tn");
     assertIsMetaProto(p.parse(), name + ".parse()");
 }
@@ -162,7 +162,7 @@ function assertIsMetaProto(mp: ProtoBuf.MetaProto, name: string) {
     assert.ok("imports" in mp, name + " should contain proeprty imports");
     assert.ok("options" in mp, name + " should contain proeprty options");
     assert.ok("services" in mp, name + " should contain proeprty services");
-    
+
     for (var message in mp.messages) {
         assertIsProtoMessage(mp.messages[message], name + ".messages." + message);
     }
@@ -178,7 +178,7 @@ function assertIsProtoEnum(pe: ProtoBuf.ProtoEnum, name: string) {
     assert.ok("name" in pe, name + " should contain property name");
     assert.ok("values" in pe, name + " should contain property values");
     assert.ok("options" in pe, name + " should contain property options");
-    
+
     assertIsProtoEnumValue(pe.values, name + ".values");
 }
 
@@ -202,7 +202,7 @@ function assertIsProtoMessage(pm: ProtoBuf.ProtoMessage, name: string) {
     assert.ok("messages" in pm, name + " should contain property messages");
     assert.ok("options" in pm, name + " should contain property options");
     assert.ok("oneofs" in pm, name + " should contain property oneofs");
-    
+
     for (var f in pm.fields) {
         assertIsProtoField(pm.fields[f], name + ".fields." + f);
     }
@@ -224,7 +224,7 @@ function assertIsProtoService(ps: ProtoBuf.ProtoService, name: string) {
     assert.ok("name" in ps, name + " should contain property name");
     assert.ok("rpc" in ps, name + " should contain property rpc");
     assert.ok("options" in ps, name + " should contain property options");
-    
+
     for (var rpc in ps.rpc) {
       assertIsProtoRpcService(ps.rpc[rpc], name + ".rpc." + rpc);
     }
@@ -237,14 +237,14 @@ function assertIsReflect(r: ProtoBuf.Reflect, name: string) {
     assert.ok("Enum" in r, name + " should contain property Enum");
     assert.ok("Extension" in r, name + " should contain property Extension");
     assert.ok("Service" in r, name + " should contain property Service");
-    
+
     assertIsT(new ProtoBuf.Reflect.T(), "new ProtoBuf.Reflect.T()");
     assertIsNamespace(new ProtoBuf.Reflect.Namespace(), "new ProtoBuf.Reflect.Namespace()");
     assertIsMessage(new ProtoBuf.Reflect.Message(), "new ProtoBuf.Reflect.Message()");
     assertIsEnum(new ProtoBuf.Reflect.Enum(), "new ProtoBuf.Reflect.Enum()");
     assertIsExtension(new ProtoBuf.Reflect.Extension(), "new ProtoBuf.Reflect.Extension()");
     assertIsService(new ProtoBuf.Reflect.Service(), "new ProtoBuf.Reflect.Service()");
-    
+
     assertIsValue(new ProtoBuf.Reflect.Enum.Value(), "new ProtoBuf.Reflect.Enum.Value()");
     assertIsOneOf(new ProtoBuf.Reflect.Message.OneOf(), "new ProtoBuf.Reflect.Message.OneOf()");
     assertIsMethod(new ProtoBuf.Reflect.Service.Method(), "new ProtoBuf.Reflect.Service.Method()");
@@ -255,7 +255,7 @@ function assertIsReflect(r: ProtoBuf.Reflect, name: string) {
 function assertIsT(t: ProtoBuf.ReflectT, name: string) {
     if (t != null && t != undefined) {
         assertIsTNoRecursion(t, name);
-    
+
         assertIsProtoBuilder(t.builder, name + ".builder");
         assertIsTNoRecursion(t.parent, name + ".parent");
     }
@@ -273,9 +273,9 @@ function assertIsTNoRecursion(t: ProtoBuf.ReflectT, name: string) {
 
 function assertIsNamespace(ns: ProtoBuf.ReflectNamespace, name: string) {
     assertIsNamespaceNoRecursion(ns, name);
-    
+
     assertIsT(ns, name);
-    
+
     for (var child in ns.children) {
         assertIsT(ns.children[child], name + ".children." + child);
     }
@@ -308,7 +308,7 @@ function assertIsMessage(m: ProtoBuf.ReflectMessage, name: string) {
         assert.ok("encode" in m, name + " should contain property encode");
         assert.ok("calculate" in m, name + " should contain property calculate");
         assert.ok("decode" in m, name + " should contain property decode");
-        
+
         assertIsNamespace(m, name);
     }
 }
@@ -316,22 +316,22 @@ function assertIsMessage(m: ProtoBuf.ReflectMessage, name: string) {
 function assertIsEnum(e: ProtoBuf.ReflectEnum, name: string) {
     assert.ok("object" in e, name + " should contain property object");
     assert.ok("build" in e, name + " should contain property build");
-    
+
     assertIsNamespace(e, name);
 }
 
 function assertIsExtension(e: ProtoBuf.ReflectExtension, name: string) {
     assert.ok("field" in e, name + " should contain property field");
-    
+
     assertIsT(e, name);
-    
+
     assertIsField(e.field, name + ".field");
 }
 
 function assertIsService(s: ProtoBuf.ReflectService, name: string) {
     assert.ok("clazz" in s, name + " should contain property clazz");
     assert.ok("build" in s, name + " should contain property build");
-    
+
     assertIsNamespace(s, name);
 }
 
@@ -355,9 +355,9 @@ function assertIsField(f: ProtoBuf.ReflectField, name: string) {
         assert.ok("calculate" in f, name + " should contain property calculate");
         assert.ok("calculateValue" in f, name + " should contain property calculateValue");
         assert.ok("decode" in f, name + " should contain property decode");
-        
+
         assertIsT(f, name);
-        
+
         assertIsT(f.resolvedType, name + ".resolvedType");
         assertIsOneOf(f.oneof, name + ".oneof");
     }
@@ -370,15 +370,15 @@ function assertIsWireTuple(wt: ProtoBuf.WireTuple, name: string) {
 
 function assertIsExtensionField(ef: ProtoBuf.ReflectExtensionField, name: string) {
     assert.ok("extension" in ef, name + " should contain property extension");
-    
+
     assertIsField(ef, name);
-    
+
     assertIsExtension(ef.extension, name + ".extension");
 }
 
 function assertIsOneOf(oo: ProtoBuf.ReflectOneOf, name: string) {
     assert.ok("fields" in oo, name + " should contain property fields");
-    
+
     for (var f in oo.fields) {
         assertIsField(oo.fields[f], name + ".fields." + f);
     }
@@ -387,7 +387,7 @@ function assertIsOneOf(oo: ProtoBuf.ReflectOneOf, name: string) {
 function assertIsValue(v: ProtoBuf.ReflectValue, name: string) {
     assert.ok("className" in v, name + " should contain property className");
     assert.ok("id" in v, name + " should contain property id");
-    
+
     assertIsT(v, name);
 }
 
@@ -395,7 +395,7 @@ function assertIsMethod(m: ProtoBuf.ReflectMethod, name: string) {
     assert.ok("className" in m, name + " should contain property className");
     assert.ok("options" in m, name + " should contain property options");
     assert.ok("buildOpt" in m, name + " should contain property buildOpt");
-    
+
     assertIsT(m, name);
 }
 
@@ -405,9 +405,9 @@ function assertIsRPCMethod(rpc: ProtoBuf.ReflectRPCMethod, name: string) {
     assert.ok("resolvedRequestType" in rpc, name + " should contain property resolvedRequestType");
     assert.ok("resolvedResponseType" in rpc,
         name + " should contain property resolvedResponseType");
-        
+
     assertIsMethod(rpc, name);
-        
+
     assertIsMessage(rpc.resolvedRequestType, name + ".resolvedRequestType");
     assertIsMessage(rpc.resolveResponseType, name + ".resolvedResponsetype");
 }
@@ -415,4 +415,4 @@ function assertIsRPCMethod(rpc: ProtoBuf.ReflectRPCMethod, name: string) {
 testProtoBufJs();
 testBuilderJs();
 testDotProtoJs();
-testReflectJs();
\ No newline at end of file
+testReflectJs();
diff --git a/q-retry/q-retry-tests.ts b/q-retry/q-retry-tests.ts
index e5d5dd8ca..fc33d7ba9 100644
--- a/q-retry/q-retry-tests.ts
+++ b/q-retry/q-retry-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./q-retry.d.ts" />
+
 import Q = require('q-retry');
 
 Q
@@ -9,7 +11,7 @@ Q
         return 0;
     })
     .retry(num => {
-        num.toFixed;    
+        num.toFixed;
     })
     .retry(() => {
 
@@ -32,8 +34,8 @@ Q
         limit: 10,
         interval: 1000,
         maxInterval: 20000,
-        intervalMultiplier: 1.5    
+        intervalMultiplier: 1.5
     })
     .then(str => {
         str.charAt;
-    });
\ No newline at end of file
+    });
diff --git a/react/react-addons-tests.ts b/react/react-addons-tests.ts
index 6976d9959..ff01806c5 100644
--- a/react/react-addons-tests.ts
+++ b/react/react-addons-tests.ts
@@ -57,9 +57,10 @@ var ClassicComponent: React.ClassicComponentClass<Props> =
                 seconds: this.props.foo
             };
         },
-        reset: () => {
-            this.replaceState(this.getInitialState());
-        },
+        // NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
+        // reset: () => {
+        //     this.replaceState(this.getInitialState());
+        // },
         render: () => {
             return React.DOM.div(null,
                 React.DOM.input({
@@ -71,32 +72,32 @@ var ClassicComponent: React.ClassicComponentClass<Props> =
 
 class ModernComponent extends React.Component<Props, State>
     implements React.ChildContextProvider<ChildContext> {
-    
+
     static propTypes: React.ValidationMap<Props> = {
         foo: React.PropTypes.number
     }
-    
+
     static contextTypes: React.ValidationMap<Context> = {
         someValue: React.PropTypes.string
     }
-    
+
     static childContextTypes: React.ValidationMap<ChildContext> = {
         someOtherValue: React.PropTypes.string
     }
-    
+
     context: Context;
-    
+
     getChildContext() {
         return {
             someOtherValue: 'foo'
         }
     }
-    
+
     state = {
         inputValue: this.context.someValue,
         seconds: this.props.foo
     }
-    
+
     reset() {
         this.setState({
             inputValue: this.context.someValue,
@@ -105,7 +106,7 @@ class ModernComponent extends React.Component<Props, State>
     }
 
     private _input: React.HTMLComponent;
-    
+
     render() {
         return React.DOM.div(null,
             React.DOM.input({
diff --git a/rest/rest-tests.ts b/rest/rest-tests.ts
index 6d267c792..cedc11b00 100644
--- a/rest/rest-tests.ts
+++ b/rest/rest-tests.ts
@@ -117,24 +117,24 @@ var promiseOrResponse = interceptor({
 });
 
 client = rest
-    .wrap(defaultRequest)
-    .wrap(hateoas)
-    .wrap(location)
-    .wrap(mime)
-    .wrap(pathPrefix)
-    .wrap(basicAuth)
-    .wrap(oAuth)
-    .wrap(csrf)
-    .wrap(errorCode)
-    .wrap(retry)
-    .wrap(timeout)
-    .wrap(jsonp)
-    .wrap(xdomain)
-    .wrap(xhr)
-    .wrap(noop)
-    .wrap(fail)
-    .wrap(knownConfig, { prop: 'value' })
-    .wrap(transformedConfig, { prop: 'value' });
+    .wrap<any>(defaultRequest)
+    .wrap<any>(hateoas)
+    .wrap<any>(location)
+    .wrap<any>(mime)
+    .wrap<any>(pathPrefix)
+    .wrap<any>(basicAuth)
+    .wrap<any>(oAuth)
+    .wrap<any>(csrf)
+    .wrap<any>(errorCode)
+    .wrap<any>(retry)
+    .wrap<any>(timeout)
+    .wrap<any>(jsonp)
+    .wrap<any>(xdomain)
+    .wrap<any>(xhr)
+    .wrap<any>(noop)
+    .wrap<any>(fail)
+    .wrap<any>(knownConfig, { prop: 'value' })
+    .wrap<any>(transformedConfig, { prop: 'value' });
 
 import xhrClient = require('rest/client/xhr');
 import nodeClient = require('rest/client/node');
diff --git a/rsmq-worker/rsmq-worker-tests.ts b/rsmq-worker/rsmq-worker-tests.ts
index fa635e415..d5d974bd0 100644
--- a/rsmq-worker/rsmq-worker-tests.ts
+++ b/rsmq-worker/rsmq-worker-tests.ts
@@ -1,3 +1,4 @@
+/// <reference path="./rsmq-worker.d.ts" />
 
 import RSMQWorker = require('rsmq-worker');
 
@@ -20,4 +21,3 @@ worker.send('message2', 1, (e: Error, id:string) => {
 worker.send('message3', () => {});
 
 worker.stop();
-
diff --git a/seedrandom/seedrandom-tests.ts b/seedrandom/seedrandom-tests.ts
index 1f913a406..69a11622f 100644
--- a/seedrandom/seedrandom-tests.ts
+++ b/seedrandom/seedrandom-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./seedrandom.d.ts" />
+
 import seedrandom = require("seedrandom");
 
 var rng = seedrandom("hello.");
diff --git a/selectize/selectize-tests.ts b/selectize/selectize-tests.ts
index b5ea65829..caf0b06e3 100644
--- a/selectize/selectize-tests.ts
+++ b/selectize/selectize-tests.ts
@@ -212,7 +212,7 @@ interface Link {
 }
 
 $('#select-links').selectize({
-    theme: 'links',
+    // NOTE ( https://github.com/borisyankov/DefinitelyTyped/pull/5590 ) theme: 'links',
     maxItems: null,
     valueField: 'id',
     searchField: 'title',
@@ -418,4 +418,3 @@ $("#select-car").selectize({
     plugins: ['optgroup_columns'],
     openOnFocus: false
 });
-
diff --git a/sequelize/sequelize-tests.ts b/sequelize/sequelize-tests.ts
index 2651453d6..ae6fd7af4 100644
--- a/sequelize/sequelize-tests.ts
+++ b/sequelize/sequelize-tests.ts
@@ -587,7 +587,9 @@ User.findOne( { where : { name : 'worker' }, include : [User] } );
 User.findOne( { where : { name : 'Boris' }, include : [User, { model : User, as : 'Photos' }] } );
 User.findOne( { where : { username : 'someone' }, include : [User] } );
 User.findOne( { where : { username : 'barfooz' }, raw : true } );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 User.findOne( { updatedAt : { ne : null } } );
+ */
 User.find( { where : { intVal : { gt : 5 } } } );
 User.find( { where : { intVal : { lte : 5 } } } );
 
@@ -639,7 +641,9 @@ User.findOrInitialize( { where : { username : 'foo' }, defaults : { foo : 'asd'
 
 User.findOrCreate( { where : { a : 'b' }, defaults : { json : { a : { b : 'c' }, d : [1, 2, 3] } } } );
 User.findOrCreate( { where : { a : 'b' }, defaults : { json : 'a', data : 'b' } } );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 User.findOrCreate( { where : { a : 'b' }, transaction : t, lock : t.LOCK.UPDATE } );
+ */
 User.findOrCreate( { where : { a : 'b' }, logging : function(  ) { } } );
 User.findOrCreate( { where : { username : 'Username' }, defaults : { data : 'some data' }, transaction : t } );
 User.findOrCreate( { where : { objectId : 'asdasdasd' }, defaults : { username : 'gottlieb' } } );
@@ -719,24 +723,32 @@ queryInterface.dropAllTables();
 queryInterface.showAllTables( { logging : function() { } } );
 queryInterface.createTable( 'table', { name : Sequelize.STRING }, { logging : function() { } } );
 queryInterface.createTable( 'skipme', { name : Sequelize.STRING } );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 queryInterface.dropAllTables( { skip : ['skipme'] } );
+ */
 queryInterface.dropTable( 'Group', { logging : function() { } } );
 queryInterface.addIndex( 'Group', ['username', 'isAdmin'], { logging : function() { } } );
 queryInterface.showIndex( 'Group', { logging : function() { } } );
 queryInterface.removeIndex( 'Group', ['username', 'isAdmin'], { logging : function() { } } );
 queryInterface.showIndex( 'Group' );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 queryInterface.createTable( 'table', { name : { type : Sequelize.STRING } }, { schema : 'schema' } );
+ */
 queryInterface.addIndex( { schema : 'a', tableName : 'c' }, ['d', 'e'], { logging : function() {} }, 'schema_table' );
 queryInterface.showIndex( { schema : 'schema', tableName : 'table' }, { logging : function() {} } );
 queryInterface.addIndex( 'Group', ['from'] );
 queryInterface.describeTable( '_Users', { logging : function() {} } );
 queryInterface.createTable( 's', { table_id : { type : Sequelize.INTEGER, primaryKey : true, autoIncrement : true } } );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 queryInterface.insert( null, 'TableWithPK', {}, { raw : true, returning : true, plain : true } );
+ */
 queryInterface.createTable( 'SomeTable', { someEnum : Sequelize.ENUM( 'value1', 'value2', 'value3' ) } );
 queryInterface.createTable( 'SomeTable', { someEnum : { type : Sequelize.ENUM, values : ['b1', 'b2', 'b3'] } } );
 queryInterface.createTable( 't', { someEnum : { type : Sequelize.ENUM, values : ['c1', 'c2', 'c3'], field : 'd' } } );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 queryInterface.createTable( 'User', { name : { type : Sequelize.STRING } }, { schema : 'hero' } );
 queryInterface.rawSelect( 'User', { schema : 'hero', logging : function() {} }, 'name' );
+ */
 queryInterface.renameColumn( '_Users', 'username', 'pseudo', { logging : function() {} } );
 queryInterface.renameColumn( { schema : 'archive', tableName : 'Users' }, 'username', 'pseudo' );
 queryInterface.renameColumn( '_Users', 'username', 'pseudo' );
@@ -918,6 +930,7 @@ s.define( 'UserWithUniqueUsername', {
     username : { type : Sequelize.STRING, unique : { name : 'user_and_email', msg : 'User and email must be unique' } },
     email : { type : Sequelize.STRING, unique : 'user_and_email' }
 } );
+/* NOTE https://github.com/borisyankov/DefinitelyTyped/pull/5590
 s.define( 'UserWithUniqueUsername', {
     user_id : { type : Sequelize.INTEGER },
     email : { type : Sequelize.STRING }
@@ -931,7 +944,7 @@ s.define( 'UserWithUniqueUsername', {
             fields : ['user_id', { attribute : 'email', collate : 'en_US', order : 'DESC', length : 5 }]
         }]
 } );
-
+ */
 s.define( 'TaskBuild', {
     title : { type : Sequelize.STRING, defaultValue : 'a task!' },
     foo : { type : Sequelize.INTEGER, defaultValue : 2 },
@@ -1239,49 +1252,3 @@ s.transaction( function() {
 s.transaction( { isolationLevel : 'SERIALIZABLE' }, function( t ) { return Promise.resolve(); } );
 s.transaction( { isolationLevel : s.Transaction.ISOLATION_LEVELS.SERIALIZABLE }, (t) => Promise.resolve() );
 s.transaction( { isolationLevel : s.Transaction.ISOLATION_LEVELS.READ_COMMITTED }, (t) => Promise.resolve() );
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/sequelize/sequelize.d.ts b/sequelize/sequelize.d.ts
index 41e8410ae..ba465db5e 100644
--- a/sequelize/sequelize.d.ts
+++ b/sequelize/sequelize.d.ts
@@ -2034,6 +2034,7 @@ declare module "sequelize" {
              */
             logging? : boolean | Function;
 
+            transaction?: Transaction;
         }
 
         /**
@@ -2085,6 +2086,9 @@ declare module "sequelize" {
              */
             logging? : boolean | Function;
 
+            silent? : boolean;
+
+            returning? : boolean;
         }
 
         /**
@@ -4878,4 +4882,3 @@ declare module "sequelize" {
     export = sequelize;
 
 }
-
diff --git a/socket.io-client/legacy/socket.io-client-0.9-commonjs-tests.ts b/socket.io-client/legacy/socket.io-client-0.9-commonjs-tests.ts
deleted file mode 100644
index beb8f0fad..000000000
--- a/socket.io-client/legacy/socket.io-client-0.9-commonjs-tests.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import io = require('socket.io-client-0.9');
-
-var socket = io.connect('http://localhost:80');
-
-socket.on('connect', function () {
-    console.log('Connected!');
-    socket.emit('event', 'some test data', function () {
-        console.log('Sent some data.');
-    });
-});
diff --git a/socket.io-client/legacy/socket.io-client-0.9-tests.ts b/socket.io-client/legacy/socket.io-client-0.9-tests.ts
deleted file mode 100644
index 717830628..000000000
--- a/socket.io-client/legacy/socket.io-client-0.9-tests.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-/// <reference path="socket.io-client-0.9.d.ts"/>
-
-var socket = io.connect('http://localhost:80');
-
-socket.on('connect', function () {
-    console.log('Connected!');
-    socket.emit('event', 'some test data', function () {
-        console.log('Sent some data.');
-    });
-});
diff --git a/socket.io-client/legacy/socket.io-client-0.9.d.ts b/socket.io-client/legacy/socket.io-client-0.9.d.ts
deleted file mode 100644
index 0b3626e42..000000000
--- a/socket.io-client/legacy/socket.io-client-0.9.d.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-// Type definitions for socket.io nodejs client
-// Project: http://socket.io/
-// Definitions by: Maido Kaara <https://github.com/v3rm0n>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-declare module "socket.io-client-0.9" {
-  export = io;
-}
-
-declare var io: SocketIOStatic;
-
-interface SocketIOStatic {
-    connect(host: string, details?: any): SocketIOClient.Socket;
-}
-
-declare module SocketIOClient {
-    interface EventEmitter {
-        emit(name: string, ...data: any[]): any;
-        on(ns: string, fn: Function): EventEmitter;
-        addListener(ns: string, fn: Function): EventEmitter;
-        removeListener(ns: string, fn: Function): EventEmitter;
-        removeAllListeners(ns: string): EventEmitter;
-        once(ns: string, fn: Function): EventEmitter;
-        listeners(ns: string): Function[];
-    }
-
-    interface SocketNamespace extends EventEmitter {
-        of(name: string): SocketNamespace;
-        send(data: any, fn: Function): SocketNamespace;
-        emit(name: string): SocketNamespace;
-    }
-
-    interface Socket extends EventEmitter {
-        of(name: string): SocketNamespace;
-        connect(fn: Function): Socket;
-        packet(data: any): Socket;
-        flushBuffer(): void;
-        disconnect(): Socket;
-    }
-}
diff --git a/socket.io-client/legacy/socket.io-client-1.2.0-tests.ts b/socket.io-client/legacy/socket.io-client-1.2.0-tests.ts
deleted file mode 100644
index 3ad8db95f..000000000
--- a/socket.io-client/legacy/socket.io-client-1.2.0-tests.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-/// <reference path="socket.io-client-1.2.0.d.ts"/>
-
-function testUsingWithNodeHTTPServer() {
-    var socket = io('http://localhost');
-    socket.on('news', function (data: any) {
-        console.log(data);
-        socket.emit('my other event', { my: 'data' });
-    });
-}
-
-function testUsingWithExpress() {
-    var socket = io.connect('http://localhost');
-    socket.on('news', function (data: any) {
-        console.log(data);
-        socket.emit('my other event', { my: 'data' });
-    });
-}
-
-function testUsingWithTheExpressFramework() {
-    var socket = io.connect('http://localhost');
-    socket.on('news', function (data: any) {
-        console.log(data);
-        socket.emit('my other event', { my: 'data' });
-    });
-}
-
-function testRestrictingYourselfToANamespace() {
-    var chat = io.connect('http://localhost/chat')
-        , news = io.connect('http://localhost/news');
-
-    chat.on('connect', function () {
-        chat.emit('hi!');
-    });
-
-    news.on('news', function () {
-        news.emit('woot');
-    });
-}
-
-function testSendingAndGettingData() {
-    var socket = io();
-    socket.on('connect', function () {
-        socket.emit('ferret', 'tobi', function (data: any) {
-            console.log(data);
-        });
-    });
-}
-
-function testUsingItJustAsACrossBrowserWebSocket() {
-    var socket = io('http://localhost/');
-    socket.on('connect', function () {
-        socket.emit('hi');
-
-        socket.on('message', function (msg: any) {
-        });
-    });
-}
diff --git a/socket.io-client/legacy/socket.io-client-1.2.0.d.ts b/socket.io-client/legacy/socket.io-client-1.2.0.d.ts
deleted file mode 100644
index c5d783764..000000000
--- a/socket.io-client/legacy/socket.io-client-1.2.0.d.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-// Type definitions for socket.io-client 1.2.0
-// Project: http://socket.io/
-// Definitions by: PROGRE <https://github.com/progre/>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-declare var io: SocketIOClientStatic;
-
-declare module 'socket.io-client' {
-    export = io;
-}
-
-interface SocketIOClientStatic {
-    (host: string, details?: any): SocketIOClient.Socket;
-    (details?: any): SocketIOClient.Socket;
-    connect(host: string, details?: any): SocketIOClient.Socket;
-    connect(details?: any): SocketIOClient.Socket;
-    protocol: number;
-    Socket: { new (...args: any[]): SocketIOClient.Socket };
-    Manager: SocketIOClient.ManagerStatic;
-}
-
-declare module SocketIOClient {
-    interface Socket {
-        on(event: string, fn: Function): Socket;
-        once(event: string, fn: Function): Socket;
-        off(event?: string, fn?: Function): Socket;
-        emit(event: string, ...args: any[]): Socket;
-        listeners(event: string): Function[];
-        hasListeners(event: string): boolean;
-        connected: boolean;
-    }
-
-    interface ManagerStatic {
-        (url: string, opts: any): SocketIOClient.Manager;
-        new (url: string, opts: any): SocketIOClient.Manager;
-    }
-
-    interface Manager {
-        reconnection(v: boolean): Manager;
-        reconnectionAttempts(v: boolean): Manager;
-        reconnectionDelay(v: boolean): Manager;
-        reconnectionDelayMax(v: boolean): Manager;
-        timeout(v: boolean): Manager;
-    }
-}
diff --git a/socket.io/legacy/socket.io-0.9-tests.ts b/socket.io/legacy/socket.io-0.9-tests.ts
deleted file mode 100644
index 0d7e12bb6..000000000
--- a/socket.io/legacy/socket.io-0.9-tests.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import io = require('socket.io-0.9');
-
-var socketManager = io.listen(80);
-
-socketManager.sockets.on('connection', socket => {
-	socket.emit('news', { hello: 'world' });
-	socket.on('my other event', data => {
-		console.log(data);
-	});
-});
-
-// Storing data Associated to a client. 
-// Server side sample 
-io.listen(80).sockets.on('connection', function (socket) {
-    socket.on('set nickname', function (name) {
-        socket.set('nickname', name, function () { socket.emit('ready'); });
-    });
-
-    socket.on('msg', function () {
-        socket.get('nickname', function (err, name) {
-            console.log('Chat message by ', name);
-        });
-    });
-});
\ No newline at end of file
diff --git a/socket.io/legacy/socket.io-0.9-tests.ts.tscparams b/socket.io/legacy/socket.io-0.9-tests.ts.tscparams
deleted file mode 100644
index 8b1378917..000000000
--- a/socket.io/legacy/socket.io-0.9-tests.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/socket.io/legacy/socket.io-0.9.d.ts b/socket.io/legacy/socket.io-0.9.d.ts
deleted file mode 100644
index 5ead4abde..000000000
--- a/socket.io/legacy/socket.io-0.9.d.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-// Type definitions for socket.io
-// Project: http://socket.io/
-// Definitions by: William Orr <https://github.com/worr>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-
-///<reference path='../../node/node.d.ts' />
-
-declare module "socket.io-0.9" {
-	import http = require('http');
-
-	export function listen(server: http.Server, options: any, fn: Function): SocketManager;
-	export function listen(server: http.Server, fn?: Function): SocketManager;
-	export function listen(port: Number): SocketManager;
-
-
-  interface Socket {
-    id: string;
-    json:any;
-    log: any;
-    volatile: any;
-    broadcast: any;
-    handshake: any;
-    in(room: string): Socket;
-    to(room: string): Socket;
-    join(name: string, fn: Function): Socket;
-    leave(name: string, fn: Function): Socket;
-    set(key: string, value: any, fn: Function): Socket;
-    get(key: string, fn: Function): Socket;
-    has(key: string, fn: Function): Socket;
-    del(key: string, fn: Function): Socket;
-    disconnect(): Socket;
-    send(data: any, fn: Function): Socket;
-    emit(ev: any, ...data:any[]): Socket;
-    on(ns: string, fn: Function): Socket;
-  }
-
-  interface SocketNamespace {
-    clients(room: string): Socket[];
-    log: any;
-    store: any;
-    json: any;
-    volatile: any;
-    in(room: string): SocketNamespace;
-    on(evt: string, fn: (socket: Socket) => void): SocketNamespace;
-    to(room: string): SocketNamespace;
-    except(id: any): SocketNamespace;
-    send(data: any): any;
-    emit(ev: any, ...data:any[]): Socket;
-    socket(sid: any, readable: boolean): Socket;
-    authorization(fn: Function): SocketNamespace;
-  }
-
-  interface SocketManager {
-    get(key: any): any;
-    set(key: any, value: any): SocketManager;
-    enable(key: any): SocketManager;
-    disable(key: any): SocketManager;
-    enabled(key: any): boolean;
-    disabled(key: any): boolean;
-    configure(env: string, fn: Function): SocketManager;
-    configure(fn: Function): SocketManager;
-    of(nsp: string): SocketNamespace;
-    on(ns: string, fn: Function): SocketManager;
-    sockets: SocketNamespace;
-  }
-
-
-}
-
diff --git a/socket.io/legacy/socket.io-1.2.0-tests.ts b/socket.io/legacy/socket.io-1.2.0-tests.ts
deleted file mode 100644
index c2664f9cd..000000000
--- a/socket.io/legacy/socket.io-1.2.0-tests.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-/// <reference path="socket.io-1.2.0.d.ts"/>
-
-import socketIO = require('socket.io-1.2.0');
-
-function testUsingWithNodeHTTPServer() {
-    var app = require('http').createServer(handler);
-    var io = socketIO(app);
-    var fs = require('fs');
-
-    app.listen(80);
-
-    function handler(req: any, res: any) {
-        fs.readFile(__dirname + '/index.html',
-            function (err: any, data: any) {
-                if (err) {
-                    res.writeHead(500);
-                    return res.end('Error loading index.html');
-                }
-
-                res.writeHead(200);
-                res.end(data);
-            });
-    }
-
-    io.on('connection', function (socket) {
-        socket.emit('news', { hello: 'world' });
-        socket.on('my other event', function (data: any) {
-            console.log(data);
-        });
-    });
-}
-
-function testUsingWithExpress() {
-    var app = require('express')();
-    var server = require('http').Server(app);
-    var io = socketIO(server);
-
-    server.listen(80);
-
-    app.get('/', function (req: any, res: any) {
-        res.sendfile(__dirname + '/index.html');
-    });
-
-    io.on('connection', function (socket) {
-        socket.emit('news', { hello: 'world' });
-        socket.on('my other event', function (data: any) {
-            console.log(data);
-        });
-    });
-}
-
-function testUsingWithTheExpressFramework() {
-    var app = require('express').createServer();
-    var io = socketIO(app);
-
-    app.listen(80);
-
-    app.get('/', function (req: any, res: any) {
-        res.sendfile(__dirname + '/index.html');
-    });
-
-    io.on('connection', function (socket) {
-        socket.emit('news', { hello: 'world' });
-        socket.on('my other event', function (data: any) {
-            console.log(data);
-        });
-    });
-}
-
-function testSendingAndReceivingEvents() {
-    var io = socketIO(80);
-
-    io.on('connection', function (socket) {
-        io.emit('this', { will: 'be received by everyone' });
-
-        socket.on('private message', function (from: any, msg: any) {
-            console.log('I received a private message by ', from, ' saying ', msg);
-        });
-
-        socket.on('disconnect', function () {
-            io.sockets.emit('user disconnected');
-        });
-    });
-}
-
-function testRestrictingYourselfToANamespace() {
-    var io = socketIO.listen(80);
-    var chat = io
-        .of('/chat')
-        .on('connection', function (socket) {
-            socket.emit('a message', {
-                that: 'only'
-                , '/chat': 'will get'
-            });
-            chat.emit('a message', {
-                everyone: 'in'
-                , '/chat': 'will get'
-            });
-        });
-
-    var news = io
-        .of('/news')
-        .on('connection', function (socket) {
-            socket.emit('item', { news: 'item' });
-        });
-}
-
-function testSendingVolatileMessages() {
-    var io = socketIO.listen(80);
-
-    io.sockets.on('connection', function (socket) {
-        var tweets = setInterval(function () {
-            socket.volatile.emit('bieber tweet', {});
-        }, 100);
-
-        socket.on('disconnect', function () {
-            clearInterval(tweets);
-        });
-    });
-}
-
-function testSendingAndGettingData() {
-    var io = socketIO.listen(80);
-
-    io.sockets.on('connection', function (socket) {
-        socket.on('ferret', function (name: any, fn: any) {
-            fn('woot');
-        });
-    });
-}
-
-function testBroadcastingMessages() {
-    var io = socketIO.listen(80);
-
-    io.sockets.on('connection', function (socket) {
-        socket.broadcast.emit('user connected');
-    });
-}
-
-function testUsingItJustAsACrossBrowserWebSocket() {
-    var io = socketIO.listen(80);
-
-    io.sockets.on('connection', function (socket) {
-        socket.on('message', function () { });
-        socket.on('disconnect', function () { });
-    });
-}
diff --git a/socket.io/legacy/socket.io-1.2.0.d.ts b/socket.io/legacy/socket.io-1.2.0.d.ts
deleted file mode 100644
index 01b5e0836..000000000
--- a/socket.io/legacy/socket.io-1.2.0.d.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-// Type definitions for socket.io 1.2.0
-// Project: http://socket.io/
-// Definitions by: PROGRE <https://github.com/progre/>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-///<reference path='../../node/node.d.ts' />
-
-declare module 'socket.io-1.2.0' {
-    var server: SocketIOStatic;
-
-    export = server;
-}
-
-interface SocketIOStatic {
-    (): SocketIO.Server;
-    (srv: any, opts?: any): SocketIO.Server;
-    (port: number, opts?: any): SocketIO.Server;
-    (opts: any): SocketIO.Server;
-
-    listen: SocketIOStatic;
-}
-
-declare module SocketIO {
-    interface Server {
-        serveClient(v: boolean): Server;
-        path(v: string): Server;
-        adapter(v: any): Server;
-        origins(v: string): Server;
-        sockets: Namespace;
-        attach(srv: any, opts?: any): Server;
-        attach(port: number, opts?: any): Server;
-        listen(srv: any, opts?: any): Server;
-        listen(port: number, opts?: any): Server;
-        bind(srv: any): Server;
-        onconnection(socket: any): Server;
-        of(nsp: string): Namespace;
-        emit(name: string, ...args: any[]): Socket;
-        use(fn: Function): Namespace;
-
-        on(event: 'connection', listener: (socket: Socket) => void): Namespace;
-        on(event: 'connect', listener: (socket: Socket) => void): Namespace;
-        on(event: string, listener: Function): Namespace;
-    }
-
-    interface Namespace extends NodeJS.EventEmitter {
-        name: string;
-        connected: { [id: string]: Socket };
-        use(fn: Function): Namespace;
-        in(room: string): Namespace;
-
-        on(event: 'connection', listener: (socket: Socket) => void): Namespace;
-        on(event: 'connect', listener: (socket: Socket) => void): Namespace;
-        on(event: string, listener: Function): Namespace;
-    }
-
-    interface Socket {
-        rooms: string[];
-        client: Client;
-        conn: any;
-        request: any;
-        id: string;
-        handshake: {
-            headers: any;
-            time: string;
-            address: any;
-            xdomain: boolean;
-            secure: boolean;
-            issued: number;
-            url: string;
-            query: any;
-        };
-
-        emit(name: string, ...args: any[]): Socket;
-        join(name: string, fn?: Function): Socket;
-        leave(name: string, fn?: Function): Socket;
-        to(room: string): Socket;
-        in(room: string): Socket;
-        send(...args: any[]): Socket;
-        write(...args: any[]): Socket;
-
-        on(event: string, listener: Function): Socket;
-        once(event: string, listener: Function): Socket;
-        removeListener(event: string, listener: Function): Socket;
-        removeAllListeners(event: string): Socket;
-        broadcast: Socket;
-        volatile: Socket;
-        connected: boolean;
-        disconnect(close?: boolean): Socket;
-    }
-
-    interface Client {
-        conn: any;
-        request: any;
-        id: string;
-    }
-}
diff --git a/source-map/source-map-tests.ts b/source-map/source-map-tests.ts
index f7ad78e85..3ec6b666d 100644
--- a/source-map/source-map-tests.ts
+++ b/source-map/source-map-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./source-map.d.ts" />
+
 import SourceMap = require('source-map');
 
 function testSourceMapConsumer() {
@@ -162,4 +164,4 @@ function testSourceNode() {
         result = node.toStringWithSourceMap();
         result = node.toStringWithSourceMap(sos);
     }
-}
\ No newline at end of file
+}
diff --git a/stack-trace/stack-trace-tests.ts b/stack-trace/stack-trace-tests.ts
index a0b2f8d55..c18f63751 100644
--- a/stack-trace/stack-trace-tests.ts
+++ b/stack-trace/stack-trace-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./stack-trace.d.ts" />
+
 import stackTrace = require('stack-trace');
 
 var currentStackTrace = stackTrace.get();
diff --git a/stampit/stampit-1.2.0.d.ts b/stampit/stampit-1.2.0.d.ts
deleted file mode 100644
index 8d46e7477..000000000
--- a/stampit/stampit-1.2.0.d.ts
+++ /dev/null
@@ -1,155 +0,0 @@
-// Type definitions for stampit
-// Project: https://github.com/ericelliott/stampit
-// Definitions by: Vasyl Boroviak <https://github.com/koresar>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-declare var stampit: stampit.Stampit;
-
-declare module stampit {
-    interface Stampit {
-        /**
-         * Return a factory (akaStamp) function that will produce new objects using the
-         * prototypes that are passed in or composed.
-         * @param methods A map of method names and bodies for delegation.
-         * @param state A map of property names and values to clone for each new object.
-         * @param enclose A closure (function) used to create private data and privileged methods.
-         * */
-        (methods?:{}, state?:{}, enclose?:{(...encloseArgs:any[]): void}[]):stampit.Stamp;
-
-        /**
-         * Take two or more Stamps and combine them to produce a new Stamp.
-         * Combining overrides properties with last-in priority.
-         * @param stamps Stamps produced by stampit.
-         * @return A new Stamp made of all the given.
-         */
-        compose(...stamps:Stamp[]): Stamp;
-
-        /**
-         * Take a destination object followed by one or more source objects,
-         * and copy the source object properties to the destination object,
-         * with last in priority overrides.
-         * @param destination An object to copy properties to.
-         * @param source Objects to copy properties from.
-         * @return The destination object.
-         */
-        mixIn(destination:any, ...source:any[]): any;
-
-        /**
-         * Alias for mixIn.
-         * Take a destination object followed by one or more source objects,
-         * and copy the source object properties to the destination object,
-         * with last in priority overrides.
-         * @param destination An object to copy properties to.
-         * @param source Objects to copy properties from.
-         * @return The destination object.
-         */
-        extend(destination:any, ...source:any[]): any;
-
-        /**
-         * Check if an object is a Stamp.
-         * @param obj An object to check.
-         * @return true if the object is a Stamp; otherwise - false.
-         */
-        isStamp(obj:any): boolean;
-
-        /**
-         * Take an old-fashioned JS constructor and return a Stamp
-         * that you can freely compose with other Stamps.
-         * @param Constructor Old-fashioned constructor function.
-         * @return A new Stamp based on the given constructor.
-         */
-        convertConstructor(Constructor:any): Stamp;
-    }
-
-    /**
-     * A factory function that will produce new objects using the
-     * prototypes that are passed in or composed.
-     */
-    export interface Stamp {
-        /**
-         * Just like calling stamp() invokes the stamp and returns a new object instance.
-         * @param state Properties you wish to set on the new objects.
-         * @param encloseArgs The remaining arguments are passed to all .enclose() functions.
-         * WARNING Avoid using two different .enclose() functions that expect different arguments.
-         * .enclose() functions that take arguments should not be considered safe to compose
-         * with other .enclose() functions that also take arguments. Taking arguments with
-         * an .enclose() function is an anti-pattern that should be avoided, when possible.
-         * @return A new object composed of the Stamps and prototypes provided.
-         */
-        (state?:{}, ...encloseArgs:any[]): any;
-
-        /**
-         * Just like calling stamp(), stamp.create() invokes the stamp and returns a new instance.
-         * @param state Properties you wish to set on the new objects.
-         * @param encloseArgs The remaining arguments are passed to all .enclose() functions.
-         * WARNING Avoid using two different .enclose() functions that expect different arguments.
-         * .enclose() functions that take arguments should not be considered safe to compose
-         * with other .enclose() functions that also take arguments. Taking arguments with
-         * an .enclose() function is an anti-pattern that should be avoided, when possible.
-         * @return A new object composed of the Stamps and prototypes provided.
-         */
-        create(state?:{}, ...encloseArgs:any[]): any;
-
-        /**
-         * An object map containing the fixed prototypes.
-         */
-        fixed: Fixed;
-
-        /**
-         * Add methods to the methods prototype. Chainable.
-         * @param methods Object(s) containing map of method names and bodies for delegation.
-         * @return Self.
-         */
-        methods(...methods:{}[]): Stamp;
-
-        /**
-         * Take n objects and add them to the state prototype. Changes `this` object. Chainable.
-         * @param states Object(s) containing map of property names and values to clone for each new object.
-         * @return Self.
-         */
-        state(...states:{}[]): Stamp;
-
-        /**
-         * Take n functions, an array of functions, or n objects and add the functions to the enclose prototype.
-         * Functions passed into .enclose() are called any time an object is instantiated.
-         * That happens when the stamp function is invoked, or when the .create() method is called.
-         * Changes `this` object. Chainable.
-         * @param functions Closures (functions) used to create private data and privileged methods.
-         * @return Self.
-         */
-        enclose(...functions:{(...encloseArgs:any[]): void}[]): Stamp;
-
-        /**
-         * Take n functions, an array of functions, or n objects and add the functions to the enclose prototype.
-         * Functions passed into .enclose() are called any time an object is instantiated.
-         * That happens when the stamp function is invoked, or when the .create() method is called.
-         * Changes `this` object. Chainable.
-         * @param methods Function properties of these objects will be treated as closure functions.
-         * @return Self.
-         */
-        enclose(...methods:{}[]): Stamp;
-
-        /**
-         * Take one or more Stamps and
-         * combine them with `this` to produce and return a new Stamp.
-         * Combining overrides properties with last-in priority.
-         * NOT chainable.
-         * @param stamps Stampit factories, aka Stamps.
-         * @return A new Stamp composed from arguments and `this`.
-         */
-        compose(...stamps:Stamp[]): Stamp;
-    }
-
-    /**
-     * An object map containing the fixed prototypes.
-     */
-    interface Fixed {
-        methods: {};
-        state: {};
-        enclose: {(...encloseArgs:any[]): void}[];
-    }
-}
-
-declare module "stampit" {
-    export = stampit;
-}
\ No newline at end of file
diff --git a/stampit/stampit-tests-1.2.0.ts b/stampit/stampit-tests-1.2.0.ts
deleted file mode 100644
index ce404651a..000000000
--- a/stampit/stampit-tests-1.2.0.ts
+++ /dev/null
@@ -1,168 +0,0 @@
-/// <reference path="stampit-1.2.0.d.ts" />
-
-var a = stampit().enclose(() => {
-    var a = 'a';
-    this.getA = () => {
-        return a;
-    };
-});
-a(); // Object -- so far so good.
-a().getA(); // "a"
-
-
-var b = stampit().enclose(function () {
-    var a = 'b';
-    this.getB = function () {
-        return a;
-    };
-});
-
-
-var c = stampit.compose(a, b);
-var foo = c(); // we won't throw this one away...
-foo.getA(); // "a"
-foo.getB(); // "b"
-
-
-// Some more privileged methods, with some private data.
-// Use stampit.mixIn() to make this feel declarative:
-var availability = stampit().enclose(function () {
-    var isOpen = false; // private
-
-    return stampit.mixIn(this, {
-        open: function open() {
-            isOpen = true;
-            return this;
-        },
-        close: function close() {
-            isOpen = false;
-            return this;
-        },
-        isOpen: function isOpenMethod() {
-            return isOpen;
-        }
-    });
-});
-// Hre's a mixin with public methods, and some state:
-var membership = stampit({
-        members: {},
-        add: function (member: any) {
-            this.members[member.name] = member;
-            return this;
-        },
-        getMember: function (name: any) {
-            return this.members[name];
-        }
-    },
-    {
-        members: {}
-    });
-// Let's set some defaults:
-var defaults = stampit().state({
-    name: 'The Saloon',
-    specials: 'Whisky, Gin, Tequila'
-});
-
-// Classical inheritance has nothing on this. No parent/child coupling. No deep inheritance hierarchies.
-// Just good, clean code reusability.
-var bar = stampit.compose(defaults, availability, membership);
-// Note that you can override state on instantiation:
-var myBar = bar({name: 'Moe\'s'});
-// Silly, but proves that everything is as it should be.
-myBar.add({name: 'Homer' }).open().getMember('Homer');
-
-
-
-var myStamp = stampit().methods({
-    foo: function () {
-        return 'foo';
-    },
-    methodOverride: function () {
-        return false;
-    }
-}).methods({
-    bar: function () {
-        return 'bar'
-    },
-    methodOverride: function () {
-        return true;
-    }
-});
-
-myStamp.state({
-    foo: {bar: 'bar'},
-    stateOverride: false
-}).state({
-    bar: 'bar',
-    stateOverride: true
-});
-
-myStamp.enclose(function () {
-    var secret = 'foo';
-
-    this.getSecret = function () {
-        return secret;
-    };
-}).enclose(function () {
-    this.a = true;
-}).enclose({
-    bar: function bar() {
-        this.b = true;
-    }
-}, {
-    baz: function baz() {
-        this.c = true;
-    }
-});
-
-var obj = myStamp.create();
-obj.getSecret && obj.a && obj.b && obj.c; // true
-
-var newStamp = stampit(null, { defaultNum: 1 }).compose(myStamp);
-
-
-
-var obj1 = stampit().methods({
-    a: function () { return 'a'; }
-}, {
-    b: function () { return 'b'; }
-}).create();
-
-var obj2 = stampit().state({
-    a: 'a'
-}, {
-    b: 'b'
-}).create();
-
-var obj = defaults.compose(newStamp, membership, availability).create();
-
-
-
-// The old constructor / class thing...
-var Constructor = function Constructor() {
-    this.thing = 'initialized';
-};
-Constructor.prototype.foo = function foo() { return 'foo'; };
-
-// The conversion
-var oldskool = stampit.convertConstructor(Constructor);
-
-// A new stamp to compose with...
-var newskool = stampit().methods({
-    bar: function bar() { return 'bar'; }
-    // your methods here...
-}).enclose(function () {
-    this.baz = 'baz';
-});
-
-// Now you can compose those old constructors just like you could
-// with any other stamp...
-var myThing = stampit.compose(oldskool, newskool);
-
-var t = myThing();
-
-t.thing; // 'initialized',
-
-t.foo(); // 'foo',
-
-t.bar(); // 'bar'
diff --git a/stampit/stampit-tests.ts b/stampit/stampit-tests.ts
index f813482d8..07d3fe858 100644
--- a/stampit/stampit-tests.ts
+++ b/stampit/stampit-tests.ts
@@ -1,5 +1,6 @@
 /// <reference path="stampit.d.ts" />
-import stampit = require('./stampit.d');
+
+import stampit = require('stampit');
 
 var a = stampit().init((options) => {
     var a = options.args[0];
diff --git a/stampit/stampit.d.ts b/stampit/stampit.d.ts
index e56035c4f..5b03237f2 100644
--- a/stampit/stampit.d.ts
+++ b/stampit/stampit.d.ts
@@ -294,4 +294,6 @@ declare module stampit {
     export function convertConstructor(Constructor:any): Stamp;
 }
 
-export = stampit;
+declare module "stampit" {
+    export = stampit;
+}
diff --git a/through/through-tests.ts b/through/through-tests.ts
index 93fc6d2fa..35822c9e8 100644
--- a/through/through-tests.ts
+++ b/through/through-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./through.d.ts" />
+
 import through = require('through');
 
 var i = 0;
@@ -6,4 +8,4 @@ through(
 		this.queue((i++).toString());
 	}, function () {
 		this.queue(null);
-	}, { autoDestroy: true }).pipe(process.stdout);
\ No newline at end of file
+	}, { autoDestroy: true }).pipe(process.stdout);
diff --git a/tspromise/tspromise-tests.ts b/tspromise/tspromise-tests.ts
index fcb52212a..e1ce0c1d5 100644
--- a/tspromise/tspromise-tests.ts
+++ b/tspromise/tspromise-tests.ts
@@ -4,7 +4,7 @@ import Promise = require('tspromise');
 
 var MyFuncFunc = Promise.async((a: boolean, b: number) => {
 	console.log('[a] ' + a);
-	yield(Promise.waitAsync(1000));
+	// NOTE( https://github.com/borisyankov/DefinitelyTyped/pull/5590 ) yield(Promise.waitAsync(1000));
 	console.log('[b]' + b);
 });
 
@@ -18,4 +18,4 @@ Promise.all([Promise.waitAsync(10), Promise.waitAsync(20)]).then(() => {
 	throw (new Error());
 }).catch((e) => {
 	console.log(e.message);
-});
\ No newline at end of file
+});
diff --git a/uniq/uniq-tests.ts b/uniq/uniq-tests.ts
index b9facc8e2..1dc3d6fd8 100644
--- a/uniq/uniq-tests.ts
+++ b/uniq/uniq-tests.ts
@@ -1,3 +1,5 @@
+/// <reference path="./uniq.d.ts" />
+
 import unique = require("uniq");
 var data = [1, 2, 2, 3, 4, 5, 5, 5, 6];
 var datastr = ["1", "2", "2", "3", "4", "5", "5", "5", "6"];
diff --git a/vinyl-fs/vinyl-fs-tests.ts b/vinyl-fs/vinyl-fs-tests.ts
index a29746166..c8ca09070 100644
--- a/vinyl-fs/vinyl-fs-tests.ts
+++ b/vinyl-fs/vinyl-fs-tests.ts
@@ -229,7 +229,7 @@ var dataWrap = function (fn: any) {
 };
 
 var realMode = function (n: any) {
-   return n & 07777;
+   return n & parseInt("07777", 8);
 };
 
 describe('dest stream', function () {
@@ -372,7 +372,7 @@ describe('dest stream', function () {
       var expectedContents = fs.readFileSync(inputPath);
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, "./out-fixtures");
-      var expectedMode = 0655;
+      var expectedMode = parseInt("0655", 8);
 
       var expectedFile = new File({
          base: inputBase,
@@ -412,7 +412,7 @@ describe('dest stream', function () {
       var expectedContents = fs.readFileSync(inputPath);
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, "./out-fixtures");
-      var expectedMode = 0655;
+      var expectedMode = parseInt("0655", 8);
 
       var contentStream = through.obj();
       var expectedFile = new File({
@@ -456,7 +456,7 @@ describe('dest stream', function () {
       var expectedPath = path.join(__dirname, "./out-fixtures/test");
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, "./out-fixtures");
-      var expectedMode = 0655;
+      var expectedMode = parseInt("0655", 8);
 
       var expectedFile = new File({
          base: inputBase,
@@ -555,7 +555,7 @@ var dataWrap = function (fn: any) {
 };
 
 var realMode = function (n: any) {
-   return n & 07777;
+   return n & parseInt("07777", 8);
 };
 
 describe('symlink stream', function () {
@@ -706,7 +706,7 @@ describe('symlink stream', function () {
       var expectedContents = fs.readFileSync(inputPath);
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, './out-fixtures');
-      var expectedMode = 0655;
+      var expectedMode = parseInt("0655", 8);
 
       var expectedFile = new File({
          base: inputBase,
@@ -746,7 +746,7 @@ describe('symlink stream', function () {
       var expectedContents = fs.readFileSync(inputPath);
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, './out-fixtures');
-      var expectedMode = 0655;
+      var expectedMode = parseInt("0655", 8);
 
       var contentStream = through.obj();
       var expectedFile = new File({
@@ -790,7 +790,7 @@ describe('symlink stream', function () {
       var expectedPath = path.join(__dirname, './out-fixtures/wow');
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, './out-fixtures');
-      var expectedMode = 0655;
+      var expectedMode = parseInt("0655", 8);
 
       var expectedFile = new File({
          base: inputBase,
@@ -830,8 +830,8 @@ describe('symlink stream', function () {
       var inputBase = path.join(__dirname, './fixtures');
       var inputPath = path.join(__dirname, './fixtures/wow/suchempty');
       var expectedBase = path.join(__dirname, './out-fixtures/wow');
-      var expectedDirMode = 0755;
-      var expectedFileMode = 0655;
+      var expectedDirMode = parseInt("0755", 8);
+      var expectedFileMode = parseInt("0655", 8);
 
       var firstFile = new File({
          base: inputBase,
@@ -867,7 +867,7 @@ describe('symlink stream', function () {
       var expectedContents = fs.readFileSync(inputPath);
       var expectedCwd = __dirname;
       var expectedBase = path.join(__dirname, './out-fixtures');
-      var expectedMode = 0722;
+      var expectedMode = parseInt("0722", 8);
 
       var expectedFile = new File({
          base: inputBase,
diff --git a/vinyl-fs/vinyl-fs.d.ts b/vinyl-fs/vinyl-fs.d.ts
index 98bb34339..70fc32aba 100644
--- a/vinyl-fs/vinyl-fs.d.ts
+++ b/vinyl-fs/vinyl-fs.d.ts
@@ -21,7 +21,7 @@ declare module "vinyl-fs" {
       cwd?: string;
 
       /**
-      * Specifies the folder relative to the cwd 
+      * Specifies the folder relative to the cwd
       * This is used to determine the file names when saving in .dest()
       * Default is where the glob begins
       */
@@ -34,16 +34,16 @@ declare module "vinyl-fs" {
       */
       buffer?: boolean;
 
-      /** 
+      /**
       * Setting this to false will ignore the contents of the file and disable writing to disk to speed up operations
-      * Defaults to true 
+      * Defaults to true
       */
       read?: boolean;
 
       /**  Only find files that have been modified since the time specified */
       since?: Date|number;
 
-      /** Setting this to true will create a duplex stream, one that passes through items and emits globbed files. 
+      /** Setting this to true will create a duplex stream, one that passes through items and emits globbed files.
       * Defaults to false */
       passthrough?: boolean;
 
@@ -63,7 +63,7 @@ declare module "vinyl-fs" {
 
    /**
    * This is just a glob-watcher
-   * 
+   *
    * @param globs Takes a glob string or an array of glob strings as the first argument
    * Globs are executed in order, so negations should follow positive globs
    * fs.src(['!b*.js', '*.js']) would not exclude any files, but this would: fs.src(['*.js', '!b*.js'])
@@ -72,7 +72,7 @@ declare module "vinyl-fs" {
 
    /**
    * This is just a glob-watcher
-   * 
+   *
    * @param globs Takes a glob string or an array of glob strings as the first argument
    * Globs are executed in order, so negations should follow positive globs
    * fs.src(['!b*.js', '*.js']) would not exclude any files, but this would: fs.src(['*.js', '!b*.js'])
@@ -89,8 +89,8 @@ declare module "vinyl-fs" {
    * @param folder destination folder
    */
    function dest(folder: string, opt?: {
-      /** Specify the working directory the folder is relative to 
-      * Default is process.cwd() 
+      /** Specify the working directory the folder is relative to
+      * Default is process.cwd()
       */
       cwd?: string;
 
@@ -125,14 +125,17 @@ declare module "vinyl-fs" {
    * cwd, base, and path will be overwritten to match the folder
    */
    function symlink(folder: string, opts?: {
-      /** 
-      * Specify the working directory the folder is relative to 
+      /**
+      * Specify the working directory the folder is relative to
       * Default is process.cwd()
       */
       cwd?: string;
 
-      /** 
-      * Specify the mode the directory should be created with 
+      /** Specify the mode the directory should be created with. Default is the process mode */
+      mode?: number|string;
+
+      /**
+      * Specify the mode the directory should be created with
       * Default is the process mode
       */
       dirMode?: number
@@ -146,14 +149,14 @@ declare module "vinyl-fs" {
    */
    function symlink(getFolderPath: (File: File) => string, opts?:
       {
-         /** 
-         * Specify the working directory the folder is relative to 
+         /**
+         * Specify the working directory the folder is relative to
          * Default is process.cwd()
          */
          cwd?: string;
 
-         /** 
-         * Specify the mode the directory should be created with 
+         /**
+         * Specify the mode the directory should be created with
          * Default is the process mode
          */
          dirMode?: number
diff --git a/webrtc/RTCPeerConnection.d.ts b/webrtc/RTCPeerConnection.d.ts
index 9e96a86c8..0e186fd27 100644
--- a/webrtc/RTCPeerConnection.d.ts
+++ b/webrtc/RTCPeerConnection.d.ts
@@ -360,5 +360,4 @@ interface Window{
   RTCIceCandidate: RTCIceCandidate;
   webkitRTCIceCandidate: webkitRTCIceCandidate;
   mozRTCIceCandidate: mozRTCIceCandidate;
-  URL: URL;
 }