ember-source 2.16.0 → 2.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43c8f3909c7a87a7ac1e94333fae5b3b33f5f5a0
-  data.tar.gz: 5543b7d65d790f3d63eb3f4629065d6dc5fedf09
+  metadata.gz: 32904c39bf4645df84aaa32684719aca56947dfb
+  data.tar.gz: 45044a3f4272492ae8542a926e2418abea44518f
 SHA512:
-  metadata.gz: 042b7c42ed44843f21d8095f2174c62f62341f9933d88162888fbcaab43dddf6d13d6ff9b6b8e4fa365ed03dc9311d3b448a01a9835246510b66e3de22ce1464
-  data.tar.gz: 34d38a568ebaba7486f1def24a9a8b31db3476cdff1ef112fe85cd917b2e2ef2fbdb74f01ccdbed3c215df7304146ce595c0a26e1b273c057800071b6f523b66
+  metadata.gz: d392ac2f69a378a36ce85475a41dcff567a796e975df5c8a340ef4d43b498d78d93daa1cc11e5db118c8e1aa68d6ccb67dd387260ce00973c31b43ce0334e24d
+  data.tar.gz: 8b4231fbecf3a1b99c3ec9070881c4ce35dea2821eb6a8eb37943172f38d22a953b5be47813d4383872577a78c3aba49bcdd875daa0f2108226b48c94e469004

data/VERSION

@@ -1 +1 @@
-2.16.0
+2.16.1

data/dist/ember-runtime.js

@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   2.16.0
+ * @version   2.16.1
  */
 
 var enifed, requireModule, Ember;
