remove jinja

1 files changed, 12945 insertions, 0 deletions

diff --git a/imdb-lookup/libs/ember-data-1.0.0-beta.12.js b/imdb-lookup/libs/ember-data-1.0.0-beta.12.js
new file mode 100644
index 0000000..a2851b9
--- /dev/null
+++ b/imdb-lookup/libs/ember-data-1.0.0-beta.12.js
@@ -0,0 +1,12945 @@
+(function(global){
+var enifed, requireModule, eriuqer, requirejs;
+
+(function() {
+
+  var _isArray;
+  if (!Array.isArray) {
+    _isArray = function (x) {
+      return Object.prototype.toString.call(x) === "[object Array]";
+    };
+  } else {
+    _isArray = Array.isArray;
+  }
+  
+  var registry = {}, seen = {}, state = {};
+  var FAILED = false;
+
+  enifed = function(name, deps, callback) {
+  
+    if (!_isArray(deps)) {
+      callback = deps;
+      deps     =  [];
+    }
+  
+    registry[name] = {
+      deps: deps,
+      callback: callback
+    };
+  };
+
+  function reify(deps, name, seen) {
+    var length = deps.length;
+    var reified = new Array(length);
+    var dep;
+    var exports;
+
+    for (var i = 0, l = length; i < l; i++) {
+      dep = deps[i];
+      if (dep === 'exports') {
+        exports = reified[i] = seen;
+      } else {
+        reified[i] = eriuqer(resolve(dep, name));
+      }
+    }
+
+    return {
+      deps: reified,
+      exports: exports
+    };
+  }
+
+  requirejs = eriuqer = requireModule = function(name) {
+    if (state[name] !== FAILED &&
+        seen.hasOwnProperty(name)) {
+      return seen[name];
+    }
+
+    if (!registry[name]) {
+      throw new Error('Could not find module ' + name);
+    }
+
+    var mod = registry[name];
+    var reified;
+    var module;
+    var loaded = false;
+
+    seen[name] = { }; // placeholder for run-time cycles
+
+    try {
+      reified = reify(mod.deps, name, seen[name]);
+      module = mod.callback.apply(this, reified.deps);
+      loaded = true;
+    } finally {
+      if (!loaded) {
+        state[name] = FAILED;
+      }
+    }
+
+    return reified.exports ? seen[name] : (seen[name] = module);
+  };
+
+  function resolve(child, name) {
+    if (child.charAt(0) !== '.') { return child; }
+
+    var parts = child.split('/');
+    var nameParts = name.split('/');
+    var parentBase;
+
+    if (nameParts.length === 1) {
+      parentBase = nameParts;
+    } else {
+      parentBase = nameParts.slice(0, -1);
+    }
+
+    for (var i = 0, l = parts.length; i < l; i++) {
+      var part = parts[i];
+
+      if (part === '..') { parentBase.pop(); }
+      else if (part === '.') { continue; }
+      else { parentBase.push(part); }
+    }
+
+    return parentBase.join('/');
+  }
+
+  requirejs.entries = requirejs._eak_seen = registry;
+  requirejs.clear = function(){
+    requirejs.entries = requirejs._eak_seen = registry = {};
+    seen = state = {};
+  };
+})();
+
+enifed("activemodel-adapter",
+  ["activemodel-adapter/system","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var ActiveModelAdapter = __dependency1__.ActiveModelAdapter;
+    var ActiveModelSerializer = __dependency1__.ActiveModelSerializer;
+
+    __exports__.ActiveModelAdapter = ActiveModelAdapter;
+    __exports__.ActiveModelSerializer = ActiveModelSerializer;
+  });
+enifed("activemodel-adapter/setup-container",
+  ["ember-data/system/container_proxy","activemodel-adapter/system/active_model_serializer","activemodel-adapter/system/active_model_adapter","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+    "use strict";
+    var ContainerProxy = __dependency1__["default"];
+    var ActiveModelSerializer = __dependency2__["default"];
+    var ActiveModelAdapter = __dependency3__["default"];
+
+    __exports__["default"] = function setupActiveModelAdapter(container, application){
+      var proxy = new ContainerProxy(container);
+      proxy.registerDeprecations([
+        { deprecated: 'serializer:_ams',  valid: 'serializer:-active-model' },
+        { deprecated: 'adapter:_ams',     valid: 'adapter:-active-model' }
+      ]);
+
+      container.register('serializer:-active-model', ActiveModelSerializer);
+      container.register('adapter:-active-model', ActiveModelAdapter);
+    };
+  });
+enifed("activemodel-adapter/system",
+  ["activemodel-adapter/system/active_model_adapter","activemodel-adapter/system/active_model_serializer","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var ActiveModelAdapter = __dependency1__["default"];
+    var ActiveModelSerializer = __dependency2__["default"];
+
+    __exports__.ActiveModelAdapter = ActiveModelAdapter;
+    __exports__.ActiveModelSerializer = ActiveModelSerializer;
+  });
+enifed("activemodel-adapter/system/active_model_adapter",
+  ["ember-data/adapters","ember-data/system/adapter","ember-inflector","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+    "use strict";
+    var RESTAdapter = __dependency1__.RESTAdapter;
+    var InvalidError = __dependency2__.InvalidError;
+    var pluralize = __dependency3__.pluralize;
+
+    /**
+      @module ember-data
+    */
+
+    var decamelize = Ember.String.decamelize,
+        underscore = Ember.String.underscore;
+
+    /**
+      The ActiveModelAdapter is a subclass of the RESTAdapter designed to integrate
+      with a JSON API that uses an underscored naming convention instead of camelCasing.
+      It has been designed to work out of the box with the
+      [active_model_serializers](http://github.com/rails-api/active_model_serializers)
+      Ruby gem. This Adapter expects specific settings using ActiveModel::Serializers,
+      `embed :ids, embed_in_root: true` which sideloads the records.
+
+      This adapter extends the DS.RESTAdapter by making consistent use of the camelization,
+      decamelization and pluralization methods to normalize the serialized JSON into a
+      format that is compatible with a conventional Rails backend and Ember Data.
+
+      ## JSON Structure
+
+      The ActiveModelAdapter expects the JSON returned from your server to follow
+      the REST adapter conventions substituting underscored keys for camelcased ones.
+
+      Unlike the DS.RESTAdapter, async relationship keys must be the singular form
+      of the relationship name, followed by "_id" for DS.belongsTo relationships,
+      or "_ids" for DS.hasMany relationships.
+
+      ### Conventional Names
+
+      Attribute names in your JSON payload should be the underscored versions of
+      the attributes in your Ember.js models.
+
+      For example, if you have a `Person` model:
+
+      ```js
+      App.FamousPerson = DS.Model.extend({
+        firstName: DS.attr('string'),
+        lastName: DS.attr('string'),
+        occupation: DS.attr('string')
+      });
+      ```
+
+      The JSON returned should look like this:
+
+      ```js
+      {
+        "famous_person": {
+          "id": 1,
+          "first_name": "Barack",
+          "last_name": "Obama",
+          "occupation": "President"
+        }
+      }
+      ```
+
+      Let's imagine that `Occupation` is just another model:
+
+      ```js
+      App.Person = DS.Model.extend({
+        firstName: DS.attr('string'),
+        lastName: DS.attr('string'),
+        occupation: DS.belongsTo('occupation')
+      });
+
+      App.Occupation = DS.Model.extend({
+        name: DS.attr('string'),
+        salary: DS.attr('number'),
+        people: DS.hasMany('person')
+      });
+      ```
+
+      The JSON needed to avoid extra server calls, should look like this:
+
+      ```js
+      {
+        "people": [{
+          "id": 1,
+          "first_name": "Barack",
+          "last_name": "Obama",
+          "occupation_id": 1
+        }],
+
+        "occupations": [{
+          "id": 1,
+          "name": "President",
+          "salary": 100000,
+          "person_ids": [1]
+        }]
+      }
+      ```
+
+      @class ActiveModelAdapter
+      @constructor
+      @namespace DS
+      @extends DS.RESTAdapter
+    **/
+
+    var ActiveModelAdapter = RESTAdapter.extend({
+      defaultSerializer: '-active-model',
+      /**
+        The ActiveModelAdapter overrides the `pathForType` method to build
+        underscored URLs by decamelizing and pluralizing the object type name.
+
+        ```js
+          this.pathForType("famousPerson");
+          //=> "famous_people"
+        ```
+
+        @method pathForType
+        @param {String} type
+        @return String
+      */
+      pathForType: function(type) {
+        var decamelized = decamelize(type);
+        var underscored = underscore(decamelized);
+        return pluralize(underscored);
+      },
+
+      /**
+        The ActiveModelAdapter overrides the `ajaxError` method
+        to return a DS.InvalidError for all 422 Unprocessable Entity
+        responses.
+
+        A 422 HTTP response from the server generally implies that the request
+        was well formed but the API was unable to process it because the
+        content was not semantically correct or meaningful per the API.
+
+        For more information on 422 HTTP Error code see 11.2 WebDAV RFC 4918
+        https://tools.ietf.org/html/rfc4918#section-11.2
+
+        @method ajaxError
+        @param {Object} jqXHR
+        @return error
+      */
+      ajaxError: function(jqXHR) {
+        var error = this._super(jqXHR);
+
+        if (jqXHR && jqXHR.status === 422) {
+          return new InvalidError(Ember.$.parseJSON(jqXHR.responseText));
+        } else {
+          return error;
+        }
+      }
+    });
+
+    __exports__["default"] = ActiveModelAdapter;
+  });
+enifed("activemodel-adapter/system/active_model_serializer",
+  ["ember-inflector","ember-data/serializers/rest_serializer","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var singularize = __dependency1__.singularize;
+    var RESTSerializer = __dependency2__["default"];
+    /**
+      @module ember-data
+    */
+
+    var get = Ember.get,
+        forEach = Ember.EnumerableUtils.forEach,
+        camelize =   Ember.String.camelize,
+        capitalize = Ember.String.capitalize,
+        decamelize = Ember.String.decamelize,
+        underscore = Ember.String.underscore;
+    /**
+      The ActiveModelSerializer is a subclass of the RESTSerializer designed to integrate
+      with a JSON API that uses an underscored naming convention instead of camelCasing.
+      It has been designed to work out of the box with the
+      [active_model_serializers](http://github.com/rails-api/active_model_serializers)
+      Ruby gem. This Serializer expects specific settings using ActiveModel::Serializers,
+      `embed :ids, embed_in_root: true` which sideloads the records.
+
+      This serializer extends the DS.RESTSerializer by making consistent
+      use of the camelization, decamelization and pluralization methods to
+      normalize the serialized JSON into a format that is compatible with
+      a conventional Rails backend and Ember Data.
+
+      ## JSON Structure
+
+      The ActiveModelSerializer expects the JSON returned from your server
+      to follow the REST adapter conventions substituting underscored keys
+      for camelcased ones.
+
+      ### Conventional Names
+
+      Attribute names in your JSON payload should be the underscored versions of
+      the attributes in your Ember.js models.
+
+      For example, if you have a `Person` model:
+
+      ```js
+      App.FamousPerson = DS.Model.extend({
+        firstName: DS.attr('string'),
+        lastName: DS.attr('string'),
+        occupation: DS.attr('string')
+      });
+      ```
+
+      The JSON returned should look like this:
+
+      ```js
+      {
+        "famous_person": {
+          "id": 1,
+          "first_name": "Barack",
+          "last_name": "Obama",
+          "occupation": "President"
+        }
+      }
+      ```
+
+      Let's imagine that `Occupation` is just another model:
+
+      ```js
+      App.Person = DS.Model.extend({
+        firstName: DS.attr('string'),
+        lastName: DS.attr('string'),
+        occupation: DS.belongsTo('occupation')
+      });
+
+      App.Occupation = DS.Model.extend({
+        name: DS.attr('string'),
+        salary: DS.attr('number'),
+        people: DS.hasMany('person')
+      });
+      ```
+
+      The JSON needed to avoid extra server calls, should look like this:
+
+      ```js
+      {
+        "people": [{
+          "id": 1,
+          "first_name": "Barack",
+          "last_name": "Obama",
+          "occupation_id": 1
+        }],
+
+        "occupations": [{
+          "id": 1,
+          "name": "President",
+          "salary": 100000,
+          "person_ids": [1]
+        }]
+      }
+      ```
+
+      @class ActiveModelSerializer
+      @namespace DS
+      @extends DS.RESTSerializer
+    */
+    var ActiveModelSerializer = RESTSerializer.extend({
+      // SERIALIZE
+
+      /**
+        Converts camelCased attributes to underscored when serializing.
+
+        @method keyForAttribute
+        @param {String} attribute
+        @return String
+      */
+      keyForAttribute: function(attr) {
+        return decamelize(attr);
+      },
+
+      /**
+        Underscores relationship names and appends "_id" or "_ids" when serializing
+        relationship keys.
+
+        @method keyForRelationship
+        @param {String} key
+        @param {String} kind
+        @return String
+      */
+      keyForRelationship: function(rawKey, kind) {
+        var key = decamelize(rawKey);
+        if (kind === "belongsTo") {
+          return key + "_id";
+        } else if (kind === "hasMany") {
+          return singularize(key) + "_ids";
+        } else {
+          return key;
+        }
+      },
+
+      /*
+        Does not serialize hasMany relationships by default.
+      */
+      serializeHasMany: Ember.K,
+
+      /**
+        Underscores the JSON root keys when serializing.
+
+        @method serializeIntoHash
+        @param {Object} hash
+        @param {subclass of DS.Model} type
+        @param {DS.Model} record
+        @param {Object} options
+      */
+      serializeIntoHash: function(data, type, record, options) {
+        var root = underscore(decamelize(type.typeKey));
+        data[root] = this.serialize(record, options);
+      },
+
+      /**
+        Serializes a polymorphic type as a fully capitalized model name.
+
+        @method serializePolymorphicType
+        @param {DS.Model} record
+        @param {Object} json
+        @param {Object} relationship
+      */
+      serializePolymorphicType: function(record, json, relationship) {
+        var key = relationship.key;
+        var belongsTo = get(record, key);
+        var jsonKey = underscore(key + "_type");
+
+        if (Ember.isNone(belongsTo)) {
+          json[jsonKey] = null;
+        } else {
+          json[jsonKey] = capitalize(camelize(belongsTo.constructor.typeKey));
+        }
+      },
+
+      // EXTRACT
+
+      /**
+        Add extra step to `DS.RESTSerializer.normalize` so links are normalized.
+
+        If your payload looks like:
+
+        ```js
+        {
+          "post": {
+            "id": 1,
+            "title": "Rails is omakase",
+            "links": { "flagged_comments": "api/comments/flagged" }
+          }
+        }
+        ```
+
+        The normalized version would look like this
+
+        ```js
+        {
+          "post": {
+            "id": 1,
+            "title": "Rails is omakase",
+            "links": { "flaggedComments": "api/comments/flagged" }
+          }
+        }
+        ```
+
+        @method normalize
+        @param {subclass of DS.Model} type
+        @param {Object} hash
+        @param {String} prop
+        @return Object
+      */
+
+      normalize: function(type, hash, prop) {
+        this.normalizeLinks(hash);
+
+        return this._super(type, hash, prop);
+      },
+
+      /**
+        Convert `snake_cased` links  to `camelCase`
+
+        @method normalizeLinks
+        @param {Object} data
+      */
+
+      normalizeLinks: function(data){
+        if (data.links) {
+          var links = data.links;
+
+          for (var link in links) {
+            var camelizedLink = camelize(link);
+
+            if (camelizedLink !== link) {
+              links[camelizedLink] = links[link];
+              delete links[link];
+            }
+          }
+        }
+      },
+
+      /**
+        Normalize the polymorphic type from the JSON.
+
+        Normalize:
+        ```js
+          {
+            id: "1"
+            minion: { type: "evil_minion", id: "12"}
+          }
+        ```
+
+        To:
+        ```js
+          {
+            id: "1"
+            minion: { type: "evilMinion", id: "12"}
+          }
+        ```
+
+        @method normalizeRelationships
+        @private
+      */
+      normalizeRelationships: function(type, hash) {
+
+        if (this.keyForRelationship) {
+          type.eachRelationship(function(key, relationship) {
+            var payloadKey, payload;
+            if (relationship.options.polymorphic) {
+              payloadKey = this.keyForAttribute(key);
+              payload = hash[payloadKey];
+              if (payload && payload.type) {
+                payload.type = this.typeForRoot(payload.type);
+              } else if (payload && relationship.kind === "hasMany") {
+                var self = this;
+                forEach(payload, function(single) {
+                  single.type = self.typeForRoot(single.type);
+                });
+              }
+            } else {
+              payloadKey = this.keyForRelationship(key, relationship.kind);
+              if (!hash.hasOwnProperty(payloadKey)) { return; }
+              payload = hash[payloadKey];
+            }
+
+            hash[key] = payload;
+
+            if (key !== payloadKey) {
+              delete hash[payloadKey];
+            }
+          }, this);
+        }
+      }
+    });
+
+    __exports__["default"] = ActiveModelSerializer;
+  });
+enifed("ember-data",
+  ["ember-data/system/create","ember-data/core","ember-data/ext/date","ember-data/system/promise_proxies","ember-data/system/store","ember-data/system/model","ember-data/system/adapter","ember-data/system/debug","ember-data/system/record_arrays","ember-data/system/record_array_manager","ember-data/adapters","ember-data/serializers/json_serializer","ember-data/serializers/rest_serializer","ember-inflector","ember-data/serializers/embedded_records_mixin","activemodel-adapter","ember-data/transforms","ember-data/system/relationships","ember-data/ember-initializer","ember-data/setup-container","ember-data/system/container_proxy","ember-data/system/relationships/relationship","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __dependency17__, __dependency18__, __dependency19__, __dependency20__, __dependency21__, __dependency22__, __exports__) {
+    "use strict";
+    /**
+      Ember Data
+
+      @module ember-data
+      @main ember-data
+    */
+
+    // support RSVP 2.x via resolve,  but prefer RSVP 3.x's Promise.cast
+    Ember.RSVP.Promise.cast = Ember.RSVP.Promise.cast || Ember.RSVP.resolve;
+
+    var DS = __dependency2__["default"];
+
+    var PromiseArray = __dependency4__.PromiseArray;
+    var PromiseObject = __dependency4__.PromiseObject;
+    var Store = __dependency5__.Store;
+    var Model = __dependency6__.Model;
+    var Errors = __dependency6__.Errors;
+    var RootState = __dependency6__.RootState;
+    var attr = __dependency6__.attr;
+    var InvalidError = __dependency7__.InvalidError;
+    var Adapter = __dependency7__.Adapter;
+    var DebugAdapter = __dependency8__["default"];
+    var RecordArray = __dependency9__.RecordArray;
+    var FilteredRecordArray = __dependency9__.FilteredRecordArray;
+    var AdapterPopulatedRecordArray = __dependency9__.AdapterPopulatedRecordArray;
+    var ManyArray = __dependency9__.ManyArray;
+    var RecordArrayManager = __dependency10__["default"];
+    var RESTAdapter = __dependency11__.RESTAdapter;
+    var FixtureAdapter = __dependency11__.FixtureAdapter;
+    var JSONSerializer = __dependency12__["default"];
+    var RESTSerializer = __dependency13__["default"];
+    var EmbeddedRecordsMixin = __dependency15__["default"];
+    var ActiveModelAdapter = __dependency16__.ActiveModelAdapter;
+    var ActiveModelSerializer = __dependency16__.ActiveModelSerializer;
+
+    var Transform = __dependency17__.Transform;
+    var DateTransform = __dependency17__.DateTransform;
+    var NumberTransform = __dependency17__.NumberTransform;
+    var StringTransform = __dependency17__.StringTransform;
+    var BooleanTransform = __dependency17__.BooleanTransform;
+
+    var hasMany = __dependency18__.hasMany;
+    var belongsTo = __dependency18__.belongsTo;
+    var setupContainer = __dependency20__["default"];
+
+    var ContainerProxy = __dependency21__["default"];
+    var Relationship = __dependency22__.Relationship;
+
+    DS.Store         = Store;
+    DS.PromiseArray  = PromiseArray;
+    DS.PromiseObject = PromiseObject;
+
+    DS.Model     = Model;
+    DS.RootState = RootState;
+    DS.attr      = attr;
+    DS.Errors    = Errors;
+
+    DS.Adapter      = Adapter;
+    DS.InvalidError = InvalidError;
+
+    DS.DebugAdapter = DebugAdapter;
+
+    DS.RecordArray                 = RecordArray;
+    DS.FilteredRecordArray         = FilteredRecordArray;
+    DS.AdapterPopulatedRecordArray = AdapterPopulatedRecordArray;
+    DS.ManyArray                   = ManyArray;
+
+    DS.RecordArrayManager = RecordArrayManager;
+
+    DS.RESTAdapter    = RESTAdapter;
+    DS.FixtureAdapter = FixtureAdapter;
+
+    DS.RESTSerializer = RESTSerializer;
+    DS.JSONSerializer = JSONSerializer;
+
+    DS.Transform       = Transform;
+    DS.DateTransform   = DateTransform;
+    DS.StringTransform = StringTransform;
+    DS.NumberTransform = NumberTransform;
+    DS.BooleanTransform = BooleanTransform;
+
+    DS.ActiveModelAdapter    = ActiveModelAdapter;
+    DS.ActiveModelSerializer = ActiveModelSerializer;
+    DS.EmbeddedRecordsMixin  = EmbeddedRecordsMixin;
+
+    DS.belongsTo = belongsTo;
+    DS.hasMany   = hasMany;
+
+    DS.Relationship  = Relationship;
+
+    DS.ContainerProxy = ContainerProxy;
+
+    DS._setupContainer = setupContainer;
+
+    Ember.lookup.DS = DS;
+
+    __exports__["default"] = DS;
+  });
+enifed("ember-data/adapters",
+  ["ember-data/adapters/fixture_adapter","ember-data/adapters/rest_adapter","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    var FixtureAdapter = __dependency1__["default"];
+    var RESTAdapter = __dependency2__["default"];
+
+    __exports__.RESTAdapter = RESTAdapter;
+    __exports__.FixtureAdapter = FixtureAdapter;
+  });
+enifed("ember-data/adapters/fixture_adapter",
+  ["ember-data/system/adapter","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    var get = Ember.get;
+    var fmt = Ember.String.fmt;
+    var indexOf = Ember.EnumerableUtils.indexOf;
+
+    var counter = 0;
+
+    var Adapter = __dependency1__["default"];
+
+    /**
+      `DS.FixtureAdapter` is an adapter that loads records from memory.
+      It's primarily used for development and testing. You can also use
+      `DS.FixtureAdapter` while working on the API but is not ready to
+      integrate yet. It is a fully functioning adapter. All CRUD methods
+      are implemented. You can also implement query logic that a remote
+      system would do. It's possible to develop your entire application
+      with `DS.FixtureAdapter`.
+
+      For information on how to use the `FixtureAdapter` in your
+      application please see the [FixtureAdapter
+      guide](/guides/models/the-fixture-adapter/).
+
+      @class FixtureAdapter
+      @namespace DS
+      @extends DS.Adapter
+    */
+    __exports__["default"] = Adapter.extend({
+      // by default, fixtures are already in normalized form
+      serializer: null,
+
+      /**
+        If `simulateRemoteResponse` is `true` the `FixtureAdapter` will
+        wait a number of milliseconds before resolving promises with the
+        fixture values. The wait time can be configured via the `latency`
+        property.
+
+        @property simulateRemoteResponse
+        @type {Boolean}
+        @default true
+      */
+      simulateRemoteResponse: true,
+
+      /**
+        By default the `FixtureAdapter` will simulate a wait of the
+        `latency` milliseconds before resolving promises with the fixture
+        values. This behavior can be turned off via the
+        `simulateRemoteResponse` property.
+
+        @property latency
+        @type {Number}
+        @default 50
+      */
+      latency: 50,
+
+      /**
+        Implement this method in order to provide data associated with a type
+
+        @method fixturesForType
+        @param {Subclass of DS.Model} type
+        @return {Array}
+      */
+      fixturesForType: function(type) {
+        if (type.FIXTURES) {
+          var fixtures = Ember.A(type.FIXTURES);
+          return fixtures.map(function(fixture){
+            var fixtureIdType = typeof fixture.id;
+            if(fixtureIdType !== "number" && fixtureIdType !== "string"){
+              throw new Error(fmt('the id property must be defined as a number or string for fixture %@', [fixture]));
+            }
+            fixture.id = fixture.id + '';
+            return fixture;
+          });
+        }
+        return null;
+      },
+
+      /**
+        Implement this method in order to query fixtures data
+
+        @method queryFixtures
+        @param {Array} fixture
+        @param {Object} query
+        @param {Subclass of DS.Model} type
+        @return {Promise|Array}
+      */
+      queryFixtures: function(fixtures, query, type) {
+        Ember.assert('Not implemented: You must override the DS.FixtureAdapter::queryFixtures method to support querying the fixture store.');
+      },
+
+      /**
+        @method updateFixtures
+        @param {Subclass of DS.Model} type
+        @param {Array} fixture
+      */
+      updateFixtures: function(type, fixture) {
+        if(!type.FIXTURES) {
+          type.FIXTURES = [];
+        }
+
+        var fixtures = type.FIXTURES;
+
+        this.deleteLoadedFixture(type, fixture);
+
+        fixtures.push(fixture);
+      },
+
+      /**
+        Implement this method in order to provide json for CRUD methods
+
+        @method mockJSON
+        @param {Subclass of DS.Model} type
+        @param {DS.Model} record
+      */
+      mockJSON: function(store, type, record) {
+        return store.serializerFor(type).serialize(record, { includeId: true });
+      },
+
+      /**
+        @method generateIdForRecord
+        @param {DS.Store} store
+        @param {DS.Model} record
+        @return {String} id
+      */
+      generateIdForRecord: function(store) {
+        return "fixture-" + counter++;
+      },
+
+      /**
+        @method find
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {String} id
+        @return {Promise} promise
+      */
+      find: function(store, type, id) {
+        var fixtures = this.fixturesForType(type);
+        var fixture;
+
+        Ember.assert("Unable to find fixtures for model type "+type.toString() +". If you're defining your fixtures using `Model.FIXTURES = ...`, please change it to `Model.reopenClass({ FIXTURES: ... })`.", fixtures);
+
+        if (fixtures) {
+          fixture = Ember.A(fixtures).findBy('id', id);
+        }
+
+        if (fixture) {
+          return this.simulateRemoteCall(function() {
+            return fixture;
+          }, this);
+        }
+      },
+
+      /**
+        @method findMany
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Array} ids
+        @return {Promise} promise
+      */
+      findMany: function(store, type, ids) {
+        var fixtures = this.fixturesForType(type);
+
+        Ember.assert("Unable to find fixtures for model type "+type.toString(), fixtures);
+
+        if (fixtures) {
+          fixtures = fixtures.filter(function(item) {
+            return indexOf(ids, item.id) !== -1;
+          });
+        }
+
+        if (fixtures) {
+          return this.simulateRemoteCall(function() {
+            return fixtures;
+          }, this);
+        }
+      },
+
+      /**
+        @private
+        @method findAll
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {String} sinceToken
+        @return {Promise} promise
+      */
+      findAll: function(store, type) {
+        var fixtures = this.fixturesForType(type);
+
+        Ember.assert("Unable to find fixtures for model type "+type.toString(), fixtures);
+
+        return this.simulateRemoteCall(function() {
+          return fixtures;
+        }, this);
+      },
+
+      /**
+        @private
+        @method findQuery
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} query
+        @param {DS.AdapterPopulatedRecordArray} recordArray
+        @return {Promise} promise
+      */
+      findQuery: function(store, type, query, array) {
+        var fixtures = this.fixturesForType(type);
+
+        Ember.assert("Unable to find fixtures for model type " + type.toString(), fixtures);
+
+        fixtures = this.queryFixtures(fixtures, query, type);
+
+        if (fixtures) {
+          return this.simulateRemoteCall(function() {
+            return fixtures;
+          }, this);
+        }
+      },
+
+      /**
+        @method createRecord
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {DS.Model} record
+        @return {Promise} promise
+      */
+      createRecord: function(store, type, record) {
+        var fixture = this.mockJSON(store, type, record);
+
+        this.updateFixtures(type, fixture);
+
+        return this.simulateRemoteCall(function() {
+          return fixture;
+        }, this);
+      },
+
+      /**
+        @method updateRecord
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {DS.Model} record
+        @return {Promise} promise
+      */
+      updateRecord: function(store, type, record) {
+        var fixture = this.mockJSON(store, type, record);
+
+        this.updateFixtures(type, fixture);
+
+        return this.simulateRemoteCall(function() {
+          return fixture;
+        }, this);
+      },
+
+      /**
+        @method deleteRecord
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {DS.Model} record
+        @return {Promise} promise
+      */
+      deleteRecord: function(store, type, record) {
+        this.deleteLoadedFixture(type, record);
+
+        return this.simulateRemoteCall(function() {
+          // no payload in a deletion
+          return null;
+        });
+      },
+
+      /*
+        @method deleteLoadedFixture
+        @private
+        @param type
+        @param record
+      */
+      deleteLoadedFixture: function(type, record) {
+        var existingFixture = this.findExistingFixture(type, record);
+
+        if (existingFixture) {
+          var index = indexOf(type.FIXTURES, existingFixture);
+          type.FIXTURES.splice(index, 1);
+          return true;
+        }
+      },
+
+      /*
+        @method findExistingFixture
+        @private
+        @param type
+        @param record
+      */
+      findExistingFixture: function(type, record) {
+        var fixtures = this.fixturesForType(type);
+        var id = get(record, 'id');
+
+        return this.findFixtureById(fixtures, id);
+      },
+
+      /*
+        @method findFixtureById
+        @private
+        @param fixtures
+        @param id
+      */
+      findFixtureById: function(fixtures, id) {
+        return Ember.A(fixtures).find(function(r) {
+          if (''+get(r, 'id') === ''+id) {
+            return true;
+          } else {
+            return false;
+          }
+        });
+      },
+
+      /*
+        @method simulateRemoteCall
+        @private
+        @param callback
+        @param context
+      */
+      simulateRemoteCall: function(callback, context) {
+        var adapter = this;
+
+        return new Ember.RSVP.Promise(function(resolve) {
+          var value = Ember.copy(callback.call(context), true);
+          if (get(adapter, 'simulateRemoteResponse')) {
+            // Schedule with setTimeout
+            Ember.run.later(function() {
+              resolve(value);
+            }, get(adapter, 'latency'));
+          } else {
+            // Asynchronous, but at the of the runloop with zero latency
+            Ember.run.schedule('actions', null, function() {
+              resolve(value);
+            });
+          }
+        }, "DS: FixtureAdapter#simulateRemoteCall");
+      }
+    });
+  });
+enifed("ember-data/adapters/rest_adapter",
+  ["ember-data/system/adapter","ember-data/system/map","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    var Adapter = __dependency1__.Adapter;
+    var InvalidError = __dependency1__.InvalidError;
+    var MapWithDefault = __dependency2__.MapWithDefault;
+    var get = Ember.get;
+    var forEach = Ember.ArrayPolyfills.forEach;
+
+    /**
+      The REST adapter allows your store to communicate with an HTTP server by
+      transmitting JSON via XHR. Most Ember.js apps that consume a JSON API
+      should use the REST adapter.
+
+      This adapter is designed around the idea that the JSON exchanged with
+      the server should be conventional.
+
+      ## JSON Structure
+
+      The REST adapter expects the JSON returned from your server to follow
+      these conventions.
+
+      ### Object Root
+
+      The JSON payload should be an object that contains the record inside a
+      root property. For example, in response to a `GET` request for
+      `/posts/1`, the JSON should look like this:
+
+      ```js
+      {
+        "post": {
+          "id": 1,
+          "title": "I'm Running to Reform the W3C's Tag",
+          "author": "Yehuda Katz"
+        }
+      }
+      ```
+
+      Similarly, in response to a `GET` request for `/posts`, the JSON should
+      look like this:
+
+      ```js
+      {
+        "posts": [
+          {
+            "id": 1,
+            "title": "I'm Running to Reform the W3C's Tag",
+            "author": "Yehuda Katz"
+          },
+          {
+            "id": 2,
+            "title": "Rails is omakase",
+            "author": "D2H"
+          }
+        ]
+      }
+      ```
+
+      ### Conventional Names
+
+      Attribute names in your JSON payload should be the camelCased versions of
+      the attributes in your Ember.js models.
+
+      For example, if you have a `Person` model:
+
+      ```js
+      App.Person = DS.Model.extend({
+        firstName: DS.attr('string'),
+        lastName: DS.attr('string'),
+        occupation: DS.attr('string')
+      });
+      ```
+
+      The JSON returned should look like this:
+
+      ```js
+      {
+        "person": {
+          "id": 5,
+          "firstName": "Barack",
+          "lastName": "Obama",
+          "occupation": "President"
+        }
+      }
+      ```
+
+      ## Customization
+
+      ### Endpoint path customization
+
+      Endpoint paths can be prefixed with a `namespace` by setting the namespace
+      property on the adapter:
+
+      ```js
+      DS.RESTAdapter.reopen({
+        namespace: 'api/1'
+      });
+      ```
+      Requests for `App.Person` would now target `/api/1/people/1`.
+
+      ### Host customization
+
+      An adapter can target other hosts by setting the `host` property.
+
+      ```js
+      DS.RESTAdapter.reopen({
+        host: 'https://api.example.com'
+      });
+      ```
+
+      ### Headers customization
+
+      Some APIs require HTTP headers, e.g. to provide an API key. Arbitrary
+      headers can be set as key/value pairs on the `RESTAdapter`'s `headers`
+      object and Ember Data will send them along with each ajax request.
+
+
+      ```js
+      App.ApplicationAdapter = DS.RESTAdapter.extend({
+        headers: {
+          "API_KEY": "secret key",
+          "ANOTHER_HEADER": "Some header value"
+        }
+      });
+      ```
+
+      `headers` can also be used as a computed property to support dynamic
+      headers. In the example below, the `session` object has been
+      injected into an adapter by Ember's container.
+
+      ```js
+      App.ApplicationAdapter = DS.RESTAdapter.extend({
+        headers: function() {
+          return {
+            "API_KEY": this.get("session.authToken"),
+            "ANOTHER_HEADER": "Some header value"
+          };
+        }.property("session.authToken")
+      });
+      ```
+
+      In some cases, your dynamic headers may require data from some
+      object outside of Ember's observer system (for example
+      `document.cookie`). You can use the
+      [volatile](/api/classes/Ember.ComputedProperty.html#method_volatile)
+      function to set the property into a non-cached mode causing the headers to
+      be recomputed with every request.
+
+      ```js
+      App.ApplicationAdapter = DS.RESTAdapter.extend({
+        headers: function() {
+          return {
+            "API_KEY": Ember.get(document.cookie.match(/apiKey\=([^;]*)/), "1"),
+            "ANOTHER_HEADER": "Some header value"
+          };
+        }.property().volatile()
+      });
+      ```
+
+      @class RESTAdapter
+      @constructor
+      @namespace DS
+      @extends DS.Adapter
+    */
+    __exports__["default"] = Adapter.extend({
+      defaultSerializer: '-rest',
+
+      /**
+        By default the RESTAdapter will send each find request coming from a `store.find`
+        or from accessing a relationship separately to the server. If your server supports passing
+        ids as a query string, you can set coalesceFindRequests to true to coalesce all find requests
+        within a single runloop.
+
+        For example, if you have an initial payload of
+        ```javascript
+        post: {
+          id:1,
+          comments: [1,2]
+        }
+        ```
+
+        By default calling `post.get('comments')` will trigger the following requests(assuming the
+        comments haven't been loaded before):
+
+        ```
+        GET /comments/1
+        GET /comments/2
+        ```
+
+        If you set coalesceFindRequests to `true` it will instead trigger the following request:
+
+        ```
+        GET /comments?ids[]=1&ids[]=2
+        ```
+
+        Setting coalesceFindRequests to `true` also works for `store.find` requests and `belongsTo`
+        relationships accessed within the same runloop. If you set `coalesceFindRequests: true`
+
+        ```javascript
+        store.find('comment', 1);
+        store.find('comment', 2);
+        ```
+
+        will also send a request to: `GET /comments?ids[]=1&ids[]=2`
+
+        Note: Requests coalescing rely on URL building strategy. So if you override `buildUrl` in your app
+        `groupRecordsForFindMany` more likely should be overriden as well in order for coalescing to work.
+
+        @property coalesceFindRequests
+        @type {boolean}
+      */
+      coalesceFindRequests: false,
+
+      /**
+        Endpoint paths can be prefixed with a `namespace` by setting the namespace
+        property on the adapter:
+
+        ```javascript
+        DS.RESTAdapter.reopen({
+          namespace: 'api/1'
+        });
+        ```
+
+        Requests for `App.Post` would now target `/api/1/post/`.
+
+        @property namespace
+        @type {String}
+      */
+
+      /**
+        An adapter can target other hosts by setting the `host` property.
+
+        ```javascript
+        DS.RESTAdapter.reopen({
+          host: 'https://api.example.com'
+        });
+        ```
+
+        Requests for `App.Post` would now target `https://api.example.com/post/`.
+
+        @property host
+        @type {String}
+      */
+
+      /**
+        Some APIs require HTTP headers, e.g. to provide an API
+        key. Arbitrary headers can be set as key/value pairs on the
+        `RESTAdapter`'s `headers` object and Ember Data will send them
+        along with each ajax request. For dynamic headers see [headers
+        customization](/api/data/classes/DS.RESTAdapter.html#toc_headers-customization).
+
+        ```javascript
+        App.ApplicationAdapter = DS.RESTAdapter.extend({
+          headers: {
+            "API_KEY": "secret key",
+            "ANOTHER_HEADER": "Some header value"
+          }
+        });
+        ```
+
+        @property headers
+        @type {Object}
+      */
+
+      /**
+        Called by the store in order to fetch the JSON for a given
+        type and ID.
+
+        The `find` method makes an Ajax request to a URL computed by `buildURL`, and returns a
+        promise for the resulting payload.
+
+        This method performs an HTTP `GET` request with the id provided as part of the query string.
+
+        @method find
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {String} id
+        @param {DS.Model} record
+        @return {Promise} promise
+      */
+      find: function(store, type, id, record) {
+        return this.ajax(this.buildURL(type.typeKey, id, record), 'GET');
+      },
+
+      /**
+        Called by the store in order to fetch a JSON array for all
+        of the records for a given type.
+
+        The `findAll` method makes an Ajax (HTTP GET) request to a URL computed by `buildURL`, and returns a
+        promise for the resulting payload.
+
+        @private
+        @method findAll
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {String} sinceToken
+        @return {Promise} promise
+      */
+      findAll: function(store, type, sinceToken) {
+        var query;
+
+        if (sinceToken) {
+          query = { since: sinceToken };
+        }
+
+        return this.ajax(this.buildURL(type.typeKey), 'GET', { data: query });
+      },
+
+      /**
+        Called by the store in order to fetch a JSON array for
+        the records that match a particular query.
+
+        The `findQuery` method makes an Ajax (HTTP GET) request to a URL computed by `buildURL`, and returns a
+        promise for the resulting payload.
+
+        The `query` argument is a simple JavaScript object that will be passed directly
+        to the server as parameters.
+
+        @private
+        @method findQuery
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} query
+        @return {Promise} promise
+      */
+      findQuery: function(store, type, query) {
+        return this.ajax(this.buildURL(type.typeKey), 'GET', { data: query });
+      },
+
+      /**
+        Called by the store in order to fetch several records together if `coalesceFindRequests` is true
+
+        For example, if the original payload looks like:
+
+        ```js
+        {
+          "id": 1,
+          "title": "Rails is omakase",
+          "comments": [ 1, 2, 3 ]
+        }
+        ```
+
+        The IDs will be passed as a URL-encoded Array of IDs, in this form:
+
+        ```
+        ids[]=1&ids[]=2&ids[]=3
+        ```
+
+        Many servers, such as Rails and PHP, will automatically convert this URL-encoded array
+        into an Array for you on the server-side. If you want to encode the
+        IDs, differently, just override this (one-line) method.
+
+        The `findMany` method makes an Ajax (HTTP GET) request to a URL computed by `buildURL`, and returns a
+        promise for the resulting payload.
+
+        @method findMany
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Array} ids
+        @param {Array} records
+        @return {Promise} promise
+      */
+      findMany: function(store, type, ids, records) {
+        return this.ajax(this.buildURL(type.typeKey, ids, records), 'GET', { data: { ids: ids } });
+      },
+
+      /**
+        Called by the store in order to fetch a JSON array for
+        the unloaded records in a has-many relationship that were originally
+        specified as a URL (inside of `links`).
+
+        For example, if your original payload looks like this:
+
+        ```js
+        {
+          "post": {
+            "id": 1,
+            "title": "Rails is omakase",
+            "links": { "comments": "/posts/1/comments" }
+          }
+        }
+        ```
+
+        This method will be called with the parent record and `/posts/1/comments`.
+
+        The `findHasMany` method will make an Ajax (HTTP GET) request to the originally specified URL.
+        If the URL is host-relative (starting with a single slash), the
+        request will use the host specified on the adapter (if any).
+
+        @method findHasMany
+        @param {DS.Store} store
+        @param {DS.Model} record
+        @param {String} url
+        @return {Promise} promise
+      */
+      findHasMany: function(store, record, url, relationship) {
+        var host = get(this, 'host');
+        var id   = get(record, 'id');
+        var type = record.constructor.typeKey;
+
+        if (host && url.charAt(0) === '/' && url.charAt(1) !== '/') {
+          url = host + url;
+        }
+
+        return this.ajax(this.urlPrefix(url, this.buildURL(type, id)), 'GET');
+      },
+
+      /**
+        Called by the store in order to fetch a JSON array for
+        the unloaded records in a belongs-to relationship that were originally
+        specified as a URL (inside of `links`).
+
+        For example, if your original payload looks like this:
+
+        ```js
+        {
+          "person": {
+            "id": 1,
+            "name": "Tom Dale",
+            "links": { "group": "/people/1/group" }
+          }
+        }
+        ```
+
+        This method will be called with the parent record and `/people/1/group`.
+
+        The `findBelongsTo` method will make an Ajax (HTTP GET) request to the originally specified URL.
+
+        @method findBelongsTo
+        @param {DS.Store} store
+        @param {DS.Model} record
+        @param {String} url
+        @return {Promise} promise
+      */
+      findBelongsTo: function(store, record, url, relationship) {
+        var id   = get(record, 'id');
+        var type = record.constructor.typeKey;
+
+        return this.ajax(this.urlPrefix(url, this.buildURL(type, id)), 'GET');
+      },
+
+      /**
+        Called by the store when a newly created record is
+        saved via the `save` method on a model record instance.
+
+        The `createRecord` method serializes the record and makes an Ajax (HTTP POST) request
+        to a URL computed by `buildURL`.
+
+        See `serialize` for information on how to customize the serialized form
+        of a record.
+
+        @method createRecord
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {DS.Model} record
+        @return {Promise} promise
+      */
+      createRecord: function(store, type, record) {
+        var data = {};
+        var serializer = store.serializerFor(type.typeKey);
+
+        serializer.serializeIntoHash(data, type, record, { includeId: true });
+
+        return this.ajax(this.buildURL(type.typeKey, null, record), "POST", { data: data });
+      },
+
+      /**
+        Called by the store when an existing record is saved
+        via the `save` method on a model record instance.
+
+        The `updateRecord` method serializes the record and makes an Ajax (HTTP PUT) request
+        to a URL computed by `buildURL`.
+
+        See `serialize` for information on how to customize the serialized form
+        of a record.
+
+        @method updateRecord
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {DS.Model} record
+        @return {Promise} promise
+      */
+      updateRecord: function(store, type, record) {
+        var data = {};
+        var serializer = store.serializerFor(type.typeKey);
+
+        serializer.serializeIntoHash(data, type, record);
+
+        var id = get(record, 'id');
+
+        return this.ajax(this.buildURL(type.typeKey, id, record), "PUT", { data: data });
+      },
+
+      /**
+        Called by the store when a record is deleted.
+
+        The `deleteRecord` method  makes an Ajax (HTTP DELETE) request to a URL computed by `buildURL`.
+
+        @method deleteRecord
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {DS.Model} record
+        @return {Promise} promise
+      */
+      deleteRecord: function(store, type, record) {
+        var id = get(record, 'id');
+
+        return this.ajax(this.buildURL(type.typeKey, id, record), "DELETE");
+      },
+
+      /**
+        Builds a URL for a given type and optional ID.
+
+        By default, it pluralizes the type's name (for example, 'post'
+        becomes 'posts' and 'person' becomes 'people'). To override the
+        pluralization see [pathForType](#method_pathForType).
+
+        If an ID is specified, it adds the ID to the path generated
+        for the type, separated by a `/`.
+
+        @method buildURL
+        @param {String} type
+        @param {String} id
+        @param {DS.Model} record
+        @return {String} url
+      */
+      buildURL: function(type, id, record) {
+        var url = [],
+            host = get(this, 'host'),
+            prefix = this.urlPrefix();
+
+        if (type) { url.push(this.pathForType(type)); }
+
+        //We might get passed in an array of ids from findMany
+        //in which case we don't want to modify the url, as the
+        //ids will be passed in through a query param
+        if (id && !Ember.isArray(id)) { url.push(encodeURIComponent(id)); }
+
+        if (prefix) { url.unshift(prefix); }
+
+        url = url.join('/');
+        if (!host && url) { url = '/' + url; }
+
+        return url;
+      },
+
+      /**
+        @method urlPrefix
+        @private
+        @param {String} path
+        @param {String} parentUrl
+        @return {String} urlPrefix
+      */
+      urlPrefix: function(path, parentURL) {
+        var host = get(this, 'host');
+        var namespace = get(this, 'namespace');
+        var url = [];
+
+        if (path) {
+          // Absolute path
+          if (path.charAt(0) === '/') {
+            if (host) {
+              path = path.slice(1);
+              url.push(host);
+            }
+          // Relative path
+          } else if (!/^http(s)?:\/\//.test(path)) {
+            url.push(parentURL);
+          }
+        } else {
+          if (host) { url.push(host); }
+          if (namespace) { url.push(namespace); }
+        }
+
+        if (path) {
+          url.push(path);
+        }
+
+        return url.join('/');
+      },
+
+      _stripIDFromURL: function(store, record) {
+        var type = record.constructor;
+        var url = this.buildURL(type.typeKey, record.get('id'), record);
+
+        var expandedURL = url.split('/');
+        //Case when the url is of the format ...something/:id
+        var lastSegment = expandedURL[ expandedURL.length - 1 ];
+        var id = record.get('id');
+        if (lastSegment === id) {
+          expandedURL[expandedURL.length - 1] = "";
+        } else if(endsWith(lastSegment, '?id=' + id)) {
+          //Case when the url is of the format ...something?id=:id
+          expandedURL[expandedURL.length - 1] = lastSegment.substring(0, lastSegment.length - id.length - 1);
+        }
+
+        return expandedURL.join('/');
+      },
+
+      /**
+        http://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers
+      */
+      maxUrlLength: 2048,
+
+      /**
+        Organize records into groups, each of which is to be passed to separate
+        calls to `findMany`.
+
+        This implementation groups together records that have the same base URL but
+        differing ids. For example `/comments/1` and `/comments/2` will be grouped together
+        because we know findMany can coalesce them together as `/comments?ids[]=1&ids[]=2`
+
+        It also supports urls where ids are passed as a query param, such as `/comments?id=1`
+        but not those where there is more than 1 query param such as `/comments?id=2&name=David`
+        Currently only the query param of `id` is supported. If you need to support others, please
+        override this or the `_stripIDFromURL` method.
+
+        It does not group records that have differing base urls, such as for example: `/posts/1/comments/2`
+        and `/posts/2/comments/3`
+
+        @method groupRecordsForFindMany
+        @param {DS.Store} store
+        @param {Array} records
+        @return {Array}  an array of arrays of records, each of which is to be
+                          loaded separately by `findMany`.
+      */
+      groupRecordsForFindMany: function (store, records) {
+        var groups = MapWithDefault.create({defaultValue: function(){return [];}});
+        var adapter = this;
+        var maxUrlLength = this.maxUrlLength;
+
+        forEach.call(records, function(record){
+          var baseUrl = adapter._stripIDFromURL(store, record);
+          groups.get(baseUrl).push(record);
+        });
+
+        function splitGroupToFitInUrl(group, maxUrlLength, paramNameLength) {
+          var baseUrl = adapter._stripIDFromURL(store, group[0]);
+          var idsSize = 0;
+          var splitGroups = [[]];
+
+          forEach.call(group, function(record) {
+            var additionalLength = encodeURIComponent(record.get('id')).length + paramNameLength;
+            if (baseUrl.length + idsSize + additionalLength >= maxUrlLength) {
+              idsSize = 0;
+              splitGroups.push([]);
+            }
+
+            idsSize += additionalLength;
+
+            var lastGroupIndex = splitGroups.length - 1;
+            splitGroups[lastGroupIndex].push(record);
+          });
+
+          return splitGroups;
+        }
+
+        var groupsArray = [];
+        groups.forEach(function(group, key){
+          var paramNameLength = '&ids%5B%5D='.length;
+          var splitGroups = splitGroupToFitInUrl(group, maxUrlLength, paramNameLength);
+
+          forEach.call(splitGroups, function(splitGroup) {
+            groupsArray.push(splitGroup);
+          });
+        });
+
+        return groupsArray;
+      },
+
+      /**
+        Determines the pathname for a given type.
+
+        By default, it pluralizes the type's name (for example,
+        'post' becomes 'posts' and 'person' becomes 'people').
+
+        ### Pathname customization
+
+        For example if you have an object LineItem with an
+        endpoint of "/line_items/".
+
+        ```js
+        App.ApplicationAdapter = DS.RESTAdapter.extend({
+          pathForType: function(type) {
+            var decamelized = Ember.String.decamelize(type);
+            return Ember.String.pluralize(decamelized);
+          }
+        });
+        ```
+
+        @method pathForType
+        @param {String} type
+        @return {String} path
+      **/
+      pathForType: function(type) {
+        var camelized = Ember.String.camelize(type);
+        return Ember.String.pluralize(camelized);
+      },
+
+      /**
+        Takes an ajax response, and returns an error payload.
+
+        Returning a `DS.InvalidError` from this method will cause the
+        record to transition into the `invalid` state and make the
+        `errors` object available on the record.
+
+        This function should return the entire payload as received from the
+        server.  Error object extraction and normalization of model errors
+        should be performed by `extractErrors` on the serializer.
+
+        Example
+
+        ```javascript
+        App.ApplicationAdapter = DS.RESTAdapter.extend({
+          ajaxError: function(jqXHR) {
+            var error = this._super(jqXHR);
+
+            if (jqXHR && jqXHR.status === 422) {
+              var jsonErrors = Ember.$.parseJSON(jqXHR.responseText);
+
+              return new DS.InvalidError(jsonErrors);
+            } else {
+              return error;
+            }
+          }
+        });
+        ```
+
+        Note: As a correctness optimization, the default implementation of
+        the `ajaxError` method strips out the `then` method from jquery's
+        ajax response (jqXHR). This is important because the jqXHR's
+        `then` method fulfills the promise with itself resulting in a
+        circular "thenable" chain which may cause problems for some
+        promise libraries.
+
+        @method ajaxError
+        @param  {Object} jqXHR
+        @param  {Object} responseText
+        @return {Object} jqXHR
+      */
+      ajaxError: function(jqXHR, responseText) {
+        if (jqXHR && typeof jqXHR === 'object') {
+          jqXHR.then = null;
+        }
+
+        return jqXHR;
+      },
+
+      /**
+        Takes an ajax response, and returns the json payload.
+
+        By default this hook just returns the jsonPayload passed to it.
+        You might want to override it in two cases:
+
+        1. Your API might return useful results in the request headers.
+        If you need to access these, you can override this hook to copy them
+        from jqXHR to the payload object so they can be processed in you serializer.
+
+
+        2. Your API might return errors as successful responses with status code
+        200 and an Errors text or object. You can return a DS.InvalidError from
+        this hook and it will automatically reject the promise and put your record
+        into the invalid state.
+
+        @method ajaxSuccess
+        @param  {Object} jqXHR
+        @param  {Object} jsonPayload
+        @return {Object} jsonPayload
+      */
+
+      ajaxSuccess: function(jqXHR, jsonPayload) {
+        return jsonPayload;
+      },
+
+      /**
+        Takes a URL, an HTTP method and a hash of data, and makes an
+        HTTP request.
+
+        When the server responds with a payload, Ember Data will call into `extractSingle`
+        or `extractArray` (depending on whether the original query was for one record or
+        many records).
+
+        By default, `ajax` method has the following behavior:
+
+        * It sets the response `dataType` to `"json"`
+        * If the HTTP method is not `"GET"`, it sets the `Content-Type` to be
+          `application/json; charset=utf-8`
+        * If the HTTP method is not `"GET"`, it stringifies the data passed in. The
+          data is the serialized record in the case of a save.
+        * Registers success and failure handlers.
+
+        @method ajax
+        @private
+        @param {String} url
+        @param {String} type The request type GET, POST, PUT, DELETE etc.
+        @param {Object} hash
+        @return {Promise} promise
+      */
+      ajax: function(url, type, options) {
+        var adapter = this;
+
+        return new Ember.RSVP.Promise(function(resolve, reject) {
+          var hash = adapter.ajaxOptions(url, type, options);
+
+          hash.success = function(json, textStatus, jqXHR) {
+            json = adapter.ajaxSuccess(jqXHR, json);
+            if (json instanceof InvalidError) {
+              Ember.run(null, reject, json);
+            } else {
+              Ember.run(null, resolve, json);
+            }
+          };
+
+          hash.error = function(jqXHR, textStatus, errorThrown) {
+            Ember.run(null, reject, adapter.ajaxError(jqXHR, jqXHR.responseText));
+          };
+
+          Ember.$.ajax(hash);
+        }, "DS: RESTAdapter#ajax " + type + " to " + url);
+      },
+
+      /**
+        @method ajaxOptions
+        @private
+        @param {String} url
+        @param {String} type The request type GET, POST, PUT, DELETE etc.
+        @param {Object} hash
+        @return {Object} hash
+      */
+      ajaxOptions: function(url, type, options) {
+        var hash = options || {};
+        hash.url = url;
+        hash.type = type;
+        hash.dataType = 'json';
+        hash.context = this;
+
+        if (hash.data && type !== 'GET') {
+          hash.contentType = 'application/json; charset=utf-8';
+          hash.data = JSON.stringify(hash.data);
+        }
+
+        var headers = get(this, 'headers');
+        if (headers !== undefined) {
+          hash.beforeSend = function (xhr) {
+            forEach.call(Ember.keys(headers), function(key) {
+              xhr.setRequestHeader(key, headers[key]);
+            });
+          };
+        }
+
+        return hash;
+      }
+    });
+
+    //From http://stackoverflow.com/questions/280634/endswith-in-javascript
+    function endsWith(string, suffix){
+      if (typeof String.prototype.endsWith !== 'function') {
+        return string.indexOf(suffix, string.length - suffix.length) !== -1;
+      } else {
+        return string.endsWith(suffix);
+      }
+    }
+  });
+enifed("ember-data/core",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    /**
+      All Ember Data methods and functions are defined inside of this namespace.
+
+      @class DS
+      @static
+    */
+    var DS;
+    if ('undefined' === typeof DS) {
+      /**
+        @property VERSION
+        @type String
+        @default '1.0.0-beta.12'
+        @static
+      */
+      DS = Ember.Namespace.create({
+        VERSION: '1.0.0-beta.12'
+      });
+
+      if (Ember.libraries) {
+        Ember.libraries.registerCoreLibrary('Ember Data', DS.VERSION);
+      }
+    }
+
+    __exports__["default"] = DS;
+  });
+enifed("ember-data/ember-initializer",
+  ["ember-data/setup-container"],
+  function(__dependency1__) {
+    "use strict";
+    var setupContainer = __dependency1__["default"];
+
+    var K = Ember.K;
+
+    /**
+      @module ember-data
+    */
+
+    /*
+
+      This code initializes Ember-Data onto an Ember application.
+
+      If an Ember.js developer defines a subclass of DS.Store on their application,
+      as `App.ApplicationStore` (or via a module system that resolves to `store:application`)
+      this code will automatically instantiate it and make it available on the
+      router.
+
+      Additionally, after an application's controllers have been injected, they will
+      each have the store made available to them.
+
+      For example, imagine an Ember.js application with the following classes:
+
+      App.ApplicationStore = DS.Store.extend({
+        adapter: 'custom'
+      });
+
+      App.PostsController = Ember.ArrayController.extend({
+        // ...
+      });
+
+      When the application is initialized, `App.ApplicationStore` will automatically be
+      instantiated, and the instance of `App.PostsController` will have its `store`
+      property set to that instance.
+
+      Note that this code will only be run if the `ember-application` package is
+      loaded. If Ember Data is being used in an environment other than a
+      typical application (e.g., node.js where only `ember-runtime` is available),
+      this code will be ignored.
+    */
+
+    Ember.onLoad('Ember.Application', function(Application) {
+
+      Application.initializer({
+        name:       "ember-data",
+        initialize: setupContainer
+      });
+
+      // Deprecated initializers to satisfy old code that depended on them
+
+      Application.initializer({
+        name:       "store",
+        after:      "ember-data",
+        initialize: K
+      });
+
+      Application.initializer({
+        name:       "activeModelAdapter",
+        before:     "store",
+        initialize: K
+      });
+
+      Application.initializer({
+        name:       "transforms",
+        before:     "store",
+        initialize: K
+      });
+
+      Application.initializer({
+        name:       "data-adapter",
+        before:     "store",
+        initialize: K
+      });
+
+      Application.initializer({
+        name:       "injectStore",
+        before:     "store",
+        initialize: K
+      });
+    });
+  });
+enifed("ember-data/ext/date",
+  [],
+  function() {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    /**
+      Date.parse with progressive enhancement for ISO 8601 <https://github.com/csnover/js-iso8601>
+
+      © 2011 Colin Snover <http://zetafleet.com>
+
+      Released under MIT license.
+
+      @class Date
+      @namespace Ember
+      @static
+    */
+    Ember.Date = Ember.Date || {};
+
+    var origParse = Date.parse, numericKeys = [ 1, 4, 5, 6, 7, 10, 11 ];
+
+    /**
+      @method parse
+      @param {Date} date
+      @return {Number} timestamp
+    */
+    Ember.Date.parse = function (date) {
+        var timestamp, struct, minutesOffset = 0;
+
+        // ES5 §15.9.4.2 states that the string should attempt to be parsed as a Date Time String Format string
+        // before falling back to any implementation-specific date parsing, so that’s what we do, even if native
+        // implementations could be faster
+        //              1 YYYY                2 MM       3 DD           4 HH    5 mm       6 ss        7 msec        8 Z 9 ±    10 tzHH    11 tzmm
+        if ((struct = /^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/.exec(date))) {
+            // avoid NaN timestamps caused by “undefined” values being passed to Date.UTC
+            for (var i = 0, k; (k = numericKeys[i]); ++i) {
+                struct[k] = +struct[k] || 0;
+            }
+
+            // allow undefined days and months
+            struct[2] = (+struct[2] || 1) - 1;
+            struct[3] = +struct[3] || 1;
+
+            if (struct[8] !== 'Z' && struct[9] !== undefined) {
+                minutesOffset = struct[10] * 60 + struct[11];
+
+                if (struct[9] === '+') {
+                    minutesOffset = 0 - minutesOffset;
+                }
+            }
+
+            timestamp = Date.UTC(struct[1], struct[2], struct[3], struct[4], struct[5] + minutesOffset, struct[6], struct[7]);
+        }
+        else {
+            timestamp = origParse ? origParse(date) : NaN;
+        }
+
+        return timestamp;
+    };
+
+    if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Date) {
+      Date.parse = Ember.Date.parse;
+    }
+  });
+enifed("ember-data/initializers/data_adapter",
+  ["ember-data/system/debug/debug_adapter","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var DebugAdapter = __dependency1__["default"];
+
+    /**
+      Configures a container with injections on Ember applications
+      for the Ember-Data store. Accepts an optional namespace argument.
+
+      @method initializeStoreInjections
+      @param {Ember.Container} container
+    */
+    __exports__["default"] = function initializeDebugAdapter(container){
+      container.register('data-adapter:main', DebugAdapter);
+    };
+  });
+enifed("ember-data/initializers/store",
+  ["ember-data/serializers","ember-data/adapters","ember-data/system/container_proxy","ember-data/system/store","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+    "use strict";
+    var JSONSerializer = __dependency1__.JSONSerializer;
+    var RESTSerializer = __dependency1__.RESTSerializer;
+    var RESTAdapter = __dependency2__.RESTAdapter;
+    var ContainerProxy = __dependency3__["default"];
+    var Store = __dependency4__["default"];
+
+    /**
+      Configures a container for use with an Ember-Data
+      store. Accepts an optional namespace argument.
+
+      @method initializeStore
+      @param {Ember.Container} container
+      @param {Object} [application] an application namespace
+    */
+    __exports__["default"] = function initializeStore(container, application){
+      Ember.deprecate('Specifying a custom Store for Ember Data on your global namespace as `App.Store` ' +
+                      'has been deprecated. Please use `App.ApplicationStore` instead.', !(application && application.Store));
+
+      container.register('store:main', container.lookupFactory('store:application') || (application && application.Store) || Store);
+
+      // allow older names to be looked up
+
+      var proxy = new ContainerProxy(container);
+      proxy.registerDeprecations([
+        { deprecated: 'serializer:_default',  valid: 'serializer:-default' },
+        { deprecated: 'serializer:_rest',     valid: 'serializer:-rest' },
+        { deprecated: 'adapter:_rest',        valid: 'adapter:-rest' }
+      ]);
+
+      // new go forward paths
+      container.register('serializer:-default', JSONSerializer);
+      container.register('serializer:-rest', RESTSerializer);
+      container.register('adapter:-rest', RESTAdapter);
+
+      // Eagerly generate the store so defaultStore is populated.
+      // TODO: Do this in a finisher hook
+      container.lookup('store:main');
+    };
+  });
+enifed("ember-data/initializers/store_injections",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /**
+      Configures a container with injections on Ember applications
+      for the Ember-Data store. Accepts an optional namespace argument.
+
+      @method initializeStoreInjections
+      @param {Ember.Container} container
+    */
+    __exports__["default"] = function initializeStoreInjections(container){
+      container.injection('controller',   'store', 'store:main');
+      container.injection('route',        'store', 'store:main');
+      container.injection('serializer',   'store', 'store:main');
+      container.injection('data-adapter', 'store', 'store:main');
+    };
+  });
+enifed("ember-data/initializers/transforms",
+  ["ember-data/transforms","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var BooleanTransform = __dependency1__.BooleanTransform;
+    var DateTransform = __dependency1__.DateTransform;
+    var StringTransform = __dependency1__.StringTransform;
+    var NumberTransform = __dependency1__.NumberTransform;
+
+    /**
+      Configures a container for use with Ember-Data
+      transforms.
+
+      @method initializeTransforms
+      @param {Ember.Container} container
+    */
+    __exports__["default"] = function initializeTransforms(container){
+      container.register('transform:boolean', BooleanTransform);
+      container.register('transform:date',    DateTransform);
+      container.register('transform:number',  NumberTransform);
+      container.register('transform:string',  StringTransform);
+    };
+  });
+enifed("ember-data/serializers",
+  ["ember-data/serializers/json_serializer","ember-data/serializers/rest_serializer","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var JSONSerializer = __dependency1__["default"];
+    var RESTSerializer = __dependency2__["default"];
+
+    __exports__.JSONSerializer = JSONSerializer;
+    __exports__.RESTSerializer = RESTSerializer;
+  });
+enifed("ember-data/serializers/embedded_records_mixin",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var get = Ember.get;
+    var forEach = Ember.EnumerableUtils.forEach;
+    var camelize = Ember.String.camelize;
+
+    /**
+      ## Using Embedded Records
+
+      `DS.EmbeddedRecordsMixin` supports serializing embedded records.
+
+      To set up embedded records, include the mixin when extending a serializer
+      then define and configure embedded (model) relationships.
+
+      Below is an example of a per-type serializer ('post' type).
+
+      ```js
+      App.PostSerializer = DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
+        attrs: {
+          author: { embedded: 'always' },
+          comments: { serialize: 'ids' }
+        }
+      });
+      ```
+      Note that this use of `{ embedded: 'always' }` is unrelated to
+      the `{ embedded: 'always' }` that is defined as an option on `DS.attr` as part of
+      defining a model while working with the ActiveModelSerializer.  Nevertheless,
+      using `{ embedded: 'always' }` as an option to DS.attr is not a valid way to setup
+      embedded records.
+
+      The `attrs` option for a resource `{ embedded: 'always' }` is shorthand for:
+
+      ```js
+      { 
+        serialize: 'records',
+        deserialize: 'records'
+      }
+      ```
+
+      ### Configuring Attrs
+
+      A resource's `attrs` option may be set to use `ids`, `records` or false for the
+      `serialize`  and `deserialize` settings.
+
+      The `attrs` property can be set on the ApplicationSerializer or a per-type
+      serializer.
+
+      In the case where embedded JSON is expected while extracting a payload (reading)
+      the setting is `deserialize: 'records'`, there is no need to use `ids` when
+      extracting as that is the default behavior without this mixin if you are using
+      the vanilla EmbeddedRecordsMixin. Likewise, to embed JSON in the payload while
+      serializing `serialize: 'records'` is the setting to use. There is an option of
+      not embedding JSON in the serialized payload by using `serialize: 'ids'`. If you
+      do not want the relationship sent at all, you can use `serialize: false`.
+
+
+      ### EmbeddedRecordsMixin defaults
+      If you do not overwrite `attrs` for a specific relationship, the `EmbeddedRecordsMixin`
+      will behave in the following way:
+
+      BelongsTo: `{ serialize: 'id', deserialize: 'id' }`  
+      HasMany:   `{ serialize: false, deserialize: 'ids' }`
+
+      ### Model Relationships
+
+      Embedded records must have a model defined to be extracted and serialized. Note that
+      when defining any relationships on your model such as `belongsTo` and `hasMany`, you
+      should not both specify `async:true` and also indicate through the serializer's
+      `attrs` attribute that the related model should be embedded.  If a model is
+      declared embedded, then do not use `async:true`.
+
+      To successfully extract and serialize embedded records the model relationships
+      must be setup correcty See the
+      [defining relationships](/guides/models/defining-models/#toc_defining-relationships)
+      section of the **Defining Models** guide page.
+
+      Records without an `id` property are not considered embedded records, model
+      instances must have an `id` property to be used with Ember Data.
+
+      ### Example JSON payloads, Models and Serializers
+
+      **When customizing a serializer it is important to grok what the customizations
+      are. Please read the docs for the methods this mixin provides, in case you need
+      to modify it to fit your specific needs.**
+
+      For example review the docs for each method of this mixin:
+      * [normalize](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_normalize)
+      * [serializeBelongsTo](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_serializeBelongsTo)
+      * [serializeHasMany](/api/data/classes/DS.EmbeddedRecordsMixin.html#method_serializeHasMany)
+
+      @class EmbeddedRecordsMixin
+      @namespace DS
+    */
+    var EmbeddedRecordsMixin = Ember.Mixin.create({
+
+      /**
+        Normalize the record and recursively normalize/extract all the embedded records
+        while pushing them into the store as they are encountered
+
+        A payload with an attr configured for embedded records needs to be extracted:
+
+        ```js
+        {
+          "post": {
+            "id": "1"
+            "title": "Rails is omakase",
+            "comments": [{
+              "id": "1",
+              "body": "Rails is unagi"
+            }, {
+              "id": "2",
+              "body": "Omakase O_o"
+            }]
+          }
+        }
+        ```
+       @method normalize
+       @param {subclass of DS.Model} type
+       @param {Object} hash to be normalized
+       @param {String} key the hash has been referenced by
+       @return {Object} the normalized hash
+      **/
+      normalize: function(type, hash, prop) {
+        var normalizedHash = this._super(type, hash, prop);
+        return extractEmbeddedRecords(this, this.store, type, normalizedHash);
+      },
+
+      keyForRelationship: function(key, type){
+        if (this.hasDeserializeRecordsOption(key)) {
+          return this.keyForAttribute(key);
+        } else {
+          return this._super(key, type) || key;
+        }
+      },
+
+      /**
+        Serialize `belongsTo` relationship when it is configured as an embedded object.
+
+        This example of an author model belongs to a post model:
+
+        ```js
+        Post = DS.Model.extend({
+          title:    DS.attr('string'),
+          body:     DS.attr('string'),
+          author:   DS.belongsTo('author')
+        });
+
+        Author = DS.Model.extend({
+          name:     DS.attr('string'),
+          post:     DS.belongsTo('post')
+        });
+        ```
+
+        Use a custom (type) serializer for the post model to configure embedded author
+
+        ```js
+        App.PostSerializer = DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
+          attrs: {
+            author: {embedded: 'always'}
+          }
+        })
+        ```
+
+        A payload with an attribute configured for embedded records can serialize
+        the records together under the root attribute's payload:
+
+        ```js
+        {
+          "post": {
+            "id": "1"
+            "title": "Rails is omakase",
+            "author": {
+              "id": "2"
+              "name": "dhh"
+            }
+          }
+        }
+        ```
+
+        @method serializeBelongsTo
+        @param {DS.Model} record
+        @param {Object} json
+        @param {Object} relationship
+      */
+      serializeBelongsTo: function(record, json, relationship) {
+        var attr = relationship.key;
+        if (this.noSerializeOptionSpecified(attr)) {
+          this._super(record, json, relationship);
+          return;
+        }
+        var includeIds = this.hasSerializeIdsOption(attr);
+        var includeRecords = this.hasSerializeRecordsOption(attr);
+        var embeddedRecord = record.get(attr);
+        var key;
+        if (includeIds) {
+          key = this.keyForRelationship(attr, relationship.kind);
+          if (!embeddedRecord) {
+            json[key] = null;
+          } else {
+            json[key] = get(embeddedRecord, 'id');
+          }
+        } else if (includeRecords) {
+          key = this.keyForAttribute(attr);
+          if (!embeddedRecord) {
+            json[key] = null;
+          } else {
+            json[key] = embeddedRecord.serialize({includeId: true});
+            this.removeEmbeddedForeignKey(record, embeddedRecord, relationship, json[key]);
+          }
+        }
+      },
+
+      /**
+        Serialize `hasMany` relationship when it is configured as embedded objects.
+
+        This example of a post model has many comments:
+
+        ```js
+        Post = DS.Model.extend({
+          title:    DS.attr('string'),
+          body:     DS.attr('string'),
+          comments: DS.hasMany('comment')
+        });
+
+        Comment = DS.Model.extend({
+          body:     DS.attr('string'),
+          post:     DS.belongsTo('post')
+        });
+        ```
+
+        Use a custom (type) serializer for the post model to configure embedded comments
+
+        ```js
+        App.PostSerializer = DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
+          attrs: {
+            comments: {embedded: 'always'}
+          }
+        })
+        ```
+
+        A payload with an attribute configured for embedded records can serialize
+        the records together under the root attribute's payload:
+
+        ```js
+        {
+          "post": {
+            "id": "1"
+            "title": "Rails is omakase",
+            "body": "I want this for my ORM, I want that for my template language..."
+            "comments": [{
+              "id": "1",
+              "body": "Rails is unagi"
+            }, {
+              "id": "2",
+              "body": "Omakase O_o"
+            }]
+          }
+        }
+        ```
+
+        The attrs options object can use more specific instruction for extracting and
+        serializing. When serializing, an option to embed `ids` or `records` can be set.
+        When extracting the only option is `records`.
+
+        So `{embedded: 'always'}` is shorthand for:
+        `{serialize: 'records', deserialize: 'records'}`
+
+        To embed the `ids` for a related object (using a hasMany relationship):
+
+        ```js
+        App.PostSerializer = DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
+          attrs: {
+            comments: {serialize: 'ids', deserialize: 'records'}
+          }
+        })
+        ```
+
+        ```js
+        {
+          "post": {
+            "id": "1"
+            "title": "Rails is omakase",
+            "body": "I want this for my ORM, I want that for my template language..."
+            "comments": ["1", "2"]
+          }
+        }
+        ```
+
+        @method serializeHasMany
+        @param {DS.Model} record
+        @param {Object} json
+        @param {Object} relationship
+      */
+      serializeHasMany: function(record, json, relationship) {
+        var attr = relationship.key;
+        if (this.noSerializeOptionSpecified(attr)) {
+          this._super(record, json, relationship);
+          return;
+        }
+        var includeIds = this.hasSerializeIdsOption(attr);
+        var includeRecords = this.hasSerializeRecordsOption(attr);
+        var key;
+        if (includeIds) {
+          key = this.keyForRelationship(attr, relationship.kind);
+          json[key] = get(record, attr).mapBy('id');
+        } else if (includeRecords) {
+          key = this.keyForAttribute(attr);
+          json[key] = get(record, attr).map(function(embeddedRecord) {
+            var serializedEmbeddedRecord = embeddedRecord.serialize({includeId: true});
+            this.removeEmbeddedForeignKey(record, embeddedRecord, relationship, serializedEmbeddedRecord);
+            return serializedEmbeddedRecord;
+          }, this);
+        }
+      },
+
+      /**
+        When serializing an embedded record, modify the property (in the json payload)
+        that refers to the parent record (foreign key for relationship).
+
+        Serializing a `belongsTo` relationship removes the property that refers to the
+        parent record
+
+        Serializing a `hasMany` relationship does not remove the property that refers to
+        the parent record.
+
+        @method removeEmbeddedForeignKey
+        @param {DS.Model} record
+        @param {DS.Model} embeddedRecord
+        @param {Object} relationship
+        @param {Object} json
+      */
+      removeEmbeddedForeignKey: function (record, embeddedRecord, relationship, json) {
+        if (relationship.kind === 'hasMany') {
+          return;
+        } else if (relationship.kind === 'belongsTo') {
+          var parentRecord = record.constructor.inverseFor(relationship.key);
+          if (parentRecord) {
+            var name = parentRecord.name;
+            var embeddedSerializer = this.store.serializerFor(embeddedRecord.constructor);
+            var parentKey = embeddedSerializer.keyForRelationship(name, parentRecord.kind);
+            if (parentKey) {
+              delete json[parentKey];
+            }
+          }
+        }
+      },
+
+      // checks config for attrs option to embedded (always) - serialize and deserialize
+      hasEmbeddedAlwaysOption: function (attr) {
+        var option = this.attrsOption(attr);
+        return option && option.embedded === 'always';
+      },
+
+      // checks config for attrs option to serialize ids
+      hasSerializeRecordsOption: function(attr) {
+        var alwaysEmbed = this.hasEmbeddedAlwaysOption(attr);
+        var option = this.attrsOption(attr);
+        return alwaysEmbed || (option && (option.serialize === 'records'));
+      },
+
+      // checks config for attrs option to serialize records
+      hasSerializeIdsOption: function(attr) {
+        var option = this.attrsOption(attr);
+        return option && (option.serialize === 'ids' || option.serialize === 'id');
+      },
+
+      // checks config for attrs option to serialize records
+      noSerializeOptionSpecified: function(attr) {
+        var option = this.attrsOption(attr);
+        return !(option && (option.serialize || option.embedded));
+      },
+
+      // checks config for attrs option to deserialize records
+      // a defined option object for a resource is treated the same as
+      // `deserialize: 'records'`
+      hasDeserializeRecordsOption: function(attr) {
+        var alwaysEmbed = this.hasEmbeddedAlwaysOption(attr);
+        var option = this.attrsOption(attr);
+        return alwaysEmbed || (option && option.deserialize === 'records');
+      },
+
+      attrsOption: function(attr) {
+        var attrs = this.get('attrs');
+        return attrs && (attrs[camelize(attr)] || attrs[attr]);
+      }
+    });
+
+    // chooses a relationship kind to branch which function is used to update payload
+    // does not change payload if attr is not embedded
+    function extractEmbeddedRecords(serializer, store, type, partial) {
+
+      type.eachRelationship(function(key, relationship) {
+        if (serializer.hasDeserializeRecordsOption(key)) {
+          var embeddedType = store.modelFor(relationship.type.typeKey);
+          if (relationship.kind === "hasMany") {
+            if (relationship.options.polymorphic) {
+              extractEmbeddedHasManyPolymorphic(store, key, partial);
+            }
+            else {
+              extractEmbeddedHasMany(store, key, embeddedType, partial);
+            }
+          }
+          if (relationship.kind === "belongsTo") {
+            extractEmbeddedBelongsTo(store, key, embeddedType, partial);
+          }
+        }
+      });
+
+      return partial;
+    }
+
+    // handles embedding for `hasMany` relationship
+    function extractEmbeddedHasMany(store, key, embeddedType, hash) {
+      if (!hash[key]) {
+        return hash;
+      }
+
+      var ids = [];
+
+      var embeddedSerializer = store.serializerFor(embeddedType.typeKey);
+      forEach(hash[key], function(data) {
+        var embeddedRecord = embeddedSerializer.normalize(embeddedType, data, null);
+        store.push(embeddedType, embeddedRecord);
+        ids.push(embeddedRecord.id);
+      });
+
+      hash[key] = ids;
+      return hash;
+    }
+
+    function extractEmbeddedHasManyPolymorphic(store, key, hash) {
+      if (!hash[key]) {
+        return hash;
+      }
+
+      var ids = [];
+
+      forEach(hash[key], function(data) {
+        var typeKey = data.type;
+        var embeddedSerializer = store.serializerFor(typeKey);
+        var embeddedType = store.modelFor(typeKey);
+        var primaryKey = get(embeddedSerializer, 'primaryKey');
+
+        var embeddedRecord = embeddedSerializer.normalize(embeddedType, data, null);
+        store.push(embeddedType, embeddedRecord);
+        ids.push({ id: embeddedRecord[primaryKey], type: typeKey });
+      });
+
+      hash[key] = ids;
+      return hash;
+    }
+
+    function extractEmbeddedBelongsTo(store, key, embeddedType, hash) {
+      if (!hash[key]) {
+        return hash;
+      }
+
+      var embeddedSerializer = store.serializerFor(embeddedType.typeKey);
+      var embeddedRecord = embeddedSerializer.normalize(embeddedType, hash[key], null);
+      store.push(embeddedType, embeddedRecord);
+
+      hash[key] = embeddedRecord.id;
+      //TODO Need to add a reference to the parent later so relationship works between both `belongsTo` records
+      return hash;
+    }
+
+    __exports__["default"] = EmbeddedRecordsMixin;
+  });
+enifed("ember-data/serializers/json_serializer",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var get = Ember.get;
+    var isNone = Ember.isNone;
+    var map = Ember.ArrayPolyfills.map;
+    var merge = Ember.merge;
+
+    /**
+      In Ember Data a Serializer is used to serialize and deserialize
+      records when they are transferred in and out of an external source.
+      This process involves normalizing property names, transforming
+      attribute values and serializing relationships.
+
+      For maximum performance Ember Data recommends you use the
+      [RESTSerializer](DS.RESTSerializer.html) or one of its subclasses.
+
+      `JSONSerializer` is useful for simpler or legacy backends that may
+      not support the http://jsonapi.org/ spec.
+
+      @class JSONSerializer
+      @namespace DS
+    */
+    __exports__["default"] = Ember.Object.extend({
+      /**
+        The primaryKey is used when serializing and deserializing
+        data. Ember Data always uses the `id` property to store the id of
+        the record. The external source may not always follow this
+        convention. In these cases it is useful to override the
+        primaryKey property to match the primaryKey of your external
+        store.
+
+        Example
+
+        ```javascript
+        App.ApplicationSerializer = DS.JSONSerializer.extend({
+          primaryKey: '_id'
+        });
+        ```
+
+        @property primaryKey
+        @type {String}
+        @default 'id'
+      */
+      primaryKey: 'id',
+
+      /**
+        The `attrs` object can be used to declare a simple mapping between
+        property names on `DS.Model` records and payload keys in the
+        serialized JSON object representing the record. An object with the
+        property `key` can also be used to designate the attribute's key on
+        the response payload.
+
+        Example
+
+        ```javascript
+        App.Person = DS.Model.extend({
+          firstName: DS.attr('string'),
+          lastName: DS.attr('string'),
+          occupation: DS.attr('string'),
+          admin: DS.attr('boolean')
+        });
+
+        App.PersonSerializer = DS.JSONSerializer.extend({
+          attrs: {
+            admin: 'is_admin',
+            occupation: {key: 'career'}
+          }
+        });
+        ```
+
+        You can also remove attributes by setting the `serialize` key to
+        false in your mapping object.
+
+        Example
+
+        ```javascript
+        App.PersonSerializer = DS.JSONSerializer.extend({
+          attrs: {
+            admin: {serialize: false},
+            occupation: {key: 'career'}
+          }
+        });
+        ```
+
+        When serialized:
+
+        ```javascript
+        {
+          "career": "magician"
+        }
+        ```
+
+        Note that the `admin` is now not included in the payload.
+
+        @property attrs
+        @type {Object}
+      */
+
+      /**
+       Given a subclass of `DS.Model` and a JSON object this method will
+       iterate through each attribute of the `DS.Model` and invoke the
+       `DS.Transform#deserialize` method on the matching property of the
+       JSON object.  This method is typically called after the
+       serializer's `normalize` method.
+
+       @method applyTransforms
+       @private
+       @param {subclass of DS.Model} type
+       @param {Object} data The data to transform
+       @return {Object} data The transformed data object
+      */
+      applyTransforms: function(type, data) {
+        type.eachTransformedAttribute(function applyTransform(key, type) {
+          if (!data.hasOwnProperty(key)) { return; }
+
+          var transform = this.transformFor(type);
+          data[key] = transform.deserialize(data[key]);
+        }, this);
+
+        return data;
+      },
+
+      /**
+        Normalizes a part of the JSON payload returned by
+        the server. You should override this method, munge the hash
+        and call super if you have generic normalization to do.
+
+        It takes the type of the record that is being normalized
+        (as a DS.Model class), the property where the hash was
+        originally found, and the hash to normalize.
+
+        You can use this method, for example, to normalize underscored keys to camelized
+        or other general-purpose normalizations.
+
+        Example
+
+        ```javascript
+        App.ApplicationSerializer = DS.JSONSerializer.extend({
+          normalize: function(type, hash) {
+            var fields = Ember.get(type, 'fields');
+            fields.forEach(function(field) {
+              var payloadField = Ember.String.underscore(field);
+              if (field === payloadField) { return; }
+
+              hash[field] = hash[payloadField];
+              delete hash[payloadField];
+            });
+            return this._super.apply(this, arguments);
+          }
+        });
+        ```
+
+        @method normalize
+        @param {subclass of DS.Model} type
+        @param {Object} hash
+        @return {Object}
+      */
+      normalize: function(type, hash) {
+        if (!hash) { return hash; }
+
+        this.normalizeId(hash);
+        this.normalizeAttributes(type, hash);
+        this.normalizeRelationships(type, hash);
+
+        this.normalizeUsingDeclaredMapping(type, hash);
+        this.applyTransforms(type, hash);
+        return hash;
+      },
+
+      /**
+        You can use this method to normalize all payloads, regardless of whether they
+        represent single records or an array.
+
+        For example, you might want to remove some extraneous data from the payload:
+
+        ```js
+        App.ApplicationSerializer = DS.JSONSerializer.extend({
+          normalizePayload: function(payload) {
+            delete payload.version;
+            delete payload.status;
+            return payload;
+          }
+        });
+        ```
+
+        @method normalizePayload
+        @param {Object} payload
+        @return {Object} the normalized payload
+      */
+      normalizePayload: function(payload) {
+        return payload;
+      },
+
+      /**
+        @method normalizeAttributes
+        @private
+      */
+      normalizeAttributes: function(type, hash) {
+        var payloadKey;
+
+        if (this.keyForAttribute) {
+          type.eachAttribute(function(key) {
+            payloadKey = this.keyForAttribute(key);
+            if (key === payloadKey) { return; }
+            if (!hash.hasOwnProperty(payloadKey)) { return; }
+
+            hash[key] = hash[payloadKey];
+            delete hash[payloadKey];
+          }, this);
+        }
+      },
+
+      /**
+        @method normalizeRelationships
+        @private
+      */
+      normalizeRelationships: function(type, hash) {
+        var payloadKey;
+
+        if (this.keyForRelationship) {
+          type.eachRelationship(function(key, relationship) {
+            payloadKey = this.keyForRelationship(key, relationship.kind);
+            if (key === payloadKey) { return; }
+            if (!hash.hasOwnProperty(payloadKey)) { return; }
+
+            hash[key] = hash[payloadKey];
+            delete hash[payloadKey];
+          }, this);
+        }
+      },
+
+      /**
+        @method normalizeUsingDeclaredMapping
+        @private
+      */
+      normalizeUsingDeclaredMapping: function(type, hash) {
+        var attrs = get(this, 'attrs'), payloadKey, key;
+
+        if (attrs) {
+          for (key in attrs) {
+            payloadKey = this._getMappedKey(key);
+            if (!hash.hasOwnProperty(payloadKey)) { continue; }
+
+            if (payloadKey !== key) {
+              hash[key] = hash[payloadKey];
+              delete hash[payloadKey];
+            }
+          }
+        }
+      },
+
+      /**
+        @method normalizeId
+        @private
+      */
+      normalizeId: function(hash) {
+        var primaryKey = get(this, 'primaryKey');
+
+        if (primaryKey === 'id') { return; }
+
+        hash.id = hash[primaryKey];
+        delete hash[primaryKey];
+      },
+
+      /**
+        @method normalizeErrors
+        @private
+      */
+      normalizeErrors: function(type, hash) {
+        this.normalizeId(hash);
+        this.normalizeAttributes(type, hash);
+        this.normalizeRelationships(type, hash);
+      },
+
+      /**
+        Looks up the property key that was set by the custom `attr` mapping
+        passed to the serializer.
+
+        @method _getMappedKey
+        @private
+        @param {String} key
+        @return {String} key
+      */
+      _getMappedKey: function(key) {
+        var attrs = get(this, 'attrs');
+        var mappedKey;
+        if (attrs && attrs[key]) {
+          mappedKey = attrs[key];
+          //We need to account for both the {title: 'post_title'} and
+          //{title: {key: 'post_title'}} forms
+          if (mappedKey.key){
+            mappedKey = mappedKey.key;
+          }
+          if (typeof mappedKey === 'string'){
+            key = mappedKey;
+          }
+        }
+
+        return key;
+      },
+
+      /**
+        Check attrs.key.serialize property to inform if the `key`
+        can be serialized
+
+        @method _canSerialize
+        @private
+        @param {String} key
+        @return {boolean} true if the key can be serialized
+      */
+      _canSerialize: function(key) {
+        var attrs = get(this, 'attrs');
+
+        return !attrs || !attrs[key] || attrs[key].serialize !== false;
+      },
+
+      // SERIALIZE
+      /**
+        Called when a record is saved in order to convert the
+        record into JSON.
+
+        By default, it creates a JSON object with a key for
+        each attribute and belongsTo relationship.
+
+        For example, consider this model:
+
+        ```javascript
+        App.Comment = DS.Model.extend({
+          title: DS.attr(),
+          body: DS.attr(),
+
+          author: DS.belongsTo('user')
+        });
+        ```
+
+        The default serialization would create a JSON object like:
+
+        ```javascript
+        {
+          "title": "Rails is unagi",
+          "body": "Rails? Omakase? O_O",
+          "author": 12
+        }
+        ```
+
+        By default, attributes are passed through as-is, unless
+        you specified an attribute type (`DS.attr('date')`). If
+        you specify a transform, the JavaScript value will be
+        serialized when inserted into the JSON hash.
+
+        By default, belongs-to relationships are converted into
+        IDs when inserted into the JSON hash.
+
+        ## IDs
+
+        `serialize` takes an options hash with a single option:
+        `includeId`. If this option is `true`, `serialize` will,
+        by default include the ID in the JSON object it builds.
+
+        The adapter passes in `includeId: true` when serializing
+        a record for `createRecord`, but not for `updateRecord`.
+
+        ## Customization
+
+        Your server may expect a different JSON format than the
+        built-in serialization format.
+
+        In that case, you can implement `serialize` yourself and
+        return a JSON hash of your choosing.
+
+        ```javascript
+        App.PostSerializer = DS.JSONSerializer.extend({
+          serialize: function(post, options) {
+            var json = {
+              POST_TTL: post.get('title'),
+              POST_BDY: post.get('body'),
+              POST_CMS: post.get('comments').mapBy('id')
+            }
+
+            if (options.includeId) {
+              json.POST_ID_ = post.get('id');
+            }
+
+            return json;
+          }
+        });
+        ```
+
+        ## Customizing an App-Wide Serializer
+
+        If you want to define a serializer for your entire
+        application, you'll probably want to use `eachAttribute`
+        and `eachRelationship` on the record.
+
+        ```javascript
+        App.ApplicationSerializer = DS.JSONSerializer.extend({
+          serialize: function(record, options) {
+            var json = {};
+
+            record.eachAttribute(function(name) {
+              json[serverAttributeName(name)] = record.get(name);
+            })
+
+            record.eachRelationship(function(name, relationship) {
+              if (relationship.kind === 'hasMany') {
+                json[serverHasManyName(name)] = record.get(name).mapBy('id');
+              }
+            });
+
+            if (options.includeId) {
+              json.ID_ = record.get('id');
+            }
+
+            return json;
+          }
+        });
+
+        function serverAttributeName(attribute) {
+          return attribute.underscore().toUpperCase();
+        }
+
+        function serverHasManyName(name) {
+          return serverAttributeName(name.singularize()) + "_IDS";
+        }
+        ```
+
+        This serializer will generate JSON that looks like this:
+
+        ```javascript
+        {
+          "TITLE": "Rails is omakase",
+          "BODY": "Yep. Omakase.",
+          "COMMENT_IDS": [ 1, 2, 3 ]
+        }
+        ```
+
+        ## Tweaking the Default JSON
+
+        If you just want to do some small tweaks on the default JSON,
+        you can call super first and make the tweaks on the returned
+        JSON.
+
+        ```javascript
+        App.PostSerializer = DS.JSONSerializer.extend({
+          serialize: function(record, options) {
+            var json = this._super.apply(this, arguments);
+
+            json.subject = json.title;
+            delete json.title;
+
+            return json;
+          }
+        });
+        ```
+
+        @method serialize
+        @param {subclass of DS.Model} record
+        @param {Object} options
+        @return {Object} json
+      */
+      serialize: function(record, options) {
+        var json = {};
+
+        if (options && options.includeId) {
+          var id = get(record, 'id');
+
+          if (id) {
+            json[get(this, 'primaryKey')] = id;
+          }
+        }
+
+        record.eachAttribute(function(key, attribute) {
+          this.serializeAttribute(record, json, key, attribute);
+        }, this);
+
+        record.eachRelationship(function(key, relationship) {
+          if (relationship.kind === 'belongsTo') {
+            this.serializeBelongsTo(record, json, relationship);
+          } else if (relationship.kind === 'hasMany') {
+            this.serializeHasMany(record, json, relationship);
+          }
+        }, this);
+
+        return json;
+      },
+
+      /**
+        You can use this method to customize how a serialized record is added to the complete
+        JSON hash to be sent to the server. By default the JSON Serializer does not namespace
+        the payload and just sends the raw serialized JSON object.
+        If your server expects namespaced keys, you should consider using the RESTSerializer.
+        Otherwise you can override this method to customize how the record is added to the hash.
+
+        For example, your server may expect underscored root objects.
+
+        ```js
+        App.ApplicationSerializer = DS.RESTSerializer.extend({
+          serializeIntoHash: function(data, type, record, options) {
+            var root = Ember.String.decamelize(type.typeKey);
+            data[root] = this.serialize(record, options);
+          }
+        });
+        ```
+
+        @method serializeIntoHash
+        @param {Object} hash
+        @param {subclass of DS.Model} type
+        @param {DS.Model} record
+        @param {Object} options
+      */
+      serializeIntoHash: function(hash, type, record, options) {
+        merge(hash, this.serialize(record, options));
+      },
+
+      /**
+       `serializeAttribute` can be used to customize how `DS.attr`
+       properties are serialized
+
+       For example if you wanted to ensure all your attributes were always
+       serialized as properties on an `attributes` object you could
+       write:
+
+       ```javascript
+       App.ApplicationSerializer = DS.JSONSerializer.extend({
+         serializeAttribute: function(record, json, key, attributes) {
+           json.attributes = json.attributes || {};
+           this._super(record, json.attributes, key, attributes);
+         }
+       });
+       ```
+
+       @method serializeAttribute
+       @param {DS.Model} record
+       @param {Object} json
+       @param {String} key
+       @param {Object} attribute
+      */
+      serializeAttribute: function(record, json, key, attribute) {
+        var type = attribute.type;
+
+        if (this._canSerialize(key)) {
+          var value = get(record, key);
+          if (type) {
+            var transform = this.transformFor(type);
+            value = transform.serialize(value);
+          }
+
+          // if provided, use the mapping provided by `attrs` in
+          // the serializer
+          var payloadKey =  this._getMappedKey(key);
+
+          if (payloadKey === key && this.keyForAttribute) {
+            payloadKey = this.keyForAttribute(key);
+          }
+
+          json[payloadKey] = value;
+        }
+      },
+
+      /**
+       `serializeBelongsTo` can be used to customize how `DS.belongsTo`
+       properties are serialized.
+
+       Example
+
+       ```javascript
+       App.PostSerializer = DS.JSONSerializer.extend({
+         serializeBelongsTo: function(record, json, relationship) {
+           var key = relationship.key;
+
+           var belongsTo = get(record, key);
+
+           key = this.keyForRelationship ? this.keyForRelationship(key, "belongsTo") : key;
+
+           json[key] = Ember.isNone(belongsTo) ? belongsTo : belongsTo.toJSON();
+         }
+       });
+       ```
+
+       @method serializeBelongsTo
+       @param {DS.Model} record
+       @param {Object} json
+       @param {Object} relationship
+      */
+      serializeBelongsTo: function(record, json, relationship) {
+        var key = relationship.key;
+
+        if (this._canSerialize(key)) {
+          var belongsTo = get(record, key);
+
+          // if provided, use the mapping provided by `attrs` in
+          // the serializer
+          var payloadKey = this._getMappedKey(key);
+          if (payloadKey === key && this.keyForRelationship) {
+            payloadKey = this.keyForRelationship(key, "belongsTo");
+          }
+
+          //Need to check whether the id is there for new&async records
+          if (isNone(belongsTo) || isNone(get(belongsTo, 'id'))) {
+            json[payloadKey] = null;
+          } else {
+            json[payloadKey] = get(belongsTo, 'id');
+          }
+
+          if (relationship.options.polymorphic) {
+            this.serializePolymorphicType(record, json, relationship);
+          }
+        }
+      },
+
+      /**
+       `serializeHasMany` can be used to customize how `DS.hasMany`
+       properties are serialized.
+
+       Example
+
+       ```javascript
+       App.PostSerializer = DS.JSONSerializer.extend({
+         serializeHasMany: function(record, json, relationship) {
+           var key = relationship.key;
+           if (key === 'comments') {
+             return;
+           } else {
+             this._super.apply(this, arguments);
+           }
+         }
+       });
+       ```
+
+       @method serializeHasMany
+       @param {DS.Model} record
+       @param {Object} json
+       @param {Object} relationship
+      */
+      serializeHasMany: function(record, json, relationship) {
+        var key = relationship.key;
+
+        if (this._canSerialize(key)) {
+          var payloadKey;
+
+          // if provided, use the mapping provided by `attrs` in
+          // the serializer
+          payloadKey = this._getMappedKey(key);
+          if (payloadKey === key && this.keyForRelationship) {
+            payloadKey = this.keyForRelationship(key, "hasMany");
+          }
+
+          var relationshipType = record.constructor.determineRelationshipType(relationship);
+
+          if (relationshipType === 'manyToNone' || relationshipType === 'manyToMany') {
+            json[payloadKey] = get(record, key).mapBy('id');
+            // TODO support for polymorphic manyToNone and manyToMany relationships
+          }
+        }
+      },
+
+      /**
+        You can use this method to customize how polymorphic objects are
+        serialized. Objects are considered to be polymorphic if
+        `{polymorphic: true}` is pass as the second argument to the
+        `DS.belongsTo` function.
+
+        Example
+
+        ```javascript
+        App.CommentSerializer = DS.JSONSerializer.extend({
+          serializePolymorphicType: function(record, json, relationship) {
+            var key = relationship.key,
+                belongsTo = get(record, key);
+            key = this.keyForAttribute ? this.keyForAttribute(key) : key;
+
+            if (Ember.isNone(belongsTo)) {
+              json[key + "_type"] = null;
+            } else {
+              json[key + "_type"] = belongsTo.constructor.typeKey;
+            }
+          }
+        });
+       ```
+
+        @method serializePolymorphicType
+        @param {DS.Model} record
+        @param {Object} json
+        @param {Object} relationship
+      */
+      serializePolymorphicType: Ember.K,
+
+      // EXTRACT
+
+      /**
+        The `extract` method is used to deserialize payload data from the
+        server. By default the `JSONSerializer` does not push the records
+        into the store. However records that subclass `JSONSerializer`
+        such as the `RESTSerializer` may push records into the store as
+        part of the extract call.
+
+        This method delegates to a more specific extract method based on
+        the `requestType`.
+
+        Example
+
+        ```javascript
+        var get = Ember.get;
+        socket.on('message', function(message) {
+          var modelName = message.model;
+          var data = message.data;
+          var type = store.modelFor(modelName);
+          var serializer = store.serializerFor(type.typeKey);
+          var record = serializer.extract(store, type, data, get(data, 'id'), 'single');
+          store.push(modelName, record);
+        });
+        ```
+
+        @method extract
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @param {String} requestType
+        @return {Object} json The deserialized payload
+      */
+      extract: function(store, type, payload, id, requestType) {
+        this.extractMeta(store, type, payload);
+
+        var specificExtract = "extract" + requestType.charAt(0).toUpperCase() + requestType.substr(1);
+        return this[specificExtract](store, type, payload, id, requestType);
+      },
+
+      /**
+        `extractFindAll` is a hook into the extract method used when a
+        call is made to `DS.Store#findAll`. By default this method is an
+        alias for [extractArray](#method_extractArray).
+
+        @method extractFindAll
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @param {String} requestType
+        @return {Array} array An array of deserialized objects
+      */
+      extractFindAll: function(store, type, payload, id, requestType){
+        return this.extractArray(store, type, payload, id, requestType);
+      },
+      /**
+        `extractFindQuery` is a hook into the extract method used when a
+        call is made to `DS.Store#findQuery`. By default this method is an
+        alias for [extractArray](#method_extractArray).
+
+        @method extractFindQuery
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @param {String} requestType
+        @return {Array} array An array of deserialized objects
+      */
+      extractFindQuery: function(store, type, payload, id, requestType){
+        return this.extractArray(store, type, payload, id, requestType);
+      },
+      /**
+        `extractFindMany` is a hook into the extract method used when a
+        call is made to `DS.Store#findMany`. By default this method is
+        alias for [extractArray](#method_extractArray).
+
+        @method extractFindMany
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @param {String} requestType
+        @return {Array} array An array of deserialized objects
+      */
+      extractFindMany: function(store, type, payload, id, requestType){
+        return this.extractArray(store, type, payload, id, requestType);
+      },
+      /**
+        `extractFindHasMany` is a hook into the extract method used when a
+        call is made to `DS.Store#findHasMany`. By default this method is
+        alias for [extractArray](#method_extractArray).
+
+        @method extractFindHasMany
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @param {String} requestType
+        @return {Array} array An array of deserialized objects
+      */
+      extractFindHasMany: function(store, type, payload, id, requestType){
+        return this.extractArray(store, type, payload, id, requestType);
+      },
+
+      /**
+        `extractCreateRecord` is a hook into the extract method used when a
+        call is made to `DS.Store#createRecord`. By default this method is
+        alias for [extractSave](#method_extractSave).
+
+        @method extractCreateRecord
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @param {String} requestType
+        @return {Object} json The deserialized payload
+      */
+      extractCreateRecord: function(store, type, payload, id, requestType) {
+        return this.extractSave(store, type, payload, id, requestType);
+      },
+      /**
+        `extractUpdateRecord` is a hook into the extract method used when
+        a call is made to `DS.Store#update`. By default this method is alias
+        for [extractSave](#method_extractSave).
+
+        @method extractUpdateRecord
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @param {String} requestType
+        @return {Object} json The deserialized payload
+      */
+      extractUpdateRecord: function(store, type, payload, id, requestType) {
+        return this.extractSave(store, type, payload, id, requestType);
+      },
+      /**
+        `extractDeleteRecord` is a hook into the extract method used when
+        a call is made to `DS.Store#deleteRecord`. By default this method is
+        alias for [extractSave](#method_extractSave).
+
+        @method extractDeleteRecord
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @param {String} requestType
+        @return {Object} json The deserialized payload
+      */
+      extractDeleteRecord: function(store, type, payload, id, requestType) {
+        return this.extractSave(store, type, payload, id, requestType);
+      },
+
+      /**
+        `extractFind` is a hook into the extract method used when
+        a call is made to `DS.Store#find`. By default this method is
+        alias for [extractSingle](#method_extractSingle).
+
+        @method extractFind
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @param {String} requestType
+        @return {Object} json The deserialized payload
+      */
+      extractFind: function(store, type, payload, id, requestType) {
+        return this.extractSingle(store, type, payload, id, requestType);
+      },
+      /**
+        `extractFindBelongsTo` is a hook into the extract method used when
+        a call is made to `DS.Store#findBelongsTo`. By default this method is
+        alias for [extractSingle](#method_extractSingle).
+
+        @method extractFindBelongsTo
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @param {String} requestType
+        @return {Object} json The deserialized payload
+      */
+      extractFindBelongsTo: function(store, type, payload, id, requestType) {
+        return this.extractSingle(store, type, payload, id, requestType);
+      },
+      /**
+        `extractSave` is a hook into the extract method used when a call
+        is made to `DS.Model#save`. By default this method is alias
+        for [extractSingle](#method_extractSingle).
+
+        @method extractSave
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @param {String} requestType
+        @return {Object} json The deserialized payload
+      */
+      extractSave: function(store, type, payload, id, requestType) {
+        return this.extractSingle(store, type, payload, id, requestType);
+      },
+
+      /**
+        `extractSingle` is used to deserialize a single record returned
+        from the adapter.
+
+        Example
+
+        ```javascript
+        App.PostSerializer = DS.JSONSerializer.extend({
+          extractSingle: function(store, type, payload) {
+            payload.comments = payload._embedded.comment;
+            delete payload._embedded;
+
+            return this._super(store, type, payload);
+          },
+        });
+        ```
+
+        @method extractSingle
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @param {String} requestType
+        @return {Object} json The deserialized payload
+      */
+      extractSingle: function(store, type, payload, id, requestType) {
+        payload = this.normalizePayload(payload);
+        return this.normalize(type, payload);
+      },
+
+      /**
+        `extractArray` is used to deserialize an array of records
+        returned from the adapter.
+
+        Example
+
+        ```javascript
+        App.PostSerializer = DS.JSONSerializer.extend({
+          extractArray: function(store, type, payload) {
+            return payload.map(function(json) {
+              return this.extractSingle(store, type, json);
+            }, this);
+          }
+        });
+        ```
+
+        @method extractArray
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @param {String} requestType
+        @return {Array} array An array of deserialized objects
+      */
+      extractArray: function(store, type, arrayPayload, id, requestType) {
+        var normalizedPayload = this.normalizePayload(arrayPayload);
+        var serializer = this;
+
+        return map.call(normalizedPayload, function(singlePayload) {
+          return serializer.normalize(type, singlePayload);
+        });
+      },
+
+      /**
+        `extractMeta` is used to deserialize any meta information in the
+        adapter payload. By default Ember Data expects meta information to
+        be located on the `meta` property of the payload object.
+
+        Example
+
+        ```javascript
+        App.PostSerializer = DS.JSONSerializer.extend({
+          extractMeta: function(store, type, payload) {
+            if (payload && payload._pagination) {
+              store.metaForType(type, payload._pagination);
+              delete payload._pagination;
+            }
+          }
+        });
+        ```
+
+        @method extractMeta
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+      */
+      extractMeta: function(store, type, payload) {
+        if (payload && payload.meta) {
+          store.metaForType(type, payload.meta);
+          delete payload.meta;
+        }
+      },
+
+      /**
+        `extractErrors` is used to extract model errors when a call is made
+        to `DS.Model#save` which fails with an InvalidError`. By default
+        Ember Data expects error information to be located on the `errors`
+        property of the payload object.
+
+        Example
+
+        ```javascript
+        App.PostSerializer = DS.JSONSerializer.extend({
+          extractErrors: function(store, type, payload, id) {
+            if (payload && typeof payload === 'object' && payload._problems) {
+              payload = payload._problems;
+              this.normalizeErrors(type, payload);
+            }
+            return payload;
+          }
+        });
+        ```
+
+        @method extractErrors
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} payload
+        @param {String or Number} id
+        @return {Object} json The deserialized errors
+      */
+      extractErrors: function(store, type, payload, id) {
+        if (payload && typeof payload === 'object' && payload.errors) {
+          payload = payload.errors;
+          this.normalizeErrors(type, payload);
+        }
+        return payload;
+      },
+
+      /**
+       `keyForAttribute` can be used to define rules for how to convert an
+       attribute name in your model to a key in your JSON.
+
+       Example
+
+       ```javascript
+       App.ApplicationSerializer = DS.RESTSerializer.extend({
+         keyForAttribute: function(attr) {
+           return Ember.String.underscore(attr).toUpperCase();
+         }
+       });
+       ```
+
+       @method keyForAttribute
+       @param {String} key
+       @return {String} normalized key
+      */
+      keyForAttribute: function(key){
+        return key;
+      },
+
+      /**
+       `keyForRelationship` can be used to define a custom key when
+       serializing relationship properties. By default `JSONSerializer`
+       does not provide an implementation of this method.
+
+       Example
+
+        ```javascript
+        App.PostSerializer = DS.JSONSerializer.extend({
+          keyForRelationship: function(key, relationship) {
+             return 'rel_' + Ember.String.underscore(key);
+          }
+        });
+        ```
+
+       @method keyForRelationship
+       @param {String} key
+       @param {String} relationship type
+       @return {String} normalized key
+      */
+
+      keyForRelationship: function(key, type){
+        return key;
+      },
+
+      // HELPERS
+
+      /**
+       @method transformFor
+       @private
+       @param {String} attributeType
+       @param {Boolean} skipAssertion
+       @return {DS.Transform} transform
+      */
+      transformFor: function(attributeType, skipAssertion) {
+        var transform = this.container.lookup('transform:' + attributeType);
+        Ember.assert("Unable to find transform for '" + attributeType + "'", skipAssertion || !!transform);
+        return transform;
+      }
+    });
+  });
+enifed("ember-data/serializers/rest_serializer",
+  ["ember-data/serializers/json_serializer","ember-inflector/system/string","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    var JSONSerializer = __dependency1__["default"];
+    var get = Ember.get;
+    var forEach = Ember.ArrayPolyfills.forEach;
+    var map = Ember.ArrayPolyfills.map;
+    var camelize = Ember.String.camelize;
+
+    var singularize = __dependency2__.singularize;
+
+    function coerceId(id) {
+      return id == null ? null : id + '';
+    }
+
+    /**
+      Normally, applications will use the `RESTSerializer` by implementing
+      the `normalize` method and individual normalizations under
+      `normalizeHash`.
+
+      This allows you to do whatever kind of munging you need, and is
+      especially useful if your server is inconsistent and you need to
+      do munging differently for many different kinds of responses.
+
+      See the `normalize` documentation for more information.
+
+      ## Across the Board Normalization
+
+      There are also a number of hooks that you might find useful to define
+      across-the-board rules for your payload. These rules will be useful
+      if your server is consistent, or if you're building an adapter for
+      an infrastructure service, like Parse, and want to encode service
+      conventions.
+
+      For example, if all of your keys are underscored and all-caps, but
+      otherwise consistent with the names you use in your models, you
+      can implement across-the-board rules for how to convert an attribute
+      name in your model to a key in your JSON.
+
+      ```js
+      App.ApplicationSerializer = DS.RESTSerializer.extend({
+        keyForAttribute: function(attr) {
+          return Ember.String.underscore(attr).toUpperCase();
+        }
+      });
+      ```
+
+      You can also implement `keyForRelationship`, which takes the name
+      of the relationship as the first parameter, and the kind of
+      relationship (`hasMany` or `belongsTo`) as the second parameter.
+
+      @class RESTSerializer
+      @namespace DS
+      @extends DS.JSONSerializer
+    */
+    var RESTSerializer = JSONSerializer.extend({
+      /**
+        If you want to do normalizations specific to some part of the payload, you
+        can specify those under `normalizeHash`.
+
+        For example, given the following json where the the `IDs` under
+        `"comments"` are provided as `_id` instead of `id`.
+
+        ```javascript
+        {
+          "post": {
+            "id": 1,
+            "title": "Rails is omakase",
+            "comments": [ 1, 2 ]
+          },
+          "comments": [{
+            "_id": 1,
+            "body": "FIRST"
+          }, {
+            "_id": 2,
+            "body": "Rails is unagi"
+          }]
+        }
+        ```
+
+        You use `normalizeHash` to normalize just the comments:
+
+        ```javascript
+        App.PostSerializer = DS.RESTSerializer.extend({
+          normalizeHash: {
+            comments: function(hash) {
+              hash.id = hash._id;
+              delete hash._id;
+              return hash;
+            }
+          }
+        });
+        ```
+
+        The key under `normalizeHash` is usually just the original key
+        that was in the original payload. However, key names will be
+        impacted by any modifications done in the `normalizePayload`
+        method. The `DS.RESTSerializer`'s default implementation makes no
+        changes to the payload keys.
+
+        @property normalizeHash
+        @type {Object}
+        @default undefined
+      */
+
+      /**
+        Normalizes a part of the JSON payload returned by
+        the server. You should override this method, munge the hash
+        and call super if you have generic normalization to do.
+
+        It takes the type of the record that is being normalized
+        (as a DS.Model class), the property where the hash was
+        originally found, and the hash to normalize.
+
+        For example, if you have a payload that looks like this:
+
+        ```js
+        {
+          "post": {
+            "id": 1,
+            "title": "Rails is omakase",
+            "comments": [ 1, 2 ]
+          },
+          "comments": [{
+            "id": 1,
+            "body": "FIRST"
+          }, {
+            "id": 2,
+            "body": "Rails is unagi"
+          }]
+        }
+        ```
+
+        The `normalize` method will be called three times:
+
+        * With `App.Post`, `"posts"` and `{ id: 1, title: "Rails is omakase", ... }`
+        * With `App.Comment`, `"comments"` and `{ id: 1, body: "FIRST" }`
+        * With `App.Comment`, `"comments"` and `{ id: 2, body: "Rails is unagi" }`
+
+        You can use this method, for example, to normalize underscored keys to camelized
+        or other general-purpose normalizations.
+
+        If you want to do normalizations specific to some part of the payload, you
+        can specify those under `normalizeHash`.
+
+        For example, if the `IDs` under `"comments"` are provided as `_id` instead of
+        `id`, you can specify how to normalize just the comments:
+
+        ```js
+        App.PostSerializer = DS.RESTSerializer.extend({
+          normalizeHash: {
+            comments: function(hash) {
+              hash.id = hash._id;
+              delete hash._id;
+              return hash;
+            }
+          }
+        });
+        ```
+
+        The key under `normalizeHash` is just the original key that was in the original
+        payload.
+
+        @method normalize
+        @param {subclass of DS.Model} type
+        @param {Object} hash
+        @param {String} prop
+        @return {Object}
+      */
+      normalize: function(type, hash, prop) {
+        this.normalizeId(hash);
+        this.normalizeAttributes(type, hash);
+        this.normalizeRelationships(type, hash);
+
+        this.normalizeUsingDeclaredMapping(type, hash);
+
+        if (this.normalizeHash && this.normalizeHash[prop]) {
+          this.normalizeHash[prop](hash);
+        }
+
+        this.applyTransforms(type, hash);
+        return hash;
+      },
+
+
+      /**
+        Called when the server has returned a payload representing
+        a single record, such as in response to a `find` or `save`.
+
+        It is your opportunity to clean up the server's response into the normalized
+        form expected by Ember Data.
+
+        If you want, you can just restructure the top-level of your payload, and
+        do more fine-grained normalization in the `normalize` method.
+
+        For example, if you have a payload like this in response to a request for
+        post 1:
+
+        ```js
+        {
+          "id": 1,
+          "title": "Rails is omakase",
+
+          "_embedded": {
+            "comment": [{
+              "_id": 1,
+              "comment_title": "FIRST"
+            }, {
+              "_id": 2,
+              "comment_title": "Rails is unagi"
+            }]
+          }
+        }
+        ```
+
+        You could implement a serializer that looks like this to get your payload
+        into shape:
+
+        ```js
+        App.PostSerializer = DS.RESTSerializer.extend({
+          // First, restructure the top-level so it's organized by type
+          extractSingle: function(store, type, payload, id) {
+            var comments = payload._embedded.comment;
+            delete payload._embedded;
+
+            payload = { comments: comments, post: payload };
+            return this._super(store, type, payload, id);
+          },
+
+          normalizeHash: {
+            // Next, normalize individual comments, which (after `extract`)
+            // are now located under `comments`
+            comments: function(hash) {
+              hash.id = hash._id;
+              hash.title = hash.comment_title;
+              delete hash._id;
+              delete hash.comment_title;
+              return hash;
+            }
+          }
+        })
+        ```
+
+        When you call super from your own implementation of `extractSingle`, the
+        built-in implementation will find the primary record in your normalized
+        payload and push the remaining records into the store.
+
+        The primary record is the single hash found under `post` or the first
+        element of the `posts` array.
+
+        The primary record has special meaning when the record is being created
+        for the first time or updated (`createRecord` or `updateRecord`). In
+        particular, it will update the properties of the record that was saved.
+
+        @method extractSingle
+        @param {DS.Store} store
+        @param {subclass of DS.Model} primaryType
+        @param {Object} payload
+        @param {String} recordId
+        @return {Object} the primary response to the original request
+      */
+      extractSingle: function(store, primaryType, rawPayload, recordId) {
+        var payload = this.normalizePayload(rawPayload);
+        var primaryTypeName = primaryType.typeKey;
+        var primaryRecord;
+
+        for (var prop in payload) {
+          var typeName  = this.typeForRoot(prop);
+
+          if (!store.modelFactoryFor(typeName)){
+            Ember.warn(this.warnMessageNoModelForKey(prop, typeName), false);
+            continue;
+          }
+          var type = store.modelFor(typeName);
+          var isPrimary = type.typeKey === primaryTypeName;
+          var value = payload[prop];
+
+          if (value === null) {
+            continue;
+          }
+
+          // legacy support for singular resources
+          if (isPrimary && Ember.typeOf(value) !== "array" ) {
+            primaryRecord = this.normalize(primaryType, value, prop);
+            continue;
+          }
+
+          /*jshint loopfunc:true*/
+          forEach.call(value, function(hash) {
+            var typeName = this.typeForRoot(prop);
+            var type = store.modelFor(typeName);
+            var typeSerializer = store.serializerFor(type);
+
+            hash = typeSerializer.normalize(type, hash, prop);
+
+            var isFirstCreatedRecord = isPrimary && !recordId && !primaryRecord;
+            var isUpdatedRecord = isPrimary && coerceId(hash.id) === recordId;
+
+            // find the primary record.
+            //
+            // It's either:
+            // * the record with the same ID as the original request
+            // * in the case of a newly created record that didn't have an ID, the first
+            //   record in the Array
+            if (isFirstCreatedRecord || isUpdatedRecord) {
+              primaryRecord = hash;
+            } else {
+              store.push(typeName, hash);
+            }
+          }, this);
+        }
+
+        return primaryRecord;
+      },
+
+      /**
+        Called when the server has returned a payload representing
+        multiple records, such as in response to a `findAll` or `findQuery`.
+
+        It is your opportunity to clean up the server's response into the normalized
+        form expected by Ember Data.
+
+        If you want, you can just restructure the top-level of your payload, and
+        do more fine-grained normalization in the `normalize` method.
+
+        For example, if you have a payload like this in response to a request for
+        all posts:
+
+        ```js
+        {
+          "_embedded": {
+            "post": [{
+              "id": 1,
+              "title": "Rails is omakase"
+            }, {
+              "id": 2,
+              "title": "The Parley Letter"
+            }],
+            "comment": [{
+              "_id": 1,
+              "comment_title": "Rails is unagi"
+              "post_id": 1
+            }, {
+              "_id": 2,
+              "comment_title": "Don't tread on me",
+              "post_id": 2
+            }]
+          }
+        }
+        ```
+
+        You could implement a serializer that looks like this to get your payload
+        into shape:
+
+        ```js
+        App.PostSerializer = DS.RESTSerializer.extend({
+          // First, restructure the top-level so it's organized by type
+          // and the comments are listed under a post's `comments` key.
+          extractArray: function(store, type, payload) {
+            var posts = payload._embedded.post;
+            var comments = [];
+            var postCache = {};
+
+            posts.forEach(function(post) {
+              post.comments = [];
+              postCache[post.id] = post;
+            });
+
+            payload._embedded.comment.forEach(function(comment) {
+              comments.push(comment);
+              postCache[comment.post_id].comments.push(comment);
+              delete comment.post_id;
+            });
+
+            payload = { comments: comments, posts: payload };
+
+            return this._super(store, type, payload);
+          },
+
+          normalizeHash: {
+            // Next, normalize individual comments, which (after `extract`)
+            // are now located under `comments`
+            comments: function(hash) {
+              hash.id = hash._id;
+              hash.title = hash.comment_title;
+              delete hash._id;
+              delete hash.comment_title;
+              return hash;
+            }
+          }
+        })
+        ```
+
+        When you call super from your own implementation of `extractArray`, the
+        built-in implementation will find the primary array in your normalized
+        payload and push the remaining records into the store.
+
+        The primary array is the array found under `posts`.
+
+        The primary record has special meaning when responding to `findQuery`
+        or `findHasMany`. In particular, the primary array will become the
+        list of records in the record array that kicked off the request.
+
+        If your primary array contains secondary (embedded) records of the same type,
+        you cannot place these into the primary array `posts`. Instead, place the
+        secondary items into an underscore prefixed property `_posts`, which will
+        push these items into the store and will not affect the resulting query.
+
+        @method extractArray
+        @param {DS.Store} store
+        @param {subclass of DS.Model} primaryType
+        @param {Object} payload
+        @return {Array} The primary array that was returned in response
+          to the original query.
+      */
+      extractArray: function(store, primaryType, rawPayload) {
+        var payload = this.normalizePayload(rawPayload);
+        var primaryTypeName = primaryType.typeKey;
+        var primaryArray;
+
+        for (var prop in payload) {
+          var typeKey = prop;
+          var forcedSecondary = false;
+
+          if (prop.charAt(0) === '_') {
+            forcedSecondary = true;
+            typeKey = prop.substr(1);
+          }
+
+          var typeName = this.typeForRoot(typeKey);
+          if (!store.modelFactoryFor(typeName)) {
+            Ember.warn(this.warnMessageNoModelForKey(prop, typeName), false);
+            continue;
+          }
+          var type = store.modelFor(typeName);
+          var typeSerializer = store.serializerFor(type);
+          var isPrimary = (!forcedSecondary && (type.typeKey === primaryTypeName));
+
+          /*jshint loopfunc:true*/
+          var normalizedArray = map.call(payload[prop], function(hash) {
+            return typeSerializer.normalize(type, hash, prop);
+          }, this);
+
+          if (isPrimary) {
+            primaryArray = normalizedArray;
+          } else {
+            store.pushMany(typeName, normalizedArray);
+          }
+        }
+
+        return primaryArray;
+      },
+
+      /**
+        This method allows you to push a payload containing top-level
+        collections of records organized per type.
+
+        ```js
+        {
+          "posts": [{
+            "id": "1",
+            "title": "Rails is omakase",
+            "author", "1",
+            "comments": [ "1" ]
+          }],
+          "comments": [{
+            "id": "1",
+            "body": "FIRST"
+          }],
+          "users": [{
+            "id": "1",
+            "name": "@d2h"
+          }]
+        }
+        ```
+
+        It will first normalize the payload, so you can use this to push
+        in data streaming in from your server structured the same way
+        that fetches and saves are structured.
+
+        @method pushPayload
+        @param {DS.Store} store
+        @param {Object} payload
+      */
+      pushPayload: function(store, rawPayload) {
+        var payload = this.normalizePayload(rawPayload);
+
+        for (var prop in payload) {
+          var typeName = this.typeForRoot(prop);
+          if (!store.modelFactoryFor(typeName, prop)){
+            Ember.warn(this.warnMessageNoModelForKey(prop, typeName), false);
+            continue;
+          }
+          var type = store.modelFor(typeName);
+          var typeSerializer = store.serializerFor(type);
+
+          /*jshint loopfunc:true*/
+          var normalizedArray = map.call(Ember.makeArray(payload[prop]), function(hash) {
+            return typeSerializer.normalize(type, hash, prop);
+          }, this);
+
+          store.pushMany(typeName, normalizedArray);
+        }
+      },
+
+      /**
+        This method is used to convert each JSON root key in the payload
+        into a typeKey that it can use to look up the appropriate model for
+        that part of the payload. By default the typeKey for a model is its
+        name in camelCase, so if your JSON root key is 'fast-car' you would
+        use typeForRoot to convert it to 'fastCar' so that Ember Data finds
+        the `FastCar` model.
+
+        If you diverge from this norm you should also consider changes to
+        store._normalizeTypeKey as well.
+
+        For example, your server may return prefixed root keys like so:
+
+        ```js
+        {
+          "response-fast-car": {
+            "id": "1",
+            "name": "corvette"
+          }
+        }
+        ```
+
+        In order for Ember Data to know that the model corresponding to
+        the 'response-fast-car' hash is `FastCar` (typeKey: 'fastCar'),
+        you can override typeForRoot to convert 'response-fast-car' to
+        'fastCar' like so:
+
+        ```js
+        App.ApplicationSerializer = DS.RESTSerializer.extend({
+          typeForRoot: function(root) {
+            // 'response-fast-car' should become 'fast-car'
+            var subRoot = root.substring(9);
+
+            // _super normalizes 'fast-car' to 'fastCar'
+            return this._super(subRoot);
+          }
+        });
+        ```
+
+        @method typeForRoot
+        @param {String} key
+        @return {String} the model's typeKey
+      */
+      typeForRoot: function(key) {
+        return camelize(singularize(key));
+      },
+
+      // SERIALIZE
+
+      /**
+        Called when a record is saved in order to convert the
+        record into JSON.
+
+        By default, it creates a JSON object with a key for
+        each attribute and belongsTo relationship.
+
+        For example, consider this model:
+
+        ```js
+        App.Comment = DS.Model.extend({
+          title: DS.attr(),
+          body: DS.attr(),
+
+          author: DS.belongsTo('user')
+        });
+        ```
+
+        The default serialization would create a JSON object like:
+
+        ```js
+        {
+          "title": "Rails is unagi",
+          "body": "Rails? Omakase? O_O",
+          "author": 12
+        }
+        ```
+
+        By default, attributes are passed through as-is, unless
+        you specified an attribute type (`DS.attr('date')`). If
+        you specify a transform, the JavaScript value will be
+        serialized when inserted into the JSON hash.
+
+        By default, belongs-to relationships are converted into
+        IDs when inserted into the JSON hash.
+
+        ## IDs
+
+        `serialize` takes an options hash with a single option:
+        `includeId`. If this option is `true`, `serialize` will,
+        by default include the ID in the JSON object it builds.
+
+        The adapter passes in `includeId: true` when serializing
+        a record for `createRecord`, but not for `updateRecord`.
+
+        ## Customization
+
+        Your server may expect a different JSON format than the
+        built-in serialization format.
+
+        In that case, you can implement `serialize` yourself and
+        return a JSON hash of your choosing.
+
+        ```js
+        App.PostSerializer = DS.RESTSerializer.extend({
+          serialize: function(post, options) {
+            var json = {
+              POST_TTL: post.get('title'),
+              POST_BDY: post.get('body'),
+              POST_CMS: post.get('comments').mapBy('id')
+            }
+
+            if (options.includeId) {
+              json.POST_ID_ = post.get('id');
+            }
+
+            return json;
+          }
+        });
+        ```
+
+        ## Customizing an App-Wide Serializer
+
+        If you want to define a serializer for your entire
+        application, you'll probably want to use `eachAttribute`
+        and `eachRelationship` on the record.
+
+        ```js
+        App.ApplicationSerializer = DS.RESTSerializer.extend({
+          serialize: function(record, options) {
+            var json = {};
+
+            record.eachAttribute(function(name) {
+              json[serverAttributeName(name)] = record.get(name);
+            })
+
+            record.eachRelationship(function(name, relationship) {
+              if (relationship.kind === 'hasMany') {
+                json[serverHasManyName(name)] = record.get(name).mapBy('id');
+              }
+            });
+
+            if (options.includeId) {
+              json.ID_ = record.get('id');
+            }
+
+            return json;
+          }
+        });
+
+        function serverAttributeName(attribute) {
+          return attribute.underscore().toUpperCase();
+        }
+
+        function serverHasManyName(name) {
+          return serverAttributeName(name.singularize()) + "_IDS";
+        }
+        ```
+
+        This serializer will generate JSON that looks like this:
+
+        ```js
+        {
+          "TITLE": "Rails is omakase",
+          "BODY": "Yep. Omakase.",
+          "COMMENT_IDS": [ 1, 2, 3 ]
+        }
+        ```
+
+        ## Tweaking the Default JSON
+
+        If you just want to do some small tweaks on the default JSON,
+        you can call super first and make the tweaks on the returned
+        JSON.
+
+        ```js
+        App.PostSerializer = DS.RESTSerializer.extend({
+          serialize: function(record, options) {
+            var json = this._super(record, options);
+
+            json.subject = json.title;
+            delete json.title;
+
+            return json;
+          }
+        });
+        ```
+
+        @method serialize
+        @param {subclass of DS.Model} record
+        @param {Object} options
+        @return {Object} json
+      */
+      serialize: function(record, options) {
+        return this._super.apply(this, arguments);
+      },
+
+      /**
+        You can use this method to customize the root keys serialized into the JSON.
+        By default the REST Serializer sends the typeKey of a model, which is a camelized
+        version of the name.
+
+        For example, your server may expect underscored root objects.
+
+        ```js
+        App.ApplicationSerializer = DS.RESTSerializer.extend({
+          serializeIntoHash: function(data, type, record, options) {
+            var root = Ember.String.decamelize(type.typeKey);
+            data[root] = this.serialize(record, options);
+          }
+        });
+        ```
+
+        @method serializeIntoHash
+        @param {Object} hash
+        @param {subclass of DS.Model} type
+        @param {DS.Model} record
+        @param {Object} options
+      */
+      serializeIntoHash: function(hash, type, record, options) {
+        hash[type.typeKey] = this.serialize(record, options);
+      },
+
+      /**
+        You can use this method to customize how polymorphic objects are serialized.
+        By default the JSON Serializer creates the key by appending `Type` to
+        the attribute and value from the model's camelcased model name.
+
+        @method serializePolymorphicType
+        @param {DS.Model} record
+        @param {Object} json
+        @param {Object} relationship
+      */
+      serializePolymorphicType: function(record, json, relationship) {
+        var key = relationship.key;
+        var belongsTo = get(record, key);
+        key = this.keyForAttribute ? this.keyForAttribute(key) : key;
+        if (Ember.isNone(belongsTo)) {
+          json[key + "Type"] = null;
+        } else {
+          json[key + "Type"] = Ember.String.camelize(belongsTo.constructor.typeKey);
+        }
+      }
+    });
+
+    Ember.runInDebug(function(){
+      RESTSerializer.reopen({
+        warnMessageNoModelForKey: function(prop, typeKey){
+          return 'Encountered "' + prop + '" in payload, but no model was found for model name "' + typeKey + '" (resolved model name using ' + this.constructor.toString() + '.typeForRoot("' + prop + '"))';
+        }
+      });
+    });
+
+    __exports__["default"] = RESTSerializer;
+  });
+enifed("ember-data/setup-container",
+  ["ember-data/initializers/store","ember-data/initializers/transforms","ember-data/initializers/store_injections","ember-data/initializers/data_adapter","activemodel-adapter/setup-container","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+    "use strict";
+    var initializeStore = __dependency1__["default"];
+    var initializeTransforms = __dependency2__["default"];
+    var initializeStoreInjections = __dependency3__["default"];
+    var initializeDataAdapter = __dependency4__["default"];
+    var setupActiveModelContainer = __dependency5__["default"];
+
+    __exports__["default"] = function setupContainer(container, application){
+      // application is not a required argument. This ensures
+      // testing setups can setup a container without booting an
+      // entire ember application.
+
+      initializeDataAdapter(container, application);
+      initializeTransforms(container, application);
+      initializeStoreInjections(container, application);
+      initializeStore(container, application);
+      setupActiveModelContainer(container, application);
+    };
+  });
+enifed("ember-data/system/adapter",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    var get = Ember.get;
+
+    var errorProps = [
+      'description',
+      'fileName',
+      'lineNumber',
+      'message',
+      'name',
+      'number',
+      'stack'
+    ];
+
+    /**
+      A `DS.InvalidError` is used by an adapter to signal the external API
+      was unable to process a request because the content was not
+      semantically correct or meaningful per the API. Usually this means a
+      record failed some form of server side validation. When a promise
+      from an adapter is rejected with a `DS.InvalidError` the record will
+      transition to the `invalid` state and the errors will be set to the
+      `errors` property on the record.
+
+      This function should return the entire payload as received from the
+      server.  Error object extraction and normalization of model errors
+      should be performed by `extractErrors` on the serializer.
+
+      Example
+
+      ```javascript
+      App.ApplicationAdapter = DS.RESTAdapter.extend({
+        ajaxError: function(jqXHR) {
+          var error = this._super(jqXHR);
+
+          if (jqXHR && jqXHR.status === 422) {
+            var jsonErrors = Ember.$.parseJSON(jqXHR.responseText);
+            return new DS.InvalidError(jsonErrors);
+          } else {
+            return error;
+          }
+        }
+      });
+      ```
+
+      The `DS.InvalidError` must be constructed with a single object whose
+      keys are the invalid model properties, and whose values are the
+      corresponding error messages. For example:
+
+      ```javascript
+      return new DS.InvalidError({
+        length: 'Must be less than 15',
+        name: 'Must not be blank'
+      });
+      ```
+
+      @class InvalidError
+      @namespace DS
+    */
+    function InvalidError(errors) {
+      var tmp = Error.prototype.constructor.call(this, "The backend rejected the commit because it was invalid: " + Ember.inspect(errors));
+      this.errors = errors;
+
+      for (var i=0, l=errorProps.length; i<l; i++) {
+        this[errorProps[i]] = tmp[errorProps[i]];
+      }
+    }
+
+    InvalidError.prototype = Ember.create(Error.prototype);
+
+    /**
+      An adapter is an object that receives requests from a store and
+      translates them into the appropriate action to take against your
+      persistence layer. The persistence layer is usually an HTTP API, but
+      may be anything, such as the browser's local storage. Typically the
+      adapter is not invoked directly instead its functionality is accessed
+      through the `store`.
+
+      ### Creating an Adapter
+
+      Create a new subclass of `DS.Adapter`, then assign
+      it to the `ApplicationAdapter` property of the application.
+
+      ```javascript
+      var MyAdapter = DS.Adapter.extend({
+        // ...your code here
+      });
+
+      App.ApplicationAdapter = MyAdapter;
+      ```
+
+      Model-specific adapters can be created by assigning your adapter
+      class to the `ModelName` + `Adapter` property of the application.
+
+      ```javascript
+      var MyPostAdapter = DS.Adapter.extend({
+        // ...Post-specific adapter code goes here
+      });
+
+      App.PostAdapter = MyPostAdapter;
+      ```
+
+      `DS.Adapter` is an abstract base class that you should override in your
+      application to customize it for your backend. The minimum set of methods
+      that you should implement is:
+
+        * `find()`
+        * `createRecord()`
+        * `updateRecord()`
+        * `deleteRecord()`
+        * `findAll()`
+        * `findQuery()`
+
+      To improve the network performance of your application, you can optimize
+      your adapter by overriding these lower-level methods:
+
+        * `findMany()`
+
+
+      For an example implementation, see `DS.RESTAdapter`, the
+      included REST adapter.
+
+      @class Adapter
+      @namespace DS
+      @extends Ember.Object
+    */
+
+    var Adapter = Ember.Object.extend({
+
+      /**
+        If you would like your adapter to use a custom serializer you can
+        set the `defaultSerializer` property to be the name of the custom
+        serializer.
+
+        Note the `defaultSerializer` serializer has a lower priority than
+        a model specific serializer (i.e. `PostSerializer`) or the
+        `application` serializer.
+
+        ```javascript
+        var DjangoAdapter = DS.Adapter.extend({
+          defaultSerializer: 'django'
+        });
+        ```
+
+        @property defaultSerializer
+        @type {String}
+      */
+
+      /**
+        The `find()` method is invoked when the store is asked for a record that
+        has not previously been loaded. In response to `find()` being called, you
+        should query your persistence layer for a record with the given ID. Once
+        found, you can asynchronously call the store's `push()` method to push
+        the record into the store.
+
+        Here is an example `find` implementation:
+
+        ```javascript
+        App.ApplicationAdapter = DS.Adapter.extend({
+          find: function(store, type, id) {
+            var url = [type.typeKey, id].join('/');
+
+            return new Ember.RSVP.Promise(function(resolve, reject) {
+              jQuery.getJSON(url).then(function(data) {
+                Ember.run(null, resolve, data);
+              }, function(jqXHR) {
+                jqXHR.then = null; // tame jQuery's ill mannered promises
+                Ember.run(null, reject, jqXHR);
+              });
+            });
+          }
+        });
+        ```
+
+        @method find
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {String} id
+        @return {Promise} promise
+      */
+      find: Ember.required(Function),
+
+      /**
+        The `findAll()` method is called when you call `find` on the store
+        without an ID (i.e. `store.find('post')`).
+
+        Example
+
+        ```javascript
+        App.ApplicationAdapter = DS.Adapter.extend({
+          findAll: function(store, type, sinceToken) {
+            var url = type;
+            var query = { since: sinceToken };
+            return new Ember.RSVP.Promise(function(resolve, reject) {
+              jQuery.getJSON(url, query).then(function(data) {
+                Ember.run(null, resolve, data);
+              }, function(jqXHR) {
+                jqXHR.then = null; // tame jQuery's ill mannered promises
+                Ember.run(null, reject, jqXHR);
+              });
+            });
+          }
+        });
+        ```
+
+        @private
+        @method findAll
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {String} sinceToken
+        @return {Promise} promise
+      */
+      findAll: null,
+
+      /**
+        This method is called when you call `find` on the store with a
+        query object as the second parameter (i.e. `store.find('person', {
+        page: 1 })`).
+
+        Example
+
+        ```javascript
+        App.ApplicationAdapter = DS.Adapter.extend({
+          findQuery: function(store, type, query) {
+            var url = type;
+            return new Ember.RSVP.Promise(function(resolve, reject) {
+              jQuery.getJSON(url, query).then(function(data) {
+                Ember.run(null, resolve, data);
+              }, function(jqXHR) {
+                jqXHR.then = null; // tame jQuery's ill mannered promises
+                Ember.run(null, reject, jqXHR);
+              });
+            });
+          }
+        });
+        ```
+
+        @private
+        @method findQuery
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type
+        @param {Object} query
+        @param {DS.AdapterPopulatedRecordArray} recordArray
+        @return {Promise} promise
+      */
+      findQuery: null,
+
+      /**
+        If the globally unique IDs for your records should be generated on the client,
+        implement the `generateIdForRecord()` method. This method will be invoked
+        each time you create a new record, and the value returned from it will be
+        assigned to the record's `primaryKey`.
+
+        Most traditional REST-like HTTP APIs will not use this method. Instead, the ID
+        of the record will be set by the server, and your adapter will update the store
+        with the new ID when it calls `didCreateRecord()`. Only implement this method if
+        you intend to generate record IDs on the client-side.
+
+        The `generateIdForRecord()` method will be invoked with the requesting store as
+        the first parameter and the newly created record as the second parameter:
+
+        ```javascript
+        generateIdForRecord: function(store, record) {
+          var uuid = App.generateUUIDWithStatisticallyLowOddsOfCollision();
+          return uuid;
+        }
+        ```
+
+        @method generateIdForRecord
+        @param {DS.Store} store
+        @param {DS.Model} record
+        @return {String|Number} id
+      */
+      generateIdForRecord: null,
+
+      /**
+        Proxies to the serializer's `serialize` method.
+
+        Example
+
+        ```javascript
+        App.ApplicationAdapter = DS.Adapter.extend({
+          createRecord: function(store, type, record) {
+            var data = this.serialize(record, { includeId: true });
+            var url = type;
+
+            // ...
+          }
+        });
+        ```
+
+        @method serialize
+        @param {DS.Model} record
+        @param {Object}   options
+        @return {Object} serialized record
+      */
+      serialize: function(record, options) {
+        return get(record, 'store').serializerFor(record.constructor.typeKey).serialize(record, options);
+      },
+
+      /**
+        Implement this method in a subclass to handle the creation of
+        new records.
+
+        Serializes the record and send it to the server.
+
+        Example
+
+        ```javascript
+        App.ApplicationAdapter = DS.Adapter.extend({
+          createRecord: function(store, type, record) {
+            var data = this.serialize(record, { includeId: true });
+            var url = type;
+
+            return new Ember.RSVP.Promise(function(resolve, reject) {
+              jQuery.ajax({
+                type: 'POST',
+                url: url,
+                dataType: 'json',
+                data: data
+              }).then(function(data) {
+                Ember.run(null, resolve, data);
+              }, function(jqXHR) {
+                jqXHR.then = null; // tame jQuery's ill mannered promises
+                Ember.run(null, reject, jqXHR);
+              });
+            });
+          }
+        });
+        ```
+
+        @method createRecord
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type   the DS.Model class of the record
+        @param {DS.Model} record
+        @return {Promise} promise
+      */
+      createRecord: Ember.required(Function),
+
+      /**
+        Implement this method in a subclass to handle the updating of
+        a record.
+
+        Serializes the record update and send it to the server.
+
+        Example
+
+        ```javascript
+        App.ApplicationAdapter = DS.Adapter.extend({
+          updateRecord: function(store, type, record) {
+            var data = this.serialize(record, { includeId: true });
+            var id = record.get('id');
+            var url = [type, id].join('/');
+
+            return new Ember.RSVP.Promise(function(resolve, reject) {
+              jQuery.ajax({
+                type: 'PUT',
+                url: url,
+                dataType: 'json',
+                data: data
+              }).then(function(data) {
+                Ember.run(null, resolve, data);
+              }, function(jqXHR) {
+                jqXHR.then = null; // tame jQuery's ill mannered promises
+                Ember.run(null, reject, jqXHR);
+              });
+            });
+          }
+        });
+        ```
+
+        @method updateRecord
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type   the DS.Model class of the record
+        @param {DS.Model} record
+        @return {Promise} promise
+      */
+      updateRecord: Ember.required(Function),
+
+      /**
+        Implement this method in a subclass to handle the deletion of
+        a record.
+
+        Sends a delete request for the record to the server.
+
+        Example
+
+        ```javascript
+        App.ApplicationAdapter = DS.Adapter.extend({
+          deleteRecord: function(store, type, record) {
+            var data = this.serialize(record, { includeId: true });
+            var id = record.get('id');
+            var url = [type, id].join('/');
+
+            return new Ember.RSVP.Promise(function(resolve, reject) {
+              jQuery.ajax({
+                type: 'DELETE',
+                url: url,
+                dataType: 'json',
+                data: data
+              }).then(function(data) {
+                Ember.run(null, resolve, data);
+              }, function(jqXHR) {
+                jqXHR.then = null; // tame jQuery's ill mannered promises
+                Ember.run(null, reject, jqXHR);
+              });
+            });
+          }
+        });
+        ```
+
+        @method deleteRecord
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type   the DS.Model class of the record
+        @param {DS.Model} record
+        @return {Promise} promise
+      */
+      deleteRecord: Ember.required(Function),
+
+      /**
+        By default the store will try to coalesce all `fetchRecord` calls within the same runloop
+        into as few requests as possible by calling groupRecordsForFindMany and passing it into a findMany call.
+        You can opt out of this behaviour by either not implementing the findMany hook or by setting
+        coalesceFindRequests to false
+
+        @property coalesceFindRequests
+        @type {boolean}
+      */
+      coalesceFindRequests: true,
+
+      /**
+        Find multiple records at once if coalesceFindRequests is true
+
+        @method findMany
+        @param {DS.Store} store
+        @param {subclass of DS.Model} type   the DS.Model class of the records
+        @param {Array}    ids
+        @param {Array} records
+        @return {Promise} promise
+      */
+
+      /**
+        Organize records into groups, each of which is to be passed to separate
+        calls to `findMany`.
+
+        For example, if your api has nested URLs that depend on the parent, you will
+        want to group records by their parent.
+
+        The default implementation returns the records as a single group.
+
+        @method groupRecordsForFindMany
+        @param {DS.Store} store
+        @param {Array} records
+        @return {Array}  an array of arrays of records, each of which is to be
+                          loaded separately by `findMany`.
+      */
+      groupRecordsForFindMany: function (store, records) {
+        return [records];
+      }
+    });
+
+    __exports__.InvalidError = InvalidError;
+    __exports__.Adapter = Adapter;
+    __exports__["default"] = Adapter;
+  });
+enifed("ember-data/system/container_proxy",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /**
+      This is used internally to enable deprecation of container paths and provide
+      a decent message to the user indicating how to fix the issue.
+
+      @class ContainerProxy
+      @namespace DS
+      @private
+    */
+    function ContainerProxy(container){
+      this.container = container;
+    }
+
+    ContainerProxy.prototype.aliasedFactory = function(path, preLookup) {
+      var _this = this;
+
+      return {create: function(){
+        if (preLookup) { preLookup(); }
+
+        return _this.container.lookup(path);
+      }};
+    };
+
+    ContainerProxy.prototype.registerAlias = function(source, dest, preLookup) {
+      var factory = this.aliasedFactory(dest, preLookup);
+
+      return this.container.register(source, factory);
+    };
+
+    ContainerProxy.prototype.registerDeprecation = function(deprecated, valid) {
+      var preLookupCallback = function(){
+        Ember.deprecate("You tried to look up '" + deprecated + "', " +
+                        "but this has been deprecated in favor of '" + valid + "'.", false);
+      };
+
+      return this.registerAlias(deprecated, valid, preLookupCallback);
+    };
+
+    ContainerProxy.prototype.registerDeprecations = function(proxyPairs) {
+      var i, proxyPair, deprecated, valid;
+
+      for (i = proxyPairs.length; i > 0; i--) {
+        proxyPair = proxyPairs[i - 1];
+        deprecated = proxyPair['deprecated'];
+        valid = proxyPair['valid'];
+
+        this.registerDeprecation(deprecated, valid);
+      }
+    };
+
+    __exports__["default"] = ContainerProxy;
+  });
+enifed("ember-data/system/create",
+  [],
+  function() {
+    "use strict";
+    /*
+      Detect if the user has a correct Object.create shim.
+      Ember has provided this for a long time but has had an incorrect shim before 1.8
+      TODO: Remove for Ember Data 1.0.
+    */
+    var object = Ember.create(null);
+    if (object.toString !== undefined && Ember.keys(Ember.create({}))[0] === '__proto__'){
+      throw new Error("Ember Data requires a correct Object.create shim. You should upgrade to Ember >= 1.8 which provides one for you. If you are using ES5-shim, you should try removing that after upgrading Ember.");
+    }
+  });
+enifed("ember-data/system/debug",
+  ["ember-data/system/debug/debug_info","ember-data/system/debug/debug_adapter","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    var DebugAdapter = __dependency2__["default"];
+
+    __exports__["default"] = DebugAdapter;
+  });
+enifed("ember-data/system/debug/debug_adapter",
+  ["ember-data/system/model","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+    var Model = __dependency1__.Model;
+    var get = Ember.get;
+    var capitalize = Ember.String.capitalize;
+    var underscore = Ember.String.underscore;
+
+    /**
+      Extend `Ember.DataAdapter` with ED specific code.
+
+      @class DebugAdapter
+      @namespace DS
+      @extends Ember.DataAdapter
+      @private
+    */
+    __exports__["default"] = Ember.DataAdapter.extend({
+      getFilters: function() {
+        return [
+          { name: 'isNew', desc: 'New' },
+          { name: 'isModified', desc: 'Modified' },
+          { name: 'isClean', desc: 'Clean' }
+        ];
+      },
+
+      detect: function(klass) {
+        return klass !== Model && Model.detect(klass);
+      },
+
+      columnsForType: function(type) {
+        var columns = [{
+          name: 'id',
+          desc: 'Id'
+        }];
+        var count = 0;
+        var self = this;
+        get(type, 'attributes').forEach(function(meta, name) {
+            if (count++ > self.attributeLimit) { return false; }
+            var desc = capitalize(underscore(name).replace('_', ' '));
+            columns.push({ name: name, desc: desc });
+        });
+        return columns;
+      },
+
+      getRecords: function(type) {
+        return this.get('store').all(type);
+      },
+
+      getRecordColumnValues: function(record) {
+        var self = this, count = 0;
+        var columnValues = { id: get(record, 'id') };
+
+        record.eachAttribute(function(key) {
+          if (count++ > self.attributeLimit) {
+            return false;
+          }
+          var value = get(record, key);
+          columnValues[key] = value;
+        });
+        return columnValues;
+      },
+
+      getRecordKeywords: function(record) {
+        var keywords = [];
+        var keys = Ember.A(['id']);
+        record.eachAttribute(function(key) {
+          keys.push(key);
+        });
+        keys.forEach(function(key) {
+          keywords.push(get(record, key));
+        });
+        return keywords;
+      },
+
+      getRecordFilterValues: function(record) {
+        return {
+          isNew: record.get('isNew'),
+          isModified: record.get('isDirty') && !record.get('isNew'),
+          isClean: !record.get('isDirty')
+        };
+      },
+
+      getRecordColor: function(record) {
+        var color = 'black';
+        if (record.get('isNew')) {
+          color = 'green';
+        } else if (record.get('isDirty')) {
+          color = 'blue';
+        }
+        return color;
+      },
+
+      observeRecord: function(record, recordUpdated) {
+        var releaseMethods = Ember.A(), self = this;
+        var keysToObserve = Ember.A(['id', 'isNew', 'isDirty']);
+
+        record.eachAttribute(function(key) {
+          keysToObserve.push(key);
+        });
+
+        keysToObserve.forEach(function(key) {
+          var handler = function() {
+            recordUpdated(self.wrapRecord(record));
+          };
+          Ember.addObserver(record, key, handler);
+          releaseMethods.push(function() {
+            Ember.removeObserver(record, key, handler);
+          });
+        });
+
+        var release = function() {
+          releaseMethods.forEach(function(fn) { fn(); } );
+        };
+
+        return release;
+      }
+
+    });
+  });
+enifed("ember-data/system/debug/debug_info",
+  ["ember-data/system/model","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Model = __dependency1__.Model;
+
+    Model.reopen({
+
+      /**
+        Provides info about the model for debugging purposes
+        by grouping the properties into more semantic groups.
+
+        Meant to be used by debugging tools such as the Chrome Ember Extension.
+
+        - Groups all attributes in "Attributes" group.
+        - Groups all belongsTo relationships in "Belongs To" group.
+        - Groups all hasMany relationships in "Has Many" group.
+        - Groups all flags in "Flags" group.
+        - Flags relationship CPs as expensive properties.
+
+        @method _debugInfo
+        @for DS.Model
+        @private
+      */
+      _debugInfo: function() {
+        var attributes = ['id'],
+            relationships = { belongsTo: [], hasMany: [] },
+            expensiveProperties = [];
+
+        this.eachAttribute(function(name, meta) {
+          attributes.push(name);
+        }, this);
+
+        this.eachRelationship(function(name, relationship) {
+          relationships[relationship.kind].push(name);
+          expensiveProperties.push(name);
+        });
+
+        var groups = [
+          {
+            name: 'Attributes',
+            properties: attributes,
+            expand: true
+          },
+          {
+            name: 'Belongs To',
+            properties: relationships.belongsTo,
+            expand: true
+          },
+          {
+            name: 'Has Many',
+            properties: relationships.hasMany,
+            expand: true
+          },
+          {
+            name: 'Flags',
+            properties: ['isLoaded', 'isDirty', 'isSaving', 'isDeleted', 'isError', 'isNew', 'isValid']
+          }
+        ];
+
+        return {
+          propertyInfo: {
+            // include all other mixins / properties (not just the grouped ones)
+            includeOtherProperties: true,
+            groups: groups,
+            // don't pre-calculate unless cached
+            expensiveProperties: expensiveProperties
+          }
+        };
+      }
+    });
+
+    __exports__["default"] = Model;
+  });
+enifed("ember-data/system/map",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /**
+     * Polyfill Ember.Map behavior for Ember <= 1.7
+     * This can probably be removed before 1.0 final
+    */
+    var mapForEach, deleteFn;
+
+    function OrderedSet(){
+      Ember.OrderedSet.apply(this, arguments);
+    }
+
+    function Map() {
+      Ember.Map.apply(this, arguments);
+    }
+
+    function MapWithDefault(){
+      Ember.MapWithDefault.apply(this, arguments);
+    }
+
+    var testMap = Ember.Map.create();
+    testMap.set('key', 'value');
+
+    var usesOldBehavior = false;
+
+    testMap.forEach(function(value, key){
+      usesOldBehavior = value === 'key' && key === 'value';
+    });
+
+    Map.prototype            = Ember.create(Ember.Map.prototype);
+    MapWithDefault.prototype = Ember.create(Ember.MapWithDefault.prototype);
+    OrderedSet.prototype     = Ember.create(Ember.OrderedSet.prototype);
+
+    OrderedSet.create = function(){
+      return new OrderedSet();
+    };
+
+    /**
+     * returns a function that calls the original
+     * callback function in the correct order.
+     * if we are in pre-Ember.1.8 land, Map/MapWithDefault
+     * forEach calls with key, value, in that order.
+     * >= 1.8 forEach is called with the order value, key as per
+     * the ES6 spec.
+    */
+    function translate(valueKeyOrderedCallback){
+      return function(key, value){
+        valueKeyOrderedCallback.call(this, value, key);
+      };
+    }
+
+    // old, non ES6 compliant behavior
+    if (usesOldBehavior){
+      mapForEach = function(callback, thisArg){
+        this.__super$forEach(translate(callback), thisArg);
+      };
+
+      /* alias to remove */
+      deleteFn = function(thing){
+        this.remove(thing);
+      };
+
+      Map.prototype.__super$forEach = Ember.Map.prototype.forEach;
+      Map.prototype.forEach = mapForEach;
+      Map.prototype["delete"] = deleteFn;
+
+      MapWithDefault.prototype.forEach = mapForEach;
+      MapWithDefault.prototype.__super$forEach = Ember.MapWithDefault.prototype.forEach;
+      MapWithDefault.prototype["delete"] = deleteFn;
+
+      OrderedSet.prototype["delete"] = deleteFn;
+    }
+
+    MapWithDefault.constructor = MapWithDefault;
+    Map.constructor = Map;
+
+    MapWithDefault.create = function(options){
+      if (options) {
+        return new MapWithDefault(options);
+      } else {
+        return new Map();
+      }
+    };
+
+    Map.create = function(){
+      return new this.constructor();
+    };
+
+    __exports__["default"] = Map;
+    __exports__.Map = Map;
+    __exports__.MapWithDefault = MapWithDefault;
+    __exports__.OrderedSet = OrderedSet;
+  });
+enifed("ember-data/system/model",
+  ["ember-data/system/model/model","ember-data/system/model/attributes","ember-data/system/model/states","ember-data/system/model/errors","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    var Model = __dependency1__["default"];
+    var attr = __dependency2__["default"];
+    var RootState = __dependency3__["default"];
+    var Errors = __dependency4__["default"];
+
+    __exports__.Model = Model;
+    __exports__.RootState = RootState;
+    __exports__.attr = attr;
+    __exports__.Errors = Errors;
+  });
+enifed("ember-data/system/model/attributes",
+  ["ember-data/system/model/model","ember-data/system/map","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var Model = __dependency1__["default"];
+    var Map = __dependency2__.Map;
+
+    /**
+      @module ember-data
+    */
+
+    var get = Ember.get;
+
+    /**
+      @class Model
+      @namespace DS
+    */
+    Model.reopenClass({
+      /**
+        A map whose keys are the attributes of the model (properties
+        described by DS.attr) and whose values are the meta object for the
+        property.
+
+        Example
+
+        ```javascript
+
+        App.Person = DS.Model.extend({
+          firstName: attr('string'),
+          lastName: attr('string'),
+          birthday: attr('date')
+        });
+
+        var attributes = Ember.get(App.Person, 'attributes')
+
+        attributes.forEach(function(name, meta) {
+          console.log(name, meta);
+        });
+
+        // prints:
+        // firstName {type: "string", isAttribute: true, options: Object, parentType: function, name: "firstName"}
+        // lastName {type: "string", isAttribute: true, options: Object, parentType: function, name: "lastName"}
+        // birthday {type: "date", isAttribute: true, options: Object, parentType: function, name: "birthday"}
+        ```
+
+        @property attributes
+        @static
+        @type {Ember.Map}
+        @readOnly
+      */
+      attributes: Ember.computed(function() {
+        var map = Map.create();
+
+        this.eachComputedProperty(function(name, meta) {
+          if (meta.isAttribute) {
+            Ember.assert("You may not set `id` as an attribute on your model. Please remove any lines that look like: `id: DS.attr('<type>')` from " + this.toString(), name !== 'id');
+
+            meta.name = name;
+            map.set(name, meta);
+          }
+        });
+
+        return map;
+      }).readOnly(),
+
+      /**
+        A map whose keys are the attributes of the model (properties
+        described by DS.attr) and whose values are type of transformation
+        applied to each attribute. This map does not include any
+        attributes that do not have an transformation type.
+
+        Example
+
+        ```javascript
+        App.Person = DS.Model.extend({
+          firstName: attr(),
+          lastName: attr('string'),
+          birthday: attr('date')
+        });
+
+        var transformedAttributes = Ember.get(App.Person, 'transformedAttributes')
+
+        transformedAttributes.forEach(function(field, type) {
+          console.log(field, type);
+        });
+
+        // prints:
+        // lastName string
+        // birthday date
+        ```
+
+        @property transformedAttributes
+        @static
+        @type {Ember.Map}
+        @readOnly
+      */
+      transformedAttributes: Ember.computed(function() {
+        var map = Map.create();
+
+        this.eachAttribute(function(key, meta) {
+          if (meta.type) {
+            map.set(key, meta.type);
+          }
+        });
+
+        return map;
+      }).readOnly(),
+
+      /**
+        Iterates through the attributes of the model, calling the passed function on each
+        attribute.
+
+        The callback method you provide should have the following signature (all
+        parameters are optional):
+
+        ```javascript
+        function(name, meta);
+        ```
+
+        - `name` the name of the current property in the iteration
+        - `meta` the meta object for the attribute property in the iteration
+
+        Note that in addition to a callback, you can also pass an optional target
+        object that will be set as `this` on the context.
+
+        Example
+
+        ```javascript
+        App.Person = DS.Model.extend({
+          firstName: attr('string'),
+          lastName: attr('string'),
+          birthday: attr('date')
+        });
+
+        App.Person.eachAttribute(function(name, meta) {
+          console.log(name, meta);
+        });
+
+        // prints:
+        // firstName {type: "string", isAttribute: true, options: Object, parentType: function, name: "firstName"}
+        // lastName {type: "string", isAttribute: true, options: Object, parentType: function, name: "lastName"}
+        // birthday {type: "date", isAttribute: true, options: Object, parentType: function, name: "birthday"}
+       ```
+
+        @method eachAttribute
+        @param {Function} callback The callback to execute
+        @param {Object} [target] The target object to use
+        @static
+      */
+      eachAttribute: function(callback, binding) {
+        get(this, 'attributes').forEach(function(meta, name) {
+          callback.call(binding, name, meta);
+        }, binding);
+      },
+
+      /**
+        Iterates through the transformedAttributes of the model, calling
+        the passed function on each attribute. Note the callback will not be
+        called for any attributes that do not have an transformation type.
+
+        The callback method you provide should have the following signature (all
+        parameters are optional):
+
+        ```javascript
+        function(name, type);
+        ```
+
+        - `name` the name of the current property in the iteration
+        - `type` a string containing the name of the type of transformed
+          applied to the attribute
+
+        Note that in addition to a callback, you can also pass an optional target
+        object that will be set as `this` on the context.
+
+        Example
+
+        ```javascript
+        App.Person = DS.Model.extend({
+          firstName: attr(),
+          lastName: attr('string'),
+          birthday: attr('date')
+        });
+
+        App.Person.eachTransformedAttribute(function(name, type) {
+          console.log(name, type);
+        });
+
+        // prints:
+        // lastName string
+        // birthday date
+       ```
+
+        @method eachTransformedAttribute
+        @param {Function} callback The callback to execute
+        @param {Object} [target] The target object to use
+        @static
+      */
+      eachTransformedAttribute: function(callback, binding) {
+        get(this, 'transformedAttributes').forEach(function(type, name) {
+          callback.call(binding, name, type);
+        });
+      }
+    });
+
+
+    Model.reopen({
+      eachAttribute: function(callback, binding) {
+        this.constructor.eachAttribute(callback, binding);
+      }
+    });
+
+    function getDefaultValue(record, options, key) {
+      if (typeof options.defaultValue === "function") {
+        return options.defaultValue.apply(null, arguments);
+      } else {
+        return options.defaultValue;
+      }
+    }
+
+    function hasValue(record, key) {
+      return record._attributes.hasOwnProperty(key) ||
+             record._inFlightAttributes.hasOwnProperty(key) ||
+             record._data.hasOwnProperty(key);
+    }
+
+    function getValue(record, key) {
+      if (record._attributes.hasOwnProperty(key)) {
+        return record._attributes[key];
+      } else if (record._inFlightAttributes.hasOwnProperty(key)) {
+        return record._inFlightAttributes[key];
+      } else {
+        return record._data[key];
+      }
+    }
+
+    /**
+      `DS.attr` defines an attribute on a [DS.Model](/api/data/classes/DS.Model.html).
+      By default, attributes are passed through as-is, however you can specify an
+      optional type to have the value automatically transformed.
+      Ember Data ships with four basic transform types: `string`, `number`,
+      `boolean` and `date`. You can define your own transforms by subclassing
+      [DS.Transform](/api/data/classes/DS.Transform.html).
+
+      Note that you cannot use `attr` to define an attribute of `id`.
+
+      `DS.attr` takes an optional hash as a second parameter, currently
+      supported options are:
+
+      - `defaultValue`: Pass a string or a function to be called to set the attribute
+                        to a default value if none is supplied.
+
+      Example
+
+      ```javascript
+      var attr = DS.attr;
+
+      App.User = DS.Model.extend({
+        username: attr('string'),
+        email: attr('string'),
+        verified: attr('boolean', {defaultValue: false})
+      });
+      ```
+
+      @namespace
+      @method attr
+      @for DS
+      @param {String} type the attribute type
+      @param {Object} options a hash of options
+      @return {Attribute}
+    */
+
+    __exports__["default"] = function attr(type, options) {
+      options = options || {};
+
+      var meta = {
+        type: type,
+        isAttribute: true,
+        options: options
+      };
+
+      return Ember.computed(function(key, value) {
+        if (arguments.length > 1) {
+          Ember.assert("You may not set `id` as an attribute on your model. Please remove any lines that look like: `id: DS.attr('<type>')` from " + this.constructor.toString(), key !== 'id');
+          var oldValue = getValue(this, key);
+
+          if (value !== oldValue) {
+            // Add the new value to the changed attributes hash; it will get deleted by
+            // the 'didSetProperty' handler if it is no different from the original value
+            this._attributes[key] = value;
+
+            this.send('didSetProperty', {
+              name: key,
+              oldValue: oldValue,
+              originalValue: this._data[key],
+              value: value
+            });
+          }
+
+          return value;
+        } else if (hasValue(this, key)) {
+          return getValue(this, key);
+        } else {
+          return getDefaultValue(this, options, key);
+        }
+
+      // `data` is never set directly. However, it may be
+      // invalidated from the state manager's setData
+      // event.
+      }).meta(meta);
+    };
+  });
+enifed("ember-data/system/model/errors",
+  ["ember-data/system/map","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var get = Ember.get;
+    var isEmpty = Ember.isEmpty;
+    var map = Ember.EnumerableUtils.map;
+
+    var MapWithDefault = __dependency1__.MapWithDefault;
+
+    /**
+    @module ember-data
+    */
+
+    /**
+      Holds validation errors for a given record organized by attribute names.
+
+      Every DS.Model has an `errors` property that is an instance of
+      `DS.Errors`. This can be used to display validation error
+      messages returned from the server when a `record.save()` rejects.
+      This works automatically with `DS.ActiveModelAdapter`, but you
+      can implement [ajaxError](/api/data/classes/DS.RESTAdapter.html#method_ajaxError)
+      in other adapters as well.
+
+      For Example, if you had an `User` model that looked like this:
+
+      ```javascript
+      App.User = DS.Model.extend({
+        username: attr('string'),
+        email: attr('string')
+      });
+      ```
+      And you attempted to save a record that did not validate on the backend.
+
+      ```javascript
+      var user = store.createRecord('user', {
+        username: 'tomster',
+        email: 'invalidEmail'
+      });
+      user.save();
+      ```
+
+      Your backend data store might return a response that looks like
+      this. This response will be used to populate the error object.
+
+      ```javascript
+      {
+        "errors": {
+          "username": ["This username is already taken!"],
+          "email": ["Doesn't look like a valid email."]
+        }
+      }
+      ```
+
+      Errors can be displayed to the user by accessing their property name
+      or using the `messages` property to get an array of all errors.
+
+      ```handlebars
+      {{#each errors.messages}}
+        <div class="error">
+          {{message}}
+        </div>
+      {{/each}}
+
+      <label>Username: {{input value=username}} </label>
+      {{#each errors.username}}
+        <div class="error">
+          {{message}}
+        </div>
+      {{/each}}
+
+      <label>Email: {{input value=email}} </label>
+      {{#each errors.email}}
+        <div class="error">
+          {{message}}
+        </div>
+      {{/each}}
+      ```
+
+      @class Errors
+      @namespace DS
+      @extends Ember.Object
+      @uses Ember.Enumerable
+      @uses Ember.Evented
+     */
+    __exports__["default"] = Ember.Object.extend(Ember.Enumerable, Ember.Evented, {
+      /**
+        Register with target handler
+
+        @method registerHandlers
+        @param {Object} target
+        @param {Function} becameInvalid
+        @param {Function} becameValid
+      */
+      registerHandlers: function(target, becameInvalid, becameValid) {
+        this.on('becameInvalid', target, becameInvalid);
+        this.on('becameValid', target, becameValid);
+      },
+
+      /**
+        @property errorsByAttributeName
+        @type {Ember.MapWithDefault}
+        @private
+      */
+      errorsByAttributeName: Ember.reduceComputed("content", {
+        initialValue: function() {
+          return MapWithDefault.create({
+            defaultValue: function() {
+              return Ember.A();
+            }
+          });
+        },
+
+        addedItem: function(errors, error) {
+          errors.get(error.attribute).pushObject(error);
+
+          return errors;
+        },
+
+        removedItem: function(errors, error) {
+          errors.get(error.attribute).removeObject(error);
+
+          return errors;
+        }
+      }),
+
+      /**
+        Returns errors for a given attribute
+
+        ```javascript
+        var user = store.createRecord('user', {
+          username: 'tomster',
+          email: 'invalidEmail'
+        });
+        user.save().catch(function(){
+          user.get('errors').errorsFor('email'); // ["Doesn't look like a valid email."]
+        });
+        ```
+
+        @method errorsFor
+        @param {String} attribute
+        @return {Array}
+      */
+      errorsFor: function(attribute) {
+        return get(this, 'errorsByAttributeName').get(attribute);
+      },
+
+      /**
+        An array containing all of the error messages for this
+        record. This is useful for displaying all errors to the user.
+
+        ```handlebars
+        {{#each errors.messages}}
+          <div class="error">
+            {{message}}
+          </div>
+        {{/each}}
+        ```
+
+        @property messages
+        @type {Array}
+      */
+      messages: Ember.computed.mapBy('content', 'message'),
+
+      /**
+        @property content
+        @type {Array}
+        @private
+      */
+      content: Ember.computed(function() {
+        return Ember.A();
+      }),
+
+      /**
+        @method unknownProperty
+        @private
+      */
+      unknownProperty: function(attribute) {
+        var errors = this.errorsFor(attribute);
+        if (isEmpty(errors)) { return null; }
+        return errors;
+      },
+
+      /**
+        @method nextObject
+        @private
+      */
+      nextObject: function(index, previousObject, context) {
+        return get(this, 'content').objectAt(index);
+      },
+
+      /**
+        Total number of errors.
+
+        @property length
+        @type {Number}
+        @readOnly
+      */
+      length: Ember.computed.oneWay('content.length').readOnly(),
+
+      /**
+        @property isEmpty
+        @type {Boolean}
+        @readOnly
+      */
+      isEmpty: Ember.computed.not('length').readOnly(),
+
+      /**
+        Adds error messages to a given attribute and sends
+        `becameInvalid` event to the record.
+
+        Example:
+
+        ```javascript
+        if (!user.get('username') {
+          user.get('errors').add('username', 'This field is required');
+        }
+        ```
+
+        @method add
+        @param {String} attribute
+        @param {Array|String} messages
+      */
+      add: function(attribute, messages) {
+        var wasEmpty = get(this, 'isEmpty');
+
+        messages = this._findOrCreateMessages(attribute, messages);
+        get(this, 'content').addObjects(messages);
+
+        this.notifyPropertyChange(attribute);
+        this.enumerableContentDidChange();
+
+        if (wasEmpty && !get(this, 'isEmpty')) {
+          this.trigger('becameInvalid');
+        }
+      },
+
+      /**
+        @method _findOrCreateMessages
+        @private
+      */
+      _findOrCreateMessages: function(attribute, messages) {
+        var errors = this.errorsFor(attribute);
+
+        return map(Ember.makeArray(messages), function(message) {
+          return errors.findBy('message', message) || {
+            attribute: attribute,
+            message: message
+          };
+        });
+      },
+
+      /**
+        Removes all error messages from the given attribute and sends
+        `becameValid` event to the record if there no more errors left.
+
+        Example:
+
+        ```javascript
+        App.User = DS.Model.extend({
+          email: DS.attr('string'),
+          twoFactorAuth: DS.attr('boolean'),
+          phone: DS.attr('string')
+        });
+
+        App.UserEditRoute = Ember.Route.extend({
+          actions: {
+            save: function(user) {
+               if (!user.get('twoFactorAuth')) {
+                 user.get('errors').remove('phone');
+               }
+               user.save();
+             }
+          }
+        });
+        ```
+
+        @method remove
+        @param {String} attribute
+      */
+      remove: function(attribute) {
+        if (get(this, 'isEmpty')) { return; }
+
+        var content = get(this, 'content').rejectBy('attribute', attribute);
+        get(this, 'content').setObjects(content);
+
+        this.notifyPropertyChange(attribute);
+        this.enumerableContentDidChange();
+
+        if (get(this, 'isEmpty')) {
+          this.trigger('becameValid');
+        }
+      },
+
+      /**
+        Removes all error messages and sends `becameValid` event
+        to the record.
+
+        Example:
+
+        ```javascript
+        App.UserEditRoute = Ember.Route.extend({
+          actions: {
+            retrySave: function(user) {
+               user.get('errors').clear();
+               user.save();
+             }
+          }
+        });
+        ```
+
+        @method clear
+      */
+      clear: function() {
+        if (get(this, 'isEmpty')) { return; }
+
+        get(this, 'content').clear();
+        this.enumerableContentDidChange();
+
+        this.trigger('becameValid');
+      },
+
+      /**
+        Checks if there is error messages for the given attribute.
+
+        ```javascript
+        App.UserEditRoute = Ember.Route.extend({
+          actions: {
+            save: function(user) {
+               if (user.get('errors').has('email')) {
+                 return alert('Please update your email before attempting to save.');
+               }
+               user.save();
+             }
+          }
+        });
+        ```
+
+        @method has
+        @param {String} attribute
+        @return {Boolean} true if there some errors on given attribute
+      */
+      has: function(attribute) {
+        return !isEmpty(this.errorsFor(attribute));
+      }
+    });
+  });
+enifed("ember-data/system/model/model",
+  ["ember-data/system/model/states","ember-data/system/model/errors","ember-data/system/promise_proxies","ember-data/system/relationships/relationship","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+    "use strict";
+    var RootState = __dependency1__["default"];
+    var Errors = __dependency2__["default"];
+    var PromiseObject = __dependency3__.PromiseObject;
+    var createRelationshipFor = __dependency4__.createRelationshipFor;
+
+    /**
+      @module ember-data
+    */
+
+    var get = Ember.get;
+    var set = Ember.set;
+    var merge = Ember.merge;
+    var Promise = Ember.RSVP.Promise;
+    var forEach = Ember.ArrayPolyfills.forEach;
+    var map = Ember.ArrayPolyfills.map;
+
+    var JSONSerializer;
+    var retrieveFromCurrentState = Ember.computed('currentState', function(key, value) {
+      return get(get(this, 'currentState'), key);
+    }).readOnly();
+
+    var _extractPivotNameCache = Ember.create(null);
+    var _splitOnDotCache = Ember.create(null);
+
+    function splitOnDot(name) {
+      return _splitOnDotCache[name] || (
+        _splitOnDotCache[name] = name.split('.')
+      );
+    }
+
+    function extractPivotName(name) {
+      return _extractPivotNameCache[name] || (
+        _extractPivotNameCache[name] = splitOnDot(name)[0]
+      );
+    }
+
+    /**
+
+      The model class that all Ember Data records descend from.
+
+      @class Model
+      @namespace DS
+      @extends Ember.Object
+      @uses Ember.Evented
+    */
+    var Model = Ember.Object.extend(Ember.Evented, {
+      _recordArrays: undefined,
+      _relationships: undefined,
+      _loadingRecordArrays: undefined,
+      /**
+        If this property is `true` the record is in the `empty`
+        state. Empty is the first state all records enter after they have
+        been created. Most records created by the store will quickly
+        transition to the `loading` state if data needs to be fetched from
+        the server or the `created` state if the record is created on the
+        client. A record can also enter the empty state if the adapter is
+        unable to locate the record.
+
+        @property isEmpty
+        @type {Boolean}
+        @readOnly
+      */
+      isEmpty: retrieveFromCurrentState,
+      /**
+        If this property is `true` the record is in the `loading` state. A
+        record enters this state when the store asks the adapter for its
+        data. It remains in this state until the adapter provides the
+        requested data.
+
+        @property isLoading
+        @type {Boolean}
+        @readOnly
+      */
+      isLoading: retrieveFromCurrentState,
+      /**
+        If this property is `true` the record is in the `loaded` state. A
+        record enters this state when its data is populated. Most of a
+        record's lifecycle is spent inside substates of the `loaded`
+        state.
+
+        Example
+
+        ```javascript
+        var record = store.createRecord('model');
+        record.get('isLoaded'); // true
+
+        store.find('model', 1).then(function(model) {
+          model.get('isLoaded'); // true
+        });
+        ```
+
+        @property isLoaded
+        @type {Boolean}
+        @readOnly
+      */
+      isLoaded: retrieveFromCurrentState,
+      /**
+        If this property is `true` the record is in the `dirty` state. The
+        record has local changes that have not yet been saved by the
+        adapter. This includes records that have been created (but not yet
+        saved) or deleted.
+
+        Example
+
+        ```javascript
+        var record = store.createRecord('model');
+        record.get('isDirty'); // true
+
+        store.find('model', 1).then(function(model) {
+          model.get('isDirty'); // false
+          model.set('foo', 'some value');
+          model.get('isDirty'); // true
+        });
+        ```
+
+        @property isDirty
+        @type {Boolean}
+        @readOnly
+      */
+      isDirty: retrieveFromCurrentState,
+      /**
+        If this property is `true` the record is in the `saving` state. A
+        record enters the saving state when `save` is called, but the
+        adapter has not yet acknowledged that the changes have been
+        persisted to the backend.
+
+        Example
+
+        ```javascript
+        var record = store.createRecord('model');
+        record.get('isSaving'); // false
+        var promise = record.save();
+        record.get('isSaving'); // true
+        promise.then(function() {
+          record.get('isSaving'); // false
+        });
+        ```
+
+        @property isSaving
+        @type {Boolean}
+        @readOnly
+      */
+      isSaving: retrieveFromCurrentState,
+      /**
+        If this property is `true` the record is in the `deleted` state
+        and has been marked for deletion. When `isDeleted` is true and
+        `isDirty` is true, the record is deleted locally but the deletion
+        was not yet persisted. When `isSaving` is true, the change is
+        in-flight. When both `isDirty` and `isSaving` are false, the
+        change has persisted.
+
+        Example
+
+        ```javascript
+        var record = store.createRecord('model');
+        record.get('isDeleted');    // false
+        record.deleteRecord();
+
+        // Locally deleted
+        record.get('isDeleted');    // true
+        record.get('isDirty');      // true
+        record.get('isSaving');     // false
+
+        // Persisting the deletion
+        var promise = record.save();
+        record.get('isDeleted');    // true
+        record.get('isSaving');     // true
+
+        // Deletion Persisted
+        promise.then(function() {
+          record.get('isDeleted');  // true
+          record.get('isSaving');   // false
+          record.get('isDirty');    // false
+        });
+        ```
+
+        @property isDeleted
+        @type {Boolean}
+        @readOnly
+      */
+      isDeleted: retrieveFromCurrentState,
+      /**
+        If this property is `true` the record is in the `new` state. A
+        record will be in the `new` state when it has been created on the
+        client and the adapter has not yet report that it was successfully
+        saved.
+
+        Example
+
+        ```javascript
+        var record = store.createRecord('model');
+        record.get('isNew'); // true
+
+        record.save().then(function(model) {
+          model.get('isNew'); // false
+        });
+        ```
+
+        @property isNew
+        @type {Boolean}
+        @readOnly
+      */
+      isNew: retrieveFromCurrentState,
+      /**
+        If this property is `true` the record is in the `valid` state.
+
+        A record will be in the `valid` state when the adapter did not report any
+        server-side validation failures.
+
+        @property isValid
+        @type {Boolean}
+        @readOnly
+      */
+      isValid: retrieveFromCurrentState,
+      /**
+        If the record is in the dirty state this property will report what
+        kind of change has caused it to move into the dirty
+        state. Possible values are:
+
+        - `created` The record has been created by the client and not yet saved to the adapter.
+        - `updated` The record has been updated by the client and not yet saved to the adapter.
+        - `deleted` The record has been deleted by the client and not yet saved to the adapter.
+
+        Example
+
+        ```javascript
+        var record = store.createRecord('model');
+        record.get('dirtyType'); // 'created'
+        ```
+
+        @property dirtyType
+        @type {String}
+        @readOnly
+      */
+      dirtyType: retrieveFromCurrentState,
+
+      /**
+        If `true` the adapter reported that it was unable to save local
+        changes to the backend for any reason other than a server-side
+        validation error.
+
+        Example
+
+        ```javascript
+        record.get('isError'); // false
+        record.set('foo', 'valid value');
+        record.save().then(null, function() {
+          record.get('isError'); // true
+        });
+        ```
+
+        @property isError
+        @type {Boolean}
+        @readOnly
+      */
+      isError: false,
+      /**
+        If `true` the store is attempting to reload the record form the adapter.
+
+        Example
+
+        ```javascript
+        record.get('isReloading'); // false
+        record.reload();
+        record.get('isReloading'); // true
+        ```
+
+        @property isReloading
+        @type {Boolean}
+        @readOnly
+      */
+      isReloading: false,
+
+      /**
+        The `clientId` property is a transient numerical identifier
+        generated at runtime by the data store. It is important
+        primarily because newly created objects may not yet have an
+        externally generated id.
+
+        @property clientId
+        @private
+        @type {Number|String}
+      */
+      clientId: null,
+      /**
+        All ember models have an id property. This is an identifier
+        managed by an external source. These are always coerced to be
+        strings before being used internally. Note when declaring the
+        attributes for a model it is an error to declare an id
+        attribute.
+
+        ```javascript
+        var record = store.createRecord('model');
+        record.get('id'); // null
+
+        store.find('model', 1).then(function(model) {
+          model.get('id'); // '1'
+        });
+        ```
+
+        @property id
+        @type {String}
+      */
+      id: null,
+
+      /**
+        @property currentState
+        @private
+        @type {Object}
+      */
+      currentState: RootState.empty,
+
+      /**
+        When the record is in the `invalid` state this object will contain
+        any errors returned by the adapter. When present the errors hash
+        typically contains keys corresponding to the invalid property names
+        and values which are an array of error messages.
+
+        ```javascript
+        record.get('errors.length'); // 0
+        record.set('foo', 'invalid value');
+        record.save().then(null, function() {
+          record.get('errors').get('foo'); // ['foo should be a number.']
+        });
+        ```
+
+        @property errors
+        @type {DS.Errors}
+      */
+      errors: Ember.computed(function() {
+        var errors = Errors.create();
+
+        errors.registerHandlers(this, function() {
+          this.send('becameInvalid');
+        }, function() {
+          this.send('becameValid');
+        });
+
+        return errors;
+      }).readOnly(),
+
+      /**
+        Create a JSON representation of the record, using the serialization
+        strategy of the store's adapter.
+
+       `serialize` takes an optional hash as a parameter, currently
+        supported options are:
+
+       - `includeId`: `true` if the record's ID should be included in the
+          JSON representation.
+
+        @method serialize
+        @param {Object} options
+        @return {Object} an object whose values are primitive JSON values only
+      */
+      serialize: function(options) {
+        var store = get(this, 'store');
+        return store.serialize(this, options);
+      },
+
+      /**
+        Use [DS.JSONSerializer](DS.JSONSerializer.html) to
+        get the JSON representation of a record.
+
+        `toJSON` takes an optional hash as a parameter, currently
+        supported options are:
+
+        - `includeId`: `true` if the record's ID should be included in the
+          JSON representation.
+
+        @method toJSON
+        @param {Object} options
+        @return {Object} A JSON representation of the object.
+      */
+      toJSON: function(options) {
+        if (!JSONSerializer) { JSONSerializer = requireModule("ember-data/serializers/json_serializer")["default"]; }
+        // container is for lazy transform lookups
+        var serializer = JSONSerializer.create({ container: this.container });
+        return serializer.serialize(this, options);
+      },
+
+      /**
+        Fired when the record is loaded from the server.
+
+        @event didLoad
+      */
+      didLoad: Ember.K,
+
+      /**
+        Fired when the record is updated.
+
+        @event didUpdate
+      */
+      didUpdate: Ember.K,
+
+      /**
+        Fired when the record is created.
+
+        @event didCreate
+      */
+      didCreate: Ember.K,
+
+      /**
+        Fired when the record is deleted.
+
+        @event didDelete
+      */
+      didDelete: Ember.K,
+
+      /**
+        Fired when the record becomes invalid.
+
+        @event becameInvalid
+      */
+      becameInvalid: Ember.K,
+
+      /**
+        Fired when the record enters the error state.
+
+        @event becameError
+      */
+      becameError: Ember.K,
+
+      /**
+        @property data
+        @private
+        @type {Object}
+      */
+      data: Ember.computed(function() {
+        this._data = this._data || {};
+        return this._data;
+      }).readOnly(),
+
+      _data: null,
+
+      init: function() {
+        this._super();
+        this._setup();
+      },
+
+      _setup: function() {
+        this._changesToSync = {};
+        this._deferredTriggers = [];
+        this._data = {};
+        this._attributes = {};
+        this._inFlightAttributes = {};
+        this._relationships = {};
+        /*
+          implicit relationships are relationship which have not been declared but the inverse side exists on
+          another record somewhere
+          For example if there was
+          ```
+            App.Comment = DS.Model.extend({
+              name: DS.attr()
+            })
+          ```
+          but there is also
+          ```
+            App.Post = DS.Model.extend({
+              name: DS.attr(),
+              comments: DS.hasMany('comment')
+            })
+          ```
+
+          would have a implicit post relationship in order to be do things like remove ourselves from the post
+          when we are deleted
+        */
+        this._implicitRelationships = Ember.create(null);
+        var model = this;
+        //TODO Move into a getter for better perf
+        this.constructor.eachRelationship(function(key, descriptor) {
+            model._relationships[key] = createRelationshipFor(model, descriptor, model.store);
+        });
+
+      },
+
+      /**
+        @method send
+        @private
+        @param {String} name
+        @param {Object} context
+      */
+      send: function(name, context) {
+        var currentState = get(this, 'currentState');
+
+        if (!currentState[name]) {
+          this._unhandledEvent(currentState, name, context);
+        }
+
+        return currentState[name](this, context);
+      },
+
+      /**
+        @method transitionTo
+        @private
+        @param {String} name
+      */
+      transitionTo: function(name) {
+        // POSSIBLE TODO: Remove this code and replace with
+        // always having direct references to state objects
+
+        var pivotName = extractPivotName(name);
+        var currentState = get(this, 'currentState');
+        var state = currentState;
+
+        do {
+          if (state.exit) { state.exit(this); }
+          state = state.parentState;
+        } while (!state.hasOwnProperty(pivotName));
+
+        var path = splitOnDot(name);
+        var setups = [], enters = [], i, l;
+
+        for (i=0, l=path.length; i<l; i++) {
+          state = state[path[i]];
+
+          if (state.enter) { enters.push(state); }
+          if (state.setup) { setups.push(state); }
+        }
+
+        for (i=0, l=enters.length; i<l; i++) {
+          enters[i].enter(this);
+        }
+
+        set(this, 'currentState', state);
+
+        for (i=0, l=setups.length; i<l; i++) {
+          setups[i].setup(this);
+        }
+
+        this.updateRecordArraysLater();
+      },
+
+      _unhandledEvent: function(state, name, context) {
+        var errorMessage = "Attempted to handle event `" + name + "` ";
+        errorMessage    += "on " + String(this) + " while in state ";
+        errorMessage    += state.stateName + ". ";
+
+        if (context !== undefined) {
+          errorMessage  += "Called with " + Ember.inspect(context) + ".";
+        }
+
+        throw new Ember.Error(errorMessage);
+      },
+
+      withTransaction: function(fn) {
+        var transaction = get(this, 'transaction');
+        if (transaction) { fn(transaction); }
+      },
+
+      /**
+        @method loadingData
+        @private
+        @param {Promise} promise
+      */
+      loadingData: function(promise) {
+        this.send('loadingData', promise);
+      },
+
+      /**
+        @method loadedData
+        @private
+      */
+      loadedData: function() {
+        this.send('loadedData');
+      },
+
+      /**
+        @method notFound
+        @private
+      */
+      notFound: function() {
+        this.send('notFound');
+      },
+
+      /**
+        @method pushedData
+        @private
+      */
+      pushedData: function() {
+        this.send('pushedData');
+      },
+
+      /**
+        Marks the record as deleted but does not save it. You must call
+        `save` afterwards if you want to persist it. You might use this
+        method if you want to allow the user to still `rollback()` a
+        delete after it was made.
+
+        Example
+
+        ```javascript
+        App.ModelDeleteRoute = Ember.Route.extend({
+          actions: {
+            softDelete: function() {
+              this.controller.get('model').deleteRecord();
+            },
+            confirm: function() {
+              this.controller.get('model').save();
+            },
+            undo: function() {
+              this.controller.get('model').rollback();
+            }
+          }
+        });
+        ```
+
+        @method deleteRecord
+      */
+      deleteRecord: function() {
+        this.send('deleteRecord');
+      },
+
+      /**
+        Same as `deleteRecord`, but saves the record immediately.
+
+        Example
+
+        ```javascript
+        App.ModelDeleteRoute = Ember.Route.extend({
+          actions: {
+            delete: function() {
+              var controller = this.controller;
+              controller.get('model').destroyRecord().then(function() {
+                controller.transitionToRoute('model.index');
+              });
+            }
+          }
+        });
+        ```
+
+        @method destroyRecord
+        @return {Promise} a promise that will be resolved when the adapter returns
+        successfully or rejected if the adapter returns with an error.
+      */
+      destroyRecord: function() {
+        this.deleteRecord();
+        return this.save();
+      },
+
+      /**
+        @method unloadRecord
+        @private
+      */
+      unloadRecord: function() {
+        if (this.isDestroyed) { return; }
+
+        this.send('unloadRecord');
+      },
+
+      /**
+        @method clearRelationships
+        @private
+      */
+      clearRelationships: function() {
+        this.eachRelationship(function(name, relationship) {
+          var rel = this._relationships[name];
+          if (rel){
+            //TODO(Igor) figure out whether we want to clear or disconnect
+            rel.clear();
+            rel.destroy();
+          }
+        }, this);
+      },
+
+      disconnectRelationships: function() {
+        this.eachRelationship(function(name, relationship) {
+          this._relationships[name].disconnect();
+        }, this);
+        var model = this;
+        forEach.call(Ember.keys(this._implicitRelationships), function(key) {
+          model._implicitRelationships[key].disconnect();
+        });
+      },
+
+      reconnectRelationships: function() {
+        this.eachRelationship(function(name, relationship) {
+          this._relationships[name].reconnect();
+        }, this);
+        var model = this;
+        forEach.call(Ember.keys(this._implicitRelationships), function(key) {
+          model._implicitRelationships[key].reconnect();
+        });
+      },
+
+
+      /**
+        @method updateRecordArrays
+        @private
+      */
+      updateRecordArrays: function() {
+        this._updatingRecordArraysLater = false;
+        get(this, 'store').dataWasUpdated(this.constructor, this);
+      },
+
+      /**
+        When a find request is triggered on the store, the user can optionally pass in
+        attributes and relationships to be preloaded. These are meant to behave as if they
+        came back from the server, except the user obtained them out of band and is informing
+        the store of their existence. The most common use case is for supporting client side
+        nested URLs, such as `/posts/1/comments/2` so the user can do
+        `store.find('comment', 2, {post:1})` without having to fetch the post.
+
+        Preloaded data can be attributes and relationships passed in either as IDs or as actual
+        models.
+
+        @method _preloadData
+        @private
+        @param {Object} preload
+      */
+      _preloadData: function(preload) {
+        var record = this;
+        //TODO(Igor) consider the polymorphic case
+        forEach.call(Ember.keys(preload), function(key) {
+          var preloadValue = get(preload, key);
+          var relationshipMeta = record.constructor.metaForProperty(key);
+          if (relationshipMeta.isRelationship) {
+            record._preloadRelationship(key, preloadValue);
+          } else {
+            get(record, '_data')[key] = preloadValue;
+          }
+        });
+      },
+
+      _preloadRelationship: function(key, preloadValue) {
+        var relationshipMeta = this.constructor.metaForProperty(key);
+        var type = relationshipMeta.type;
+        if (relationshipMeta.kind === 'hasMany'){
+          this._preloadHasMany(key, preloadValue, type);
+        } else {
+          this._preloadBelongsTo(key, preloadValue, type);
+        }
+      },
+
+      _preloadHasMany: function(key, preloadValue, type) {
+        Ember.assert("You need to pass in an array to set a hasMany property on a record", Ember.isArray(preloadValue));
+        var record = this;
+
+        var recordsToSet = map.call(preloadValue, function(recordToPush) {
+          return record._convertStringOrNumberIntoRecord(recordToPush, type);
+        });
+        //We use the pathway of setting the hasMany as if it came from the adapter
+        //because the user told us that they know this relationships exists already
+        this._relationships[key].updateRecordsFromAdapter(recordsToSet);
+      },
+
+      _preloadBelongsTo: function(key, preloadValue, type){
+        var recordToSet = this._convertStringOrNumberIntoRecord(preloadValue, type);
+
+        //We use the pathway of setting the hasMany as if it came from the adapter
+        //because the user told us that they know this relationships exists already
+        this._relationships[key].setRecord(recordToSet);
+      },
+
+      _convertStringOrNumberIntoRecord: function(value, type) {
+        if (Ember.typeOf(value) === 'string' || Ember.typeOf(value) === 'number'){
+          return this.store.recordForId(type, value);
+        }
+        return value;
+      },
+
+      /**
+        @method _notifyProperties
+        @private
+      */
+      _notifyProperties: function(keys) {
+        Ember.beginPropertyChanges();
+        var key;
+        for (var i = 0, length = keys.length; i < length; i++){
+          key = keys[i];
+          this.notifyPropertyChange(key);
+        }
+        Ember.endPropertyChanges();
+      },
+
+      /**
+        Returns an object, whose keys are changed properties, and value is
+        an [oldProp, newProp] array.
+
+        Example
+
+        ```javascript
+        App.Mascot = DS.Model.extend({
+          name: attr('string')
+        });
+
+        var person = store.createRecord('person');
+        person.changedAttributes(); // {}
+        person.set('name', 'Tomster');
+        person.changedAttributes(); // {name: [undefined, 'Tomster']}
+        ```
+
+        @method changedAttributes
+        @return {Object} an object, whose keys are changed properties,
+          and value is an [oldProp, newProp] array.
+      */
+      changedAttributes: function() {
+        var oldData = get(this, '_data');
+        var newData = get(this, '_attributes');
+        var diffData = {};
+        var prop;
+
+        for (prop in newData) {
+          diffData[prop] = [oldData[prop], newData[prop]];
+        }
+
+        return diffData;
+      },
+
+      /**
+        @method adapterWillCommit
+        @private
+      */
+      adapterWillCommit: function() {
+        this.send('willCommit');
+      },
+
+      /**
+        If the adapter did not return a hash in response to a commit,
+        merge the changed attributes and relationships into the existing
+        saved data.
+
+        @method adapterDidCommit
+      */
+      adapterDidCommit: function(data) {
+        set(this, 'isError', false);
+
+        if (data) {
+          this._data = data;
+        } else {
+          Ember.mixin(this._data, this._inFlightAttributes);
+        }
+
+        this._inFlightAttributes = {};
+
+        this.send('didCommit');
+        this.updateRecordArraysLater();
+
+        if (!data) { return; }
+
+        this._notifyProperties(Ember.keys(data));
+      },
+
+      /**
+        @method adapterDidDirty
+        @private
+      */
+      adapterDidDirty: function() {
+        this.send('becomeDirty');
+        this.updateRecordArraysLater();
+      },
+
+
+      /**
+        @method updateRecordArraysLater
+        @private
+      */
+      updateRecordArraysLater: function() {
+        // quick hack (something like this could be pushed into run.once
+        if (this._updatingRecordArraysLater) { return; }
+        this._updatingRecordArraysLater = true;
+
+        Ember.run.schedule('actions', this, this.updateRecordArrays);
+      },
+
+      /**
+        @method setupData
+        @private
+        @param {Object} data
+        @param {Boolean} partial the data should be merged into
+          the existing data, not replace it.
+      */
+      setupData: function(data, partial) {
+        Ember.assert("Expected an object as `data` in `setupData`", Ember.typeOf(data) === 'object');
+
+        if (partial) {
+          Ember.merge(this._data, data);
+        } else {
+          this._data = data;
+        }
+
+        this.pushedData();
+
+        this._notifyProperties(Ember.keys(data));
+      },
+
+      materializeId: function(id) {
+        set(this, 'id', id);
+      },
+
+      materializeAttributes: function(attributes) {
+        Ember.assert("Must pass a hash of attributes to materializeAttributes", !!attributes);
+        merge(this._data, attributes);
+      },
+
+      materializeAttribute: function(name, value) {
+        this._data[name] = value;
+      },
+
+      /**
+        If the model `isDirty` this function will discard any unsaved
+        changes
+
+        Example
+
+        ```javascript
+        record.get('name'); // 'Untitled Document'
+        record.set('name', 'Doc 1');
+        record.get('name'); // 'Doc 1'
+        record.rollback();
+        record.get('name'); // 'Untitled Document'
+        ```
+
+        @method rollback
+      */
+      rollback: function() {
+        this._attributes = {};
+
+        if (get(this, 'isError')) {
+          this._inFlightAttributes = {};
+          set(this, 'isError', false);
+        }
+
+        //Eventually rollback will always work for relationships
+        //For now we support it only out of deleted state, because we
+        //have an explicit way of knowing when the server acked the relationship change
+        if (get(this, 'isDeleted')) {
+          this.reconnectRelationships();
+        }
+
+        if (get(this, 'isNew')) {
+          this.clearRelationships();
+        }
+
+        if (!get(this, 'isValid')) {
+          this._inFlightAttributes = {};
+        }
+
+        this.send('rolledBack');
+
+        this._notifyProperties(Ember.keys(this._data));
+
+      },
+
+      toStringExtension: function() {
+        return get(this, 'id');
+      },
+
+      /**
+        Save the record and persist any changes to the record to an
+        external source via the adapter.
+
+        Example
+
+        ```javascript
+        record.set('name', 'Tomster');
+        record.save().then(function(){
+          // Success callback
+        }, function() {
+          // Error callback
+        });
+        ```
+        @method save
+        @return {Promise} a promise that will be resolved when the adapter returns
+        successfully or rejected if the adapter returns with an error.
+      */
+      save: function() {
+        var promiseLabel = "DS: Model#save " + this;
+        var resolver = Ember.RSVP.defer(promiseLabel);
+
+        this.get('store').scheduleSave(this, resolver);
+        this._inFlightAttributes = this._attributes;
+        this._attributes = {};
+
+        return PromiseObject.create({
+          promise: resolver.promise
+        });
+      },
+
+      /**
+        Reload the record from the adapter.
+
+        This will only work if the record has already finished loading
+        and has not yet been modified (`isLoaded` but not `isDirty`,
+        or `isSaving`).
+
+        Example
+
+        ```javascript
+        App.ModelViewRoute = Ember.Route.extend({
+          actions: {
+            reload: function() {
+              this.controller.get('model').reload().then(function(model) {
+                // do something with the reloaded model
+              });
+            }
+          }
+        });
+        ```
+
+        @method reload
+        @return {Promise} a promise that will be resolved with the record when the
+        adapter returns successfully or rejected if the adapter returns
+        with an error.
+      */
+      reload: function() {
+        set(this, 'isReloading', true);
+
+        var record = this;
+        var promiseLabel = "DS: Model#reload of " + this;
+        var promise = new Promise(function(resolve){
+           record.send('reloadRecord', resolve);
+        }, promiseLabel).then(function() {
+          record.set('isReloading', false);
+          record.set('isError', false);
+          return record;
+        }, function(reason) {
+          record.set('isError', true);
+          throw reason;
+        }, "DS: Model#reload complete, update flags")['finally'](function () {
+          record.updateRecordArrays();
+        });
+
+        return PromiseObject.create({
+          promise: promise
+        });
+      },
+
+      // FOR USE DURING COMMIT PROCESS
+
+      adapterDidUpdateAttribute: function(attributeName, value) {
+
+        // If a value is passed in, update the internal attributes and clear
+        // the attribute cache so it picks up the new value. Otherwise,
+        // collapse the current value into the internal attributes because
+        // the adapter has acknowledged it.
+        if (value !== undefined) {
+          this._data[attributeName] = value;
+          this.notifyPropertyChange(attributeName);
+        } else {
+          this._data[attributeName] = this._inFlightAttributes[attributeName];
+        }
+
+        this.updateRecordArraysLater();
+      },
+
+      /**
+        @method adapterDidInvalidate
+        @private
+      */
+      adapterDidInvalidate: function(errors) {
+        var recordErrors = get(this, 'errors');
+        function addError(name) {
+          if (errors[name]) {
+            recordErrors.add(name, errors[name]);
+          }
+        }
+
+        this.eachAttribute(addError);
+        this.eachRelationship(addError);
+      },
+
+      /**
+        @method adapterDidError
+        @private
+      */
+      adapterDidError: function() {
+        this.send('becameError');
+        set(this, 'isError', true);
+      },
+
+      /**
+        Override the default event firing from Ember.Evented to
+        also call methods with the given name.
+
+        @method trigger
+        @private
+        @param {String} name
+      */
+      trigger: function() {
+        var length = arguments.length;
+        var args = new Array(length - 1);
+        var name = arguments[0];
+
+        for (var i = 1; i < length; i++ ){
+          args[i - 1] = arguments[i];
+        }
+
+        Ember.tryInvoke(this, name, args);
+        this._super.apply(this, arguments);
+      },
+
+      triggerLater: function() {
+        var length = arguments.length;
+        var args = new Array(length);
+
+        for (var i = 0; i < length; i++ ){
+          args[i] = arguments[i];
+        }
+
+        if (this._deferredTriggers.push(args) !== 1) {
+          return;
+        }
+        Ember.run.schedule('actions', this, '_triggerDeferredTriggers');
+      },
+
+      _triggerDeferredTriggers: function() {
+        for (var i=0, l= this._deferredTriggers.length; i<l; i++) {
+          this.trigger.apply(this, this._deferredTriggers[i]);
+        }
+
+        this._deferredTriggers.length = 0;
+      },
+
+      willDestroy: function() {
+        this._super();
+        this.clearRelationships();
+      },
+
+      // This is a temporary solution until we refactor DS.Model to not
+      // rely on the data property.
+      willMergeMixin: function(props) {
+        Ember.assert('`data` is a reserved property name on DS.Model objects. Please choose a different property name for ' + this.constructor.toString(), !props.data);
+      }
+    });
+
+    Model.reopenClass({
+      /**
+        Alias DS.Model's `create` method to `_create`. This allows us to create DS.Model
+        instances from within the store, but if end users accidentally call `create()`
+        (instead of `createRecord()`), we can raise an error.
+
+        @method _create
+        @private
+        @static
+      */
+      _create: Model.create,
+
+      /**
+        Override the class' `create()` method to raise an error. This
+        prevents end users from inadvertently calling `create()` instead
+        of `createRecord()`. The store is still able to create instances
+        by calling the `_create()` method. To create an instance of a
+        `DS.Model` use [store.createRecord](DS.Store.html#method_createRecord).
+
+        @method create
+        @private
+        @static
+      */
+      create: function() {
+        throw new Ember.Error("You should not call `create` on a model. Instead, call `store.createRecord` with the attributes you would like to set.");
+      }
+    });
+
+    __exports__["default"] = Model;
+  });
+enifed("ember-data/system/model/states",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    var get = Ember.get;
+    var set = Ember.set;
+    /*
+      This file encapsulates the various states that a record can transition
+      through during its lifecycle.
+    */
+    /**
+      ### State
+
+      Each record has a `currentState` property that explicitly tracks what
+      state a record is in at any given time. For instance, if a record is
+      newly created and has not yet been sent to the adapter to be saved,
+      it would be in the `root.loaded.created.uncommitted` state.  If a
+      record has had local modifications made to it that are in the
+      process of being saved, the record would be in the
+      `root.loaded.updated.inFlight` state. (This state paths will be
+      explained in more detail below.)
+
+      Events are sent by the record or its store to the record's
+      `currentState` property. How the state reacts to these events is
+      dependent on which state it is in. In some states, certain events
+      will be invalid and will cause an exception to be raised.
+
+      States are hierarchical and every state is a substate of the
+      `RootState`. For example, a record can be in the
+      `root.deleted.uncommitted` state, then transition into the
+      `root.deleted.inFlight` state. If a child state does not implement
+      an event handler, the state manager will attempt to invoke the event
+      on all parent states until the root state is reached. The state
+      hierarchy of a record is described in terms of a path string. You
+      can determine a record's current state by getting the state's
+      `stateName` property:
+
+      ```javascript
+      record.get('currentState.stateName');
+      //=> "root.created.uncommitted"
+       ```
+
+      The hierarchy of valid states that ship with ember data looks like
+      this:
+
+      ```text
+      * root
+        * deleted
+          * saved
+          * uncommitted
+          * inFlight
+        * empty
+        * loaded
+          * created
+            * uncommitted
+            * inFlight
+          * saved
+          * updated
+            * uncommitted
+            * inFlight
+        * loading
+      ```
+
+      The `DS.Model` states are themselves stateless. What that means is
+      that, the hierarchical states that each of *those* points to is a
+      shared data structure. For performance reasons, instead of each
+      record getting its own copy of the hierarchy of states, each record
+      points to this global, immutable shared instance. How does a state
+      know which record it should be acting on? We pass the record
+      instance into the state's event handlers as the first argument.
+
+      The record passed as the first parameter is where you should stash
+      state about the record if needed; you should never store data on the state
+      object itself.
+
+      ### Events and Flags
+
+      A state may implement zero or more events and flags.
+
+      #### Events
+
+      Events are named functions that are invoked when sent to a record. The
+      record will first look for a method with the given name on the
+      current state. If no method is found, it will search the current
+      state's parent, and then its grandparent, and so on until reaching
+      the top of the hierarchy. If the root is reached without an event
+      handler being found, an exception will be raised. This can be very
+      helpful when debugging new features.
+
+      Here's an example implementation of a state with a `myEvent` event handler:
+
+      ```javascript
+      aState: DS.State.create({
+        myEvent: function(manager, param) {
+          console.log("Received myEvent with", param);
+        }
+      })
+      ```
+
+      To trigger this event:
+
+      ```javascript
+      record.send('myEvent', 'foo');
+      //=> "Received myEvent with foo"
+      ```
+
+      Note that an optional parameter can be sent to a record's `send()` method,
+      which will be passed as the second parameter to the event handler.
+
+      Events should transition to a different state if appropriate. This can be
+      done by calling the record's `transitionTo()` method with a path to the
+      desired state. The state manager will attempt to resolve the state path
+      relative to the current state. If no state is found at that path, it will
+      attempt to resolve it relative to the current state's parent, and then its
+      parent, and so on until the root is reached. For example, imagine a hierarchy
+      like this:
+
+          * created
+            * uncommitted <-- currentState
+            * inFlight
+          * updated
+            * inFlight
+
+      If we are currently in the `uncommitted` state, calling
+      `transitionTo('inFlight')` would transition to the `created.inFlight` state,
+      while calling `transitionTo('updated.inFlight')` would transition to
+      the `updated.inFlight` state.
+
+      Remember that *only events* should ever cause a state transition. You should
+      never call `transitionTo()` from outside a state's event handler. If you are
+      tempted to do so, create a new event and send that to the state manager.
+
+      #### Flags
+
+      Flags are Boolean values that can be used to introspect a record's current
+      state in a more user-friendly way than examining its state path. For example,
+      instead of doing this:
+
+      ```javascript
+      var statePath = record.get('stateManager.currentPath');
+      if (statePath === 'created.inFlight') {
+        doSomething();
+      }
+      ```
+
+      You can say:
+
+      ```javascript
+      if (record.get('isNew') && record.get('isSaving')) {
+        doSomething();
+      }
+      ```
+
+      If your state does not set a value for a given flag, the value will
+      be inherited from its parent (or the first place in the state hierarchy
+      where it is defined).
+
+      The current set of flags are defined below. If you want to add a new flag,
+      in addition to the area below, you will also need to declare it in the
+      `DS.Model` class.
+
+
+       * [isEmpty](DS.Model.html#property_isEmpty)
+       * [isLoading](DS.Model.html#property_isLoading)
+       * [isLoaded](DS.Model.html#property_isLoaded)
+       * [isDirty](DS.Model.html#property_isDirty)
+       * [isSaving](DS.Model.html#property_isSaving)
+       * [isDeleted](DS.Model.html#property_isDeleted)
+       * [isNew](DS.Model.html#property_isNew)
+       * [isValid](DS.Model.html#property_isValid)
+
+      @namespace DS
+      @class RootState
+    */
+
+    function didSetProperty(record, context) {
+      if (context.value === context.originalValue) {
+        delete record._attributes[context.name];
+        record.send('propertyWasReset', context.name);
+      } else if (context.value !== context.oldValue) {
+        record.send('becomeDirty');
+      }
+
+      record.updateRecordArraysLater();
+    }
+
+    // Implementation notes:
+    //
+    // Each state has a boolean value for all of the following flags:
+    //
+    // * isLoaded: The record has a populated `data` property. When a
+    //   record is loaded via `store.find`, `isLoaded` is false
+    //   until the adapter sets it. When a record is created locally,
+    //   its `isLoaded` property is always true.
+    // * isDirty: The record has local changes that have not yet been
+    //   saved by the adapter. This includes records that have been
+    //   created (but not yet saved) or deleted.
+    // * isSaving: The record has been committed, but
+    //   the adapter has not yet acknowledged that the changes have
+    //   been persisted to the backend.
+    // * isDeleted: The record was marked for deletion. When `isDeleted`
+    //   is true and `isDirty` is true, the record is deleted locally
+    //   but the deletion was not yet persisted. When `isSaving` is
+    //   true, the change is in-flight. When both `isDirty` and
+    //   `isSaving` are false, the change has persisted.
+    // * isError: The adapter reported that it was unable to save
+    //   local changes to the backend. This may also result in the
+    //   record having its `isValid` property become false if the
+    //   adapter reported that server-side validations failed.
+    // * isNew: The record was created on the client and the adapter
+    //   did not yet report that it was successfully saved.
+    // * isValid: The adapter did not report any server-side validation
+    //   failures.
+
+    // The dirty state is a abstract state whose functionality is
+    // shared between the `created` and `updated` states.
+    //
+    // The deleted state shares the `isDirty` flag with the
+    // subclasses of `DirtyState`, but with a very different
+    // implementation.
+    //
+    // Dirty states have three child states:
+    //
+    // `uncommitted`: the store has not yet handed off the record
+    //   to be saved.
+    // `inFlight`: the store has handed off the record to be saved,
+    //   but the adapter has not yet acknowledged success.
+    // `invalid`: the record has invalid information and cannot be
+    //   send to the adapter yet.
+    var DirtyState = {
+      initialState: 'uncommitted',
+
+      // FLAGS
+      isDirty: true,
+
+      // SUBSTATES
+
+      // When a record first becomes dirty, it is `uncommitted`.
+      // This means that there are local pending changes, but they
+      // have not yet begun to be saved, and are not invalid.
+      uncommitted: {
+        // EVENTS
+        didSetProperty: didSetProperty,
+
+        //TODO(Igor) reloading now triggers a
+        //loadingData event, though it seems fine?
+        loadingData: Ember.K,
+
+        propertyWasReset: function(record, name) {
+          var length = Ember.keys(record._attributes);
+          var stillDirty = length > 0;
+
+          if (!stillDirty) { record.send('rolledBack'); }
+        },
+
+        pushedData: Ember.K,
+
+        becomeDirty: Ember.K,
+
+        willCommit: function(record) {
+          record.transitionTo('inFlight');
+        },
+
+        reloadRecord: function(record, resolve) {
+          resolve(get(record, 'store').reloadRecord(record));
+        },
+
+        rolledBack: function(record) {
+          record.transitionTo('loaded.saved');
+        },
+
+        becameInvalid: function(record) {
+          record.transitionTo('invalid');
+        },
+
+        rollback: function(record) {
+          record.rollback();
+        }
+      },
+
+      // Once a record has been handed off to the adapter to be
+      // saved, it is in the 'in flight' state. Changes to the
+      // record cannot be made during this window.
+      inFlight: {
+        // FLAGS
+        isSaving: true,
+
+        // EVENTS
+        didSetProperty: didSetProperty,
+        becomeDirty: Ember.K,
+        pushedData: Ember.K,
+
+        unloadRecord: function(record) {
+          Ember.assert("You can only unload a record which is not inFlight. `" + Ember.inspect(record) + " `", false);
+        },
+
+        // TODO: More robust semantics around save-while-in-flight
+        willCommit: Ember.K,
+
+        didCommit: function(record) {
+          var dirtyType = get(this, 'dirtyType');
+
+          record.transitionTo('saved');
+          record.send('invokeLifecycleCallbacks', dirtyType);
+        },
+
+        becameInvalid: function(record) {
+          record.transitionTo('invalid');
+          record.send('invokeLifecycleCallbacks');
+        },
+
+        becameError: function(record) {
+          record.transitionTo('uncommitted');
+          record.triggerLater('becameError', record);
+        }
+      },
+
+      // A record is in the `invalid` if the adapter has indicated
+      // the the record failed server-side invalidations.
+      invalid: {
+        // FLAGS
+        isValid: false,
+
+        // EVENTS
+        deleteRecord: function(record) {
+          record.transitionTo('deleted.uncommitted');
+          record.disconnectRelationships();
+        },
+
+        didSetProperty: function(record, context) {
+          get(record, 'errors').remove(context.name);
+
+          didSetProperty(record, context);
+        },
+
+        becomeDirty: Ember.K,
+
+        willCommit: function(record) {
+          get(record, 'errors').clear();
+          record.transitionTo('inFlight');
+        },
+
+        rolledBack: function(record) {
+          get(record, 'errors').clear();
+        },
+
+        becameValid: function(record) {
+          record.transitionTo('uncommitted');
+        },
+
+        invokeLifecycleCallbacks: function(record) {
+          record.triggerLater('becameInvalid', record);
+        },
+
+        exit: function(record) {
+          record._inFlightAttributes = {};
+        }
+      }
+    };
+
+    // The created and updated states are created outside the state
+    // chart so we can reopen their substates and add mixins as
+    // necessary.
+
+    function deepClone(object) {
+      var clone = {}, value;
+
+      for (var prop in object) {
+        value = object[prop];
+        if (value && typeof value === 'object') {
+          clone[prop] = deepClone(value);
+        } else {
+          clone[prop] = value;
+        }
+      }
+
+      return clone;
+    }
+
+    function mixin(original, hash) {
+      for (var prop in hash) {
+        original[prop] = hash[prop];
+      }
+
+      return original;
+    }
+
+    function dirtyState(options) {
+      var newState = deepClone(DirtyState);
+      return mixin(newState, options);
+    }
+
+    var createdState = dirtyState({
+      dirtyType: 'created',
+      // FLAGS
+      isNew: true
+    });
+
+    createdState.uncommitted.rolledBack = function(record) {
+      record.transitionTo('deleted.saved');
+    };
+
+    var updatedState = dirtyState({
+      dirtyType: 'updated'
+    });
+
+    createdState.uncommitted.deleteRecord = function(record) {
+      record.disconnectRelationships();
+      record.transitionTo('deleted.saved');
+    };
+
+    createdState.uncommitted.rollback = function(record) {
+      DirtyState.uncommitted.rollback.apply(this, arguments);
+      record.transitionTo('deleted.saved');
+    };
+
+    createdState.uncommitted.propertyWasReset = Ember.K;
+
+    function assertAgainstUnloadRecord(record) {
+      Ember.assert("You can only unload a record which is not inFlight. `" + Ember.inspect(record) + "`", false);
+    }
+
+    updatedState.inFlight.unloadRecord = assertAgainstUnloadRecord;
+
+    updatedState.uncommitted.deleteRecord = function(record) {
+      record.transitionTo('deleted.uncommitted');
+      record.disconnectRelationships();
+    };
+
+    var RootState = {
+      // FLAGS
+      isEmpty: false,
+      isLoading: false,
+      isLoaded: false,
+      isDirty: false,
+      isSaving: false,
+      isDeleted: false,
+      isNew: false,
+      isValid: true,
+
+      // DEFAULT EVENTS
+
+      // Trying to roll back if you're not in the dirty state
+      // doesn't change your state. For example, if you're in the
+      // in-flight state, rolling back the record doesn't move
+      // you out of the in-flight state.
+      rolledBack: Ember.K,
+      unloadRecord: function(record) {
+        // clear relationships before moving to deleted state
+        // otherwise it fails
+        record.clearRelationships();
+        record.transitionTo('deleted.saved');
+      },
+
+
+      propertyWasReset: Ember.K,
+
+      // SUBSTATES
+
+      // A record begins its lifecycle in the `empty` state.
+      // If its data will come from the adapter, it will
+      // transition into the `loading` state. Otherwise, if
+      // the record is being created on the client, it will
+      // transition into the `created` state.
+      empty: {
+        isEmpty: true,
+
+        // EVENTS
+        loadingData: function(record, promise) {
+          record._loadingPromise = promise;
+          record.transitionTo('loading');
+        },
+
+        loadedData: function(record) {
+          record.transitionTo('loaded.created.uncommitted');
+          record.notifyPropertyChange('data');
+        },
+
+        pushedData: function(record) {
+          record.transitionTo('loaded.saved');
+          record.triggerLater('didLoad');
+        }
+      },
+
+      // A record enters this state when the store asks
+      // the adapter for its data. It remains in this state
+      // until the adapter provides the requested data.
+      //
+      // Usually, this process is asynchronous, using an
+      // XHR to retrieve the data.
+      loading: {
+        // FLAGS
+        isLoading: true,
+
+        exit: function(record) {
+          record._loadingPromise = null;
+        },
+
+        // EVENTS
+        pushedData: function(record) {
+          record.transitionTo('loaded.saved');
+          record.triggerLater('didLoad');
+          set(record, 'isError', false);
+        },
+
+        becameError: function(record) {
+          record.triggerLater('becameError', record);
+        },
+
+        notFound: function(record) {
+          record.transitionTo('empty');
+        }
+      },
+
+      // A record enters this state when its data is populated.
+      // Most of a record's lifecycle is spent inside substates
+      // of the `loaded` state.
+      loaded: {
+        initialState: 'saved',
+
+        // FLAGS
+        isLoaded: true,
+
+        //TODO(Igor) Reloading now triggers a loadingData event,
+        //but it should be ok?
+        loadingData: Ember.K,
+
+        // SUBSTATES
+
+        // If there are no local changes to a record, it remains
+        // in the `saved` state.
+        saved: {
+          setup: function(record) {
+            var attrs = record._attributes;
+            var isDirty = false;
+
+            for (var prop in attrs) {
+              if (attrs.hasOwnProperty(prop)) {
+                isDirty = true;
+                break;
+              }
+            }
+
+            if (isDirty) {
+              record.adapterDidDirty();
+            }
+          },
+
+          // EVENTS
+          didSetProperty: didSetProperty,
+
+          pushedData: Ember.K,
+
+          becomeDirty: function(record) {
+            record.transitionTo('updated.uncommitted');
+          },
+
+          willCommit: function(record) {
+            record.transitionTo('updated.inFlight');
+          },
+
+          reloadRecord: function(record, resolve) {
+            resolve(get(record, 'store').reloadRecord(record));
+          },
+
+          deleteRecord: function(record) {
+            record.transitionTo('deleted.uncommitted');
+            record.disconnectRelationships();
+          },
+
+          unloadRecord: function(record) {
+            // clear relationships before moving to deleted state
+            // otherwise it fails
+            record.clearRelationships();
+            record.transitionTo('deleted.saved');
+          },
+
+          didCommit: function(record) {
+            record.send('invokeLifecycleCallbacks', get(record, 'lastDirtyType'));
+          },
+
+          // loaded.saved.notFound would be triggered by a failed
+          // `reload()` on an unchanged record
+          notFound: Ember.K
+
+        },
+
+        // A record is in this state after it has been locally
+        // created but before the adapter has indicated that
+        // it has been saved.
+        created: createdState,
+
+        // A record is in this state if it has already been
+        // saved to the server, but there are new local changes
+        // that have not yet been saved.
+        updated: updatedState
+      },
+
+      // A record is in this state if it was deleted from the store.
+      deleted: {
+        initialState: 'uncommitted',
+        dirtyType: 'deleted',
+
+        // FLAGS
+        isDeleted: true,
+        isLoaded: true,
+        isDirty: true,
+
+        // TRANSITIONS
+        setup: function(record) {
+          record.updateRecordArrays();
+        },
+
+        // SUBSTATES
+
+        // When a record is deleted, it enters the `start`
+        // state. It will exit this state when the record
+        // starts to commit.
+        uncommitted: {
+
+          // EVENTS
+
+          willCommit: function(record) {
+            record.transitionTo('inFlight');
+          },
+
+          rollback: function(record) {
+            record.rollback();
+          },
+
+          becomeDirty: Ember.K,
+          deleteRecord: Ember.K,
+
+          rolledBack: function(record) {
+            record.transitionTo('loaded.saved');
+          }
+        },
+
+        // After a record starts committing, but
+        // before the adapter indicates that the deletion
+        // has saved to the server, a record is in the
+        // `inFlight` substate of `deleted`.
+        inFlight: {
+          // FLAGS
+          isSaving: true,
+
+          // EVENTS
+
+          unloadRecord: assertAgainstUnloadRecord,
+
+          // TODO: More robust semantics around save-while-in-flight
+          willCommit: Ember.K,
+          didCommit: function(record) {
+            record.transitionTo('saved');
+
+            record.send('invokeLifecycleCallbacks');
+          },
+
+          becameError: function(record) {
+            record.transitionTo('uncommitted');
+            record.triggerLater('becameError', record);
+          }
+        },
+
+        // Once the adapter indicates that the deletion has
+        // been saved, the record enters the `saved` substate
+        // of `deleted`.
+        saved: {
+          // FLAGS
+          isDirty: false,
+
+          setup: function(record) {
+            var store = get(record, 'store');
+            store.dematerializeRecord(record);
+          },
+
+          invokeLifecycleCallbacks: function(record) {
+            record.triggerLater('didDelete', record);
+            record.triggerLater('didCommit', record);
+          },
+
+          willCommit: Ember.K,
+
+          didCommit: Ember.K
+        }
+      },
+
+      invokeLifecycleCallbacks: function(record, dirtyType) {
+        if (dirtyType === 'created') {
+          record.triggerLater('didCreate', record);
+        } else {
+          record.triggerLater('didUpdate', record);
+        }
+
+        record.triggerLater('didCommit', record);
+      }
+    };
+
+    function wireState(object, parent, name) {
+      /*jshint proto:true*/
+      // TODO: Use Object.create and copy instead
+      object = mixin(parent ? Ember.create(parent) : {}, object);
+      object.parentState = parent;
+      object.stateName = name;
+
+      for (var prop in object) {
+        if (!object.hasOwnProperty(prop) || prop === 'parentState' || prop === 'stateName') { continue; }
+        if (typeof object[prop] === 'object') {
+          object[prop] = wireState(object[prop], object, name + "." + prop);
+        }
+      }
+
+      return object;
+    }
+
+    RootState = wireState(RootState, null, "root");
+
+    __exports__["default"] = RootState;
+  });
+enifed("ember-data/system/promise_proxies",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var Promise = Ember.RSVP.Promise;
+    var get = Ember.get;
+
+    /**
+      A `PromiseArray` is an object that acts like both an `Ember.Array`
+      and a promise. When the promise is resolved the resulting value
+      will be set to the `PromiseArray`'s `content` property. This makes
+      it easy to create data bindings with the `PromiseArray` that will be
+      updated when the promise resolves.
+
+      For more information see the [Ember.PromiseProxyMixin
+      documentation](/api/classes/Ember.PromiseProxyMixin.html).
+
+      Example
+
+      ```javascript
+      var promiseArray = DS.PromiseArray.create({
+        promise: $.getJSON('/some/remote/data.json')
+      });
+
+      promiseArray.get('length'); // 0
+
+      promiseArray.then(function() {
+        promiseArray.get('length'); // 100
+      });
+      ```
+
+      @class PromiseArray
+      @namespace DS
+      @extends Ember.ArrayProxy
+      @uses Ember.PromiseProxyMixin
+    */
+    var PromiseArray = Ember.ArrayProxy.extend(Ember.PromiseProxyMixin);
+
+    /**
+      A `PromiseObject` is an object that acts like both an `Ember.Object`
+      and a promise. When the promise is resolved, then the resulting value
+      will be set to the `PromiseObject`'s `content` property. This makes
+      it easy to create data bindings with the `PromiseObject` that will
+      be updated when the promise resolves.
+
+      For more information see the [Ember.PromiseProxyMixin
+      documentation](/api/classes/Ember.PromiseProxyMixin.html).
+
+      Example
+
+      ```javascript
+      var promiseObject = DS.PromiseObject.create({
+        promise: $.getJSON('/some/remote/data.json')
+      });
+
+      promiseObject.get('name'); // null
+
+      promiseObject.then(function() {
+        promiseObject.get('name'); // 'Tomster'
+      });
+      ```
+
+      @class PromiseObject
+      @namespace DS
+      @extends Ember.ObjectProxy
+      @uses Ember.PromiseProxyMixin
+    */
+    var PromiseObject = Ember.ObjectProxy.extend(Ember.PromiseProxyMixin);
+
+    var promiseObject = function(promise, label) {
+      return PromiseObject.create({
+        promise: Promise.resolve(promise, label)
+      });
+    };
+
+    var promiseArray = function(promise, label) {
+      return PromiseArray.create({
+        promise: Promise.resolve(promise, label)
+      });
+    };
+
+    /**
+      A PromiseManyArray is a PromiseArray that also proxies certain method calls
+      to the underlying manyArray.
+      Right now we proxy:
+        `reload()`
+        `createRecord()`
+        `on()`
+        `one()`
+        `trigger()`
+        `off()`
+        `has()`
+    */
+
+    function proxyToContent(method) {
+      return function() {
+        var content = get(this, 'content');
+        return content[method].apply(content, arguments);
+      };
+    }
+
+    var PromiseManyArray = PromiseArray.extend({
+      reload: function() {
+        //I don't think this should ever happen right now, but worth guarding if we refactor the async relationships
+        Ember.assert('You are trying to reload an async manyArray before it has been created', get(this, 'content'));
+        return get(this, 'content').reload();
+      },
+
+      createRecord: proxyToContent('createRecord'),
+
+      on: proxyToContent('on'),
+
+      one: proxyToContent('one'),
+
+      trigger: proxyToContent('trigger'),
+
+      off: proxyToContent('off'),
+
+      has: proxyToContent('has')
+    });
+
+    var promiseManyArray = function(promise, label) {
+      return PromiseManyArray.create({
+        promise: Promise.resolve(promise, label)
+      });
+    };
+
+
+    __exports__.PromiseArray = PromiseArray;
+    __exports__.PromiseObject = PromiseObject;
+    __exports__.PromiseManyArray = PromiseManyArray;
+    __exports__.promiseArray = promiseArray;
+    __exports__.promiseObject = promiseObject;
+    __exports__.promiseManyArray = promiseManyArray;
+  });
+enifed("ember-data/system/record_array_manager",
+  ["ember-data/system/record_arrays","ember-data/system/map","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    var RecordArray = __dependency1__.RecordArray;
+    var FilteredRecordArray = __dependency1__.FilteredRecordArray;
+    var AdapterPopulatedRecordArray = __dependency1__.AdapterPopulatedRecordArray;
+    var ManyArray = __dependency1__.ManyArray;
+    var MapWithDefault = __dependency2__.MapWithDefault;
+    var OrderedSet = __dependency2__.OrderedSet;
+    var get = Ember.get;
+    var forEach = Ember.EnumerableUtils.forEach;
+    var indexOf = Ember.EnumerableUtils.indexOf;
+
+    /**
+      @class RecordArrayManager
+      @namespace DS
+      @private
+      @extends Ember.Object
+    */
+    __exports__["default"] = Ember.Object.extend({
+      init: function() {
+        this.filteredRecordArrays = MapWithDefault.create({
+          defaultValue: function() { return []; }
+        });
+
+        this.changedRecords = [];
+        this._adapterPopulatedRecordArrays = [];
+      },
+
+      recordDidChange: function(record) {
+        if (this.changedRecords.push(record) !== 1) { return; }
+
+        Ember.run.schedule('actions', this, this.updateRecordArrays);
+      },
+
+      recordArraysForRecord: function(record) {
+        record._recordArrays = record._recordArrays || OrderedSet.create();
+        return record._recordArrays;
+      },
+
+      /**
+        This method is invoked whenever data is loaded into the store by the
+        adapter or updated by the adapter, or when a record has changed.
+
+        It updates all record arrays that a record belongs to.
+
+        To avoid thrashing, it only runs at most once per run loop.
+
+        @method updateRecordArrays
+        @param {Class} type
+        @param {Number|String} clientId
+      */
+      updateRecordArrays: function() {
+        forEach(this.changedRecords, function(record) {
+          if (get(record, 'isDeleted')) {
+            this._recordWasDeleted(record);
+          } else {
+            this._recordWasChanged(record);
+          }
+        }, this);
+
+        this.changedRecords.length = 0;
+      },
+
+      _recordWasDeleted: function (record) {
+        var recordArrays = record._recordArrays;
+
+        if (!recordArrays) { return; }
+
+        recordArrays.forEach(function(array){
+          array.removeRecord(record);
+        });
+
+        record._recordArrays = null;
+      },
+
+      _recordWasChanged: function (record) {
+        var type = record.constructor;
+        var recordArrays = this.filteredRecordArrays.get(type);
+        var filter;
+
+        forEach(recordArrays, function(array) {
+          filter = get(array, 'filterFunction');
+          this.updateRecordArray(array, filter, type, record);
+        }, this);
+
+        // loop through all manyArrays containing an unloaded copy of this
+        // clientId and notify them that the record was loaded.
+        var manyArrays = record._loadingRecordArrays;
+
+        if (manyArrays) {
+          for (var i=0, l=manyArrays.length; i<l; i++) {
+            manyArrays[i].loadedRecord();
+          }
+
+          record._loadingRecordArrays = [];
+        }
+      },
+
+      /**
+        Update an individual filter.
+
+        @method updateRecordArray
+        @param {DS.FilteredRecordArray} array
+        @param {Function} filter
+        @param {Class} type
+        @param {Number|String} clientId
+      */
+      updateRecordArray: function(array, filter, type, record) {
+        var shouldBeInArray;
+
+        if (!filter) {
+          shouldBeInArray = true;
+        } else {
+          shouldBeInArray = filter(record);
+        }
+
+        var recordArrays = this.recordArraysForRecord(record);
+
+        if (shouldBeInArray) {
+          if (!recordArrays.has(array)) {
+            array.pushRecord(record);
+            recordArrays.add(array);
+          }
+        } else if (!shouldBeInArray) {
+          recordArrays["delete"](array);
+          array.removeRecord(record);
+        }
+      },
+
+      /**
+        This method is invoked if the `filterFunction` property is
+        changed on a `DS.FilteredRecordArray`.
+
+        It essentially re-runs the filter from scratch. This same
+        method is invoked when the filter is created in th first place.
+
+        @method updateFilter
+        @param {Array} array
+        @param {String} type
+        @param {Function} filter
+      */
+      updateFilter: function(array, type, filter) {
+        var typeMap = this.store.typeMapFor(type);
+        var records = typeMap.records, record;
+
+        for (var i=0, l=records.length; i<l; i++) {
+          record = records[i];
+
+          if (!get(record, 'isDeleted') && !get(record, 'isEmpty')) {
+            this.updateRecordArray(array, filter, type, record);
+          }
+        }
+      },
+
+      /**
+        Create a `DS.ManyArray` for a type and list of record references, and index
+        the `ManyArray` under each reference. This allows us to efficiently remove
+        records from `ManyArray`s when they are deleted.
+
+        @method createManyArray
+        @param {Class} type
+        @param {Array} references
+        @return {DS.ManyArray}
+      */
+      createManyArray: function(type, records) {
+        var manyArray = ManyArray.create({
+          type: type,
+          content: records,
+          store: this.store
+        });
+
+        forEach(records, function(record) {
+          var arrays = this.recordArraysForRecord(record);
+          arrays.add(manyArray);
+        }, this);
+
+        return manyArray;
+      },
+
+      /**
+        Create a `DS.RecordArray` for a type and register it for updates.
+
+        @method createRecordArray
+        @param {Class} type
+        @return {DS.RecordArray}
+      */
+      createRecordArray: function(type) {
+        var array = RecordArray.create({
+          type: type,
+          content: Ember.A(),
+          store: this.store,
+          isLoaded: true
+        });
+
+        this.registerFilteredRecordArray(array, type);
+
+        return array;
+      },
+
+      /**
+        Create a `DS.FilteredRecordArray` for a type and register it for updates.
+
+        @method createFilteredRecordArray
+        @param {Class} type
+        @param {Function} filter
+        @param {Object} query (optional
+        @return {DS.FilteredRecordArray}
+      */
+      createFilteredRecordArray: function(type, filter, query) {
+        var array = FilteredRecordArray.create({
+          query: query,
+          type: type,
+          content: Ember.A(),
+          store: this.store,
+          manager: this,
+          filterFunction: filter
+        });
+
+        this.registerFilteredRecordArray(array, type, filter);
+
+        return array;
+      },
+
+      /**
+        Create a `DS.AdapterPopulatedRecordArray` for a type with given query.
+
+        @method createAdapterPopulatedRecordArray
+        @param {Class} type
+        @param {Object} query
+        @return {DS.AdapterPopulatedRecordArray}
+      */
+      createAdapterPopulatedRecordArray: function(type, query) {
+        var array = AdapterPopulatedRecordArray.create({
+          type: type,
+          query: query,
+          content: Ember.A(),
+          store: this.store,
+          manager: this
+        });
+
+        this._adapterPopulatedRecordArrays.push(array);
+
+        return array;
+      },
+
+      /**
+        Register a RecordArray for a given type to be backed by
+        a filter function. This will cause the array to update
+        automatically when records of that type change attribute
+        values or states.
+
+        @method registerFilteredRecordArray
+        @param {DS.RecordArray} array
+        @param {Class} type
+        @param {Function} filter
+      */
+      registerFilteredRecordArray: function(array, type, filter) {
+        var recordArrays = this.filteredRecordArrays.get(type);
+        recordArrays.push(array);
+
+        this.updateFilter(array, type, filter);
+      },
+
+      /**
+        Unregister a FilteredRecordArray.
+        So manager will not update this array.
+
+        @method unregisterFilteredRecordArray
+        @param {DS.RecordArray} array
+      */
+      unregisterFilteredRecordArray: function(array) {
+        var recordArrays = this.filteredRecordArrays.get(array.type);
+        var index = indexOf(recordArrays, array);
+        recordArrays.splice(index, 1);
+      },
+
+      // Internally, we maintain a map of all unloaded IDs requested by
+      // a ManyArray. As the adapter loads data into the store, the
+      // store notifies any interested ManyArrays. When the ManyArray's
+      // total number of loading records drops to zero, it becomes
+      // `isLoaded` and fires a `didLoad` event.
+      registerWaitingRecordArray: function(record, array) {
+        var loadingRecordArrays = record._loadingRecordArrays || [];
+        loadingRecordArrays.push(array);
+        record._loadingRecordArrays = loadingRecordArrays;
+      },
+
+      willDestroy: function(){
+        this._super();
+
+        forEach(flatten(values(this.filteredRecordArrays.values)), destroy);
+        forEach(this._adapterPopulatedRecordArrays, destroy);
+      }
+    });
+
+    function values(obj) {
+      var result = [];
+      var keys = Ember.keys(obj);
+
+      for (var i = 0; i < keys.length; i++) {
+        result.push(obj[keys[i]]);
+      }
+
+      return result;
+    }
+
+    function destroy(entry) {
+      entry.destroy();
+    }
+
+    function flatten(list) {
+      var length = list.length;
+      var result = Ember.A();
+
+      for (var i = 0; i < length; i++) {
+        result = result.concat(list[i]);
+      }
+
+      return result;
+    }
+  });
+enifed("ember-data/system/record_arrays",
+  ["ember-data/system/record_arrays/record_array","ember-data/system/record_arrays/filtered_record_array","ember-data/system/record_arrays/adapter_populated_record_array","ember-data/system/record_arrays/many_array","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    var RecordArray = __dependency1__["default"];
+    var FilteredRecordArray = __dependency2__["default"];
+    var AdapterPopulatedRecordArray = __dependency3__["default"];
+    var ManyArray = __dependency4__["default"];
+
+    __exports__.RecordArray = RecordArray;
+    __exports__.FilteredRecordArray = FilteredRecordArray;
+    __exports__.AdapterPopulatedRecordArray = AdapterPopulatedRecordArray;
+    __exports__.ManyArray = ManyArray;
+  });
+enifed("ember-data/system/record_arrays/adapter_populated_record_array",
+  ["ember-data/system/record_arrays/record_array","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var RecordArray = __dependency1__["default"];
+    /**
+      @module ember-data
+    */
+
+    var get = Ember.get;
+
+    function cloneNull(source) {
+      var clone = Ember.create(null);
+      for (var key in source) {
+        clone[key] = source[key];
+      }
+      return clone;
+    }
+
+    /**
+      Represents an ordered list of records whose order and membership is
+      determined by the adapter. For example, a query sent to the adapter
+      may trigger a search on the server, whose results would be loaded
+      into an instance of the `AdapterPopulatedRecordArray`.
+
+      @class AdapterPopulatedRecordArray
+      @namespace DS
+      @extends DS.RecordArray
+    */
+    __exports__["default"] = RecordArray.extend({
+      query: null,
+
+      replace: function() {
+        var type = get(this, 'type').toString();
+        throw new Error("The result of a server query (on " + type + ") is immutable.");
+      },
+
+      /**
+        @method load
+        @private
+        @param {Array} data
+      */
+      load: function(data) {
+        var store = get(this, 'store');
+        var type = get(this, 'type');
+        var records = store.pushMany(type, data);
+        var meta = store.metadataFor(type);
+
+        this.setProperties({
+          content: Ember.A(records),
+          isLoaded: true,
+          meta: cloneNull(meta)
+        });
+
+        records.forEach(function(record) {
+          this.manager.recordArraysForRecord(record).add(this);
+        }, this);
+
+        // TODO: should triggering didLoad event be the last action of the runLoop?
+        Ember.run.once(this, 'trigger', 'didLoad');
+      }
+    });
+  });
+enifed("ember-data/system/record_arrays/filtered_record_array",
+  ["ember-data/system/record_arrays/record_array","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var RecordArray = __dependency1__["default"];
+
+    /**
+      @module ember-data
+    */
+
+    var get = Ember.get;
+
+    /**
+      Represents a list of records whose membership is determined by the
+      store. As records are created, loaded, or modified, the store
+      evaluates them to determine if they should be part of the record
+      array.
+
+      @class FilteredRecordArray
+      @namespace DS
+      @extends DS.RecordArray
+    */
+    __exports__["default"] = RecordArray.extend({
+      /**
+        The filterFunction is a function used to test records from the store to
+        determine if they should be part of the record array.
+
+        Example
+
+        ```javascript
+        var allPeople = store.all('person');
+        allPeople.mapBy('name'); // ["Tom Dale", "Yehuda Katz", "Trek Glowacki"]
+
+        var people = store.filter('person', function(person) {
+          if (person.get('name').match(/Katz$/)) { return true; }
+        });
+        people.mapBy('name'); // ["Yehuda Katz"]
+
+        var notKatzFilter = function(person) {
+          return !person.get('name').match(/Katz$/);
+        };
+        people.set('filterFunction', notKatzFilter);
+        people.mapBy('name'); // ["Tom Dale", "Trek Glowacki"]
+        ```
+
+        @method filterFunction
+        @param {DS.Model} record
+        @return {Boolean} `true` if the record should be in the array
+      */
+      filterFunction: null,
+      isLoaded: true,
+
+      replace: function() {
+        var type = get(this, 'type').toString();
+        throw new Error("The result of a client-side filter (on " + type + ") is immutable.");
+      },
+
+      /**
+        @method updateFilter
+        @private
+      */
+      _updateFilter: function() {
+        var manager = get(this, 'manager');
+        manager.updateFilter(this, get(this, 'type'), get(this, 'filterFunction'));
+      },
+
+      updateFilter: Ember.observer(function() {
+        Ember.run.once(this, this._updateFilter);
+      }, 'filterFunction'),
+
+      /**
+        @method _unregisterFromManager
+        @private
+      */
+      _unregisterFromManager: function(){
+        this.manager.unregisterFilteredRecordArray(this);
+      },
+
+      willDestroy: function(){
+        this._unregisterFromManager();
+        this._super();
+      }
+    });
+  });
+enifed("ember-data/system/record_arrays/many_array",
+  ["ember-data/system/record_arrays/record_array","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var RecordArray = __dependency1__["default"];
+
+    /**
+      @module ember-data
+    */
+
+    var get = Ember.get, set = Ember.set;
+
+    /**
+      A `ManyArray` is a `RecordArray` that represents the contents of a has-many
+      relationship.
+
+      The `ManyArray` is instantiated lazily the first time the relationship is
+      requested.
+
+      ### Inverses
+
+      Often, the relationships in Ember Data applications will have
+      an inverse. For example, imagine the following models are
+      defined:
+
+      ```javascript
+      App.Post = DS.Model.extend({
+        comments: DS.hasMany('comment')
+      });
+
+      App.Comment = DS.Model.extend({
+        post: DS.belongsTo('post')
+      });
+      ```
+
+      If you created a new instance of `App.Post` and added
+      a `App.Comment` record to its `comments` has-many
+      relationship, you would expect the comment's `post`
+      property to be set to the post that contained
+      the has-many.
+
+      We call the record to which a relationship belongs the
+      relationship's _owner_.
+
+      @class ManyArray
+      @namespace DS
+      @extends DS.RecordArray
+    */
+    __exports__["default"] = RecordArray.extend({
+      init: function() {
+        this._super.apply(this, arguments);
+      },
+
+      /**
+        `true` if the relationship is polymorphic, `false` otherwise.
+
+        @property {Boolean} isPolymorphic
+        @private
+      */
+      isPolymorphic: false,
+
+      /**
+        The loading state of this array
+
+        @property {Boolean} isLoaded
+      */
+      isLoaded: false,
+
+       /**
+         The relationship which manages this array.
+
+         @property {ManyRelationship} relationship
+         @private
+       */
+      relationship: null,
+
+
+      /**
+        Used for async `hasMany` arrays
+        to keep track of when they will resolve.
+
+        @property {Ember.RSVP.Promise} promise
+        @private
+      */
+      promise: null,
+
+      /**
+        @method loadingRecordsCount
+        @param {Number} count
+        @private
+      */
+      loadingRecordsCount: function(count) {
+        this.loadingRecordsCount = count;
+      },
+
+      /**
+        @method loadedRecord
+        @private
+      */
+      loadedRecord: function() {
+        this.loadingRecordsCount--;
+        if (this.loadingRecordsCount === 0) {
+          set(this, 'isLoaded', true);
+          this.trigger('didLoad');
+        }
+      },
+
+      replaceContent: function(idx, amt, objects){
+        var records;
+        if (amt > 0){
+          records = get(this, 'content').slice(idx, idx+amt);
+          this.get('relationship').removeRecords(records);
+        }
+        if (objects){
+          this.get('relationship').addRecords(objects, idx);
+        }
+      },
+      /**
+        @method reload
+        @public
+      */
+      reload: function() {
+        return this.relationship.reload();
+      },
+
+      /**
+        Create a child record within the owner
+
+        @method createRecord
+        @private
+        @param {Object} hash
+        @return {DS.Model} record
+      */
+      createRecord: function(hash) {
+        var store = get(this, 'store');
+        var type = get(this, 'type');
+        var record;
+
+        Ember.assert("You cannot add '" + type.typeKey + "' records to this polymorphic relationship.", !get(this, 'isPolymorphic'));
+
+        record = store.createRecord(type, hash);
+        this.pushObject(record);
+
+        return record;
+      }
+    });
+  });
+enifed("ember-data/system/record_arrays/record_array",
+  ["ember-data/system/promise_proxies","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    var PromiseArray = __dependency1__.PromiseArray;
+    var get = Ember.get;
+
+    /**
+      A record array is an array that contains records of a certain type. The record
+      array materializes records as needed when they are retrieved for the first
+      time. You should not create record arrays yourself. Instead, an instance of
+      `DS.RecordArray` or its subclasses will be returned by your application's store
+      in response to queries.
+
+      @class RecordArray
+      @namespace DS
+      @extends Ember.ArrayProxy
+      @uses Ember.Evented
+    */
+
+    __exports__["default"] = Ember.ArrayProxy.extend(Ember.Evented, {
+      /**
+        The model type contained by this record array.
+
+        @property type
+        @type DS.Model
+      */
+      type: null,
+
+      /**
+        The array of client ids backing the record array. When a
+        record is requested from the record array, the record
+        for the client id at the same index is materialized, if
+        necessary, by the store.
+
+        @property content
+        @private
+        @type Ember.Array
+      */
+      content: null,
+
+      /**
+        The flag to signal a `RecordArray` is currently loading data.
+
+        Example
+
+        ```javascript
+        var people = store.all('person');
+        people.get('isLoaded'); // true
+        ```
+
+        @property isLoaded
+        @type Boolean
+      */
+      isLoaded: false,
+      /**
+        The flag to signal a `RecordArray` is currently loading data.
+
+        Example
+
+        ```javascript
+        var people = store.all('person');
+        people.get('isUpdating'); // false
+        people.update();
+        people.get('isUpdating'); // true
+        ```
+
+        @property isUpdating
+        @type Boolean
+      */
+      isUpdating: false,
+
+      /**
+        The store that created this record array.
+
+        @property store
+        @private
+        @type DS.Store
+      */
+      store: null,
+
+      /**
+        Retrieves an object from the content by index.
+
+        @method objectAtContent
+        @private
+        @param {Number} index
+        @return {DS.Model} record
+      */
+      objectAtContent: function(index) {
+        var content = get(this, 'content');
+
+        return content.objectAt(index);
+      },
+
+      /**
+        Used to get the latest version of all of the records in this array
+        from the adapter.
+
+        Example
+
+        ```javascript
+        var people = store.all('person');
+        people.get('isUpdating'); // false
+        people.update();
+        people.get('isUpdating'); // true
+        ```
+
+        @method update
+      */
+      update: function() {
+        if (get(this, 'isUpdating')) { return; }
+
+        var store = get(this, 'store');
+        var type = get(this, 'type');
+
+        return store.fetchAll(type, this);
+      },
+
+      /**
+        Adds a record to the `RecordArray` without duplicates
+
+        @method addRecord
+        @private
+        @param {DS.Model} record
+        @param {DS.Model} an optional index to insert at
+      */
+      addRecord: function(record, idx) {
+        var content = get(this, 'content');
+        if (idx === undefined) {
+          content.addObject(record);
+        } else {
+          if (!content.contains(record)) {
+           content.insertAt(idx, record);
+          }
+        }
+      },
+
+      /**
+        Adds a record to the `RecordArray`, but allows duplicates
+
+        @method pushRecord
+        @private
+        @param {DS.Model} record
+      */
+      pushRecord: function(record) {
+        get(this, 'content').pushObject(record);
+      },
+
+
+      /**
+        Removes a record to the `RecordArray`.
+
+        @method removeRecord
+        @private
+        @param {DS.Model} record
+      */
+      removeRecord: function(record) {
+        get(this, 'content').removeObject(record);
+      },
+
+      /**
+        Saves all of the records in the `RecordArray`.
+
+        Example
+
+        ```javascript
+        var messages = store.all('message');
+        messages.forEach(function(message) {
+          message.set('hasBeenSeen', true);
+        });
+        messages.save();
+        ```
+
+        @method save
+        @return {DS.PromiseArray} promise
+      */
+      save: function() {
+        var promiseLabel = "DS: RecordArray#save " + get(this, 'type');
+        var promise = Ember.RSVP.all(this.invoke("save"), promiseLabel).then(function(array) {
+          return Ember.A(array);
+        }, null, "DS: RecordArray#save apply Ember.NativeArray");
+
+        return PromiseArray.create({ promise: promise });
+      },
+
+      _dissociateFromOwnRecords: function() {
+        var array = this;
+
+        this.forEach(function(record){
+          var recordArrays = record._recordArrays;
+
+          if (recordArrays) {
+            recordArrays["delete"](array);
+          }
+        });
+      },
+
+      willDestroy: function(){
+        this._dissociateFromOwnRecords();
+        this._super();
+      }
+    });
+  });
+enifed("ember-data/system/relationship-meta",
+  ["ember-inflector/system","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var singularize = __dependency1__.singularize;
+
+    function typeForRelationshipMeta(store, meta) {
+      var typeKey, type;
+
+      typeKey = meta.type || meta.key;
+      if (typeof typeKey === 'string') {
+        if (meta.kind === 'hasMany') {
+          typeKey = singularize(typeKey);
+        }
+        type = store.modelFor(typeKey);
+      } else {
+        type = meta.type;
+      }
+
+      return type;
+    }
+
+    __exports__.typeForRelationshipMeta = typeForRelationshipMeta;function relationshipFromMeta(store, meta) {
+      return {
+        key:  meta.key,
+        kind: meta.kind,
+        type: typeForRelationshipMeta(store, meta),
+        options:    meta.options,
+        parentType: meta.parentType,
+        isRelationship: true
+      };
+    }
+
+    __exports__.relationshipFromMeta = relationshipFromMeta;
+  });
+enifed("ember-data/system/relationships",
+  ["./relationships/belongs_to","./relationships/has_many","ember-data/system/relationships/ext","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    var belongsTo = __dependency1__["default"];
+    var hasMany = __dependency2__["default"];
+
+
+    __exports__.belongsTo = belongsTo;
+    __exports__.hasMany = hasMany;
+  });
+enifed("ember-data/system/relationships/belongs_to",
+  ["ember-data/system/model","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Model = __dependency1__.Model;
+
+
+    /**
+      `DS.belongsTo` is used to define One-To-One and One-To-Many
+      relationships on a [DS.Model](/api/data/classes/DS.Model.html).
+
+
+      `DS.belongsTo` takes an optional hash as a second parameter, currently
+      supported options are:
+
+      - `async`: A boolean value used to explicitly declare this to be an async relationship.
+      - `inverse`: A string used to identify the inverse property on a
+        related model in a One-To-Many relationship. See [Explicit Inverses](#toc_explicit-inverses)
+
+      #### One-To-One
+      To declare a one-to-one relationship between two models, use
+      `DS.belongsTo`:
+
+      ```javascript
+      App.User = DS.Model.extend({
+        profile: DS.belongsTo('profile')
+      });
+
+      App.Profile = DS.Model.extend({
+        user: DS.belongsTo('user')
+      });
+      ```
+
+      #### One-To-Many
+      To declare a one-to-many relationship between two models, use
+      `DS.belongsTo` in combination with `DS.hasMany`, like this:
+
+      ```javascript
+      App.Post = DS.Model.extend({
+        comments: DS.hasMany('comment')
+      });
+
+      App.Comment = DS.Model.extend({
+        post: DS.belongsTo('post')
+      });
+      ```
+
+      @namespace
+      @method belongsTo
+      @for DS
+      @param {String or DS.Model} type the model type of the relationship
+      @param {Object} options a hash of options
+      @return {Ember.computed} relationship
+    */
+    function belongsTo(type, options) {
+      if (typeof type === 'object') {
+        options = type;
+        type = undefined;
+      } else {
+        Ember.assert("The first argument to DS.belongsTo must be a string representing a model type key, e.g. use DS.belongsTo('person') to define a relation to the App.Person model", !!type && (typeof type === 'string' || Model.detect(type)));
+      }
+
+      options = options || {};
+
+      var meta = {
+        type: type,
+        isRelationship: true,
+        options: options,
+        kind: 'belongsTo',
+        key: null
+      };
+
+      return Ember.computed(function(key, value) {
+        if (arguments.length>1) {
+          if ( value === undefined ) {
+            value = null;
+          }
+          if (value && value.then) {
+            this._relationships[key].setRecordPromise(value);
+          } else {
+            this._relationships[key].setRecord(value);
+          }
+        }
+
+        return this._relationships[key].getRecord();
+      }).meta(meta);
+    }
+
+    /**
+      These observers observe all `belongsTo` relationships on the record. See
+      `relationships/ext` to see how these observers get their dependencies.
+
+      @class Model
+      @namespace DS
+    */
+    Model.reopen({
+      notifyBelongsToAdded: function(key, relationship) {
+        this.notifyPropertyChange(key);
+      },
+
+      notifyBelongsToRemoved: function(key) {
+        this.notifyPropertyChange(key);
+      }
+    });
+
+    __exports__["default"] = belongsTo;
+  });
+enifed("ember-data/system/relationships/ext",
+  ["ember-data/system/relationship-meta","ember-data/system/model","ember-data/system/map"],
+  function(__dependency1__, __dependency2__, __dependency3__) {
+    "use strict";
+    var typeForRelationshipMeta = __dependency1__.typeForRelationshipMeta;
+    var relationshipFromMeta = __dependency1__.relationshipFromMeta;
+    var Model = __dependency2__.Model;
+    var Map = __dependency3__.Map;
+    var MapWithDefault = __dependency3__.MapWithDefault;
+
+    var get = Ember.get;
+    var filter = Ember.ArrayPolyfills.filter;
+
+    /**
+      @module ember-data
+    */
+
+    /*
+      This file defines several extensions to the base `DS.Model` class that
+      add support for one-to-many relationships.
+    */
+
+    /**
+      @class Model
+      @namespace DS
+    */
+    Model.reopen({
+
+      /**
+        This Ember.js hook allows an object to be notified when a property
+        is defined.
+
+        In this case, we use it to be notified when an Ember Data user defines a
+        belongs-to relationship. In that case, we need to set up observers for
+        each one, allowing us to track relationship changes and automatically
+        reflect changes in the inverse has-many array.
+
+        This hook passes the class being set up, as well as the key and value
+        being defined. So, for example, when the user does this:
+
+        ```javascript
+        DS.Model.extend({
+          parent: DS.belongsTo('user')
+        });
+        ```
+
+        This hook would be called with "parent" as the key and the computed
+        property returned by `DS.belongsTo` as the value.
+
+        @method didDefineProperty
+        @param {Object} proto
+        @param {String} key
+        @param {Ember.ComputedProperty} value
+      */
+      didDefineProperty: function(proto, key, value) {
+        // Check if the value being set is a computed property.
+        if (value instanceof Ember.ComputedProperty) {
+
+          // If it is, get the metadata for the relationship. This is
+          // populated by the `DS.belongsTo` helper when it is creating
+          // the computed property.
+          var meta = value.meta();
+
+          meta.parentType = proto.constructor;
+        }
+      }
+    });
+
+    /*
+      These DS.Model extensions add class methods that provide relationship
+      introspection abilities about relationships.
+
+      A note about the computed properties contained here:
+
+      **These properties are effectively sealed once called for the first time.**
+      To avoid repeatedly doing expensive iteration over a model's fields, these
+      values are computed once and then cached for the remainder of the runtime of
+      your application.
+
+      If your application needs to modify a class after its initial definition
+      (for example, using `reopen()` to add additional attributes), make sure you
+      do it before using your model with the store, which uses these properties
+      extensively.
+    */
+
+    Model.reopenClass({
+
+      /**
+        For a given relationship name, returns the model type of the relationship.
+
+        For example, if you define a model like this:
+
+       ```javascript
+        App.Post = DS.Model.extend({
+          comments: DS.hasMany('comment')
+        });
+       ```
+
+        Calling `App.Post.typeForRelationship('comments')` will return `App.Comment`.
+
+        @method typeForRelationship
+        @static
+        @param {String} name the name of the relationship
+        @return {subclass of DS.Model} the type of the relationship, or undefined
+      */
+      typeForRelationship: function(name) {
+        var relationship = get(this, 'relationshipsByName').get(name);
+        return relationship && relationship.type;
+      },
+
+      inverseMap: Ember.computed(function() {
+        return Ember.create(null);
+      }),
+
+      /**
+        Find the relationship which is the inverse of the one asked for.
+
+        For example, if you define models like this:
+
+       ```javascript
+          App.Post = DS.Model.extend({
+            comments: DS.hasMany('message')
+          });
+
+          App.Message = DS.Model.extend({
+            owner: DS.belongsTo('post')
+          });
+        ```
+
+        App.Post.inverseFor('comments') -> {type: App.Message, name:'owner', kind:'belongsTo'}
+        App.Message.inverseFor('owner') -> {type: App.Post, name:'comments', kind:'hasMany'}
+
+        @method inverseFor
+        @static
+        @param {String} name the name of the relationship
+        @return {Object} the inverse relationship, or null
+      */
+      inverseFor: function(name) {
+        var inverseMap = get(this, 'inverseMap');
+        if (inverseMap[name]) {
+          return inverseMap[name];
+        } else {
+          var inverse = this._findInverseFor(name);
+          inverseMap[name] = inverse;
+          return inverse;
+        }
+      },
+
+      //Calculate the inverse, ignoring the cache
+      _findInverseFor: function(name) {
+
+        var inverseType = this.typeForRelationship(name);
+        if (!inverseType) {
+          return null;
+        }
+
+        //If inverse is manually specified to be null, like  `comments: DS.hasMany('message', {inverse: null})`
+        var options = this.metaForProperty(name).options;
+        if (options.inverse === null) { return null; }
+
+        var inverseName, inverseKind, inverse;
+
+        //If inverse is specified manually, return the inverse
+        if (options.inverse) {
+          inverseName = options.inverse;
+          inverse = Ember.get(inverseType, 'relationshipsByName').get(inverseName);
+
+          Ember.assert("We found no inverse relationships by the name of '" + inverseName + "' on the '" + inverseType.typeKey +
+            "' model. This is most likely due to a missing attribute on your model definition.", !Ember.isNone(inverse));
+
+          inverseKind = inverse.kind;
+        } else {
+          //No inverse was specified manually, we need to use a heuristic to guess one
+          var possibleRelationships = findPossibleInverses(this, inverseType);
+
+          if (possibleRelationships.length === 0) { return null; }
+
+          var filteredRelationships = filter.call(possibleRelationships, function(possibleRelationship) {
+            var optionsForRelationship = inverseType.metaForProperty(possibleRelationship.name).options;
+            return name === optionsForRelationship.inverse;
+          });
+
+          Ember.assert("You defined the '" + name + "' relationship on " + this + ", but you defined the inverse relationships of type " +
+            inverseType.toString() + " multiple times. Look at http://emberjs.com/guides/models/defining-models/#toc_explicit-inverses for how to explicitly specify inverses",
+            filteredRelationships.length < 2);
+
+          if (filteredRelationships.length === 1 ) {
+            possibleRelationships = filteredRelationships;
+          }
+
+          Ember.assert("You defined the '" + name + "' relationship on " + this + ", but multiple possible inverse relationships of type " +
+            this + " were found on " + inverseType + ". Look at http://emberjs.com/guides/models/defining-models/#toc_explicit-inverses for how to explicitly specify inverses",
+            possibleRelationships.length === 1);
+
+          inverseName = possibleRelationships[0].name;
+          inverseKind = possibleRelationships[0].kind;
+        }
+
+        function findPossibleInverses(type, inverseType, relationshipsSoFar) {
+          var possibleRelationships = relationshipsSoFar || [];
+
+          var relationshipMap = get(inverseType, 'relationships');
+          if (!relationshipMap) { return; }
+
+          var relationships = relationshipMap.get(type);
+
+          relationships = filter.call(relationships, function(relationship) {
+            var optionsForRelationship = inverseType.metaForProperty(relationship.name).options;
+
+            if (!optionsForRelationship.inverse){
+              return true;
+            }
+
+            return name === optionsForRelationship.inverse;
+          });
+
+          if (relationships) {
+            possibleRelationships.push.apply(possibleRelationships, relationships);
+          }
+
+          //Recurse to support polymorphism
+          if (type.superclass) {
+            findPossibleInverses(type.superclass, inverseType, possibleRelationships);
+          }
+
+          return possibleRelationships;
+        }
+
+        return {
+          type: inverseType,
+          name: inverseName,
+          kind: inverseKind
+        };
+      },
+
+      /**
+        The model's relationships as a map, keyed on the type of the
+        relationship. The value of each entry is an array containing a descriptor
+        for each relationship with that type, describing the name of the relationship
+        as well as the type.
+
+        For example, given the following model definition:
+
+        ```javascript
+        App.Blog = DS.Model.extend({
+          users: DS.hasMany('user'),
+          owner: DS.belongsTo('user'),
+          posts: DS.hasMany('post')
+        });
+        ```
+
+        This computed property would return a map describing these
+        relationships, like this:
+
+        ```javascript
+        var relationships = Ember.get(App.Blog, 'relationships');
+        relationships.get(App.User);
+        //=> [ { name: 'users', kind: 'hasMany' },
+        //     { name: 'owner', kind: 'belongsTo' } ]
+        relationships.get(App.Post);
+        //=> [ { name: 'posts', kind: 'hasMany' } ]
+        ```
+
+        @property relationships
+        @static
+        @type Ember.Map
+        @readOnly
+      */
+      relationships: Ember.computed(function() {
+        var map = new MapWithDefault({
+          defaultValue: function() { return []; }
+        });
+
+        // Loop through each computed property on the class
+        this.eachComputedProperty(function(name, meta) {
+          // If the computed property is a relationship, add
+          // it to the map.
+          if (meta.isRelationship) {
+            meta.key = name;
+            var relationshipsForType = map.get(typeForRelationshipMeta(this.store, meta));
+
+            relationshipsForType.push({
+              name: name,
+              kind: meta.kind
+            });
+          }
+        });
+
+        return map;
+      }).cacheable(false).readOnly(),
+
+      /**
+        A hash containing lists of the model's relationships, grouped
+        by the relationship kind. For example, given a model with this
+        definition:
+
+        ```javascript
+        App.Blog = DS.Model.extend({
+          users: DS.hasMany('user'),
+          owner: DS.belongsTo('user'),
+
+          posts: DS.hasMany('post')
+        });
+        ```
+
+        This property would contain the following:
+
+        ```javascript
+        var relationshipNames = Ember.get(App.Blog, 'relationshipNames');
+        relationshipNames.hasMany;
+        //=> ['users', 'posts']
+        relationshipNames.belongsTo;
+        //=> ['owner']
+        ```
+
+        @property relationshipNames
+        @static
+        @type Object
+        @readOnly
+      */
+      relationshipNames: Ember.computed(function() {
+        var names = {
+          hasMany: [],
+          belongsTo: []
+        };
+
+        this.eachComputedProperty(function(name, meta) {
+          if (meta.isRelationship) {
+            names[meta.kind].push(name);
+          }
+        });
+
+        return names;
+      }),
+
+      /**
+        An array of types directly related to a model. Each type will be
+        included once, regardless of the number of relationships it has with
+        the model.
+
+        For example, given a model with this definition:
+
+        ```javascript
+        App.Blog = DS.Model.extend({
+          users: DS.hasMany('user'),
+          owner: DS.belongsTo('user'),
+
+          posts: DS.hasMany('post')
+        });
+        ```
+
+        This property would contain the following:
+
+        ```javascript
+        var relatedTypes = Ember.get(App.Blog, 'relatedTypes');
+        //=> [ App.User, App.Post ]
+        ```
+
+        @property relatedTypes
+        @static
+        @type Ember.Array
+        @readOnly
+      */
+      relatedTypes: Ember.computed(function() {
+        var type;
+        var types = Ember.A();
+
+        // Loop through each computed property on the class,
+        // and create an array of the unique types involved
+        // in relationships
+        this.eachComputedProperty(function(name, meta) {
+          if (meta.isRelationship) {
+            meta.key = name;
+            type = typeForRelationshipMeta(this.store, meta);
+
+            Ember.assert("You specified a hasMany (" + meta.type + ") on " + meta.parentType + " but " + meta.type + " was not found.",  type);
+
+            if (!types.contains(type)) {
+              Ember.assert("Trying to sideload " + name + " on " + this.toString() + " but the type doesn't exist.", !!type);
+              types.push(type);
+            }
+          }
+        });
+
+        return types;
+      }).cacheable(false).readOnly(),
+
+      /**
+        A map whose keys are the relationships of a model and whose values are
+        relationship descriptors.
+
+        For example, given a model with this
+        definition:
+
+        ```javascript
+        App.Blog = DS.Model.extend({
+          users: DS.hasMany('user'),
+          owner: DS.belongsTo('user'),
+
+          posts: DS.hasMany('post')
+        });
+        ```
+
+        This property would contain the following:
+
+        ```javascript
+        var relationshipsByName = Ember.get(App.Blog, 'relationshipsByName');
+        relationshipsByName.get('users');
+        //=> { key: 'users', kind: 'hasMany', type: App.User }
+        relationshipsByName.get('owner');
+        //=> { key: 'owner', kind: 'belongsTo', type: App.User }
+        ```
+
+        @property relationshipsByName
+        @static
+        @type Ember.Map
+        @readOnly
+      */
+      relationshipsByName: Ember.computed(function() {
+        var map = Map.create();
+
+        this.eachComputedProperty(function(name, meta) {
+          if (meta.isRelationship) {
+            meta.key = name;
+            var relationship = relationshipFromMeta(this.store, meta);
+            relationship.type = typeForRelationshipMeta(this.store, meta);
+            map.set(name, relationship);
+          }
+        });
+
+        return map;
+      }).cacheable(false).readOnly(),
+
+      /**
+        A map whose keys are the fields of the model and whose values are strings
+        describing the kind of the field. A model's fields are the union of all of its
+        attributes and relationships.
+
+        For example:
+
+        ```javascript
+
+        App.Blog = DS.Model.extend({
+          users: DS.hasMany('user'),
+          owner: DS.belongsTo('user'),
+
+          posts: DS.hasMany('post'),
+
+          title: DS.attr('string')
+        });
+
+        var fields = Ember.get(App.Blog, 'fields');
+        fields.forEach(function(kind, field) {
+          console.log(field, kind);
+        });
+
+        // prints:
+        // users, hasMany
+        // owner, belongsTo
+        // posts, hasMany
+        // title, attribute
+        ```
+
+        @property fields
+        @static
+        @type Ember.Map
+        @readOnly
+      */
+      fields: Ember.computed(function() {
+        var map = Map.create();
+
+        this.eachComputedProperty(function(name, meta) {
+          if (meta.isRelationship) {
+            map.set(name, meta.kind);
+          } else if (meta.isAttribute) {
+            map.set(name, 'attribute');
+          }
+        });
+
+        return map;
+      }).readOnly(),
+
+      /**
+        Given a callback, iterates over each of the relationships in the model,
+        invoking the callback with the name of each relationship and its relationship
+        descriptor.
+
+        @method eachRelationship
+        @static
+        @param {Function} callback the callback to invoke
+        @param {any} binding the value to which the callback's `this` should be bound
+      */
+      eachRelationship: function(callback, binding) {
+        get(this, 'relationshipsByName').forEach(function(relationship, name) {
+          callback.call(binding, name, relationship);
+        });
+      },
+
+      /**
+        Given a callback, iterates over each of the types related to a model,
+        invoking the callback with the related type's class. Each type will be
+        returned just once, regardless of how many different relationships it has
+        with a model.
+
+        @method eachRelatedType
+        @static
+        @param {Function} callback the callback to invoke
+        @param {any} binding the value to which the callback's `this` should be bound
+      */
+      eachRelatedType: function(callback, binding) {
+        get(this, 'relatedTypes').forEach(function(type) {
+          callback.call(binding, type);
+        });
+      },
+
+      determineRelationshipType: function(knownSide) {
+        var knownKey = knownSide.key;
+        var knownKind = knownSide.kind;
+        var inverse = this.inverseFor(knownKey);
+        var key, otherKind;
+
+        if (!inverse) {
+          return knownKind === 'belongsTo' ? 'oneToNone' : 'manyToNone';
+        }
+
+        key = inverse.name;
+        otherKind = inverse.kind;
+
+        if (otherKind === 'belongsTo') {
+          return knownKind === 'belongsTo' ? 'oneToOne' : 'manyToOne';
+        } else {
+          return knownKind === 'belongsTo' ? 'oneToMany' : 'manyToMany';
+        }
+      }
+
+    });
+
+    Model.reopen({
+      /**
+        Given a callback, iterates over each of the relationships in the model,
+        invoking the callback with the name of each relationship and its relationship
+        descriptor.
+
+        @method eachRelationship
+        @param {Function} callback the callback to invoke
+        @param {any} binding the value to which the callback's `this` should be bound
+      */
+      eachRelationship: function(callback, binding) {
+        this.constructor.eachRelationship(callback, binding);
+      },
+
+      relationshipFor: function(name) {
+        return get(this.constructor, 'relationshipsByName').get(name);
+      },
+
+      inverseFor: function(key) {
+        return this.constructor.inverseFor(key);
+      }
+
+    });
+  });
+enifed("ember-data/system/relationships/has_many",
+  ["ember-data/system/model","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    /**
+      @module ember-data
+    */
+
+    var Model = __dependency1__.Model;
+
+    /**
+      `DS.hasMany` is used to define One-To-Many and Many-To-Many
+      relationships on a [DS.Model](/api/data/classes/DS.Model.html).
+
+      `DS.hasMany` takes an optional hash as a second parameter, currently
+      supported options are:
+
+      - `async`: A boolean value used to explicitly declare this to be an async relationship.
+      - `inverse`: A string used to identify the inverse property on a related model.
+
+      #### One-To-Many
+      To declare a one-to-many relationship between two models, use
+      `DS.belongsTo` in combination with `DS.hasMany`, like this:
+
+      ```javascript
+      App.Post = DS.Model.extend({
+        comments: DS.hasMany('comment')
+      });
+
+      App.Comment = DS.Model.extend({
+        post: DS.belongsTo('post')
+      });
+      ```
+
+      #### Many-To-Many
+      To declare a many-to-many relationship between two models, use
+      `DS.hasMany`:
+
+      ```javascript
+      App.Post = DS.Model.extend({
+        tags: DS.hasMany('tag')
+      });
+
+      App.Tag = DS.Model.extend({
+        posts: DS.hasMany('post')
+      });
+      ```
+
+      #### Explicit Inverses
+
+      Ember Data will do its best to discover which relationships map to
+      one another. In the one-to-many code above, for example, Ember Data
+      can figure out that changing the `comments` relationship should update
+      the `post` relationship on the inverse because post is the only
+      relationship to that model.
+
+      However, sometimes you may have multiple `belongsTo`/`hasManys` for the
+      same type. You can specify which property on the related model is
+      the inverse using `DS.hasMany`'s `inverse` option:
+
+      ```javascript
+      var belongsTo = DS.belongsTo,
+          hasMany = DS.hasMany;
+
+      App.Comment = DS.Model.extend({
+        onePost: belongsTo('post'),
+        twoPost: belongsTo('post'),
+        redPost: belongsTo('post'),
+        bluePost: belongsTo('post')
+      });
+
+      App.Post = DS.Model.extend({
+        comments: hasMany('comment', {
+          inverse: 'redPost'
+        })
+      });
+      ```
+
+      You can also specify an inverse on a `belongsTo`, which works how
+      you'd expect.
+
+      @namespace
+      @method hasMany
+      @for DS
+      @param {String or DS.Model} type the model type of the relationship
+      @param {Object} options a hash of options
+      @return {Ember.computed} relationship
+    */
+    function hasMany(type, options) {
+      if (typeof type === 'object') {
+        options = type;
+        type = undefined;
+      }
+
+      options = options || {};
+
+      // Metadata about relationships is stored on the meta of
+      // the relationship. This is used for introspection and
+      // serialization. Note that `key` is populated lazily
+      // the first time the CP is called.
+      var meta = {
+        type: type,
+        isRelationship: true,
+        options: options,
+        kind: 'hasMany',
+        key: null
+      };
+
+      return Ember.computed(function(key) {
+        var relationship = this._relationships[key];
+        return relationship.getRecords();
+      }).meta(meta).readOnly();
+    }
+
+    Model.reopen({
+      notifyHasManyAdded: function(key, record, idx) {
+        var relationship = this._relationships[key];
+        var manyArray = relationship.manyArray;
+        manyArray.addRecord(record, idx);
+        //We need to notifyPropertyChange in the adding case because we need to make sure
+        //we fetch the newly added record in case it is unloaded
+        //TODO(Igor): Consider whether we could do this only if the record state is unloaded
+        this.notifyPropertyChange(key);
+      },
+
+      notifyHasManyRemoved: function(key, record) {
+        var relationship = this._relationships[key];
+        var manyArray = relationship.manyArray;
+        manyArray.removeRecord(record);
+      }
+    });
+
+
+    __exports__["default"] = hasMany;
+  });
+enifed("ember-data/system/relationships/relationship",
+  ["ember-data/system/promise_proxies","ember-data/system/map","exports"],
+  function(__dependency1__, __dependency2__, __exports__) {
+    "use strict";
+    var PromiseManyArray = __dependency1__.PromiseManyArray;
+    var PromiseObject = __dependency1__.PromiseObject;
+    var OrderedSet = __dependency2__.OrderedSet;
+
+    var Relationship = function(store, record, inverseKey, relationshipMeta) {
+      this.members = new OrderedSet();
+      this.store = store;
+      this.key = relationshipMeta.key;
+      this.inverseKey = inverseKey;
+      this.record = record;
+      this.isAsync = relationshipMeta.options.async;
+      this.relationshipMeta = relationshipMeta;
+      //This probably breaks for polymorphic relationship in complex scenarios, due to
+      //multiple possible typeKeys
+      this.inverseKeyForImplicit = this.store.modelFor(this.record.constructor).typeKey + this.key;
+      //Cached promise when fetching the relationship from a link
+      this.linkPromise = null;
+    };
+
+    Relationship.prototype = {
+      constructor: Relationship,
+
+      destroy: Ember.K,
+
+      clear: function() {
+        this.members.forEach(function(member) {
+          this.removeRecord(member);
+        }, this);
+      },
+
+      disconnect: function(){
+        this.members.forEach(function(member) {
+          this.removeRecordFromInverse(member);
+        }, this);
+      },
+
+      reconnect: function(){
+        this.members.forEach(function(member) {
+          this.addRecordToInverse(member);
+        }, this);
+      },
+
+      removeRecords: function(records){
+        var length = Ember.get(records, 'length');
+        var record;
+        for (var i = 0; i < length; i++){
+          record = records[i];
+          this.removeRecord(record);
+        }
+      },
+
+      addRecords: function(records, idx){
+        var length = Ember.get(records, 'length');
+        var record;
+        for (var i = 0; i < length; i++){
+          record = records[i];
+          this.addRecord(record, idx);
+          if (idx !== undefined) {
+            idx++;
+          }
+        }
+      },
+
+      addRecord: function(record, idx) {
+        if (!this.members.has(record)) {
+          this.members.add(record);
+          this.notifyRecordRelationshipAdded(record, idx);
+          if (this.inverseKey) {
+            record._relationships[this.inverseKey].addRecord(this.record);
+          } else {
+            if (!record._implicitRelationships[this.inverseKeyForImplicit]) {
+              record._implicitRelationships[this.inverseKeyForImplicit] = new Relationship(this.store, record, this.key,  {options:{}});
+            }
+            record._implicitRelationships[this.inverseKeyForImplicit].addRecord(this.record);
+          }
+          this.record.updateRecordArrays();
+        }
+      },
+
+      removeRecord: function(record) {
+        if (this.members.has(record)) {
+          this.removeRecordFromOwn(record);
+          if (this.inverseKey) {
+            this.removeRecordFromInverse(record);
+          } else {
+            if (record._implicitRelationships[this.inverseKeyForImplicit]) {
+              record._implicitRelationships[this.inverseKeyForImplicit].removeRecord(this.record);
+            }
+          }
+        }
+      },
+
+      addRecordToInverse: function(record) {
+        if (this.inverseKey) {
+          record._relationships[this.inverseKey].addRecord(this.record);
+        }
+      },
+
+      removeRecordFromInverse: function(record) {
+        var inverseRelationship = record._relationships[this.inverseKey];
+        //Need to check for existence, as the record might unloading at the moment
+        if (inverseRelationship) {
+          inverseRelationship.removeRecordFromOwn(this.record);
+        }
+      },
+
+      removeRecordFromOwn: function(record) {
+        this.members["delete"](record);
+        this.notifyRecordRelationshipRemoved(record);
+        this.record.updateRecordArrays();
+      },
+
+      updateLink: function(link) {
+        Ember.assert("You have pushed a record of type '" + this.record.constructor.typeKey + "' with '" + this.key + "' as a link, but the value of that link is not a string.", typeof link === 'string' || link === null);
+        if (link !== this.link) {
+          this.link = link;
+          this.linkPromise = null;
+          this.record.notifyPropertyChange(this.key);
+        }
+      },
+
+      findLink: function() {
+        if (this.linkPromise) {
+          return this.linkPromise;
+        } else {
+          var promise = this.fetchLink();
+          this.linkPromise = promise;
+          return promise.then(function(result) {
+            return result;
+          });
+        }
+      },
+
+      updateRecordsFromAdapter: function(records) {
+        //TODO Once we have adapter support, we need to handle updated and canonical changes
+        this.computeChanges(records);
+      },
+
+      notifyRecordRelationshipAdded: Ember.K,
+      notifyRecordRelationshipRemoved: Ember.K
+    };
+
+    var ManyRelationship = function(store, record, inverseKey, relationshipMeta) {
+      this._super$constructor(store, record, inverseKey, relationshipMeta);
+      this.belongsToType = relationshipMeta.type;
+      this.manyArray = store.recordArrayManager.createManyArray(this.belongsToType, Ember.A());
+      this.manyArray.relationship = this;
+      this.isPolymorphic = relationshipMeta.options.polymorphic;
+      this.manyArray.isPolymorphic = this.isPolymorphic;
+    };
+
+    ManyRelationship.prototype = Ember.create(Relationship.prototype);
+    ManyRelationship.prototype.constructor = ManyRelationship;
+    ManyRelationship.prototype._super$constructor = Relationship;
+
+    ManyRelationship.prototype.destroy = function() {
+      this.manyArray.destroy();
+    };
+
+    ManyRelationship.prototype.notifyRecordRelationshipAdded = function(record, idx) {
+      Ember.assert("You cannot add '" + record.constructor.typeKey + "' records to this relationship (only '" + this.belongsToType.typeKey + "' allowed)", !this.belongsToType || record instanceof this.belongsToType);
+      this.record.notifyHasManyAdded(this.key, record, idx);
+    };
+
+    ManyRelationship.prototype.notifyRecordRelationshipRemoved = function(record) {
+      this.record.notifyHasManyRemoved(this.key, record);
+    };
+
+    ManyRelationship.prototype.reload = function() {
+      var self = this;
+      if (this.link) {
+        return this.fetchLink();
+      } else {
+        return this.store.scheduleFetchMany(this.manyArray.toArray()).then(function() {
+          //Goes away after the manyArray refactor
+          self.manyArray.set('isLoaded', true);
+          return self.manyArray;
+        });
+      }
+    };
+
+    ManyRelationship.prototype.computeChanges = function(records) {
+      var members = this.members;
+      var recordsToRemove = [];
+      var length;
+      var record;
+      var i;
+
+      records = setForArray(records);
+
+      members.forEach(function(member) {
+        if (records.has(member)) return;
+
+        recordsToRemove.push(member);
+      });
+      this.removeRecords(recordsToRemove);
+
+      var hasManyArray = this.manyArray;
+
+      // Using records.toArray() since currently using
+      // removeRecord can modify length, messing stuff up
+      // forEach since it directly looks at "length" each
+      // iteration
+      records = records.toArray();
+      length = records.length;
+      for (i = 0; i < length; i++){
+        record = records[i];
+        //Need to preserve the order of incoming records
+        if (hasManyArray.objectAt(i) === record ) {
+          continue;
+        }
+        this.removeRecord(record);
+        this.addRecord(record, i);
+      }
+    };
+
+    ManyRelationship.prototype.fetchLink = function() {
+      var self = this;
+      return this.store.findHasMany(this.record, this.link, this.relationshipMeta).then(function(records){
+        self.updateRecordsFromAdapter(records);
+        return self.manyArray;
+      });
+    };
+
+    ManyRelationship.prototype.findRecords = function() {
+      var manyArray = this.manyArray;
+      return this.store.findMany(manyArray.toArray()).then(function(){
+        //Goes away after the manyArray refactor
+        manyArray.set('isLoaded', true);
+        return manyArray;
+      });
+    };
+
+    ManyRelationship.prototype.getRecords = function() {
+      if (this.isAsync) {
+        var self = this;
+        var promise;
+        if (this.link) {
+          promise = this.findLink().then(function() {
+            return self.findRecords();
+          });
+        } else {
+          promise = this.findRecords();
+        }
+        return PromiseManyArray.create({
+          content: this.manyArray,
+          promise: promise
+        });
+      } else {
+          Ember.assert("You looked up the '" + this.key + "' relationship on a '" + this.record.constructor.typeKey + "' with id " + this.record.get('id') +  " but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (`DS.hasMany({ async: true })`)", this.manyArray.isEvery('isEmpty', false));
+
+        if (!this.manyArray.get('isDestroyed')) {
+          this.manyArray.set('isLoaded', true);
+        }
+        return this.manyArray;
+     }
+    };
+
+    var BelongsToRelationship = function(store, record, inverseKey, relationshipMeta) {
+      this._super$constructor(store, record, inverseKey, relationshipMeta);
+      this.record = record;
+      this.key = relationshipMeta.key;
+      this.inverseRecord = null;
+    };
+
+    BelongsToRelationship.prototype = Ember.create(Relationship.prototype);
+    BelongsToRelationship.prototype.constructor = BelongsToRelationship;
+    BelongsToRelationship.prototype._super$constructor = Relationship;
+
+    BelongsToRelationship.prototype.setRecord = function(newRecord) {
+      if (newRecord) {
+        this.addRecord(newRecord);
+      } else if (this.inverseRecord) {
+        this.removeRecord(this.inverseRecord);
+      }
+    };
+
+    BelongsToRelationship.prototype._super$addRecord = Relationship.prototype.addRecord;
+    BelongsToRelationship.prototype.addRecord = function(newRecord) {
+      if (this.members.has(newRecord)){ return;}
+      var type = this.relationshipMeta.type;
+      Ember.assert("You can only add a '" + type.typeKey + "' record to this relationship", newRecord instanceof type);
+
+      if (this.inverseRecord) {
+        this.removeRecord(this.inverseRecord);
+      }
+
+      this.inverseRecord = newRecord;
+      this._super$addRecord(newRecord);
+    };
+
+    BelongsToRelationship.prototype.setRecordPromise = function(newPromise) {
+      var content = newPromise.get && newPromise.get('content');
+      Ember.assert("You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo or hasMany relationship to the get call.", content !== undefined);
+      this.setRecord(content);
+    };
+
+    BelongsToRelationship.prototype.notifyRecordRelationshipAdded = function(newRecord) {
+      this.record.notifyBelongsToAdded(this.key, this);
+    };
+
+    BelongsToRelationship.prototype.notifyRecordRelationshipRemoved = function(record) {
+      this.record.notifyBelongsToRemoved(this.key, this);
+    };
+
+    BelongsToRelationship.prototype._super$removeRecordFromOwn = Relationship.prototype.removeRecordFromOwn;
+    BelongsToRelationship.prototype.removeRecordFromOwn = function(record) {
+      if (!this.members.has(record)) { return; }
+      this.inverseRecord = null;
+      this._super$removeRecordFromOwn(record);
+    };
+
+    BelongsToRelationship.prototype.findRecord = function() {
+      if (this.inverseRecord) {
+        return this.store._findByRecord(this.inverseRecord);
+      } else {
+        return Ember.RSVP.Promise.resolve(null);
+      }
+    };
+
+    BelongsToRelationship.prototype.fetchLink = function() {
+      var self = this;
+      return this.store.findBelongsTo(this.record, this.link, this.relationshipMeta).then(function(record){
+        if (record) {
+          self.addRecord(record);
+        }
+        return record;
+      });
+    };
+
+    BelongsToRelationship.prototype.getRecord = function() {
+      if (this.isAsync) {
+        var promise;
+        if (this.link){
+          var self = this;
+          promise = this.findLink().then(function() {
+            return self.findRecord();
+          });
+        } else {
+          promise = this.findRecord();
+        }
+
+        return PromiseObject.create({
+          promise: promise,
+          content: this.inverseRecord
+        });
+      } else {
+        Ember.assert("You looked up the '" + this.key + "' relationship on a '" + this.record.constructor.typeKey + "' with id " + this.record.get('id') +  " but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (`DS.belongsTo({ async: true })`)", this.inverseRecord === null || !this.inverseRecord.get('isEmpty'));
+        return this.inverseRecord;
+      }
+    };
+
+    function setForArray(array) {
+      var set = new OrderedSet();
+
+      if (array) {
+        for (var i=0, l=array.length; i<l; i++) {
+          set.add(array[i]);
+        }
+      }
+
+      return set;
+    }
+
+    var createRelationshipFor = function(record, relationshipMeta, store){
+      var inverseKey;
+      var inverse = record.constructor.inverseFor(relationshipMeta.key);
+
+      if (inverse) {
+        inverseKey = inverse.name;
+      }
+
+      if (relationshipMeta.kind === 'hasMany'){
+        return new ManyRelationship(store, record, inverseKey, relationshipMeta);
+      }
+      else {
+        return new BelongsToRelationship(store, record, inverseKey, relationshipMeta);
+      }
+    };
+
+
+    __exports__.Relationship = Relationship;
+    __exports__.ManyRelationship = ManyRelationship;
+    __exports__.BelongsToRelationship = BelongsToRelationship;
+    __exports__.createRelationshipFor = createRelationshipFor;
+  });
+enifed("ember-data/system/store",
+  ["ember-data/system/adapter","ember-inflector/system/string","ember-data/system/map","ember-data/system/promise_proxies","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
+    "use strict";
+    /*globals Ember*/
+    /*jshint eqnull:true*/
+
+    /**
+      @module ember-data
+    */
+
+    var InvalidError = __dependency1__.InvalidError;
+    var Adapter = __dependency1__.Adapter;
+    var singularize = __dependency2__.singularize;
+    var Map = __dependency3__.Map;
+
+    var promiseArray = __dependency4__.promiseArray;
+    var promiseObject = __dependency4__.promiseObject;
+
+
+    var get = Ember.get;
+    var set = Ember.set;
+    var once = Ember.run.once;
+    var isNone = Ember.isNone;
+    var forEach = Ember.EnumerableUtils.forEach;
+    var indexOf = Ember.EnumerableUtils.indexOf;
+    var map = Ember.EnumerableUtils.map;
+    var Promise = Ember.RSVP.Promise;
+    var copy = Ember.copy;
+    var Store, RecordArrayManager, Model;
+
+    var camelize = Ember.String.camelize;
+
+    // Implementors Note:
+    //
+    //   The variables in this file are consistently named according to the following
+    //   scheme:
+    //
+    //   * +id+ means an identifier managed by an external source, provided inside
+    //     the data provided by that source. These are always coerced to be strings
+    //     before being used internally.
+    //   * +clientId+ means a transient numerical identifier generated at runtime by
+    //     the data store. It is important primarily because newly created objects may
+    //     not yet have an externally generated id.
+    //   * +reference+ means a record reference object, which holds metadata about a
+    //     record, even if it has not yet been fully materialized.
+    //   * +type+ means a subclass of DS.Model.
+
+    // Used by the store to normalize IDs entering the store.  Despite the fact
+    // that developers may provide IDs as numbers (e.g., `store.find(Person, 1)`),
+    // it is important that internally we use strings, since IDs may be serialized
+    // and lose type information.  For example, Ember's router may put a record's
+    // ID into the URL, and if we later try to deserialize that URL and find the
+    // corresponding record, we will not know if it is a string or a number.
+    function coerceId(id) {
+      return id == null ? null : id+'';
+    }
+
+    /**
+      The store contains all of the data for records loaded from the server.
+      It is also responsible for creating instances of `DS.Model` that wrap
+      the individual data for a record, so that they can be bound to in your
+      Handlebars templates.
+
+      Define your application's store like this:
+
+      ```javascript
+      MyApp.Store = DS.Store.extend();
+      ```
+
+      Most Ember.js applications will only have a single `DS.Store` that is
+      automatically created by their `Ember.Application`.
+
+      You can retrieve models from the store in several ways. To retrieve a record
+      for a specific id, use `DS.Store`'s `find()` method:
+
+      ```javascript
+      store.find('person', 123).then(function (person) {
+      });
+      ```
+
+      By default, the store will talk to your backend using a standard
+      REST mechanism. You can customize how the store talks to your
+      backend by specifying a custom adapter:
+
+      ```javascript
+      MyApp.ApplicationAdapter = MyApp.CustomAdapter
+      ```
+
+      You can learn more about writing a custom adapter by reading the `DS.Adapter`
+      documentation.
+
+      ### Store createRecord() vs. push() vs. pushPayload() vs. update()
+
+      The store provides multiple ways to create new record objects. They have
+      some subtle differences in their use which are detailed below:
+
+      [createRecord](#method_createRecord) is used for creating new
+      records on the client side. This will return a new record in the
+      `created.uncommitted` state. In order to persist this record to the
+      backend you will need to call `record.save()`.
+
+      [push](#method_push) is used to notify Ember Data's store of new or
+      updated records that exist in the backend. This will return a record
+      in the `loaded.saved` state. The primary use-case for `store#push` is
+      to notify Ember Data about record updates that happen
+      outside of the normal adapter methods (for example
+      [SSE](http://dev.w3.org/html5/eventsource/) or [Web
+      Sockets](http://www.w3.org/TR/2009/WD-websockets-20091222/)).
+
+      [pushPayload](#method_pushPayload) is a convenience wrapper for
+      `store#push` that will deserialize payloads if the
+      Serializer implements a `pushPayload` method.
+
+      [update](#method_update) works like `push`, except it can handle
+      partial attributes without overwriting the existing record
+      properties.
+
+      Note: When creating a new record using any of the above methods
+      Ember Data will update `DS.RecordArray`s such as those returned by
+      `store#all()`, `store#findAll()` or `store#filter()`. This means any
+      data bindings or computed properties that depend on the RecordArray
+      will automatically be synced to include the new or updated record
+      values.
+
+      @class Store
+      @namespace DS
+      @extends Ember.Object
+    */
+    Store = Ember.Object.extend({
+
+      /**
+        @method init
+        @private
+      */
+      init: function() {
+        // internal bookkeeping; not observable
+        if (!RecordArrayManager) { RecordArrayManager = requireModule("ember-data/system/record_array_manager")["default"]; }
+        this.typeMaps = {};
+        this.recordArrayManager = RecordArrayManager.create({
+          store: this
+        });
+        this._pendingSave = [];
+        //Used to keep track of all the find requests that need to be coalesced
+        this._pendingFetch = Map.create();
+      },
+
+      /**
+        The adapter to use to communicate to a backend server or other persistence layer.
+
+        This can be specified as an instance, class, or string.
+
+        If you want to specify `App.CustomAdapter` as a string, do:
+
+        ```js
+        adapter: 'custom'
+        ```
+
+        @property adapter
+        @default DS.RESTAdapter
+        @type {DS.Adapter|String}
+      */
+      adapter: '-rest',
+
+      /**
+        Returns a JSON representation of the record using a custom
+        type-specific serializer, if one exists.
+
+        The available options are:
+
+        * `includeId`: `true` if the record's ID should be included in
+          the JSON representation
+
+        @method serialize
+        @private
+        @param {DS.Model} record the record to serialize
+        @param {Object} options an options hash
+      */
+      serialize: function(record, options) {
+        return this.serializerFor(record.constructor.typeKey).serialize(record, options);
+      },
+
+      /**
+        This property returns the adapter, after resolving a possible
+        string key.
+
+        If the supplied `adapter` was a class, or a String property
+        path resolved to a class, this property will instantiate the
+        class.
+
+        This property is cacheable, so the same instance of a specified
+        adapter class should be used for the lifetime of the store.
+
+        @property defaultAdapter
+        @private
+        @return DS.Adapter
+      */
+      defaultAdapter: Ember.computed('adapter', function() {
+        var adapter = get(this, 'adapter');
+
+        Ember.assert('You tried to set `adapter` property to an instance of `DS.Adapter`, where it should be a name or a factory', !(adapter instanceof Adapter));
+
+        if (typeof adapter === 'string') {
+          adapter = this.container.lookup('adapter:' + adapter) || this.container.lookup('adapter:application') || this.container.lookup('adapter:-rest');
+        }
+
+        if (DS.Adapter.detect(adapter)) {
+          adapter = adapter.create({
+            container: this.container
+          });
+        }
+
+        return adapter;
+      }),
+
+      // .....................
+      // . CREATE NEW RECORD .
+      // .....................
+
+      /**
+        Create a new record in the current store. The properties passed
+        to this method are set on the newly created record.
+
+        To create a new instance of `App.Post`:
+
+        ```js
+        store.createRecord('post', {
+          title: "Rails is omakase"
+        });
+        ```
+
+        @method createRecord
+        @param {String} type
+        @param {Object} properties a hash of properties to set on the
+          newly created record.
+        @return {DS.Model} record
+      */
+      createRecord: function(typeName, inputProperties) {
+        var type = this.modelFor(typeName);
+        var properties = copy(inputProperties) || {};
+
+        // If the passed properties do not include a primary key,
+        // give the adapter an opportunity to generate one. Typically,
+        // client-side ID generators will use something like uuid.js
+        // to avoid conflicts.
+
+        if (isNone(properties.id)) {
+          properties.id = this._generateId(type);
+        }
+
+        // Coerce ID to a string
+        properties.id = coerceId(properties.id);
+
+        var record = this.buildRecord(type, properties.id);
+
+        // Move the record out of its initial `empty` state into
+        // the `loaded` state.
+        record.loadedData();
+
+        // Set the properties specified on the record.
+        record.setProperties(properties);
+
+        return record;
+      },
+
+      /**
+        If possible, this method asks the adapter to generate an ID for
+        a newly created record.
+
+        @method _generateId
+        @private
+        @param {String} type
+        @return {String} if the adapter can generate one, an ID
+      */
+      _generateId: function(type) {
+        var adapter = this.adapterFor(type);
+
+        if (adapter && adapter.generateIdForRecord) {
+          return adapter.generateIdForRecord(this);
+        }
+
+        return null;
+      },
+
+      // .................
+      // . DELETE RECORD .
+      // .................
+
+      /**
+        For symmetry, a record can be deleted via the store.
+
+        Example
+
+        ```javascript
+        var post = store.createRecord('post', {
+          title: "Rails is omakase"
+        });
+
+        store.deleteRecord(post);
+        ```
+
+        @method deleteRecord
+        @param {DS.Model} record
+      */
+      deleteRecord: function(record) {
+        record.deleteRecord();
+      },
+
+      /**
+        For symmetry, a record can be unloaded via the store. Only
+        non-dirty records can be unloaded.
+
+        Example
+
+        ```javascript
+        store.find('post', 1).then(function(post) {
+          store.unloadRecord(post);
+        });
+        ```
+
+        @method unloadRecord
+        @param {DS.Model} record
+      */
+      unloadRecord: function(record) {
+        record.unloadRecord();
+      },
+
+      // ................
+      // . FIND RECORDS .
+      // ................
+
+      /**
+        This is the main entry point into finding records. The first parameter to
+        this method is the model's name as a string.
+
+        ---
+
+        To find a record by ID, pass the `id` as the second parameter:
+
+        ```javascript
+        store.find('person', 1);
+        ```
+
+        The `find` method will always return a **promise** that will be resolved
+        with the record. If the record was already in the store, the promise will
+        be resolved immediately. Otherwise, the store will ask the adapter's `find`
+        method to find the necessary data.
+
+        The `find` method will always resolve its promise with the same object for
+        a given type and `id`.
+
+        ---
+
+        You can optionally `preload` specific attributes and relationships that you know of
+        by passing them as the third argument to find.
+
+        For example, if your Ember route looks like `/posts/1/comments/2` and your API route
+        for the comment also looks like `/posts/1/comments/2` if you want to fetch the comment
+        without fetching the post you can pass in the post to the `find` call:
+
+        ```javascript
+        store.find('comment', 2, {post: 1});
+        ```
+
+        If you have access to the post model you can also pass the model itself:
+
+        ```javascript
+        store.find('post', 1).then(function (myPostModel) {
+          store.find('comment', 2, {post: myPostModel});
+        });
+        ```
+
+        This way, your adapter's `find` or `buildURL` method will be able to look up the
+        relationship on the record and construct the nested URL without having to first
+        fetch the post.
+
+        ---
+
+        To find all records for a type, call `find` with no additional parameters:
+
+        ```javascript
+        store.find('person');
+        ```
+
+        This will ask the adapter's `findAll` method to find the records for the
+        given type, and return a promise that will be resolved once the server
+        returns the values.
+
+        ---
+
+        To find a record by a query, call `find` with a hash as the second
+        parameter:
+
+        ```javascript
+        store.find('person', { page: 1 });
+        ```
+
+        This will ask the adapter's `findQuery` method to find the records for
+        the query, and return a promise that will be resolved once the server
+        responds.
+
+        @method find
+        @param {String or subclass of DS.Model} type
+        @param {Object|String|Integer|null} id
+        @param {Object} preload - optional set of attributes and relationships passed in either as IDs or as actual models
+        @return {Promise} promise
+      */
+      find: function(type, id, preload) {
+        Ember.assert("You need to pass a type to the store's find method", arguments.length >= 1);
+        Ember.assert("You may not pass `" + id + "` as id to the store's find method", arguments.length === 1 || !Ember.isNone(id));
+
+        if (arguments.length === 1) {
+          return this.findAll(type);
+        }
+
+        // We are passed a query instead of an id.
+        if (Ember.typeOf(id) === 'object') {
+          return this.findQuery(type, id);
+        }
+
+        return this.findById(type, coerceId(id), preload);
+      },
+
+      /**
+        This method returns a fresh record for a given type and id combination.
+
+        If a record is available for the given type/id combination, then it will fetch this record from the store then reload it. If there's no record corresponding in the store it will simply call store.find.
+
+        @method fetch
+        @param {String or subclass of DS.Model} type
+        @param {Object|String|Integer|null} id
+        @param {Object} preload - optional set of attributes and relationships passed in either as IDs or as actual models
+        @return {Promise} promise
+      */
+      fetch: function(type, id, preload) {
+        if (this.hasRecordForId(type, id)) {
+          return this.getById(type, id).reload();
+        } else {
+          return this.find(type, id, preload);
+        }
+      },
+
+      /**
+        This method returns a record for a given type and id combination.
+
+        @method findById
+        @private
+        @param {String or subclass of DS.Model} type
+        @param {String|Integer} id
+        @param {Object} preload - optional set of attributes and relationships passed in either as IDs or as actual models
+        @return {Promise} promise
+      */
+      findById: function(typeName, id, preload) {
+
+        var type = this.modelFor(typeName);
+        var record = this.recordForId(type, id);
+
+        return this._findByRecord(record, preload);
+      },
+
+      _findByRecord: function(record, preload) {
+        var fetchedRecord;
+
+        if (preload) {
+          record._preloadData(preload);
+        }
+
+        if (get(record, 'isEmpty')) {
+          fetchedRecord = this.scheduleFetch(record);
+          //TODO double check about reloading
+        } else if (get(record, 'isLoading')){
+          fetchedRecord = record._loadingPromise;
+        }
+
+        return promiseObject(fetchedRecord || record, "DS: Store#findByRecord " + record.typeKey + " with id: " + get(record, 'id'));
+      },
+
+      /**
+        This method makes a series of requests to the adapter's `find` method
+        and returns a promise that resolves once they are all loaded.
+
+        @private
+        @method findByIds
+        @param {String} type
+        @param {Array} ids
+        @return {Promise} promise
+      */
+      findByIds: function(type, ids) {
+        var store = this;
+
+        return promiseArray(Ember.RSVP.all(map(ids, function(id) {
+          return store.findById(type, id);
+        })).then(Ember.A, null, "DS: Store#findByIds of " + type + " complete"));
+      },
+
+      /**
+        This method is called by `findById` if it discovers that a particular
+        type/id pair hasn't been loaded yet to kick off a request to the
+        adapter.
+
+        @method fetchRecord
+        @private
+        @param {DS.Model} record
+        @return {Promise} promise
+      */
+      fetchRecord: function(record) {
+        var type = record.constructor;
+        var id = get(record, 'id');
+        var adapter = this.adapterFor(type);
+
+        Ember.assert("You tried to find a record but you have no adapter (for " + type + ")", adapter);
+        Ember.assert("You tried to find a record but your adapter (for " + type + ") does not implement 'find'", typeof adapter.find === 'function');
+
+        var promise = _find(adapter, this, type, id, record);
+        return promise;
+      },
+
+      scheduleFetchMany: function(records) {
+        return Promise.all(map(records, this.scheduleFetch, this));
+      },
+
+      scheduleFetch: function(record) {
+        var type = record.constructor;
+        if (isNone(record)) { return null; }
+        if (record._loadingPromise) { return record._loadingPromise; }
+
+        var resolver = Ember.RSVP.defer('Fetching ' + type + 'with id: ' + record.get('id'));
+        var recordResolverPair = {
+          record: record,
+          resolver: resolver
+        };
+        var promise = resolver.promise;
+
+        record.loadingData(promise);
+
+        if (!this._pendingFetch.get(type)){
+          this._pendingFetch.set(type, [recordResolverPair]);
+        } else {
+          this._pendingFetch.get(type).push(recordResolverPair);
+        }
+        Ember.run.scheduleOnce('afterRender', this, this.flushAllPendingFetches);
+
+        return promise;
+      },
+
+      flushAllPendingFetches: function(){
+        if (this.isDestroyed || this.isDestroying) {
+          return;
+        }
+
+        this._pendingFetch.forEach(this._flushPendingFetchForType, this);
+        this._pendingFetch = Map.create();
+      },
+
+      _flushPendingFetchForType: function (recordResolverPairs, type) {
+        var store = this;
+        var adapter = store.adapterFor(type);
+        var shouldCoalesce = !!adapter.findMany && adapter.coalesceFindRequests;
+        var records = Ember.A(recordResolverPairs).mapBy('record');
+
+        function _fetchRecord(recordResolverPair) {
+          recordResolverPair.resolver.resolve(store.fetchRecord(recordResolverPair.record));
+        }
+
+        function resolveFoundRecords(records) {
+          forEach(records, function(record){
+            var pair = Ember.A(recordResolverPairs).findBy('record', record);
+            if (pair){
+              var resolver = pair.resolver;
+              resolver.resolve(record);
+            }
+          });
+        }
+
+        function makeMissingRecordsRejector(requestedRecords) {
+          return function rejectMissingRecords(resolvedRecords) {
+            var missingRecords = requestedRecords.without(resolvedRecords);
+            rejectRecords(missingRecords);
+          };
+        }
+
+        function makeRecordsRejector(records) {
+          return function (error) {
+            rejectRecords(records, error);
+          };
+        }
+
+        function rejectRecords(records, error) {
+          forEach(records, function(record){
+            var pair = Ember.A(recordResolverPairs).findBy('record', record);
+            if (pair){
+              var resolver = pair.resolver;
+              resolver.reject(error);
+            }
+          });
+        }
+
+        if (recordResolverPairs.length === 1) {
+          _fetchRecord(recordResolverPairs[0]);
+        } else if (shouldCoalesce) {
+          var groups = adapter.groupRecordsForFindMany(this, records);
+          forEach(groups, function (groupOfRecords) {
+            var requestedRecords = Ember.A(groupOfRecords);
+            var ids = requestedRecords.mapBy('id');
+            if (ids.length > 1) {
+              _findMany(adapter, store, type, ids, requestedRecords).
+                then(resolveFoundRecords).
+                then(makeMissingRecordsRejector(requestedRecords)).
+                then(null, makeRecordsRejector(requestedRecords));
+            } else if (ids.length === 1) {
+              var pair = Ember.A(recordResolverPairs).findBy('record', groupOfRecords[0]);
+              _fetchRecord(pair);
+            } else {
+              Ember.assert("You cannot return an empty array from adapter's method groupRecordsForFindMany", false);
+            }
+          });
+        } else {
+          forEach(recordResolverPairs, _fetchRecord);
+        }
+      },
+
+      /**
+        Get a record by a given type and ID without triggering a fetch.
+
+        This method will synchronously return the record if it is available in the store,
+        otherwise it will return `null`. A record is available if it has been fetched earlier, or
+        pushed manually into the store.
+
+        _Note: This is an synchronous method and does not return a promise._
+
+        ```js
+        var post = store.getById('post', 1);
+
+        post.get('id'); // 1
+        ```
+
+        @method getById
+        @param {String or subclass of DS.Model} type
+        @param {String|Integer} id
+        @return {DS.Model|null} record
+      */
+      getById: function(type, id) {
+        if (this.hasRecordForId(type, id)) {
+          return this.recordForId(type, id);
+        } else {
+          return null;
+        }
+      },
+
+      /**
+        This method is called by the record's `reload` method.
+
+        This method calls the adapter's `find` method, which returns a promise. When
+        **that** promise resolves, `reloadRecord` will resolve the promise returned
+        by the record's `reload`.
+
+        @method reloadRecord
+        @private
+        @param {DS.Model} record
+        @return {Promise} promise
+      */
+      reloadRecord: function(record) {
+        var type = record.constructor;
+        var adapter = this.adapterFor(type);
+        var id = get(record, 'id');
+
+        Ember.assert("You cannot reload a record without an ID", id);
+        Ember.assert("You tried to reload a record but you have no adapter (for " + type + ")", adapter);
+        Ember.assert("You tried to reload a record but your adapter does not implement `find`", typeof adapter.find === 'function');
+
+        return this.scheduleFetch(record);
+      },
+
+      /**
+        Returns true if a record for a given type and ID is already loaded.
+
+        @method hasRecordForId
+        @param {String or subclass of DS.Model} type
+        @param {String|Integer} id
+        @return {Boolean}
+      */
+      hasRecordForId: function(typeName, inputId) {
+        var type = this.modelFor(typeName);
+        var id = coerceId(inputId);
+        return !!this.typeMapFor(type).idToRecord[id];
+      },
+
+      /**
+        Returns id record for a given type and ID. If one isn't already loaded,
+        it builds a new record and leaves it in the `empty` state.
+
+        @method recordForId
+        @private
+        @param {String or subclass of DS.Model} type
+        @param {String|Integer} id
+        @return {DS.Model} record
+      */
+      recordForId: function(typeName, inputId) {
+        var type = this.modelFor(typeName);
+        var id = coerceId(inputId);
+        var idToRecord = this.typeMapFor(type).idToRecord;
+        var record = idToRecord[id];
+
+        if (!record || !idToRecord[id]) {
+          record = this.buildRecord(type, id);
+        }
+
+        return record;
+      },
+
+      /**
+        @method findMany
+        @private
+        @param {DS.Model} owner
+        @param {Array} records
+        @param {String or subclass of DS.Model} type
+        @param {Resolver} resolver
+        @return {DS.ManyArray} records
+      */
+      findMany: function(records) {
+        var store = this;
+        return Promise.all(map(records, function(record) {
+          return store._findByRecord(record);
+        }));
+      },
+
+
+      /**
+        If a relationship was originally populated by the adapter as a link
+        (as opposed to a list of IDs), this method is called when the
+        relationship is fetched.
+
+        The link (which is usually a URL) is passed through unchanged, so the
+        adapter can make whatever request it wants.
+
+        The usual use-case is for the server to register a URL as a link, and
+        then use that URL in the future to make a request for the relationship.
+
+        @method findHasMany
+        @private
+        @param {DS.Model} owner
+        @param {any} link
+        @param {String or subclass of DS.Model} type
+        @return {Promise} promise
+      */
+      findHasMany: function(owner, link, type) {
+        var adapter = this.adapterFor(owner.constructor);
+
+        Ember.assert("You tried to load a hasMany relationship but you have no adapter (for " + owner.constructor + ")", adapter);
+        Ember.assert("You tried to load a hasMany relationship from a specified `link` in the original payload but your adapter does not implement `findHasMany`", typeof adapter.findHasMany === 'function');
+
+        return _findHasMany(adapter, this, owner, link, type);
+      },
+
+      /**
+        @method findBelongsTo
+        @private
+        @param {DS.Model} owner
+        @param {any} link
+        @param {Relationship} relationship
+        @return {Promise} promise
+      */
+      findBelongsTo: function(owner, link, relationship) {
+        var adapter = this.adapterFor(owner.constructor);
+
+        Ember.assert("You tried to load a belongsTo relationship but you have no adapter (for " + owner.constructor + ")", adapter);
+        Ember.assert("You tried to load a belongsTo relationship from a specified `link` in the original payload but your adapter does not implement `findBelongsTo`", typeof adapter.findBelongsTo === 'function');
+
+        return _findBelongsTo(adapter, this, owner, link, relationship);
+      },
+
+      /**
+        This method delegates a query to the adapter. This is the one place where
+        adapter-level semantics are exposed to the application.
+
+        Exposing queries this way seems preferable to creating an abstract query
+        language for all server-side queries, and then require all adapters to
+        implement them.
+
+        This method returns a promise, which is resolved with a `RecordArray`
+        once the server returns.
+
+        @method findQuery
+        @private
+        @param {String or subclass of DS.Model} type
+        @param {any} query an opaque query to be used by the adapter
+        @return {Promise} promise
+      */
+      findQuery: function(typeName, query) {
+        var type = this.modelFor(typeName);
+        var array = this.recordArrayManager
+          .createAdapterPopulatedRecordArray(type, query);
+
+        var adapter = this.adapterFor(type);
+
+        Ember.assert("You tried to load a query but you have no adapter (for " + type + ")", adapter);
+        Ember.assert("You tried to load a query but your adapter does not implement `findQuery`", typeof adapter.findQuery === 'function');
+
+        return promiseArray(_findQuery(adapter, this, type, query, array));
+      },
+
+      /**
+        This method returns an array of all records adapter can find.
+        It triggers the adapter's `findAll` method to give it an opportunity to populate
+        the array with records of that type.
+
+        @method findAll
+        @private
+        @param {String or subclass of DS.Model} type
+        @return {DS.AdapterPopulatedRecordArray}
+      */
+      findAll: function(typeName) {
+        var type = this.modelFor(typeName);
+
+        return this.fetchAll(type, this.all(type));
+      },
+
+      /**
+        @method fetchAll
+        @private
+        @param {DS.Model} type
+        @param {DS.RecordArray} array
+        @return {Promise} promise
+      */
+      fetchAll: function(type, array) {
+        var adapter = this.adapterFor(type);
+        var sinceToken = this.typeMapFor(type).metadata.since;
+
+        set(array, 'isUpdating', true);
+
+        Ember.assert("You tried to load all records but you have no adapter (for " + type + ")", adapter);
+        Ember.assert("You tried to load all records but your adapter does not implement `findAll`", typeof adapter.findAll === 'function');
+
+        return promiseArray(_findAll(adapter, this, type, sinceToken));
+      },
+
+      /**
+        @method didUpdateAll
+        @param {DS.Model} type
+      */
+      didUpdateAll: function(type) {
+        var findAllCache = this.typeMapFor(type).findAllCache;
+        set(findAllCache, 'isUpdating', false);
+      },
+
+      /**
+        This method returns a filtered array that contains all of the
+        known records for a given type in the store.
+
+        Note that because it's just a filter, the result will contain any
+        locally created records of the type, however, it will not make a
+        request to the backend to retrieve additional records. If you
+        would like to request all the records from the backend please use
+        [store.find](#method_find).
+
+        Also note that multiple calls to `all` for a given type will always
+        return the same `RecordArray`.
+
+        Example
+
+        ```javascript
+        var localPosts = store.all('post');
+        ```
+
+        @method all
+        @param {String or subclass of DS.Model} type
+        @return {DS.RecordArray}
+      */
+      all: function(typeName) {
+        var type = this.modelFor(typeName);
+        var typeMap = this.typeMapFor(type);
+        var findAllCache = typeMap.findAllCache;
+
+        if (findAllCache) { return findAllCache; }
+
+        var array = this.recordArrayManager.createRecordArray(type);
+
+        typeMap.findAllCache = array;
+        return array;
+      },
+
+
+      /**
+        This method unloads all of the known records for a given type.
+
+        ```javascript
+        store.unloadAll('post');
+        ```
+
+        @method unloadAll
+        @param {String or subclass of DS.Model} type
+      */
+      unloadAll: function(type) {
+        var modelType = this.modelFor(type);
+        var typeMap = this.typeMapFor(modelType);
+        var records = typeMap.records.slice();
+        var record;
+
+        for (var i = 0; i < records.length; i++) {
+          record = records[i];
+          record.unloadRecord();
+          record.destroy(); // maybe within unloadRecord
+        }
+
+        typeMap.findAllCache = null;
+      },
+
+      /**
+        Takes a type and filter function, and returns a live RecordArray that
+        remains up to date as new records are loaded into the store or created
+        locally.
+
+        The filter function takes a materialized record, and returns true
+        if the record should be included in the filter and false if it should
+        not.
+
+        Example
+
+        ```javascript
+        store.filter('post', function(post) {
+          return post.get('unread');
+        });
+        ```
+
+        The filter function is called once on all records for the type when
+        it is created, and then once on each newly loaded or created record.
+
+        If any of a record's properties change, or if it changes state, the
+        filter function will be invoked again to determine whether it should
+        still be in the array.
+
+        Optionally you can pass a query, which is the equivalent of calling
+        [find](#method_find) with that same query, to fetch additional records
+        from the server. The results returned by the server could then appear
+        in the filter if they match the filter function.
+
+        The query itself is not used to filter records, it's only sent to your
+        server for you to be able to do server-side filtering. The filter
+        function will be applied on the returned results regardless.
+
+        Example
+
+        ```javascript
+        store.filter('post', { unread: true }, function(post) {
+          return post.get('unread');
+        }).then(function(unreadPosts) {
+          unreadPosts.get('length'); // 5
+          var unreadPost = unreadPosts.objectAt(0);
+          unreadPost.set('unread', false);
+          unreadPosts.get('length'); // 4
+        });
+        ```
+
+        @method filter
+        @param {String or subclass of DS.Model} type
+        @param {Object} query optional query
+        @param {Function} filter
+        @return {DS.PromiseArray}
+      */
+      filter: function(type, query, filter) {
+        var promise;
+        var length = arguments.length;
+        var array;
+        var hasQuery = length === 3;
+
+        // allow an optional server query
+        if (hasQuery) {
+          promise = this.findQuery(type, query);
+        } else if (arguments.length === 2) {
+          filter = query;
+        }
+
+        type = this.modelFor(type);
+
+        if (hasQuery) {
+          array = this.recordArrayManager.createFilteredRecordArray(type, filter, query);
+        } else {
+          array = this.recordArrayManager.createFilteredRecordArray(type, filter);
+        }
+
+        promise = promise || Promise.cast(array);
+
+
+        return promiseArray(promise.then(function() {
+          return array;
+        }, null, "DS: Store#filter of " + type));
+      },
+
+      /**
+        This method returns if a certain record is already loaded
+        in the store. Use this function to know beforehand if a find()
+        will result in a request or that it will be a cache hit.
+
+         Example
+
+        ```javascript
+        store.recordIsLoaded('post', 1); // false
+        store.find('post', 1).then(function() {
+          store.recordIsLoaded('post', 1); // true
+        });
+        ```
+
+        @method recordIsLoaded
+        @param {String or subclass of DS.Model} type
+        @param {string} id
+        @return {boolean}
+      */
+      recordIsLoaded: function(type, id) {
+        if (!this.hasRecordForId(type, id)) { return false; }
+        return !get(this.recordForId(type, id), 'isEmpty');
+      },
+
+      /**
+        This method returns the metadata for a specific type.
+
+        @method metadataFor
+        @param {String or subclass of DS.Model} type
+        @return {object}
+      */
+      metadataFor: function(type) {
+        type = this.modelFor(type);
+        return this.typeMapFor(type).metadata;
+      },
+
+      // ............
+      // . UPDATING .
+      // ............
+
+      /**
+        If the adapter updates attributes or acknowledges creation
+        or deletion, the record will notify the store to update its
+        membership in any filters.
+        To avoid thrashing, this method is invoked only once per
+
+        run loop per record.
+
+        @method dataWasUpdated
+        @private
+        @param {Class} type
+        @param {DS.Model} record
+      */
+      dataWasUpdated: function(type, record) {
+        this.recordArrayManager.recordDidChange(record);
+      },
+
+      // ..............
+      // . PERSISTING .
+      // ..............
+
+      /**
+        This method is called by `record.save`, and gets passed a
+        resolver for the promise that `record.save` returns.
+
+        It schedules saving to happen at the end of the run loop.
+
+        @method scheduleSave
+        @private
+        @param {DS.Model} record
+        @param {Resolver} resolver
+      */
+      scheduleSave: function(record, resolver) {
+        record.adapterWillCommit();
+        this._pendingSave.push([record, resolver]);
+        once(this, 'flushPendingSave');
+      },
+
+      /**
+        This method is called at the end of the run loop, and
+        flushes any records passed into `scheduleSave`
+
+        @method flushPendingSave
+        @private
+      */
+      flushPendingSave: function() {
+        var pending = this._pendingSave.slice();
+        this._pendingSave = [];
+
+        forEach(pending, function(tuple) {
+          var record = tuple[0], resolver = tuple[1];
+          var adapter = this.adapterFor(record.constructor);
+          var operation;
+
+          if (get(record, 'currentState.stateName') === 'root.deleted.saved') {
+            return resolver.resolve(record);
+          } else if (get(record, 'isNew')) {
+            operation = 'createRecord';
+          } else if (get(record, 'isDeleted')) {
+            operation = 'deleteRecord';
+          } else {
+            operation = 'updateRecord';
+          }
+
+          resolver.resolve(_commit(adapter, this, operation, record));
+        }, this);
+      },
+
+      /**
+        This method is called once the promise returned by an
+        adapter's `createRecord`, `updateRecord` or `deleteRecord`
+        is resolved.
+
+        If the data provides a server-generated ID, it will
+        update the record and the store's indexes.
+
+        @method didSaveRecord
+        @private
+        @param {DS.Model} record the in-flight record
+        @param {Object} data optional data (see above)
+      */
+      didSaveRecord: function(record, data) {
+        if (data) {
+          // normalize relationship IDs into records
+          data = normalizeRelationships(this, record.constructor, data, record);
+          setupRelationships(this, record, data);
+
+          this.updateId(record, data);
+        }
+
+        record.adapterDidCommit(data);
+      },
+
+      /**
+        This method is called once the promise returned by an
+        adapter's `createRecord`, `updateRecord` or `deleteRecord`
+        is rejected with a `DS.InvalidError`.
+
+        @method recordWasInvalid
+        @private
+        @param {DS.Model} record
+        @param {Object} errors
+      */
+      recordWasInvalid: function(record, errors) {
+        record.adapterDidInvalidate(errors);
+      },
+
+      /**
+        This method is called once the promise returned by an
+        adapter's `createRecord`, `updateRecord` or `deleteRecord`
+        is rejected (with anything other than a `DS.InvalidError`).
+
+        @method recordWasError
+        @private
+        @param {DS.Model} record
+      */
+      recordWasError: function(record) {
+        record.adapterDidError();
+      },
+
+      /**
+        When an adapter's `createRecord`, `updateRecord` or `deleteRecord`
+        resolves with data, this method extracts the ID from the supplied
+        data.
+
+        @method updateId
+        @private
+        @param {DS.Model} record
+        @param {Object} data
+      */
+      updateId: function(record, data) {
+        var oldId = get(record, 'id');
+        var id = coerceId(data.id);
+
+        Ember.assert("An adapter cannot assign a new id to a record that already has an id. " + record + " had id: " + oldId + " and you tried to update it with " + id + ". This likely happened because your server returned data in response to a find or update that had a different id than the one you sent.", oldId === null || id === oldId);
+
+        this.typeMapFor(record.constructor).idToRecord[id] = record;
+
+        set(record, 'id', id);
+      },
+
+      /**
+        Returns a map of IDs to client IDs for a given type.
+
+        @method typeMapFor
+        @private
+        @param {subclass of DS.Model} type
+        @return {Object} typeMap
+      */
+      typeMapFor: function(type) {
+        var typeMaps = get(this, 'typeMaps');
+        var guid = Ember.guidFor(type);
+        var typeMap;
+
+        typeMap = typeMaps[guid];
+
+        if (typeMap) { return typeMap; }
+
+        typeMap = {
+          idToRecord: Ember.create(null),
+          records: [],
+          metadata: Ember.create(null),
+          type: type
+        };
+
+        typeMaps[guid] = typeMap;
+
+        return typeMap;
+      },
+
+      // ................
+      // . LOADING DATA .
+      // ................
+
+      /**
+        This internal method is used by `push`.
+
+        @method _load
+        @private
+        @param {String or subclass of DS.Model} type
+        @param {Object} data
+        @param {Boolean} partial the data should be merged into
+          the existing data, not replace it.
+      */
+      _load: function(type, data, partial) {
+        var id = coerceId(data.id);
+        var record = this.recordForId(type, id);
+
+        record.setupData(data, partial);
+        this.recordArrayManager.recordDidChange(record);
+
+        return record;
+      },
+
+      /**
+        Returns a model class for a particular key. Used by
+        methods that take a type key (like `find`, `createRecord`,
+        etc.)
+
+        @method modelFor
+        @param {String or subclass of DS.Model} key
+        @return {subclass of DS.Model}
+      */
+      modelFor: function(key) {
+        var factory;
+
+        if (typeof key === 'string') {
+          factory = this.modelFactoryFor(key);
+          if (!factory) {
+            throw new Ember.Error("No model was found for '" + key + "'");
+          }
+          factory.typeKey = factory.typeKey || this._normalizeTypeKey(key);
+        } else {
+          // A factory already supplied. Ensure it has a normalized key.
+          factory = key;
+          if (factory.typeKey) {
+            factory.typeKey = this._normalizeTypeKey(factory.typeKey);
+          }
+        }
+
+        factory.store = this;
+        return factory;
+      },
+
+      modelFactoryFor: function(key){
+        return this.container.lookupFactory('model:' + key);
+      },
+
+      /**
+        Push some data for a given type into the store.
+
+        This method expects normalized data:
+
+        * The ID is a key named `id` (an ID is mandatory)
+        * The names of attributes are the ones you used in
+          your model's `DS.attr`s.
+        * Your relationships must be:
+          * represented as IDs or Arrays of IDs
+          * represented as model instances
+          * represented as URLs, under the `links` key
+
+        For this model:
+
+        ```js
+        App.Person = DS.Model.extend({
+          firstName: DS.attr(),
+          lastName: DS.attr(),
+
+          children: DS.hasMany('person')
+        });
+        ```
+
+        To represent the children as IDs:
+
+        ```js
+        {
+          id: 1,
+          firstName: "Tom",
+          lastName: "Dale",
+          children: [1, 2, 3]
+        }
+        ```
+
+        To represent the children relationship as a URL:
+
+        ```js
+        {
+          id: 1,
+          firstName: "Tom",
+          lastName: "Dale",
+          links: {
+            children: "/people/1/children"
+          }
+        }
+        ```
+
+        If you're streaming data or implementing an adapter,
+        make sure that you have converted the incoming data
+        into this form.
+
+        This method can be used both to push in brand new
+        records, as well as to update existing records.
+
+        @method push
+        @param {String or subclass of DS.Model} type
+        @param {Object} data
+        @return {DS.Model} the record that was created or
+          updated.
+      */
+      push: function(typeName, data, _partial) {
+        // _partial is an internal param used by `update`.
+        // If passed, it means that the data should be
+        // merged into the existing data, not replace it.
+        Ember.assert("Expected an object as `data` in a call to `push`/`update` for " + typeName + " , but was " + data, Ember.typeOf(data) === 'object');
+        Ember.assert("You must include an `id` for " + typeName + " in an object passed to `push`/`update`", data.id != null && data.id !== '');
+
+        var type = this.modelFor(typeName);
+        var filter = Ember.EnumerableUtils.filter;
+
+        // If the payload contains relationships that are specified as
+        // IDs, normalizeRelationships will convert them into DS.Model instances
+        // (possibly unloaded) before we push the payload into the
+        // store.
+
+        data = normalizeRelationships(this, type, data);
+
+        Ember.warn("The payload for '" + typeName + "' contains these unknown keys: " +
+          Ember.inspect(filter(Ember.keys(data), function(key) {
+            return !get(type, 'fields').has(key) && key !== 'id' && key !== 'links';
+          })) + ". Make sure they've been defined in your model.",
+          filter(Ember.keys(data), function(key) {
+            return !get(type, 'fields').has(key) && key !== 'id' && key !== 'links';
+          }).length === 0
+        );
+
+        // Actually load the record into the store.
+
+        this._load(type, data, _partial);
+
+        var record = this.recordForId(type, data.id);
+
+        // Now that the pushed record as well as any related records
+        // are in the store, create the data structures used to track
+        // relationships.
+        setupRelationships(this, record, data);
+
+        return record;
+      },
+
+      /**
+        Push some raw data into the store.
+
+        This method can be used both to push in brand new
+        records, as well as to update existing records. You
+        can push in more than one type of object at once.
+        All objects should be in the format expected by the
+        serializer.
+
+        ```js
+        App.ApplicationSerializer = DS.ActiveModelSerializer;
+
+        var pushData = {
+          posts: [
+            {id: 1, post_title: "Great post", comment_ids: [2]}
+          ],
+          comments: [
+            {id: 2, comment_body: "Insightful comment"}
+          ]
+        }
+
+        store.pushPayload(pushData);
+        ```
+
+        By default, the data will be deserialized using a default
+        serializer (the application serializer if it exists).
+
+        Alternatively, `pushPayload` will accept a model type which
+        will determine which serializer will process the payload.
+        However, the serializer itself (processing this data via
+        `normalizePayload`) will not know which model it is
+        deserializing.
+
+        ```js
+        App.ApplicationSerializer = DS.ActiveModelSerializer;
+        App.PostSerializer = DS.JSONSerializer;
+        store.pushPayload('comment', pushData); // Will use the ApplicationSerializer
+        store.pushPayload('post', pushData); // Will use the PostSerializer
+        ```
+
+        @method pushPayload
+        @param {String} type Optionally, a model used to determine which serializer will be used
+        @param {Object} payload
+      */
+      pushPayload: function (type, inputPayload) {
+        var serializer;
+        var payload;
+        if (!inputPayload) {
+          payload = type;
+          serializer = defaultSerializer(this.container);
+          Ember.assert("You cannot use `store#pushPayload` without a type unless your default serializer defines `pushPayload`", typeof serializer.pushPayload === 'function');
+        } else {
+          payload = inputPayload;
+          serializer = this.serializerFor(type);
+        }
+        serializer.pushPayload(this, payload);
+      },
+
+      /**
+        `normalize` converts a json payload into the normalized form that
+        [push](#method_push) expects.
+
+        Example
+
+        ```js
+        socket.on('message', function(message) {
+          var modelName = message.model;
+          var data = message.data;
+          store.push(modelName, store.normalize(modelName, data));
+        });
+        ```
+
+        @method normalize
+        @param {String} type The name of the model type for this payload
+        @param {Object} payload
+        @return {Object} The normalized payload
+      */
+      normalize: function (type, payload) {
+        var serializer = this.serializerFor(type);
+        var model = this.modelFor(type);
+        return serializer.normalize(model, payload);
+      },
+
+      /**
+        Update existing records in the store. Unlike [push](#method_push),
+        update will merge the new data properties with the existing
+        properties. This makes it safe to use with a subset of record
+        attributes. This method expects normalized data.
+
+        `update` is useful if your app broadcasts partial updates to
+        records.
+
+        ```js
+        App.Person = DS.Model.extend({
+          firstName: DS.attr('string'),
+          lastName: DS.attr('string')
+        });
+
+        store.get('person', 1).then(function(tom) {
+          tom.get('firstName'); // Tom
+          tom.get('lastName'); // Dale
+
+          var updateEvent = {id: 1, firstName: "TomHuda"};
+          store.update('person', updateEvent);
+
+          tom.get('firstName'); // TomHuda
+          tom.get('lastName'); // Dale
+        });
+        ```
+
+        @method update
+        @param {String} type
+        @param {Object} data
+        @return {DS.Model} the record that was updated.
+      */
+      update: function(type, data) {
+        return this.push(type, data, true);
+      },
+
+      /**
+        If you have an Array of normalized data to push,
+        you can call `pushMany` with the Array, and it will
+        call `push` repeatedly for you.
+
+        @method pushMany
+        @param {String or subclass of DS.Model} type
+        @param {Array} datas
+        @return {Array}
+      */
+      pushMany: function(type, datas) {
+        var length = datas.length;
+        var result = new Array(length);
+
+        for (var i = 0; i < length; i++) {
+          result[i] = this.push(type, datas[i]);
+        }
+
+        return result;
+      },
+
+      /**
+        If you have some metadata to set for a type
+        you can call `metaForType`.
+
+        @method metaForType
+        @param {String or subclass of DS.Model} type
+        @param {Object} metadata
+      */
+      metaForType: function(typeName, metadata) {
+        var type = this.modelFor(typeName);
+
+        Ember.merge(this.typeMapFor(type).metadata, metadata);
+      },
+
+      /**
+        Build a brand new record for a given type, ID, and
+        initial data.
+
+        @method buildRecord
+        @private
+        @param {subclass of DS.Model} type
+        @param {String} id
+        @param {Object} data
+        @return {DS.Model} record
+      */
+      buildRecord: function(type, id, data) {
+        var typeMap = this.typeMapFor(type);
+        var idToRecord = typeMap.idToRecord;
+
+        Ember.assert('The id ' + id + ' has already been used with another record of type ' + type.toString() + '.', !id || !idToRecord[id]);
+        Ember.assert("`" + Ember.inspect(type)+ "` does not appear to be an ember-data model", (typeof type._create === 'function') );
+
+        // lookupFactory should really return an object that creates
+        // instances with the injections applied
+        var record = type._create({
+          id: id,
+          store: this,
+          container: this.container
+        });
+
+        if (data) {
+          record.setupData(data);
+        }
+
+        // if we're creating an item, this process will be done
+        // later, once the object has been persisted.
+        if (id) {
+          idToRecord[id] = record;
+        }
+
+        typeMap.records.push(record);
+
+        return record;
+      },
+
+      // ...............
+      // . DESTRUCTION .
+      // ...............
+
+      /**
+        When a record is destroyed, this un-indexes it and
+        removes it from any record arrays so it can be GCed.
+
+        @method dematerializeRecord
+        @private
+        @param {DS.Model} record
+      */
+      dematerializeRecord: function(record) {
+        var type = record.constructor;
+        var typeMap = this.typeMapFor(type);
+        var id = get(record, 'id');
+
+        record.updateRecordArrays();
+
+        if (id) {
+          delete typeMap.idToRecord[id];
+        }
+
+        var loc = indexOf(typeMap.records, record);
+        typeMap.records.splice(loc, 1);
+      },
+
+      // ......................
+      // . PER-TYPE ADAPTERS
+      // ......................
+
+      /**
+        Returns the adapter for a given type.
+
+        @method adapterFor
+        @private
+        @param {subclass of DS.Model} type
+        @return DS.Adapter
+      */
+      adapterFor: function(type) {
+        var container = this.container, adapter;
+
+        if (container) {
+          adapter = container.lookup('adapter:' + type.typeKey) || container.lookup('adapter:application');
+        }
+
+        return adapter || get(this, 'defaultAdapter');
+      },
+
+      // ..............................
+      // . RECORD CHANGE NOTIFICATION .
+      // ..............................
+
+      /**
+        Returns an instance of the serializer for a given type. For
+        example, `serializerFor('person')` will return an instance of
+        `App.PersonSerializer`.
+
+        If no `App.PersonSerializer` is found, this method will look
+        for an `App.ApplicationSerializer` (the default serializer for
+        your entire application).
+
+        If no `App.ApplicationSerializer` is found, it will fall back
+        to an instance of `DS.JSONSerializer`.
+
+        @method serializerFor
+        @private
+        @param {String} type the record to serialize
+        @return {DS.Serializer}
+      */
+      serializerFor: function(type) {
+        type = this.modelFor(type);
+        var adapter = this.adapterFor(type);
+
+        return serializerFor(this.container, type.typeKey, adapter && adapter.defaultSerializer);
+      },
+
+      willDestroy: function() {
+        var typeMaps = this.typeMaps;
+        var keys = Ember.keys(typeMaps);
+
+        var types = map(keys, byType);
+
+        this.recordArrayManager.destroy();
+
+        forEach(types, this.unloadAll, this);
+
+        function byType(entry) {
+          return typeMaps[entry]['type'];
+        }
+
+      },
+
+      /**
+        All typeKeys are camelCase internally. Changing this function may
+        require changes to other normalization hooks (such as typeForRoot).
+
+        @method _normalizeTypeKey
+        @private
+        @param {String} type
+        @return {String} if the adapter can generate one, an ID
+      */
+      _normalizeTypeKey: function(key) {
+        return camelize(singularize(key));
+      }
+    });
+
+
+    function normalizeRelationships(store, type, data, record) {
+      type.eachRelationship(function(key, relationship) {
+        var kind = relationship.kind;
+        var value = data[key];
+        if (kind === 'belongsTo') {
+          deserializeRecordId(store, data, key, relationship, value);
+        } else if (kind === 'hasMany') {
+          deserializeRecordIds(store, data, key, relationship, value);
+        }
+      });
+
+      return data;
+    }
+
+    function deserializeRecordId(store, data, key, relationship, id) {
+      if (!Model) { Model = requireModule("ember-data/system/model")["Model"]; }
+      if (isNone(id) || id instanceof Model) {
+        return;
+      }
+      Ember.assert("A " + relationship.parentType + " record was pushed into the store with the value of " + key + " being " + Ember.inspect(id) + ", but " + key + " is a belongsTo relationship so the value must not be an array. You should probably check your data payload or serializer.", !Ember.isArray(id));
+
+      var type;
+
+      if (typeof id === 'number' || typeof id === 'string') {
+        type = typeFor(relationship, key, data);
+        data[key] = store.recordForId(type, id);
+      } else if (typeof id === 'object') {
+        // polymorphic
+        data[key] = store.recordForId(id.type, id.id);
+      }
+    }
+
+    function typeFor(relationship, key, data) {
+      if (relationship.options.polymorphic) {
+        return data[key + "Type"];
+      } else {
+        return relationship.type;
+      }
+    }
+
+    function deserializeRecordIds(store, data, key, relationship, ids) {
+      if (isNone(ids)) {
+        return;
+      }
+
+      Ember.assert("A " + relationship.parentType + " record was pushed into the store with the value of " + key + " being '" + Ember.inspect(ids) + "', but " + key + " is a hasMany relationship so the value must be an array. You should probably check your data payload or serializer.", Ember.isArray(ids));
+      for (var i=0, l=ids.length; i<l; i++) {
+        deserializeRecordId(store, ids, i, relationship, ids[i]);
+      }
+    }
+
+    // Delegation to the adapter and promise management
+
+
+    function serializerFor(container, type, defaultSerializer) {
+      return container.lookup('serializer:'+type) ||
+                     container.lookup('serializer:application') ||
+                     container.lookup('serializer:' + defaultSerializer) ||
+                     container.lookup('serializer:-default');
+    }
+
+    function defaultSerializer(container) {
+      return container.lookup('serializer:application') ||
+             container.lookup('serializer:-default');
+    }
+
+    function serializerForAdapter(adapter, type) {
+      var serializer = adapter.serializer;
+      var defaultSerializer = adapter.defaultSerializer;
+      var container = adapter.container;
+
+      if (container && serializer === undefined) {
+        serializer = serializerFor(container, type.typeKey, defaultSerializer);
+      }
+
+      if (serializer === null || serializer === undefined) {
+        serializer = {
+          extract: function(store, type, payload) { return payload; }
+        };
+      }
+
+      return serializer;
+    }
+
+    function _objectIsAlive(object) {
+      return !(get(object, "isDestroyed") || get(object, "isDestroying"));
+    }
+
+    function _guard(promise, test) {
+      var guarded = promise['finally'](function() {
+        if (!test()) {
+          guarded._subscribers.length = 0;
+        }
+      });
+
+      return guarded;
+    }
+
+    function _bind(fn) {
+      var args = Array.prototype.slice.call(arguments, 1);
+
+      return function() {
+        return fn.apply(undefined, args);
+      };
+    }
+
+    function _find(adapter, store, type, id, record) {
+      var promise = adapter.find(store, type, id, record);
+      var serializer = serializerForAdapter(adapter, type);
+      var label = "DS: Handle Adapter#find of " + type + " with id: " + id;
+
+      promise = Promise.cast(promise, label);
+      promise = _guard(promise, _bind(_objectIsAlive, store));
+
+      return promise.then(function(adapterPayload) {
+        Ember.assert("You made a request for a " + type.typeKey + " with id " + id + ", but the adapter's response did not have any data", adapterPayload);
+        var payload = serializer.extract(store, type, adapterPayload, id, 'find');
+
+        return store.push(type, payload);
+      }, function(error) {
+        var record = store.getById(type, id);
+        if (record) {
+          record.notFound();
+        }
+        throw error;
+      }, "DS: Extract payload of '" + type + "'");
+    }
+
+
+    function _findMany(adapter, store, type, ids, records) {
+      var promise = adapter.findMany(store, type, ids, records);
+      var serializer = serializerForAdapter(adapter, type);
+      var label = "DS: Handle Adapter#findMany of " + type;
+
+      if (promise === undefined) {
+        throw new Error('adapter.findMany returned undefined, this was very likely a mistake');
+      }
+
+      promise = Promise.cast(promise, label);
+      promise = _guard(promise, _bind(_objectIsAlive, store));
+
+      return promise.then(function(adapterPayload) {
+        var payload = serializer.extract(store, type, adapterPayload, null, 'findMany');
+
+        Ember.assert("The response from a findMany must be an Array, not " + Ember.inspect(payload), Ember.typeOf(payload) === 'array');
+
+        return store.pushMany(type, payload);
+      }, null, "DS: Extract payload of " + type);
+    }
+
+    function _findHasMany(adapter, store, record, link, relationship) {
+      var promise = adapter.findHasMany(store, record, link, relationship);
+      var serializer = serializerForAdapter(adapter, relationship.type);
+      var label = "DS: Handle Adapter#findHasMany of " + record + " : " + relationship.type;
+
+      promise = Promise.cast(promise, label);
+      promise = _guard(promise, _bind(_objectIsAlive, store));
+      promise = _guard(promise, _bind(_objectIsAlive, record));
+
+      return promise.then(function(adapterPayload) {
+        var payload = serializer.extract(store, relationship.type, adapterPayload, null, 'findHasMany');
+
+        Ember.assert("The response from a findHasMany must be an Array, not " + Ember.inspect(payload), Ember.typeOf(payload) === 'array');
+
+        var records = store.pushMany(relationship.type, payload);
+        return records;
+      }, null, "DS: Extract payload of " + record + " : hasMany " + relationship.type);
+    }
+
+    function _findBelongsTo(adapter, store, record, link, relationship) {
+      var promise = adapter.findBelongsTo(store, record, link, relationship);
+      var serializer = serializerForAdapter(adapter, relationship.type);
+      var label = "DS: Handle Adapter#findBelongsTo of " + record + " : " + relationship.type;
+
+      promise = Promise.cast(promise, label);
+      promise = _guard(promise, _bind(_objectIsAlive, store));
+      promise = _guard(promise, _bind(_objectIsAlive, record));
+
+      return promise.then(function(adapterPayload) {
+        var payload = serializer.extract(store, relationship.type, adapterPayload, null, 'findBelongsTo');
+
+        if (!payload) {
+          return null;
+        }
+
+        var record = store.push(relationship.type, payload);
+        return record;
+      }, null, "DS: Extract payload of " + record + " : " + relationship.type);
+    }
+
+    function _findAll(adapter, store, type, sinceToken) {
+      var promise = adapter.findAll(store, type, sinceToken);
+      var serializer = serializerForAdapter(adapter, type);
+      var label = "DS: Handle Adapter#findAll of " + type;
+
+      promise = Promise.cast(promise, label);
+      promise = _guard(promise, _bind(_objectIsAlive, store));
+
+      return promise.then(function(adapterPayload) {
+        var payload = serializer.extract(store, type, adapterPayload, null, 'findAll');
+
+        Ember.assert("The response from a findAll must be an Array, not " + Ember.inspect(payload), Ember.typeOf(payload) === 'array');
+
+        store.pushMany(type, payload);
+        store.didUpdateAll(type);
+        return store.all(type);
+      }, null, "DS: Extract payload of findAll " + type);
+    }
+
+    function _findQuery(adapter, store, type, query, recordArray) {
+      var promise = adapter.findQuery(store, type, query, recordArray);
+      var serializer = serializerForAdapter(adapter, type);
+      var label = "DS: Handle Adapter#findQuery of " + type;
+
+      promise = Promise.cast(promise, label);
+      promise = _guard(promise, _bind(_objectIsAlive, store));
+
+      return promise.then(function(adapterPayload) {
+        var payload = serializer.extract(store, type, adapterPayload, null, 'findQuery');
+
+        Ember.assert("The response from a findQuery must be an Array, not " + Ember.inspect(payload), Ember.typeOf(payload) === 'array');
+
+        recordArray.load(payload);
+        return recordArray;
+      }, null, "DS: Extract payload of findQuery " + type);
+    }
+
+    function _commit(adapter, store, operation, record) {
+      var type = record.constructor;
+      var promise = adapter[operation](store, type, record);
+      var serializer = serializerForAdapter(adapter, type);
+      var label = "DS: Extract and notify about " + operation + " completion of " + record;
+
+      Ember.assert("Your adapter's '" + operation + "' method must return a value, but it returned `undefined", promise !==undefined);
+
+      promise = Promise.cast(promise, label);
+      promise = _guard(promise, _bind(_objectIsAlive, store));
+      promise = _guard(promise, _bind(_objectIsAlive, record));
+
+      return promise.then(function(adapterPayload) {
+        var payload;
+
+        if (adapterPayload) {
+          payload = serializer.extract(store, type, adapterPayload, get(record, 'id'), operation);
+        } else {
+          payload = adapterPayload;
+        }
+
+        store.didSaveRecord(record, payload);
+        return record;
+      }, function(reason) {
+        if (reason instanceof InvalidError) {
+          var errors = serializer.extractErrors(store, type, reason.errors, get(record, 'id'));
+          store.recordWasInvalid(record, errors);
+          reason = new InvalidError(errors);
+        } else {
+          store.recordWasError(record, reason);
+        }
+
+        throw reason;
+      }, label);
+    }
+
+    function setupRelationships(store, record, data) {
+      var type = record.constructor;
+
+      type.eachRelationship(function(key, descriptor) {
+        var kind = descriptor.kind;
+        var value = data[key];
+        var relationship = record._relationships[key];
+
+        if (data.links && data.links[key]) {
+          relationship.updateLink(data.links[key]);
+        }
+
+        if (kind === 'belongsTo') {
+          if (value === undefined) {
+            return;
+          }
+          relationship.setRecord(value);
+        } else if (kind === 'hasMany' && value) {
+         relationship.updateRecordsFromAdapter(value);
+        }
+      });
+    }
+
+    __exports__.Store = Store;
+    __exports__["default"] = Store;
+  });
+enifed("ember-data/transforms",
+  ["ember-data/transforms/base","ember-data/transforms/number","ember-data/transforms/date","ember-data/transforms/string","ember-data/transforms/boolean","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __exports__) {
+    "use strict";
+    var Transform = __dependency1__["default"];
+    var NumberTransform = __dependency2__["default"];
+    var DateTransform = __dependency3__["default"];
+    var StringTransform = __dependency4__["default"];
+    var BooleanTransform = __dependency5__["default"];
+
+    __exports__.Transform = Transform;
+    __exports__.NumberTransform = NumberTransform;
+    __exports__.DateTransform = DateTransform;
+    __exports__.StringTransform = StringTransform;
+    __exports__.BooleanTransform = BooleanTransform;
+  });
+enifed("ember-data/transforms/base",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    /**
+      The `DS.Transform` class is used to serialize and deserialize model
+      attributes when they are saved or loaded from an
+      adapter. Subclassing `DS.Transform` is useful for creating custom
+      attributes. All subclasses of `DS.Transform` must implement a
+      `serialize` and a `deserialize` method.
+
+      Example
+
+      ```javascript
+      // Converts centigrade in the JSON to fahrenheit in the app
+      App.TemperatureTransform = DS.Transform.extend({
+        deserialize: function(serialized) {
+          return (serialized *  1.8) + 32;
+        },
+        serialize: function(deserialized) {
+          return (deserialized - 32) / 1.8;
+        }
+      });
+      ```
+
+      Usage
+
+      ```javascript
+      var attr = DS.attr;
+      App.Requirement = DS.Model.extend({
+        name: attr('string'),
+        temperature: attr('temperature')
+      });
+      ```
+
+      @class Transform
+      @namespace DS
+     */
+    __exports__["default"] = Ember.Object.extend({
+      /**
+        When given a deserialized value from a record attribute this
+        method must return the serialized value.
+
+        Example
+
+        ```javascript
+        serialize: function(deserialized) {
+          return Ember.isEmpty(deserialized) ? null : Number(deserialized);
+        }
+        ```
+
+        @method serialize
+        @param {mixed} deserialized The deserialized value
+        @return {mixed} The serialized value
+      */
+      serialize: Ember.required(),
+
+      /**
+        When given a serialize value from a JSON object this method must
+        return the deserialized value for the record attribute.
+
+        Example
+
+        ```javascript
+        deserialize: function(serialized) {
+          return empty(serialized) ? null : Number(serialized);
+        }
+        ```
+
+        @method deserialize
+        @param {mixed} serialized The serialized value
+        @return {mixed} The deserialized value
+      */
+      deserialize: Ember.required()
+    });
+  });
+enifed("ember-data/transforms/boolean",
+  ["ember-data/transforms/base","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Transform = __dependency1__["default"];
+
+    /**
+      The `DS.BooleanTransform` class is used to serialize and deserialize
+      boolean attributes on Ember Data record objects. This transform is
+      used when `boolean` is passed as the type parameter to the
+      [DS.attr](../../data#method_attr) function.
+
+      Usage
+
+      ```javascript
+      var attr = DS.attr;
+      App.User = DS.Model.extend({
+        isAdmin: attr('boolean'),
+        name: attr('string'),
+        email: attr('string')
+      });
+      ```
+
+      @class BooleanTransform
+      @extends DS.Transform
+      @namespace DS
+     */
+    __exports__["default"] = Transform.extend({
+      deserialize: function(serialized) {
+        var type = typeof serialized;
+
+        if (type === "boolean") {
+          return serialized;
+        } else if (type === "string") {
+          return serialized.match(/^true$|^t$|^1$/i) !== null;
+        } else if (type === "number") {
+          return serialized === 1;
+        } else {
+          return false;
+        }
+      },
+
+      serialize: function(deserialized) {
+        return Boolean(deserialized);
+      }
+    });
+  });
+enifed("ember-data/transforms/date",
+  ["ember-data/transforms/base","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    /**
+      The `DS.DateTransform` class is used to serialize and deserialize
+      date attributes on Ember Data record objects. This transform is used
+      when `date` is passed as the type parameter to the
+      [DS.attr](../../data#method_attr) function.
+
+      ```javascript
+      var attr = DS.attr;
+      App.Score = DS.Model.extend({
+        value: attr('number'),
+        player: DS.belongsTo('player'),
+        date: attr('date')
+      });
+      ```
+
+      @class DateTransform
+      @extends DS.Transform
+      @namespace DS
+     */
+    var Transform = __dependency1__["default"];
+
+    // Date.prototype.toISOString shim
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString
+    var toISOString = Date.prototype.toISOString || function() {
+      function pad(number) {
+        if ( number < 10 ) {
+          return '0' + number;
+        }
+        return number;
+      }
+
+      return this.getUTCFullYear() +
+        '-' + pad( this.getUTCMonth() + 1 ) +
+        '-' + pad( this.getUTCDate() ) +
+        'T' + pad( this.getUTCHours() ) +
+        ':' + pad( this.getUTCMinutes() ) +
+        ':' + pad( this.getUTCSeconds() ) +
+        '.' + (this.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) +
+        'Z';
+    };
+
+    if (Ember.SHIM_ES5) {
+      if (!Date.prototype.toISOString) {
+        Date.prototype.toISOString = toISOString;
+      }
+    }
+
+    __exports__["default"] = Transform.extend({
+      deserialize: function(serialized) {
+        var type = typeof serialized;
+
+        if (type === "string") {
+          return new Date(Ember.Date.parse(serialized));
+        } else if (type === "number") {
+          return new Date(serialized);
+        } else if (serialized === null || serialized === undefined) {
+          // if the value is not present in the data,
+          // return undefined, not null.
+          return serialized;
+        } else {
+          return null;
+        }
+      },
+
+      serialize: function(date) {
+        if (date instanceof Date) {
+          return toISOString.call(date);
+        } else {
+          return null;
+        }
+      }
+    });
+  });
+enifed("ember-data/transforms/number",
+  ["ember-data/transforms/base","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Transform = __dependency1__["default"];
+
+    var empty = Ember.isEmpty;
+
+    /**
+      The `DS.NumberTransform` class is used to serialize and deserialize
+      numeric attributes on Ember Data record objects. This transform is
+      used when `number` is passed as the type parameter to the
+      [DS.attr](../../data#method_attr) function.
+
+      Usage
+
+      ```javascript
+      var attr = DS.attr;
+      App.Score = DS.Model.extend({
+        value: attr('number'),
+        player: DS.belongsTo('player'),
+        date: attr('date')
+      });
+      ```
+
+      @class NumberTransform
+      @extends DS.Transform
+      @namespace DS
+     */
+    __exports__["default"] = Transform.extend({
+      deserialize: function(serialized) {
+        return empty(serialized) ? null : Number(serialized);
+      },
+
+      serialize: function(deserialized) {
+        return empty(deserialized) ? null : Number(deserialized);
+      }
+    });
+  });
+enifed("ember-data/transforms/string",
+  ["ember-data/transforms/base","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Transform = __dependency1__["default"];
+    var none = Ember.isNone;
+
+    /**
+      The `DS.StringTransform` class is used to serialize and deserialize
+      string attributes on Ember Data record objects. This transform is
+      used when `string` is passed as the type parameter to the
+      [DS.attr](../../data#method_attr) function.
+
+      Usage
+
+      ```javascript
+      var attr = DS.attr;
+      App.User = DS.Model.extend({
+        isAdmin: attr('boolean'),
+        name: attr('string'),
+        email: attr('string')
+      });
+      ```
+
+      @class StringTransform
+      @extends DS.Transform
+      @namespace DS
+     */
+    __exports__["default"] = Transform.extend({
+      deserialize: function(serialized) {
+        return none(serialized) ? null : String(serialized);
+      },
+      serialize: function(deserialized) {
+        return none(deserialized) ? null : String(deserialized);
+      }
+    });
+  });
+enifed("ember-inflector",
+  ["./system","./helpers","./ext/string","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+    "use strict";
+    var Inflector = __dependency1__.Inflector;
+    var defaultRules = __dependency1__.defaultRules;
+    var pluralize = __dependency1__.pluralize;
+    var singularize = __dependency1__.singularize;
+
+    Inflector.defaultRules = defaultRules;
+    Ember.Inflector        = Inflector;
+
+    Ember.String.pluralize   = pluralize;
+    Ember.String.singularize = singularize;
+
+
+    __exports__["default"] = Inflector;
+
+    __exports__.pluralize = pluralize;
+    __exports__.singularize = singularize;
+  });
+enifed("ember-inflector/ext/string",
+  ["../system/string"],
+  function(__dependency1__) {
+    "use strict";
+    var pluralize = __dependency1__.pluralize;
+    var singularize = __dependency1__.singularize;
+
+    if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.String) {
+      /**
+        See {{#crossLink "Ember.String/pluralize"}}{{/crossLink}}
+
+        @method pluralize
+        @for String
+      */
+      String.prototype.pluralize = function() {
+        return pluralize(this);
+      };
+
+      /**
+        See {{#crossLink "Ember.String/singularize"}}{{/crossLink}}
+
+        @method singularize
+        @for String
+      */
+      String.prototype.singularize = function() {
+        return singularize(this);
+      };
+    }
+  });
+enifed("ember-inflector/helpers",
+  ["./system/string"],
+  function(__dependency1__) {
+    "use strict";
+    var singularize = __dependency1__.singularize;
+    var pluralize = __dependency1__.pluralize;
+
+    /**
+     *
+     * If you have Ember Inflector (such as if Ember Data is present),
+     * singularize a word. For example, turn "oxen" into "ox".
+     *
+     * Example:
+     *
+     * {{singularize myProperty}}
+     * {{singularize "oxen"}}
+     *
+     * @for Ember.Handlebars.helpers
+     * @method singularize
+     * @param {String|Property} word word to singularize
+    */
+    Ember.Handlebars.helper('singularize', singularize);
+
+    /**
+     *
+     * If you have Ember Inflector (such as if Ember Data is present),
+     * pluralize a word. For example, turn "ox" into "oxen".
+     *
+     * Example:
+     *
+     * {{pluralize myProperty}}
+     * {{pluralize "oxen"}}
+     *
+     * @for Ember.Handlebars.helpers
+     * @method pluralize
+     * @param {String|Property} word word to pluralize
+    */
+    Ember.Handlebars.helper('pluralize', pluralize);
+  });
+enifed("ember-inflector/system",
+  ["./system/inflector","./system/string","./system/inflections","exports"],
+  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
+    "use strict";
+    var Inflector = __dependency1__["default"];
+
+    var pluralize = __dependency2__.pluralize;
+    var singularize = __dependency2__.singularize;
+
+    var defaultRules = __dependency3__["default"];
+
+    
+    Inflector.inflector = new Inflector(defaultRules);
+    
+    __exports__.Inflector = Inflector;
+    __exports__.singularize = singularize;
+    __exports__.pluralize = pluralize;
+    __exports__.defaultRules = defaultRules;
+  });
+enifed("ember-inflector/system/inflections",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    __exports__["default"] = {
+      plurals: [
+        [/$/, 's'],
+        [/s$/i, 's'],
+        [/^(ax|test)is$/i, '$1es'],
+        [/(octop|vir)us$/i, '$1i'],
+        [/(octop|vir)i$/i, '$1i'],
+        [/(alias|status)$/i, '$1es'],
+        [/(bu)s$/i, '$1ses'],
+        [/(buffal|tomat)o$/i, '$1oes'],
+        [/([ti])um$/i, '$1a'],
+        [/([ti])a$/i, '$1a'],
+        [/sis$/i, 'ses'],
+        [/(?:([^f])fe|([lr])f)$/i, '$1$2ves'],
+        [/(hive)$/i, '$1s'],
+        [/([^aeiouy]|qu)y$/i, '$1ies'],
+        [/(x|ch|ss|sh)$/i, '$1es'],
+        [/(matr|vert|ind)(?:ix|ex)$/i, '$1ices'],
+        [/^(m|l)ouse$/i, '$1ice'],
+        [/^(m|l)ice$/i, '$1ice'],
+        [/^(ox)$/i, '$1en'],
+        [/^(oxen)$/i, '$1'],
+        [/(quiz)$/i, '$1zes']
+      ],
+
+      singular: [
+        [/s$/i, ''],
+        [/(ss)$/i, '$1'],
+        [/(n)ews$/i, '$1ews'],
+        [/([ti])a$/i, '$1um'],
+        [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '$1sis'],
+        [/(^analy)(sis|ses)$/i, '$1sis'],
+        [/([^f])ves$/i, '$1fe'],
+        [/(hive)s$/i, '$1'],
+        [/(tive)s$/i, '$1'],
+        [/([lr])ves$/i, '$1f'],
+        [/([^aeiouy]|qu)ies$/i, '$1y'],
+        [/(s)eries$/i, '$1eries'],
+        [/(m)ovies$/i, '$1ovie'],
+        [/(x|ch|ss|sh)es$/i, '$1'],
+        [/^(m|l)ice$/i, '$1ouse'],
+        [/(bus)(es)?$/i, '$1'],
+        [/(o)es$/i, '$1'],
+        [/(shoe)s$/i, '$1'],
+        [/(cris|test)(is|es)$/i, '$1is'],
+        [/^(a)x[ie]s$/i, '$1xis'],
+        [/(octop|vir)(us|i)$/i, '$1us'],
+        [/(alias|status)(es)?$/i, '$1'],
+        [/^(ox)en/i, '$1'],
+        [/(vert|ind)ices$/i, '$1ex'],
+        [/(matr)ices$/i, '$1ix'],
+        [/(quiz)zes$/i, '$1'],
+        [/(database)s$/i, '$1']
+      ],
+
+      irregularPairs: [
+        ['person', 'people'],
+        ['man', 'men'],
+        ['child', 'children'],
+        ['sex', 'sexes'],
+        ['move', 'moves'],
+        ['cow', 'kine'],
+        ['zombie', 'zombies']
+      ],
+
+      uncountable: [
+        'equipment',
+        'information',
+        'rice',
+        'money',
+        'species',
+        'series',
+        'fish',
+        'sheep',
+        'jeans',
+        'police'
+      ]
+    };
+  });
+enifed("ember-inflector/system/inflector",
+  ["exports"],
+  function(__exports__) {
+    "use strict";
+    var BLANK_REGEX = /^\s*$/;
+    var LAST_WORD_DASHED_REGEX = /(\w+[_-])([a-z\d]+$)/;
+    var LAST_WORD_CAMELIZED_REGEX = /(\w+)([A-Z][a-z\d]*$)/;
+    var CAMELIZED_REGEX = /[A-Z][a-z\d]*$/;
+
+    function loadUncountable(rules, uncountable) {
+      for (var i = 0, length = uncountable.length; i < length; i++) {
+        rules.uncountable[uncountable[i].toLowerCase()] = true;
+      }
+    }
+
+    function loadIrregular(rules, irregularPairs) {
+      var pair;
+
+      for (var i = 0, length = irregularPairs.length; i < length; i++) {
+        pair = irregularPairs[i];
+
+        //pluralizing
+        rules.irregular[pair[0].toLowerCase()] = pair[1];
+        rules.irregular[pair[1].toLowerCase()] = pair[1];
+
+        //singularizing
+        rules.irregularInverse[pair[1].toLowerCase()] = pair[0];
+        rules.irregularInverse[pair[0].toLowerCase()] = pair[0];
+      }
+    }
+
+    /**
+      Inflector.Ember provides a mechanism for supplying inflection rules for your
+      application. Ember includes a default set of inflection rules, and provides an
+      API for providing additional rules.
+
+      Examples:
+
+      Creating an inflector with no rules.
+
+      ```js
+      var inflector = new Ember.Inflector();
+      ```
+
+      Creating an inflector with the default ember ruleset.
+
+      ```js
+      var inflector = new Ember.Inflector(Ember.Inflector.defaultRules);
+
+      inflector.pluralize('cow'); //=> 'kine'
+      inflector.singularize('kine'); //=> 'cow'
+      ```
+
+      Creating an inflector and adding rules later.
+
+      ```javascript
+      var inflector = Ember.Inflector.inflector;
+
+      inflector.pluralize('advice'); // => 'advices'
+      inflector.uncountable('advice');
+      inflector.pluralize('advice'); // => 'advice'
+
+      inflector.pluralize('formula'); // => 'formulas'
+      inflector.irregular('formula', 'formulae');
+      inflector.pluralize('formula'); // => 'formulae'
+
+      // you would not need to add these as they are the default rules
+      inflector.plural(/$/, 's');
+      inflector.singular(/s$/i, '');
+      ```
+
+      Creating an inflector with a nondefault ruleset.
+
+      ```javascript
+      var rules = {
+        plurals:  [ /$/, 's' ],
+        singular: [ /\s$/, '' ],
+        irregularPairs: [
+          [ 'cow', 'kine' ]
+        ],
+        uncountable: [ 'fish' ]
+      };
+
+      var inflector = new Ember.Inflector(rules);
+      ```
+
+      @class Inflector
+      @namespace Ember
+    */
+    function Inflector(ruleSet) {
+      ruleSet = ruleSet || {};
+      ruleSet.uncountable = ruleSet.uncountable || makeDictionary();
+      ruleSet.irregularPairs = ruleSet.irregularPairs || makeDictionary();
+
+      var rules = this.rules = {
+        plurals:  ruleSet.plurals || [],
+        singular: ruleSet.singular || [],
+        irregular: makeDictionary(),
+        irregularInverse: makeDictionary(),
+        uncountable: makeDictionary()
+      };
+
+      loadUncountable(rules, ruleSet.uncountable);
+      loadIrregular(rules, ruleSet.irregularPairs);
+
+      this.enableCache();
+    }
+
+    if (!Object.create && !Object.create(null).hasOwnProperty) {
+      throw new Error("This browser does not support Object.create(null), please polyfil with es5-sham: http://git.io/yBU2rg");
+    }
+
+    function makeDictionary() {
+      var cache = Object.create(null);
+      cache['_dict'] = null;
+      delete cache['_dict'];
+      return cache;
+    }
+
+    Inflector.prototype = {
+      /**
+        @public
+
+        As inflections can be costly, and commonly the same subset of words are repeatedly
+        inflected an optional cache is provided.
+
+        @method enableCache
+      */
+      enableCache: function() {
+        this.purgeCache();
+
+        this.singularize = function(word) {
+          this._cacheUsed = true;
+          return this._sCache[word] || (this._sCache[word] = this._singularize(word));
+        };
+
+        this.pluralize = function(word) {
+          this._cacheUsed = true;
+          return this._pCache[word] || (this._pCache[word] = this._pluralize(word));
+        };
+      },
+
+      /**
+        @public
+
+        @method purgedCache
+      */
+      purgeCache: function() {
+        this._cacheUsed = false;
+        this._sCache = makeDictionary();
+        this._pCache = makeDictionary();
+      },
+
+      /**
+        @public
+        disable caching
+
+        @method disableCache;
+      */
+      disableCache: function() {
+        this._sCache = null;
+        this._pCache = null;
+        this.singularize = function(word) {
+          return this._singularize(word);
+        };
+
+        this.pluralize = function(word) {
+          return this._pluralize(word);
+        };
+      },
+
+      /**
+        @method plural
+        @param {RegExp} regex
+        @param {String} string
+      */
+      plural: function(regex, string) {
+        if (this._cacheUsed) { this.purgeCache(); }
+        this.rules.plurals.push([regex, string.toLowerCase()]);
+      },
+
+      /**
+        @method singular
+        @param {RegExp} regex
+        @param {String} string
+      */
+      singular: function(regex, string) {
+        if (this._cacheUsed) { this.purgeCache(); }
+        this.rules.singular.push([regex, string.toLowerCase()]);
+      },
+
+      /**
+        @method uncountable
+        @param {String} regex
+      */
+      uncountable: function(string) {
+        if (this._cacheUsed) { this.purgeCache(); }
+        loadUncountable(this.rules, [string.toLowerCase()]);
+      },
+
+      /**
+        @method irregular
+        @param {String} singular
+        @param {String} plural
+      */
+      irregular: function (singular, plural) {
+        if (this._cacheUsed) { this.purgeCache(); }
+        loadIrregular(this.rules, [[singular, plural]]);
+      },
+
+      /**
+        @method pluralize
+        @param {String} word
+      */
+      pluralize: function(word) {
+        return this._pluralize(word);
+      },
+
+      _pluralize: function(word) {
+        return this.inflect(word, this.rules.plurals, this.rules.irregular);
+      },
+      /**
+        @method singularize
+        @param {String} word
+      */
+      singularize: function(word) {
+        return this._singularize(word);
+      },
+
+      _singularize: function(word) {
+        return this.inflect(word, this.rules.singular,  this.rules.irregularInverse);
+      },
+
+      /**
+        @protected
+
+        @method inflect
+        @param {String} word
+        @param {Object} typeRules
+        @param {Object} irregular
+      */
+      inflect: function(word, typeRules, irregular) {
+        var inflection, substitution, result, lowercase, wordSplit,
+          firstPhrase, lastWord, isBlank, isCamelized, isUncountable, 
+          isIrregular, isIrregularInverse, rule;
+      
+        isBlank = BLANK_REGEX.test(word);
+        isCamelized = CAMELIZED_REGEX.test(word);
+        firstPhrase = "";
+
+        if (isBlank) {
+          return word;
+        }
+
+        lowercase = word.toLowerCase();
+        wordSplit = LAST_WORD_DASHED_REGEX.exec(word) || LAST_WORD_CAMELIZED_REGEX.exec(word);
+        if (wordSplit){
+          firstPhrase = wordSplit[1];
+          lastWord = wordSplit[2].toLowerCase();
+        }
+
+        isUncountable = this.rules.uncountable[lowercase] || this.rules.uncountable[lastWord];
+
+        if (isUncountable) {
+          return word;
+        }
+
+        isIrregular = irregular && (irregular[lowercase] || irregular[lastWord]);
+
+        if (isIrregular) {
+          if (irregular[lowercase]){
+            return isIrregular;
+          }
+          else {
+            isIrregular = (isCamelized) ? isIrregular.capitalize() : isIrregular;
+            return firstPhrase + isIrregular;
+          }
+        }
+
+        for (var i = typeRules.length, min = 0; i > min; i--) {
+           inflection = typeRules[i-1];
+           rule = inflection[0];
+
+          if (rule.test(word)) {
+            break;
+          }
+        }
+
+        inflection = inflection || [];
+
+        rule = inflection[0];
+        substitution = inflection[1];
+
+        result = word.replace(rule, substitution);
+
+        return result;
+      }
+    };
+
+    __exports__["default"] = Inflector;
+  });
+enifed("ember-inflector/system/string",
+  ["./inflector","exports"],
+  function(__dependency1__, __exports__) {
+    "use strict";
+    var Inflector = __dependency1__["default"];
+
+    function pluralize(word) {
+      return Inflector.inflector.pluralize(word);
+    }
+
+    function singularize(word) {
+      return Inflector.inflector.singularize(word);
+    }
+
+    __exports__.pluralize = pluralize;
+    __exports__.singularize = singularize;
+  });
+ global.DS = requireModule('ember-data')['default'];
+ })(this);
\ No newline at end of file