diff --git a/ember/ember-tests.ts b/ember/ember-tests.ts
index 39e960e00..ef9b7e6d1 100644
--- a/ember/ember-tests.ts
+++ b/ember/ember-tests.ts
@@ -2,9 +2,9 @@
 /// <reference path="../handlebars/handlebars.d.ts" />
 
 
-var App;
+var App : any;
 
-App = Em.Application.create();
+App = Em.Application.create<Em.Application>();
 
 App.president = Em.Object.create({
     name: 'Barack Obama'
@@ -27,7 +27,7 @@ declare class MyPerson extends Em.Object {
 }
 
 var Person1 = Em.Object.extend<typeof MyPerson>({
-    say: (thing) => {
+    say: (thing: string) => {
         alert(thing);
     }
 });
@@ -119,7 +119,7 @@ App.AlertView = Em.View.extend({
 
 App.ListingView = Em.View.extend({
     templateName: 'listing',
-    edit: (event) => {
+    edit: (event: any) => {
         event.view.set('isEditing', true);
     }
 });
@@ -133,7 +133,7 @@ App.userController = Em.Object.create({
     })
 });
 
-Handlebars.registerHelper('highlight', function(property, options) {
+Handlebars.registerHelper('highlight', function(property: string, options: any) {
     var value = Em.Handlebars.get(this, property, options);
     return new Handlebars.SafeString('<span class="highlight">' + value + '</span>');
 });
@@ -195,7 +195,7 @@ people2.everyProperty('isHappy', true);
 people2.someProperty('isHappy', true);
 
 // Examples taken from http://emberjs.com/api/classes/Ember.RSVP.Promise.html
-var promise = new Ember.RSVP.Promise(function(resolve, reject) {
+var promise = new Ember.RSVP.Promise(function(resolve: Function, reject: Function) {
   // on success
   resolve('ok!');
 
@@ -203,8 +203,8 @@ var promise = new Ember.RSVP.Promise(function(resolve, reject) {
   reject('no-k!');
 });
 
-promise.then(function(value) {
+promise.then(function(value: any) {
   // on fulfillment
-}, function(reason) {
+}, function(reason: any) {
   // on rejection
 });
diff --git a/ember/ember.d.ts b/ember/ember.d.ts
index b6cdde9d6..22cbb8ab5 100644
--- a/ember/ember.d.ts
+++ b/ember/ember.d.ts
@@ -11,15 +11,147 @@ declare var Handlebars: HandlebarsStatic;
 declare module EmberStates {
 
     interface Transition {
-        abort(): void;
-        addInitialStates(): void;
-        matchContextsToStates(contexts: any[]): void;
-        normalize(manager: Ember.StateManager, contexts: any[]): void;
-        removeUnchangedContexts(manager: Ember.StateManager): void;
-        retry(): void;
-        sendEvents(eventName: string, sendRecursiveArguments: boolean, isUnhandledPass: boolean): void;
-        sendRecursively(event: string, currentState: Ember.State, isUnhandledPass: boolean): void;
         targetName: string;
+        urlMethod: string;
+        intent: any;
+        params: {}|any;
+        pivotHandler: any;
+        resolveIndex: number;
+        handlerInfos: any;
+        resolvedModels: {}|any;
+        isActive: boolean;
+        state: any;
+        queryParams: {}|any;
+        queryParamsOnly: boolean;
+
+        isTransition: boolean;
+
+        /**
+          The Transition's internal promise. Calling `.then` on this property
+          is that same as calling `.then` on the Transition object itself, but
+          this property is exposed for when you want to pass around a
+          Transition's promise, but not the Transition object itself, since
+          Transition object can be externally `abort`ed, while the promise
+          cannot.
+         */
+        promise: Ember.RSVP.Promise;
+
+        /**
+          Custom state can be stored on a Transition's `data` object.
+          This can be useful for decorating a Transition within an earlier
+          hook and shared with a later hook. Properties set on `data` will
+          be copied to new transitions generated by calling `retry` on this
+          transition.
+         */
+        data: any;
+
+        /**
+          A standard promise hook that resolves if the transition
+          succeeds and rejects if it fails/redirects/aborts.
+  
+          Forwards to the internal `promise` property which you can
+          use in situations where you want to pass around a thennable,
+          but not the Transition itself.
+  
+          @arg {Function} onFulfilled
+          @arg {Function} onRejected
+          @arg {String} label optional string for labeling the promise. Useful for tooling.
+          @return {Promise}
+         */
+        then(onFulfilled: Function, onRejected: Function, label?: string): Ember.RSVP.Promise;
+
+        /**
+          Forwards to the internal `promise` property which you can
+          use in situations where you want to pass around a thennable,
+          but not the Transition itself.
+  
+          @method catch
+          @arg {Function} onRejection
+          @arg {String} label optional string for labeling the promise.
+          Useful for tooling.
+          @return {Promise}
+         */
+        catch(onRejection: Function, label?: string): Ember.RSVP.Promise;
+
+        /**
+          Forwards to the internal `promise` property which you can
+          use in situations where you want to pass around a thennable,
+          but not the Transition itself.
+  
+          @method finally
+          @arg {Function} callback
+          @arg {String} label optional string for labeling the promise.
+          Useful for tooling.
+          @return {Promise}
+         */
+        finally(callback: Function, label?: string): Ember.RSVP.Promise;
+        
+        /**
+         Aborts the Transition. Note you can also implicitly abort a transition
+         by initiating another transition while a previous one is underway.
+        */
+        abort(): EmberStates.Transition;
+        normalize(manager: Ember.StateManager, contexts: any[]): void;
+
+        /**
+         Retries a previously-aborted transition (making sure to abort the
+         transition if it's still active). Returns a new transition that
+         represents the new attempt to transition.
+        */
+        retry(): EmberStates.Transition;
+
+        /**
+          Sets the URL-changing method to be employed at the end of a
+          successful transition. By default, a new Transition will just
+          use `updateURL`, but passing 'replace' to this method will
+          cause the URL to update using 'replaceWith' instead. Omitting
+          a parameter will disable the URL change, allowing for transitions
+          that don't update the URL at completion (this is also used for
+          handleURL, since the URL has already changed before the
+          transition took place).
+
+          @arg {String} method the type of URL-changing method to use
+            at the end of a transition. Accepted values are 'replace',
+            falsy values, or any other non-falsy value (which is
+            interpreted as an updateURL transition).
+
+          @return {Transition} this transition
+         */
+        method(method: string): EmberStates.Transition;
+
+        /**
+          Fires an event on the current list of resolved/resolving
+          handlers within this transition. Useful for firing events
+          on route hierarchies that haven't fully been entered yet.
+  
+          Note: This method is also aliased as `send`
+  
+          @arg {Boolean} [ignoreFailure=false] a boolean specifying whether unhandled events throw an error
+          @arg {String} name the name of the event to fire
+         */
+        trigger(ignoreFailure:boolean, eventName: string): void;
+        /**
+          Fires an event on the current list of resolved/resolving
+          handlers within this transition. Useful for firing events
+          on route hierarchies that haven't fully been entered yet.
+  
+          Note: This method is also aliased as `send`
+  
+          @arg {String} name the name of the event to fire
+         */
+        trigger(eventName: string): void;
+
+        /**
+          Transitions are aborted and their promises rejected
+          when redirects occur; this method returns a promise
+          that will follow any redirects that occur and fulfill
+          with the value fulfilled by any redirecting transitions
+          that occur.
+  
+          @return {Promise} a promise that fulfills with the same
+            value that the final redirecting transition fulfills with
+         */
+        followRedirects(): Ember.RSVP.Promise;
     }
 
 }
@@ -61,7 +193,7 @@ interface String {
 }
 
 interface Array<T> {
-    constructor(arr: any[]);
+    constructor(arr: any[]): void;
     activate(): void;
     addArrayObserver(target: any, opts?: EnumerableConfigurationOptions): any[];
     addEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): any[];
@@ -88,16 +220,40 @@ interface Array<T> {
     every(callback: Function, target?: any): boolean;
     everyBy(key: string, value?: string): boolean;
     everyProperty(key: string, value?: any): boolean;
-    filter(callback: Function, target: any): any[];
+    filter(callback: Function, target?: any): any[];
     filterBy(key: string, value?: string): any[];
-    find(callback: Function, target: any): any;
+
+ /**
+    Returns the first item in the array for which the callback returns true.
+    This method works similar to the `filter()` method defined in JavaScript 1.6
+    except that it will stop working on the array once a match is found.
+    The callback method you provide should have the following signature (all
+    parameters are optional):
+    ```javascript
+    function(item, index, enumerable);
+    ```
+    - `item` is the current item in the iteration.
+    - `index` is the current index in the iteration.
+    - `enumerable` is the enumerable object itself.
+    It should return the `true` to include the item in the results, `false`
+    otherwise.
+    Note that in addition to a callback, you can also pass an optional target
+    object that will be set as `this` on the context. This is a good way
+    to give your iterator function access to the current object.
+    @function find
+    @arg callback The callback to execute
+    @arg {Object} [target] The target object to use
+    @return {Object} Found item or `undefined`.
+*/
+    find(callback: Function, target?: any): any;
     findBy(key: string, value?: string): any;
     forEach(callback: Function, target?: any): any;
     getEach(key: string): any[];
-    indexOf(object: any, startAt: number): number;
+    indexOf(object: any, startAt?: number): number;
     insertAt(idx: number, object: any): any[];
     invoke(methodName: string, ...args: any[]): any[];
-    lastIndexOf(object: any, startAt: number): number;
+    lastIndexOf(object: any, startAt?: number): number;
+    map(callback: Function, target?: any): any[];
     mapBy(key: string): any[];
     nextObject(index: number, previousObject: any, context: any): any;
     objectAt(idx: number): any;
@@ -111,7 +267,7 @@ interface Array<T> {
     removeArrayObserver(target: any, opts: EnumerableConfigurationOptions): any[];
     removeAt(start: number, len: number): any;
     removeEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): any[];
-    replace(idx: number, amt: number, objects: any[]);
+    replace(idx: number, amt: number, objects: any[]): void;
     reverseObjects(): any[];
     setEach(key: string, value?: any): any;
     setObjects(objects: any[]): any[];
@@ -154,6 +310,9 @@ interface Array<T> {
     toggleProperty(keyName: string): any;
     copy(deep: boolean): any[];
     frozenCopy(): any[];
+    // 1.3
+    isAny(key: string, value?: string): boolean;
+    isEvery(key: string, value?: string): boolean;
 }
 
 interface ApplicationCreateArguments {
@@ -175,7 +334,7 @@ interface ApplicationInitializerArguments {
 }
 
 interface ApplicationInitializerFunction {
-    (container: Ember.Container, application: Ember.Application);
+    (container: Ember.Container, application: Ember.Application): void;
 }
 
 interface CoreObjectArguments {
@@ -202,11 +361,11 @@ interface ItemIndexEnumerableCallbackTarget {
 }
 
 interface ItemIndexEnumerableCallback {
-    (item: any, index: number, enumerable: Ember.Enumerable);
+    (item: any, index: number, enumerable: Ember.Enumerable): void;
 }
 
 interface ReduceCallback {
-    (previousValue: any, item: any, index: number, enumerable: Ember.Enumerable);
+    (previousValue: any, item: any, index: number, enumerable: Ember.Enumerable): void;
 }
 
 interface TransitionsHash {
@@ -233,10 +392,10 @@ interface RenderOptions {
 }
 
 interface ModifyObserver {
-    (obj: any, path: string, target: any, method?: Function);
-    (obj: any, path: string, target: any, method?: string);
-    (obj: any, path: string, func: Function, method?: Function);
-    (obj: any, path: string, func: Function, method?: string);
+    (obj: any, path: string, target: any, method?: Function): void;
+    (obj: any, path: string, target: any, method?: string): void;
+    (obj: any, path: string, func: Function, method?: Function): void;
+    (obj: any, path: string, func: Function, method?: string): void;
 }
 
 declare module Ember {
@@ -399,7 +558,7 @@ declare module Ember {
         everyProperty(key: string, value?: string): boolean;
         filter(callback: Function, target: any): any[];
         filterBy(key: string, value?: string): any[];
-        find(callback: Function, target: any): any;
+        find(callback: Function, target?: any): any;
         findBy(key: string, value?: string): any;
         forEach(callback: Function, target?: any): any;
         getEach(key: string): any[];
@@ -495,7 +654,7 @@ declare module Ember {
         static isClass: boolean;
         static isMethod: boolean;
         addArrayObserver(target: any, opts?: EnumerableConfigurationOptions): any[];
-        addEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): any[];
+        addEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): Enumerable;
         any(callback: Function, target?: any): boolean;
         anyBy(key: string, value?: string): boolean;
         arrayContentDidChange(startIdx: number, removeAmt: number, addAmt: number): any[];
@@ -512,10 +671,10 @@ declare module Ember {
         enumerableContentDidChange(removing: Enumerable, adding: number): any;
         enumerableContentDidChange(removing: number, adding: Enumerable): any;
         enumerableContentDidChange(removing: Enumerable, adding: Enumerable): any;
-        enumerableContentWillChange(removing: number, adding: number): any[];
-        enumerableContentWillChange(removing: Enumerable, adding: number): any[];
-        enumerableContentWillChange(removing: number, adding: Enumerable): any[];
-        enumerableContentWillChange(removing: Enumerable, adding: Enumerable): any[];
+        enumerableContentWillChange(removing: number, adding: number): Enumerable;
+        enumerableContentWillChange(removing: Enumerable, adding: number): Enumerable;
+        enumerableContentWillChange(removing: number, adding: Enumerable): Enumerable;
+        enumerableContentWillChange(removing: Enumerable, adding: Enumerable): Enumerable;
         every(callback: Function, target?: any): boolean;
         everyBy(key: string, value?: string): boolean;
         everyProperty(key: string, value?: string): boolean;
@@ -543,7 +702,7 @@ declare module Ember {
         rejectBy(key: string, value?: string): any[];
         removeArrayObserver(target: any, opts: EnumerableConfigurationOptions): any[];
         removeAt(start: number, len: number): any;
-        removeEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): any[];
+        removeEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): Enumerable;
         replace(idx: number, amt: number, objects: any[]): any;
         replaceContent(idx: number, amt: number, objects: any[]): void;
         reverseObjects(): any[];
@@ -553,10 +712,10 @@ declare module Ember {
         slice(beginIndex?: number, endIndex?: number): any[];
         some(callback: Function, target?: any): boolean;
         toArray(): any[];
-        uniq(): any[];
+        uniq(): Enumerable;
         unshiftObject(object: any): any;
         unshiftObjects(objects: any[]): any[];
-        without(value: any): any[];
+        without(value: any): Enumerable;
     '[]': any[];
     '@each': EachProxy;
         Boolean: boolean;
@@ -565,9 +724,9 @@ declare module Ember {
         lastObject: any;
         length: number;
         addObject(object: any): any;
-        addObjects(objects: Enumerable): any[];
+        addObjects(objects: Enumerable): MutableEnumberable;
         removeObject(object: any): any;
-        removeObjects(objects: Enumerable): any[];
+        removeObjects(objects: Enumerable): MutableEnumberable;
     }
     var BOOTED: boolean;
     /**
@@ -958,8 +1117,9 @@ declare module Ember {
     /**
     A subclass of the JavaScript Error object for use in Ember.
     **/
+    // Restore this to 'typeof Error' when https://github.com/Microsoft/TypeScript/issues/983 is resolved
     // ReSharper disable once DuplicatingLocalDeclaration
-    var Error: typeof Error;
+    var Error: any; // typeof Error;
     /**
     Handles delegating browser events to their corresponding Ember.Views. For example, when you click on
     a view, Ember.EventDispatcher ensures that that view's mouseDown method gets called.
@@ -1001,8 +1161,8 @@ declare module Ember {
     module Handlebars {
         function compile(string: string): Function;
         function get(root: any, path: string, options?: {}): any;
-        function helper(name: string, func: Function, dependentKeys: string): void;
-        function helper(name: string, view: View, dependentKeys: string): void;
+        function helper(name: string, func: Function, dependentKeys?: string): void;
+        function helper(name: string, view: View, dependentKeys?: string): void;
         class helpers {
             action(actionName: string, context: any, options?: {}): void;
             bindAttr(options?: {}): string;
@@ -1307,7 +1467,7 @@ declare module Ember {
         constructor(arr: any[]);
         static activate(): void;
         addArrayObserver(target: any, opts?: EnumerableConfigurationOptions): any[];
-        addEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): any[];
+        addEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): Enumerable;
         any(callback: Function, target?: any): boolean;
         anyBy(key: string, value?: string): boolean;
         arrayContentDidChange(startIdx: number, removeAmt: number, addAmt: number): any[];
@@ -1324,10 +1484,10 @@ declare module Ember {
         enumerableContentDidChange(removing: Enumerable, adding: number): any;
         enumerableContentDidChange(removing: number, adding: Enumerable): any;
         enumerableContentDidChange(removing: Enumerable, adding: Enumerable): any;
-        enumerableContentWillChange(removing: number, adding: number): any[];
-        enumerableContentWillChange(removing: Enumerable, adding: number): any[];
-        enumerableContentWillChange(removing: number, adding: Enumerable): any[];
-        enumerableContentWillChange(removing: Enumerable, adding: Enumerable): any[];
+        enumerableContentWillChange(removing: number, adding: number): Enumerable;
+        enumerableContentWillChange(removing: Enumerable, adding: number): Enumerable;
+        enumerableContentWillChange(removing: number, adding: Enumerable): Enumerable;
+        enumerableContentWillChange(removing: Enumerable, adding: Enumerable): Enumerable;
         every(callback: Function, target?: any): boolean;
         everyBy(key: string, value?: string): boolean;
         everyProperty(key: string, value?: any): boolean;
@@ -1354,7 +1514,7 @@ declare module Ember {
         rejectBy(key: string, value?: string): any[];
         removeArrayObserver(target: any, opts: EnumerableConfigurationOptions): any[];
         removeAt(start: number, len: number): any;
-        removeEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): any[];
+        removeEnumerableObserver(target: any, opts: EnumerableConfigurationOptions): Enumerable;
         replace(idx: number, amt: number, objects: any[]): any;
         reverseObjects(): any[];
         setEach(key: string, value?: any): any;
@@ -1363,10 +1523,10 @@ declare module Ember {
         slice(beginIndex?: number, endIndex?: number): any[];
         some(callback: Function, target?: any): boolean;
         toArray(): any[];
-        uniq(): any[];
+        uniq(): Enumerable;
         unshiftObject(object: any): any;
         unshiftObjects(objects: any[]): any[];
-        without(value: any): any[];
+        without(value: any): Enumerable;
         '[]': any[];
         '@each': EachProxy;
         Boolean: boolean;
@@ -1375,30 +1535,30 @@ declare module Ember {
         lastObject: any;
         length: number;
         addObject(object: any): any;
-        addObjects(objects: Enumerable): any[];
+        addObjects(objects: Enumerable): MutableEnumberable;
         removeObject(object: any): any;
-        removeObjects(objects: Enumerable): any[];
+        removeObjects(objects: Enumerable): MutableEnumberable;
         addObserver: ModifyObserver;
-        beginPropertyChanges(): any[];
+        beginPropertyChanges(): Observable;
         cacheFor(keyName: string): any;
         decrementProperty(keyName: string, decrement?: number): number;
-        endPropertyChanges(): any[];
+        endPropertyChanges(): Observable;
         get(keyName: string): any;
         getProperties(...args: string[]): {};
         getProperties(keys: string[]): {};
         getWithDefault(keyName: string, defaultValue: any): any;
         hasObserverFor(key: string): boolean;
         incrementProperty(keyName: string, increment?: number): number;
-        notifyPropertyChange(keyName: string): any[];
-        propertyDidChange(keyName: string): any[];
-        propertyWillChange(keyName: string): any[];
-        removeObserver(key: string, target: any, method: string): Observable;
-        removeObserver(key: string, target: any, method: Function): Observable;
-        set(keyName: string, value: any): any[];
-        setProperties(hash: {}): any[];
+        notifyPropertyChange(keyName: string): Observable;
+        propertyDidChange(keyName: string): Observable;
+        propertyWillChange(keyName: string): Observable;
+        removeObserver(key: string, target: any, method: string): void;
+        removeObserver(key: string, target: any, method: Function): void;
+        set(keyName: string, value: any): Observable;
+        setProperties(hash: {}): Observable;
         toggleProperty(keyName: string): any;
-        copy(deep: boolean): any[];
-        frozenCopy(): any[];
+        copy(deep: boolean): Copyable;
+        frozenCopy(): Copyable;
     }
     class NoneLocation extends Object {
         static detect(obj: any): boolean;
@@ -1422,6 +1582,7 @@ declare module Ember {
         Creates a subclass of the Object class.
         **/
         static extend<T>(arguments?: CoreObjectArguments): T;
+        static extend<T>(mixins? : Mixin, arguments?: CoreObjectArguments): T;
         /**
         Creates an instance of the class.
         @param arguments A hash containing values with which to initialize the newly instantiated object.
@@ -1522,11 +1683,14 @@ declare module Ember {
         notifyPropertyChange(keyName: string): Observable;
         propertyDidChange(keyName: string): Observable;
         propertyWillChange(keyName: string): Observable;
-        removeObserver(key: string, target: {}, method: string): Observable;
-        removeObserver(key: string, target: {}, method: Function): Observable;
+        removeObserver(key: string, target: {}, method: string): void;
+        removeObserver(key: string, target: {}, method: Function): void;
         set(keyName: string, value: any): Observable;
         setProperties(hash: {}): Observable;
-        toggleProperty(keyName: string): any;
+        /**
+        Set the value of a boolean property to the opposite of its current value.
+        */
+        toggleProperty(keyName: string): boolean;
     }
     class OrderedSet {
         add(obj: any): void;
@@ -1596,7 +1760,7 @@ declare module Ember {
         serialize(model: {}, params: string[]): string;
         setupController(controller: Controller, model: {}): void;
         // ReSharper disable once InconsistentNaming
-        transitionTo(name: string, ...object: any[]): void;
+        transitionTo(name: string, ...object: any[]): EmberStates.Transition;
         actions: ActionsHash;
     }
     class Router extends Object {
@@ -2363,9 +2527,9 @@ declare module Em {
     var copy: typeof Ember.copy;
     var create: typeof Ember.create;
     var debug: typeof Ember.debug;
-    var defineProperty: typeof defineProperty;
-    var deprecate: typeof deprecate;
-    var deprecateFunc: typeof deprecateFunc;
+    var defineProperty: typeof Ember.defineProperty;
+    var deprecate: typeof Ember.deprecate;
+    var deprecateFunc: typeof Ember.deprecateFunc;
     var destroy: typeof Ember.destroy;
     var empty: typeof deprecateFunc;
     var endPropertyChanges: typeof Ember.endPropertyChanges;
@@ -2382,7 +2546,248 @@ declare module Em {
     var handleErrors: typeof Ember.handleErrors;
     var hasListeners: typeof Ember.hasListeners;
     var hasOwnProperty: typeof Ember.hasOwnProperty;
-    var immediateObserver: typeof immediateObserver;
+    var immediateObserver: typeof Ember.immediateObserver;
+    var imports: typeof Ember.imports;
+    var inspect: typeof Ember.inspect;
+    var instrument: typeof Ember.instrument;
+    var isArray: typeof Ember.isArray;
+    var isEmpty: typeof Ember.isEmpty;
+    var isEqual: typeof Ember.isEqual;
+    var isGlobalPath: typeof Ember.isGlobalPath;
+    var isNamespace: typeof Ember.isNamespace;
+    var isNone: typeof Ember.isNone;
+    var isPrototypeOf: typeof Ember.isPrototypeOf;
+    var isWatching: typeof Ember.isWatching;
+    var keys: typeof Ember.keys;
+    var listenersDiff: typeof Ember.listenersDiff;
+    var listenersFor: typeof Ember.listenersFor;
+    var listenersUnion: typeof Ember.listenersUnion;
+    var lookup: typeof Ember.lookup;
+    var makeArray: typeof Ember.makeArray;
+    var merge: typeof Ember.merge;
+    var meta: typeof Ember.meta;
+    var metaPath: typeof Ember.metaPath;
+    var mixin: typeof Ember.mixin;
+    var none: typeof Ember.none;
+    var normalizeTuple: typeof Ember.normalizeTuple;
+    var observer: typeof Ember.observer;
+    var observersFor: typeof Ember.observersFor;
+    var onLoad: typeof Ember.onLoad;
+    var oneWay: typeof Ember.oneWay;
+    var onError: typeof Ember.onError;
+    var overrideChains: typeof Ember.overrideChains;
+    var platform: typeof Ember.platform;
+    var propertyDidChange: typeof Ember.propertyDidChange;
+    var propertyIsEnumerable: typeof Ember.propertyIsEnumerable;
+    var propertyWillChange: typeof Ember.propertyWillChange;
+    var removeBeforeObserver: typeof Ember.removeBeforeObserver;
+    var removeChainWatcher: typeof Ember.removeChainWatcher;
+    var removeListener: typeof Ember.removeListener;
+    var removeObserver: typeof Ember.removeObserver;
+    var required: typeof Ember.required;
+    var rewatch: typeof Ember.rewatch;
+    var run: typeof Ember.run;
+    var runLoadHooks: typeof Ember.runLoadHooks;
+    var sendEvent: typeof Ember.sendEvent;
+    var set: typeof Ember.set;
+    var setMeta: typeof Ember.setMeta;
+    var setPath: typeof Ember.setPath;
+    var setProperties: typeof Ember.setProperties;
+    var subscribe: typeof Ember.subscribe;
+    var toLocaleString: typeof Ember.toLocaleString;
+    var toString: typeof Ember.toString;
+    var tryCatchFinally: typeof Ember.tryCatchFinally;
+    var tryFinally: typeof Ember.tryFinally;
+    var tryInvoke: typeof Ember.tryInvoke;
+    var trySet: typeof Ember.trySet;
+    var trySetPath: typeof Ember.trySetPath;
+    var typeOf: typeof Ember.typeOf;
+    var unwatch: typeof Ember.unwatch;
+    var unwatchKey: typeof Ember.unwatchKey;
+    var unwatchPath: typeof Ember.unwatchPath;
+    var uuid: typeof Ember.uuid;
+    var valueOf: typeof Ember.valueOf;
+    var warn: typeof Ember.warn;
+    var watch: typeof Ember.watch;
+    var watchKey: typeof Ember.watchKey;
+    var watchPath: typeof Ember.watchPath;
+    var watchedEvents: typeof Ember.watchedEvents;
+    var wrap: typeof Ember.wrap;
+}
+
+/**
+ * External ambient module - to allow "import Ember = require('Ember');" to work correctly
+ */
+
+declare module "Ember" {
+
+    var $: typeof Ember.$;
+    var A: typeof Ember.A;
+    class ActionHandlerMixin extends Ember.ActionHandlerMixin { }
+    class Application extends Ember.Application { }
+    class Array extends Ember.Array { }
+    class ArrayController extends Ember.ArrayController { }
+    var ArrayPolyfills: typeof Ember.ArrayPolyfills;
+    class ArrayProxy extends Ember.ArrayProxy { }
+    var BOOTED: typeof Ember.BOOTED;
+    class Binding extends Ember.Binding { }
+    class Button extends Ember.Button { }
+    class Checkbox extends Ember.Checkbox { }
+    class CollectionView extends Ember.CollectionView { }
+    class Comparable extends Ember.Comparable { }
+    class Component extends Ember.Component { }
+    class ComputedProperty extends Ember.ComputedProperty { }
+    class Container extends Ember.Container { }
+    class ContainerView extends Ember.ContainerView { }
+    class Controller extends Ember.Controller { }
+    class ControllerMixin extends Ember.ControllerMixin { }
+    class Copyable extends Ember.Copyable { }
+    class CoreObject extends Ember.CoreObject { }
+    class CoreView extends Ember.CoreView { }
+    class DAG extends Ember.DAG { }
+    var DEFAULT_GETTER_FUNCTION: typeof Ember.DEFAULT_GETTER_FUNCTION;
+    class DefaultResolver extends Ember.DefaultResolver { }
+    class Deffered extends Ember.Deferred { }
+    class DeferredMixin extends Ember.DeferredMixin { }
+    class Descriptor extends Ember.Descriptor { }
+    var EMPTY_META: typeof Ember.EMPTY_META;
+    var ENV: typeof Ember.ENV;
+    var EXTEND_PROTOTYPES: typeof Ember.EXTEND_PROTOTYPES;
+    class EachProxy extends Ember.EachProxy { }
+    class Enumerable extends Ember.Enumerable { }
+    var EnumerableUtils: typeof Ember.EnumerableUtils;
+    var Error: typeof Ember.Error;
+    class EventDispatcher extends Ember.EventDispatcher { }
+    class Evented extends Ember.Evented { }
+    var FROZEN_ERROR: typeof Ember.FROZEN_ERROR;
+    class Freezable extends Ember.Freezable { }
+    var GUID_KEY: typeof Ember.GUID_KEY;
+    module Handlebars {
+        var compile: typeof Ember.Handlebars.compile;
+        var get: typeof Ember.Handlebars.get;
+        var helper: typeof Ember.Handlebars.helper;
+        class helpers extends Ember.Handlebars.helpers { }
+        var precompile: typeof Ember.Handlebars.precompile;
+        var registerBoundHelper: typeof Ember.Handlebars.registerBoundHelper;
+        class Compiler extends Ember.Handlebars.Compiler { }
+        class JavaScriptCompiler extends Ember.Handlebars.JavaScriptCompiler { }
+        var registerHelper: typeof Ember.Handlebars.registerHelper;
+        var registerPartial: typeof Ember.Handlebars.registerPartial;
+        var K: typeof Ember.Handlebars.K;
+        var createFrame: typeof Ember.Handlebars.createFrame;
+        var Exception: typeof Ember.Handlebars.Exception;
+        class SafeString extends Ember.Handlebars.SafeString { }
+        var parse: typeof Ember.Handlebars.parse;
+        var print: typeof Ember.Handlebars.print;
+        var logger: typeof Ember.Handlebars.logger;
+        var log: typeof Ember.Handlebars.log;
+    }
+    class HashLocation extends Ember.HashLocation { }
+    class HistoryLocation extends Ember.HistoryLocation { }
+    var IS_BINDING: typeof Ember.IS_BINDING;
+    class Instrumentation extends Ember.Instrumentation { }
+    var K: typeof Ember.K;
+    var LOG_BINDINGS: typeof Ember.LOG_BINDINGS;
+    var LOG_STACKTRACE_ON_DEPRECATION: typeof Ember.LOG_STACKTRACE_ON_DEPRECATION;
+    var LOG_VERSION: typeof Ember.LOG_VERSION;
+    class LinkView extends Ember.LinkView { }
+    class Location extends Ember.Location { }
+    var Logger: typeof Ember.Logger;
+    var MANDATORY_SETTER_FUNCTION: typeof Ember.MANDATORY_SETTER_FUNCTION;
+    var META_KEY: typeof Ember.META_KEY;
+    class Map extends Ember.Map { }
+    class MapWithDefault extends Ember.MapWithDefault { }
+    class Mixin extends Ember.Mixin { }
+    class MutableArray extends Ember.MutableArray { }
+    class MutableEnumerable extends Ember.MutableEnumberable { }
+    var NAME_KEY: typeof Ember.NAME_KEY;
+    class Namespace extends Ember.Namespace { }
+    class NativeArray extends Ember.NativeArray { }
+    class NoneLocation extends Ember.NoneLocation { }
+    var ORDER_DEFINITION: typeof Ember.ORDER_DEFINITION;
+    class Object extends Ember.Object { }
+    class ObjectController extends Ember.ObjectController { }
+    class ObjectProxy extends Ember.ObjectProxy { }
+    class Observable extends Ember.Observable { }
+    class OrderedSet extends Ember.OrderedSet { }
+    module RSVP {
+        class Promise extends Ember.RSVP.Promise { }
+    }
+    class RenderBuffer extends Ember.RenderBuffer { }
+    class Route extends Ember.Route { }
+    class Router extends Ember.Router { }
+    class RouterDSL extends Ember.RouterDSL { }
+    var SHIM_ES5: typeof Ember.SHIM_ES5;
+    var STRINGS: typeof Ember.STRINGS;
+    class Select extends Ember.Select { }
+    class SelectOption extends Ember.SelectOption { }
+    class Set extends Ember.Set { }
+    class SortableMixin extends Ember.SortableMixin { }
+    class State extends Ember.State { }
+    class StateManager extends Ember.StateManager { }
+    module String {
+        var camelize: typeof Ember.String.camelize;
+        var capitalize: typeof Ember.String.capitalize;
+        var classify: typeof Ember.String.classify;
+        var dasherize: typeof Ember.String.dasherize;
+        var decamelize: typeof Ember.String.decamelize;
+        var fmt: typeof Ember.String.fmt;
+        var htmlSafe: typeof Ember.String.htmlSafe;
+        var loc: typeof Ember.String.loc;
+        var underscore: typeof Ember.String.underscore;
+        var w: typeof Ember.String.w;
+    }
+    var TEMPLATES: typeof Ember.TEMPLATES;
+    class TargetActionSupport extends Ember.TargetActionSupport { }
+    class Test extends Ember.Test { }
+    class TextArea extends Ember.TextArea { }
+    class TextField extends Ember.TextField { }
+    class TextSupport extends Ember.TextSupport { }
+    var VERSION: typeof Ember.VERSION;
+    class View extends Ember.View { }
+    class ViewTargetActionSupport extends Ember.ViewTargetActionSupport { }
+    var ViewUtils: typeof Ember.ViewUtils;
+    var addBeforeObserver: typeof Ember.addBeforeObserver;
+    var addListener: typeof Ember.addListener;
+    var addObserver: typeof Ember.addObserver;
+    var alias: typeof Ember.alias;
+    var aliasMethod: typeof Ember.aliasMethod;
+    var anyUnprocessedMixins: typeof Ember.anyUnprocessedMixins;
+    var assert: typeof Ember.assert;
+    var beforeObserver: typeof Ember.beforeObserver;
+    var beforeObserversFor: typeof Ember.beforeObserversFor;
+    var beginPropertyChanges: typeof Ember.beginPropertyChanges;
+    var bind: typeof Ember.bind;
+    var cacheFor: typeof Ember.cacheFor;
+    var canInvoke: typeof Ember.canInvoke;
+    var changeProperties: typeof Ember.changeProperties;
+    var compare: typeof Ember.compare;
+    var computed: typeof Ember.computed;
+    var config: typeof Ember.config;
+    var controllerFor: typeof Ember.controllerFor;
+    var copy: typeof Ember.copy;
+    var create: typeof Ember.create;
+    var debug: typeof Ember.debug;
+    var defineProperty: typeof Ember.defineProperty;
+    var deprecate: typeof Ember.deprecate;
+    var deprecateFunc: typeof Ember.deprecateFunc;
+    var destroy: typeof Ember.destroy;
+    var empty: typeof Ember.deprecateFunc;
+    var endPropertyChanges: typeof Ember.endPropertyChanges;
+    var exports: typeof Ember.exports;
+    var finishChains: typeof Ember.finishChains;
+    var flushPendingChains: typeof Ember.flushPendingChains;
+    var generateController: typeof Ember.generateController;
+    var generateGuid: typeof Ember.generateGuid;
+    var get: typeof Ember.get;
+    var getMeta: typeof Ember.getMeta;
+    var getPath: typeof Ember.getPath;
+    var getWithDefault: typeof Ember.getWithDefault;
+    var guidFor: typeof Ember.guidFor;
+    var handleErrors: typeof Ember.handleErrors;
+    var hasListeners: typeof Ember.hasListeners;
+    var hasOwnProperty: typeof Ember.hasOwnProperty;
+    var immediateObserver: typeof Ember.immediateObserver;
     var imports: typeof Ember.imports;
     var inspect: typeof Ember.inspect;
     var instrument: typeof Ember.instrument;