@@ -1396,7 +1396,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
   /**
   @module ember
-  @submodule ember-metal
   */
 
   /**
@@ -1579,8 +1578,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   }
 
   /**
-  @module ember
-  @submodule ember-metal
+  @module @ember/object
   */
   /*
     The event system uses a series of nested hashes to store listeners on an
@@ -1604,7 +1602,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     Add an event listener
   
     @method addListener
-    @for Ember
+    @static
+    @for @ember/object/events
     @param obj
     @param {String} eventName
     @param {Object|Function} target A target object or a function
@@ -1613,7 +1612,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     @public
   */
   function addListener(obj, eventName, target, method, once) {
-    true && !(!!obj && !!eventName) && emberDebug.assert('You must pass at least an object and event name to Ember.addListener', !!obj && !!eventName);
+    true && !(!!obj && !!eventName) && emberDebug.assert('You must pass at least an object and event name to addListener', !!obj && !!eventName);
     true && !(eventName !== 'didInitAttrs') && emberDebug.deprecate('didInitAttrs called in ' + (obj && obj.toString && obj.toString()) + '.', eventName !== 'didInitAttrs', {
       id: 'ember-views.did-init-attrs',
       until: '3.0.0',
@@ -1640,10 +1639,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   /**
     Remove an event listener
   
-    Arguments should match those passed to `Ember.addListener`.
+    Arguments should match those passed to `addListener`.
   
     @method removeListener
-    @for Ember
+    @static
+    @for @ember/object/events
     @param obj
     @param {String} eventName
     @param {Object|Function} target A target object or a function
@@ -1651,7 +1651,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     @public
   */
   function removeListener(obj, eventName, target, method) {
-    true && !(!!obj && !!eventName) && emberDebug.assert('You must pass at least an object and event name to Ember.removeListener', !!obj && !!eventName);
+    true && !(!!obj && !!eventName) && emberDebug.assert('You must pass at least an object and event name to removeListener', !!obj && !!eventName);
 
     if (!method && 'function' === typeof target) {
       method = target;
@@ -1671,7 +1671,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     setting that property.
   
     @method suspendListener
-    @for Ember
+    @static
+    @for @ember/object/events
   
     @private
     @param obj
@@ -1688,7 +1689,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     Suspends multiple listeners during a callback.
   
     @method suspendListeners
-    @for Ember
+    @static
+    @for @ember/object/events
   
     @private
     @param obj
@@ -1710,7 +1712,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   
     @private
     @method watchedEvents
-    @for Ember
+    @static
+    @for @ember/object/events
     @param obj
   */
   function watchedEvents(obj) {
@@ -1725,7 +1728,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     is not passed, the actions stored on the passed object are invoked.
   
     @method sendEvent
-    @for Ember
+    @static
+    @for @ember/object/events
     @param obj
     @param {String} eventName
     @param {Array} params Optional parameters for each listener.
@@ -1782,7 +1786,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   /**
     @private
     @method hasListeners
-    @for Ember
+    @static
+    @for @ember/object/events
     @param obj
     @param {String} eventName
   */
@@ -1798,7 +1803,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   /**
     @private
     @method listenersFor
-    @for Ember
+    @static
+    @for @ember/object/events
     @param obj
     @param {String} eventName
   */
@@ -1826,19 +1832,24 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   
   
     ``` javascript
-    let Job = Ember.Object.extend({
-      logCompleted: Ember.on('completed', function() {
+    import EmberObject from '@ember/object';
+    import { on } from '@ember/object/evented';
+    import { sendEvent } from '@ember/object/events';
+  
+    let Job = EmberObject.extend({
+      logCompleted: on('completed', function() {
         console.log('Job completed!');
       })
     });
   
     let job = Job.create();
   
-    Ember.sendEvent(job, 'completed'); // Logs 'Job completed!'
+    sendEvent(job, 'completed'); // Logs 'Job completed!'
    ```
   
     @method on
-    @for Ember
+    @static
+    @for @ember/object/evented
     @param {String} eventNames*
     @param {Function} func
     @return func
@@ -1852,10 +1863,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     var func = args.pop();
     var events = args;
 
-    true && !(typeof func === 'function') && emberDebug.assert('Ember.on expects function as last argument', typeof func === 'function');
+    true && !(typeof func === 'function') && emberDebug.assert('on expects function as last argument', typeof func === 'function');
     true && !(events.length > 0 && events.every(function (p) {
       return typeof p === 'string' && p.length;
-    })) && emberDebug.assert('Ember.on called without valid event names', events.length > 0 && events.every(function (p) {
+    })) && emberDebug.assert('on called without valid event names', events.length > 0 && events.every(function (p) {
       return typeof p === 'string' && p.length;
     }));
 
@@ -2098,6 +2109,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     };
   }
 
+  /**
+   @module ember
+   @private
+   */
+
   var PROPERTY_DID_CHANGE = emberUtils.symbol('PROPERTY_DID_CHANGE');
 
   var beforeObserverSet = new ObserverSet();
@@ -2406,7 +2422,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   }
 
   /**
-  @module ember-metal
+  @module @ember/object
   */
 
   // ..........................................................
@@ -2450,7 +2466,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       if (!m.isInitialized(this)) {
         m.writeValues(name, value);
       } else {
-        true && !false && emberDebug.assert('You must use Ember.set() to set the `' + name + '` property (of ' + this + ') to `' + value + '`.', false);
+        true && !false && emberDebug.assert('You must use set() to set the `' + name + '` property (of ' + this + ') to `' + value + '`.', false);
       }
     }
 
@@ -2490,7 +2506,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   /**
     NOTE: This is a low-level method used by other parts of the API. You almost
     never want to call this method directly. Instead you should use
-    `Ember.mixin()` to define new properties.
+    `mixin()` to define new properties.
   
     Defines a property on an object. This method works much like the ES5
     `Object.defineProperty()` method except that it can also accept computed
@@ -2504,8 +2520,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ## Examples
   
     ```javascript
+    import { defineProperty, computed } from '@ember/object';
+  
     // ES5 compatible mode
-    Ember.defineProperty(contact, 'firstName', {
+    defineProperty(contact, 'firstName', {
       writable: true,
       configurable: false,
       enumerable: true,
@@ -2513,17 +2531,17 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     });
   
     // define a simple property
-    Ember.defineProperty(contact, 'lastName', undefined, 'Jolley');
+    defineProperty(contact, 'lastName', undefined, 'Jolley');
   
     // define a computed property
-    Ember.defineProperty(contact, 'fullName', Ember.computed('firstName', 'lastName', function() {
+    defineProperty(contact, 'fullName', computed('firstName', 'lastName', function() {
       return this.firstName+' '+this.lastName;
     }));
     ```
   
     @private
     @method defineProperty
-    @for Ember
+    @for @ember/object
     @param {Object} obj the object to define this property on. This may be a prototype.
     @param {String} keyName the name of the property
     @param {Descriptor} [desc] an instance of `Descriptor` (typically a
@@ -3191,7 +3209,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   }
 
   /**
-  @module ember-metal
+  @module ember
   */
 
   var UNDEFINED = emberUtils.symbol('undefined');
@@ -3905,7 +3923,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   }
 
   /**
-  @module ember-metal
+  @module @ember/object
   */
 
   var ALLOWABLE_TYPES = {
@@ -3944,7 +3962,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     an error.
   
     @method get
-    @for Ember
+    @for @ember/object
+    @static
     @param {Object} obj The object to retrieve from.
     @param {String} keyName The property key to retrieve
     @return {Object} the property value or `null`.
@@ -4003,7 +4022,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method getWithDefault
-    @for Ember
+    @for @ember/object
+    @static
     @param {Object} obj The object to retrieve from.
     @param {String} keyName The name of the property to retrieve
     @param {Object} defaultValue The value to return if the property value is undefined
@@ -4019,6 +4039,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     return value;
   }
 
+  /**
+   @module @ember/object
+  */
   /**
     Sets the value of a property on an object, respecting computed properties
     and notifying observers and other listeners of the change. If the
@@ -4030,7 +4053,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method set
-    @for Ember
+    @static
+    @for @ember/object
     @param {Object} obj The object to modify.
     @param {String} keyName The property key to set
     @param {Object} value The value to set
@@ -4119,7 +4143,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     an object has been destroyed.
   
     @method trySet
-    @for Ember
+    @static
+    @for @ember/object
     @param {Object} root The object to modify.
     @param {String} path The property path to set
     @param {Object} value The value to set
@@ -4130,8 +4155,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   }
 
   /**
-  @module ember
-  @submodule ember-metal
+  @module @ember/object
   */
 
   var END_WITH_EACH_REGEX = /\.@each$/;
@@ -4145,19 +4169,22 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     Example
   
     ```js
+    import { expandProperties } from '@ember/object/computed';
+  
     function echo(arg){ console.log(arg); }
   
-    Ember.expandProperties('foo.bar', echo);              //=> 'foo.bar'
-    Ember.expandProperties('{foo,bar}', echo);            //=> 'foo', 'bar'
-    Ember.expandProperties('foo.{bar,baz}', echo);        //=> 'foo.bar', 'foo.baz'
-    Ember.expandProperties('{foo,bar}.baz', echo);        //=> 'foo.baz', 'bar.baz'
-    Ember.expandProperties('foo.{bar,baz}.[]', echo)      //=> 'foo.bar.[]', 'foo.baz.[]'
-    Ember.expandProperties('{foo,bar}.{spam,eggs}', echo) //=> 'foo.spam', 'foo.eggs', 'bar.spam', 'bar.eggs'
-    Ember.expandProperties('{foo}.bar.{baz}')             //=> 'foo.bar.baz'
+    expandProperties('foo.bar', echo);              //=> 'foo.bar'
+    expandProperties('{foo,bar}', echo);            //=> 'foo', 'bar'
+    expandProperties('foo.{bar,baz}', echo);        //=> 'foo.bar', 'foo.baz'
+    expandProperties('{foo,bar}.baz', echo);        //=> 'foo.baz', 'bar.baz'
+    expandProperties('foo.{bar,baz}.[]', echo)      //=> 'foo.bar.[]', 'foo.baz.[]'
+    expandProperties('{foo,bar}.{spam,eggs}', echo) //=> 'foo.spam', 'foo.eggs', 'bar.spam', 'bar.eggs'
+    expandProperties('{foo}.bar.{baz}')             //=> 'foo.bar.baz'
     ```
   
     @method expandProperties
-    @for Ember
+    @static
+    @for @ember/object
     @public
     @param {String} pattern The property pattern to expand.
     @param {Function} callback The callback to invoke.  It is invoked once per
@@ -4199,7 +4226,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   }
 
   /**
-  @module ember-metal
+  @module ember
   */
   /**
     Starts watching a property on an object. Whenever the property changes,
@@ -4239,11 +4266,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     }
   }
 
-  /**
-  @module ember
-  @submodule ember-metal
-  */
-
   // ..........................................................
   // DEPENDENT KEYS
   //
@@ -4283,8 +4305,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   }
 
   /**
-  @module ember
-  @submodule ember-metal
+  @module @ember/object
   */
 
   var DEEP_EACH_REGEX = /\.@each\.[^.]+\./;
@@ -4298,23 +4319,25 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     result to be recomputed if the dependencies are modified.
   
     In the following example we declare a computed property - `fullName` - by calling
-    `.Ember.computed()` with property dependencies (`firstName` and `lastName`) as leading arguments and getter accessor function. The `fullName` getter function
+    `computed` with property dependencies (`firstName` and `lastName`) as leading arguments and getter accessor function. The `fullName` getter function
     will be called once (regardless of how many times it is accessed) as long
     as its dependencies have not changed. Once `firstName` or `lastName` are updated
     any future calls (or anything bound) to `fullName` will incorporate the new
     values.
   
     ```javascript
-    let Person = Ember.Object.extend({
+    import EmberObject, { computed } from '@ember/object';
+  
+    let Person = EmberObject.extend({
       // these will be supplied by `create`
       firstName: null,
       lastName: null,
   
-      fullName: Ember.computed('firstName', 'lastName', function() {
+      fullName: computed('firstName', 'lastName', function() {
         let firstName = this.get('firstName'),
             lastName  = this.get('lastName');
   
-        return firstName + ' ' + lastName;
+        return `${firstName} ${lastName}`;
       })
     });
   
@@ -4331,12 +4354,14 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     value you want to set it to as arguments.
   
     ```javascript
-    let Person = Ember.Object.extend({
+    import EmberObject, { computed } from '@ember/object';
+  
+    let Person = EmberObject.extend({
       // these will be supplied by `create`
       firstName: null,
       lastName: null,
   
-      fullName: Ember.computed('firstName', 'lastName', {
+      fullName: computed('firstName', 'lastName', {
         get(key) {
           let firstName = this.get('firstName'),
               lastName  = this.get('lastName');
@@ -4366,12 +4391,14 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     You can also mark computed property as `.readOnly()` and block all attempts to set it.
   
     ```javascript
-    let Person = Ember.Object.extend({
+    import EmberObject, { computed } from '@ember/object';
+  
+    let Person = EmberObject.extend({
       // these will be supplied by `create`
       firstName: null,
       lastName: null,
   
-      fullName: Ember.computed('firstName', 'lastName', {
+      fullName: computed('firstName', 'lastName', {
         get(key) {
           let firstName = this.get('firstName');
           let lastName  = this.get('lastName');
@@ -4390,7 +4417,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     - [New computed syntax explained in "Ember 1.12 released" ](https://emberjs.com/blog/2015/05/13/ember-1-12-released.html#toc_new-computed-syntax)
   
     @class ComputedProperty
-    @namespace Ember
     @public
   */
   function ComputedProperty(config, opts) {
@@ -4399,10 +4425,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     if (hasGetterOnly) {
       this._getter = config;
     } else {
-      true && !(typeof config === 'object' && !Array.isArray(config)) && emberDebug.assert('Ember.computed expects a function or an object as last argument.', typeof config === 'object' && !Array.isArray(config));
+      true && !(typeof config === 'object' && !Array.isArray(config)) && emberDebug.assert('computed expects a function or an object as last argument.', typeof config === 'object' && !Array.isArray(config));
       true && !Object.keys(config).every(function (key) {
         return key === 'get' || key === 'set';
-      }) && emberDebug.assert('Config object passed to an Ember.computed can only contain `get` or `set` keys.', Object.keys(config).every(function (key) {
+      }) && emberDebug.assert('Config object passed to computed can only contain `get` or `set` keys.', Object.keys(config).every(function (key) {
         return key === 'get' || key === 'set';
       }));
 
@@ -4435,15 +4461,19 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     invalidation and notification when cached value is invalidated.
   
     ```javascript
-    let outsideService = Ember.Object.extend({
-      value: Ember.computed(function() {
+    import EmberObject, { computed } from '@ember/object';
+  
+    let outsideService = EmberObject.extend({
+      value: computed(function() {
         return OutsideService.getValue();
       }).volatile()
     }).create();
     ```
   
     @method volatile
-    @return {Ember.ComputedProperty} this
+    @static
+    @for @ember/object/computed
+    @return {ComputedProperty} this
     @chainable
     @public
   */
@@ -4457,8 +4487,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     mode the computed property will throw an error when set.
   
     ```javascript
-    let Person = Ember.Object.extend({
-      guid: Ember.computed(function() {
+    import EmberObject, { computed } from '@ember/object';
+  
+    let Person = EmberObject.extend({
+      guid: computed(function() {
         return 'guid-guid-guid';
       }).readOnly()
     });
@@ -4469,7 +4501,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method readOnly
-    @return {Ember.ComputedProperty} this
+    @static
+    @for @ember/object/computed
+    @return {ComputedProperty} this
     @chainable
     @public
   */
@@ -4485,13 +4519,15 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     arguments containing key paths that this computed property depends on.
   
     ```javascript
-    let President = Ember.Object.extend({
-      fullName: Ember.computed(function() {
+    import EmberObject, { computed } from '@ember/object';
+  
+    let President = EmberObject.extend({
+      fullName: computed('firstName', 'lastName', function() {
         return this.get('firstName') + ' ' + this.get('lastName');
   
         // Tell Ember that this computed property depends on firstName
         // and lastName
-      }).property('firstName', 'lastName')
+      })
     });
   
     let president = President.create({
@@ -4503,8 +4539,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method property
+    @static
+    @for @ember/object/computed
     @param {String} path* zero or more property paths
-    @return {Ember.ComputedProperty} this
+    @return {ComputedProperty} this
     @chainable
     @public
   */
@@ -4549,6 +4587,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     via the `metaForProperty()` function.
   
     @method meta
+    @static
+    @for @ember/object/computed
     @param {Object} meta
     @chainable
     @public
@@ -4705,13 +4745,15 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   /**
     This helper returns a new property descriptor that wraps the passed
     computed property function. You can use this helper to define properties
-    with mixins or via `Ember.defineProperty()`.
+    with mixins or via `defineProperty()`.
   
     If you pass a function as an argument, it will be used as a getter. A computed
     property defined in this way might look like this:
   
     ```js
-    let Person = Ember.Object.extend({
+    import EmberObject, { computed } from '@ember/object';
+  
+    let Person = EmberObject.extend({
       init() {
         this._super(...arguments);
   
@@ -4719,7 +4761,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
         this.lastName = 'Jones';
       },
   
-      fullName: Ember.computed('firstName', 'lastName', function() {
+      fullName: computed('firstName', 'lastName', function() {
         return `${this.get('firstName')} ${this.get('lastName')}`;
       })
     });
@@ -4736,7 +4778,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     argument to provide both a getter and setter:
   
     ```js
-    let Person = Ember.Object.extend({
+    import EmberObject, { computed } from '@ember/object';
+  
+    let Person = EmberObject.extend({
       init() {
         this._super(...arguments);
   
@@ -4744,7 +4788,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
         this.lastName = 'Jones';
       },
   
-      fullName: Ember.computed('firstName', 'lastName', {
+      fullName: computed('firstName', 'lastName', {
         get(key) {
           return `${this.get('firstName')} ${this.get('lastName')}`;
         },
@@ -4778,13 +4822,12 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     }.property('firstName', 'lastName')
     ```
   
-    @class computed
-    @namespace Ember
-    @constructor
+    @method computed
+    @for @ember/object
     @static
     @param {String} [dependentKeys*] Optional dependent keys that trigger this computed property.
     @param {Function} func The computed property function.
-    @return {Ember.ComputedProperty} property descriptor instance
+    @return {ComputedProperty} property descriptor instance
     @public
   */
   function computed() {
@@ -4810,7 +4853,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     it to be created.
   
     @method cacheFor
-    @for Ember
+    @static
+    @for @ember/object/internals
     @param {Object} obj the object whose property you want to check
     @param {String} key the name of the property whose cached value you want
       to return
@@ -4932,18 +4976,24 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   AliasedProperty.prototype._meta = undefined;
   AliasedProperty.prototype.meta = ComputedProperty.prototype.meta;
 
+  /**
+   @module @ember/polyfills
+  */
   /**
     Merge the contents of two objects together into the first object.
   
     ```javascript
-    Ember.merge({ first: 'Tom' }, { last: 'Dale' }); // { first: 'Tom', last: 'Dale' }
+    import { merge } from '@ember/polyfills';
+  
+    merge({ first: 'Tom' }, { last: 'Dale' }); // { first: 'Tom', last: 'Dale' }
     var a = { first: 'Yehuda' };
     var b = { last: 'Katz' };
-    Ember.merge(a, b); // a == { first: 'Yehuda', last: 'Katz' }, b == { last: 'Katz' }
+    merge(a, b); // a == { first: 'Yehuda', last: 'Katz' }, b == { last: 'Katz' }
     ```
   
     @method merge
-    @for Ember
+    @static
+    @for @ember/polyfills
     @param {Object} original The object to merge into
     @param {Object} updates The object to copy properties from
     @return {Object}
@@ -4967,7 +5017,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
   /**
   @module ember
-  @submodule ember-metal
   */
 
   /**
@@ -5004,15 +5053,22 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   /* eslint no-console:off */
   /* global console */
 
+  /**
+  @module @ember/instrumentation
+  @private
+  */
+
   /**
     The purpose of the Ember Instrumentation module is
     to provide efficient, general-purpose instrumentation
     for Ember.
   
-    Subscribe to a listener by using `Ember.subscribe`:
+    Subscribe to a listener by using `subscribe`:
   
     ```javascript
-    Ember.subscribe("render", {
+    import { subscribe } from '@ember/instrumentation';
+  
+    subscribe("render", {
       before(name, timestamp, payload) {
   
       },
@@ -5027,15 +5083,17 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     value will be passed as a fourth parameter to the `after`
     callback.
   
-    Instrument a block of code by using `Ember.instrument`:
+    Instrument a block of code by using `instrument`:
   
     ```javascript
-    Ember.instrument("render.handlebars", payload, function() {
+    import { instrument } from '@ember/instrumentation';
+  
+    instrument("render.handlebars", payload, function() {
       // rendering logic
     }, binding);
     ```
   
-    Event names passed to `Ember.instrument` are namespaced
+    Event names passed to `instrument` are namespaced
     by periods, from more general to more specific. Subscribers
     can listen for events by whatever level of granularity they
     are interested in.
@@ -5047,7 +5105,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     even `render.handlebars.layout`.
   
     @class Instrumentation
-    @namespace Ember
     @static
     @private
   */
@@ -5082,8 +5139,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     Notifies event's subscribers, calls `before` and `after` hooks.
   
     @method instrument
-    @namespace Ember.Instrumentation
-  
+    @for @ember/instrumentation
+    @static
     @param {String} [name] Namespaced event name.
     @param {Object} _payload
     @param {Function} callback Function that you're instrumenting.
@@ -5189,7 +5246,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     Subscribes to a particular event or instrumented block of code.
   
     @method subscribe
-    @namespace Ember.Instrumentation
+    @for @ember/instrumentation
+    @static
   
     @param {String} [pattern] Namespaced event name.
     @param {Object} [object] Before and After hooks.
@@ -5230,7 +5288,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     Unsubscribes from a particular event or instrumented block of code.
   
     @method unsubscribe
-    @namespace Ember.Instrumentation
+    @for @ember/instrumentation
+    @static
   
     @param {Object} [subscriber]
     @private
@@ -5249,10 +5308,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   }
 
   /**
-    Resets `Ember.Instrumentation` by flushing list of subscribers.
+    Resets `Instrumentation` by flushing list of subscribers.
   
     @method reset
-    @namespace Ember.Instrumentation
+    @for @ember/instrumentation
+    @static
     @private
   */
   function reset() {
@@ -5317,6 +5377,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     }
   }
 
+  /**
+   @module ember
+  */
   var id = 0;
 
   // Returns whether Type(value) is Object according to the terminology in the spec
@@ -5454,22 +5517,26 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
   var weak_map = emberUtils.HAS_NATIVE_WEAKMAP ? WeakMap : WeakMapPolyfill;
 
+  /**
+   @module @ember/utils
+  */
   /**
     Returns true if the passed value is null or undefined. This avoids errors
     from JSLint complaining about use of ==, which can be technically
     confusing.
   
     ```javascript
-    Ember.isNone();              // true
-    Ember.isNone(null);          // true
-    Ember.isNone(undefined);     // true
-    Ember.isNone('');            // false
-    Ember.isNone([]);            // false
-    Ember.isNone(function() {}); // false
+    isNone();              // true
+    isNone(null);          // true
+    isNone(undefined);     // true
+    isNone('');            // false
+    isNone([]);            // false
+    isNone(function() {}); // false
     ```
   
     @method isNone
-    @for Ember
+    @static
+    @for @ember/utils
     @param {Object} obj Value to test
     @return {Boolean}
     @public
@@ -5478,28 +5545,32 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     return obj === null || obj === undefined;
   }
 
+  /**
+   @module @ember/utils
+  */
   /**
     Verifies that a value is `null` or `undefined`, an empty string, or an empty
     array.
   
-    Constrains the rules on `Ember.isNone` by returning true for empty strings and
+    Constrains the rules on `isNone` by returning true for empty strings and
     empty arrays.
   
     ```javascript
-    Ember.isEmpty();                // true
-    Ember.isEmpty(null);            // true
-    Ember.isEmpty(undefined);       // true
-    Ember.isEmpty('');              // true
-    Ember.isEmpty([]);              // true
-    Ember.isEmpty({});              // false
-    Ember.isEmpty('Adam Hawkins');  // false
-    Ember.isEmpty([0,1,2]);         // false
-    Ember.isEmpty('\n\t');          // false
-    Ember.isEmpty('  ');            // false
+    isEmpty();                // true
+    isEmpty(null);            // true
+    isEmpty(undefined);       // true
+    isEmpty('');              // true
+    isEmpty([]);              // true
+    isEmpty({});              // false
+    isEmpty('Adam Hawkins');  // false
+    isEmpty([0,1,2]);         // false
+    isEmpty('\n\t');          // false
+    isEmpty('  ');            // false
     ```
   
     @method isEmpty
-    @for Ember
+    @static
+    @for @ember/utils
     @param {Object} obj Value to test
     @return {Boolean}
     @public
@@ -5537,25 +5608,31 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     return false;
   }
 
+  /**
+   @module @ember/utils
+  */
   /**
     A value is blank if it is empty or a whitespace string.
   
     ```javascript
-    Ember.isBlank();                // true
-    Ember.isBlank(null);            // true
-    Ember.isBlank(undefined);       // true
-    Ember.isBlank('');              // true
-    Ember.isBlank([]);              // true
-    Ember.isBlank('\n\t');          // true
-    Ember.isBlank('  ');            // true
-    Ember.isBlank({});              // false
-    Ember.isBlank('\n\t Hello');    // false
-    Ember.isBlank('Hello world');   // false
-    Ember.isBlank([1,2,3]);         // false
+    import { isBlank } from '@ember/utils';
+  
+    isBlank();                // true
+    isBlank(null);            // true
+    isBlank(undefined);       // true
+    isBlank('');              // true
+    isBlank([]);              // true
+    isBlank('\n\t');          // true
+    isBlank('  ');            // true
+    isBlank({});              // false
+    isBlank('\n\t Hello');    // false
+    isBlank('Hello world');   // false
+    isBlank([1,2,3]);         // false
     ```
   
     @method isBlank
-    @for Ember
+    @static
+    @for @ember/utils
     @param {Object} obj Value to test
     @return {Boolean}
     @since 1.5.0
@@ -5565,31 +5642,35 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     return isEmpty(obj) || typeof obj === 'string' && /\S/.test(obj) === false;
   }
 
+  /**
+   @module @ember/utils
+  */
   /**
     A value is present if it not `isBlank`.
   
     ```javascript
-    Ember.isPresent();                // false
-    Ember.isPresent(null);            // false
-    Ember.isPresent(undefined);       // false
-    Ember.isPresent('');              // false
-    Ember.isPresent('  ');            // false
-    Ember.isPresent('\n\t');          // false
-    Ember.isPresent([]);              // false
-    Ember.isPresent({ length: 0 })    // false
-    Ember.isPresent(false);           // true
-    Ember.isPresent(true);            // true
-    Ember.isPresent('string');        // true
-    Ember.isPresent(0);               // true
-    Ember.isPresent(function() {})    // true
-    Ember.isPresent({});              // true
-    Ember.isPresent(false);           // true
-    Ember.isPresent('\n\t Hello');    // true
-    Ember.isPresent([1,2,3]);         // true
+    isPresent();                // false
+    isPresent(null);            // false
+    isPresent(undefined);       // false
+    isPresent('');              // false
+    isPresent('  ');            // false
+    isPresent('\n\t');          // false
+    isPresent([]);              // false
+    isPresent({ length: 0 })    // false
+    isPresent(false);           // true
+    isPresent(true);            // true
+    isPresent('string');        // true
+    isPresent(0);               // true
+    isPresent(function() {})    // true
+    isPresent({});              // true
+    isPresent(false);           // true
+    isPresent('\n\t Hello');    // true
+    isPresent([1,2,3]);         // true
     ```
   
     @method isPresent
-    @for Ember
+    @static
+    @for @ember/utils
     @param {Object} obj Value to test
     @return {Boolean}
     @since 1.8.0
@@ -5620,6 +5701,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     onErrorMethod: 'onerror'
   });
 
+  /**
+   @module @ember/runloop
+  */
   // ..........................................................
   // run - this is ideally the only public API the dev sees
   //
@@ -5640,8 +5724,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     });
     ```
   
-    @class run
-    @namespace Ember
+    @class @ember/runloop
     @static
     @constructor
     @param {Object} [target] target of method to call
@@ -5684,7 +5767,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method join
-    @namespace Ember
+    @static
+    @for @ember/runloop
     @param {Object} [target] target of method to call
     @param {Function|String} method Method to invoke.
       May be a function or a string. If you pass a string
@@ -5748,7 +5832,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     method be safely handled and executed by the Ember run loop.
   
     @method bind
-    @namespace Ember
+    @static
+    @for @ember/runloop
     @param {Object} [target] target of method to call
     @param {Function|String} method Method to invoke.
       May be a function or a string. If you pass a string
@@ -5788,6 +5873,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method begin
+    @static
+    @for @ember/runloop
     @return {void}
     @public
   */
@@ -5807,6 +5894,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method end
+    @static
+    @for @ember/runloop
     @return {void}
     @public
   */
@@ -5854,6 +5943,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method schedule
+    @static
+    @for @ember/runloop
     @param {String} queue The name of the queue to schedule against.
       Default queues are 'sync' and 'actions'
     @param {Object} [target] target object to use as the context when invoking a method.
@@ -5894,6 +5985,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method sync
+    @static
+    @for @ember/runloop
     @return {void}
     @private
   */
@@ -5920,6 +6013,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method later
+    @static
+    @for @ember/runloop
     @param {Object} [target] target of method to invoke
     @param {Function|String} method The method to invoke.
       If you pass a string it will be resolved on the
@@ -5938,6 +6033,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     to calling `scheduleOnce` with the "actions" queue.
   
     @method once
+    @static
+    @for @ember/runloop
     @param {Object} [target] The target of the method to invoke.
     @param {Function|String} method The method to invoke.
       If you pass a string it will be resolved on the
@@ -6014,6 +6111,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     Available queues, and their order, can be found at `run.queues`
   
     @method scheduleOnce
+    @static
+    @for @ember/runloop
     @param {String} [queue] The name of the queue to schedule against. Default queues are 'sync' and 'actions'.
     @param {Object} [target] The target of the method to invoke.
     @param {Function|String} method The method to invoke.
@@ -6086,6 +6185,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     outside of the current run loop, i.e. with `run.next`.
   
     @method next
+    @static
+    @for @ember/runloop
     @param {Object} [target] target of method to invoke
     @param {Function|String} method The method to invoke.
       If you pass a string it will be resolved on the
@@ -6154,6 +6255,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method cancel
+    @static
+    @for @ember/runloop
     @param {Object} timer Timer object to cancel
     @return {Boolean} true if canceled or false/undefined if it wasn't found
     @public
@@ -6220,6 +6323,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method debounce
+    @static
+    @for @ember/runloop
     @param {Object} [target] target of method to invoke
     @param {Function|String} method The method to invoke.
       May be a function or a string. If you pass a string
@@ -6263,6 +6368,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method throttle
+    @static
+    @for @ember/runloop
     @param {Object} [target] target of method to invoke
     @param {Function|String} method The method to invoke.
       May be a function or a string. If you pass a string
@@ -6294,6 +6401,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     }
   };
 
+  /**
+   @module ember
+  */
   /**
     Helper class that allows you to register your library with Ember.
   
@@ -6367,7 +6477,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
   /**
   @module ember
-  @submodule ember-metal
   */
 
   /*
@@ -6375,7 +6484,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     which are often used as dictionaries, may only have Strings as keys.
   
     Because Ember has a way to get a unique identifier for every object
-    via `Ember.guidFor`, we can implement a performant Map with arbitrary
+    via `guidFor`, we can implement a performant Map with arbitrary
     keys. Because it is commonly used in low-level bookkeeping, Map is
     implemented as a pure JavaScript object for performance.
   
@@ -6385,7 +6494,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     forEach method for iteration.
   
     Map is mocked out to look like an Ember object, so you can do
-    `Ember.Map.create()` for symmetry with other Ember classes.
+    `EmberMap.create()` for symmetry with other Ember classes.
   */
   function missingFunction(fn) {
     throw new TypeError(Object.prototype.toString.call(fn) + ' is not a function');
@@ -6593,7 +6702,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     Internally, a Map has two data structures:
   
     1. `keys`: an OrderedSet of all of the existing keys
-    2. `values`: a JavaScript Object indexed by the `Ember.guidFor(key)`
+    2. `values`: a JavaScript Object indexed by the `guidFor(key)`
   
     When a key/value pair is added for the first time, we
     add the key to the `keys` OrderedSet, and create or
@@ -6798,7 +6907,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     @param [options]
       @param {*} [options.defaultValue]
     @return {Ember.MapWithDefault|Ember.Map} If options are passed, returns
-      `Ember.MapWithDefault` otherwise returns `Ember.Map`
+      `MapWithDefault` otherwise returns `EmberMap`
     @private
   */
   MapWithDefault.create = function (options) {
@@ -6847,23 +6956,32 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   };
 
   /**
-    To get multiple properties at once, call `Ember.getProperties`
+   @module @ember/object
+  */
+
+  /**
+    To get multiple properties at once, call `getProperties`
     with an object followed by a list of strings or an array:
   
     ```javascript
-    Ember.getProperties(record, 'firstName', 'lastName', 'zipCode');
+    import { getProperties } from '@ember/object';
+  
+    getProperties(record, 'firstName', 'lastName', 'zipCode');
     // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
     ```
   
     is equivalent to:
   
     ```javascript
-    Ember.getProperties(record, ['firstName', 'lastName', 'zipCode']);
+    import { getProperties } from '@ember/object';
+  
+    getProperties(record, ['firstName', 'lastName', 'zipCode']);
     // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
     ```
   
     @method getProperties
-    @for Ember
+    @static
+    @for @ember/object
     @param {Object} obj
     @param {String...|Array} list of keys to get
     @return {Object}
@@ -6884,6 +7002,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     return ret;
   }
 
+  /**
+   @module @ember/object
+  */
   /**
     Set a list of properties on an object. These properties are set inside
     a single `beginPropertyChanges` and `endPropertyChanges` batch, so
@@ -6900,6 +7021,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method setProperties
+    @static
+    @for @ember/object
     @param obj
     @param {Object} properties
     @return properties
@@ -6923,7 +7046,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   }
 
   /**
-  @module ember-metal
+  @module @ember/object
   */
 
   var AFTER_OBSERVERS = ':change';
@@ -6939,7 +7062,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
   /**
     @method addObserver
-    @for Ember
+    @static
+    @for @ember/object/observers
     @param obj
     @param {String} _path
     @param {Object|Function} target
@@ -6959,7 +7083,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
   /**
     @method removeObserver
-    @for Ember
+    @static
+    @for @ember/object/observers
     @param obj
     @param {String} path
     @param {Object|Function} target
@@ -6975,7 +7100,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
   /**
     @method _addBeforeObserver
-    @for Ember
+    @static
+    @for @ember/object/observers
     @param obj
     @param {String} path
     @param {Object|Function} target
@@ -7005,7 +7131,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
   /**
     @method removeBeforeObserver
-    @for Ember
+    @static
+    @for @ember/object/observers
     @param obj
     @param {String} path
     @param {Object|Function} target
@@ -7022,7 +7149,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
   /**
   @module ember
-  @submodule ember-metal
   */
 
   // ..........................................................
@@ -7503,8 +7629,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   }
 
   /**
-  @module ember
-  @submodule ember-metal
+  @module @ember/object
   */
   var a_concat = Array.prototype.concat;
   var isArray = Array.isArray;
@@ -7880,7 +8005,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
   /**
     @method mixin
-    @for Ember
     @param obj
     @param mixins*
     @return obj
@@ -7896,21 +8020,28 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   }
 
   /**
-    The `Ember.Mixin` class allows you to create mixins, whose properties can be
+    The `Mixin` class allows you to create mixins, whose properties can be
     added to other classes. For instance,
   
     ```javascript
-    const EditableMixin = Ember.Mixin.create({
+    import Mixin from '@ember/object/mixin';
+  
+    const EditableMixin = Mixin.create({
       edit() {
         console.log('starting to edit');
         this.set('isEditing', true);
       },
       isEditing: false
     });
+    ```
+  
+    ```javascript
+    import EmberObject from '@ember/object';
+    import EditableMixin from '../mixins/editable';
   
     // Mix mixins into classes by passing them as the first arguments to
     // `.extend.`
-    const Comment = Ember.Object.extend(EditableMixin, {
+    const Comment = EmberObject.extend(EditableMixin, {
       post: null
     });
   
@@ -7921,8 +8052,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     comment.edit(); // outputs 'starting to edit'
     ```
   
-    Note that Mixins are created with `Ember.Mixin.create`, not
-    `Ember.Mixin.extend`.
+    Note that Mixins are created with `Mixin.create`, not
+    `Mixin.extend`.
   
     Note that mixins extend a constructor's prototype so arrays and object literals
     defined as properties will be shared amongst objects that implement the mixin.
@@ -7931,28 +8062,43 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   
     ```javascript
     // filters array will be shared amongst any object implementing mixin
-    const FilterableMixin = Ember.Mixin.create({
-      filters: Ember.A()
+    import Mixin from '@ember/object/mixin';
+    import { A } from '@ember/array';
+  
+    const FilterableMixin = Mixin.create({
+      filters: A()
     });
+    ```
+  
+    ```javascript
+    import Mixin from '@ember/object/mixin';
+    import { A } from '@ember/array';
+    import { computed } from '@ember/object';
   
     // filters will be a separate array for every object implementing the mixin
-    const FilterableMixin = Ember.Mixin.create({
-      filters: Ember.computed(function() {
-        return Ember.A();
+    const FilterableMixin = Mixin.create({
+      filters: computed(function() {
+        return A();
       })
     });
+    ```
+  
+    ```javascript
+    import Mixin from '@ember/object/mixin';
+    import { A } from '@ember/array';
   
     // filters will be created as a separate array during the object's initialization
-    const Filterable = Ember.Mixin.create({
+    const Filterable = Mixin.create({
+      filters: null,
+  
       init() {
         this._super(...arguments);
-        this.set("filters", Ember.A());
+        this.set("filters", A());
       }
     });
     ```
   
     @class Mixin
-    @namespace Ember
     @public
   */
 
@@ -7997,6 +8143,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
     /**
       @method create
+      @for @ember/object/mixin
       @static
       @param arguments*
       @public
@@ -8015,7 +8162,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     };
 
     // returns the mixins currently applied to the specified object
-    // TODO: Make Ember.mixin
+    // TODO: Make `mixin`
 
 
     Mixin.mixins = function mixins(obj) {
@@ -8234,7 +8381,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     ```
   
     @method aliasMethod
-    @for Ember
+    @static
+    @for @ember/object
     @param {String} methodName name of the method to alias
     @public
   */
@@ -8250,8 +8398,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     Specify a method that observes property changes.
   
     ```javascript
-    Ember.Object.extend({
-      valueObserver: Ember.observer('value', function() {
+    import EmberObject from '@ember/object';
+    import { observer } from '@ember/object';
+  
+    export default EmberObject.extend({
+      valueObserver: observer('value', function() {
         // Executes whenever the "value" property changes
       })
     });
@@ -8261,11 +8412,12 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     enabled.
   
     @method observer
-    @for Ember
+    @for @ember/object
     @param {String} propertyNames*
     @param {Function} func
     @return func
     @public
+    @static
   */
   function observer() {
     var _paths = void 0,
@@ -8277,7 +8429,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
     if (typeof args[args.length - 1] !== 'function') {
       // revert to old, soft-deprecated argument ordering
-      true && !false && emberDebug.deprecate('Passing the dependentKeys after the callback function in Ember.observer is deprecated. Ensure the callback function is the last argument.', false, { id: 'ember-metal.observer-argument-order', until: '3.0.0' });
+      true && !false && emberDebug.deprecate('Passing the dependentKeys after the callback function in observer is deprecated. Ensure the callback function is the last argument.', false, { id: 'ember-metal.observer-argument-order', until: '3.0.0' });
 
       func = args.shift();
       _paths = args;
@@ -8286,10 +8438,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       _paths = args;
     }
 
-    true && !(typeof func === 'function') && emberDebug.assert('Ember.observer called without a function', typeof func === 'function');
+    true && !(typeof func === 'function') && emberDebug.assert('observer called without a function', typeof func === 'function');
     true && !(_paths.length > 0 && _paths.every(function (p) {
       return typeof p === 'string' && p.length;
-    })) && emberDebug.assert('Ember.observer called without valid path', _paths.length > 0 && _paths.every(function (p) {
+    })) && emberDebug.assert('observer called without valid path', _paths.length > 0 && _paths.every(function (p) {
       return typeof p === 'string' && p.length;
     }));
 
@@ -8310,15 +8462,17 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     Specify a method that observes property changes.
   
     ```javascript
-    Ember.Object.extend({
+    import EmberObject from '@ember/object';
+  
+    EmberObject.extend({
       valueObserver: Ember.immediateObserver('value', function() {
         // Executes whenever the "value" property changes
       })
     });
     ```
   
-    In the future, `Ember.observer` may become asynchronous. In this event,
-    `Ember.immediateObserver` will maintain the synchronous behavior.
+    In the future, `observer` may become asynchronous. In this event,
+    `immediateObserver` will maintain the synchronous behavior.
   
     Also available as `Function.prototype.observesImmediately` if prototype extensions are
     enabled.
@@ -8327,12 +8481,12 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     @for Ember
     @param {String} propertyNames*
     @param {Function} func
-    @deprecated Use `Ember.observer` instead.
+    @deprecated Use `observer` instead.
     @return func
     @private
   */
   function _immediateObserver() {
-    true && !false && emberDebug.deprecate('Usage of `Ember.immediateObserver` is deprecated, use `Ember.observer` instead.', false, { id: 'ember-metal.immediate-observer', until: '3.0.0' });
+    true && !false && emberDebug.deprecate('Usage of `Ember.immediateObserver` is deprecated, use `observer` instead.', false, { id: 'ember-metal.immediate-observer', until: '3.0.0' });
 
     for (var i = 0; i < arguments.length; i++) {
       var arg = arguments[i];
@@ -8393,6 +8547,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     return func;
   }
 
+  /**
+   @module ember
+   @private
+   */
+
   /**
     Read-only property that returns the result of a container lookup.
   
@@ -8416,7 +8575,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     var desc = this[keyName];
     var owner = emberUtils.getOwner(this) || this.container; // fallback to `container` for backwards compat
 
-    true && !(desc && desc.isDescriptor && desc.type) && emberDebug.assert('InjectedProperties should be defined with the Ember.inject computed property macros.', desc && desc.isDescriptor && desc.type);
+    true && !(desc && desc.isDescriptor && desc.type) && emberDebug.assert('InjectedProperties should be defined with the inject computed property macros.', desc && desc.isDescriptor && desc.type);
     true && !owner && emberDebug.assert('Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container.', owner);
 
     return owner.lookup(desc.type + ':' + (desc.name || keyName));
@@ -8506,11 +8665,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     return Descriptor$$1;
   }(Descriptor);
 
-  /**
-  @module ember
-  @submodule ember-metal
-  */
-
   exports['default'] = Ember;
   exports.computed = computed;
   exports.cacheFor = cacheFor;