@ember-data/serializer 5.4.0-alpha.32 → 5.4.0-alpha.33

package/unstable-preview-types/json.d.ts

@@ -1,1092 +1,1094 @@
-/// <reference types="ember-source/types" />
-export default JSONSerializer;
-/**
- * <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
-  <p>
-    ⚠️ <strong>This is LEGACY documentation</strong> for a feature that is no longer encouraged to be used.
-    If starting a new app or thinking of implementing a new adapter, consider writing a
-    <a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
-  </p>
-  </blockquote>
-
-  In EmberData 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.
-
-  By default, EmberData uses and recommends the `JSONAPISerializer`.
-
-  `JSONSerializer` is useful for simpler or legacy backends that may
-  not support the http://jsonapi.org/ spec.
-
-  For example, given the following `User` model and JSON payload:
-
-  ```app/models/user.js
-  import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
-
-  export default class UserModel extends Model {
-    @hasMany('user') friends;
-    @belongsTo('location') house;
-
-    @attr('string') name;
-  }
-  ```
-
-  ```js
-  {
-    id: 1,
-    name: 'Sebastian',
-    friends: [3, 4],
-    links: {
-      house: '/houses/lefkada'
+declare module '@ember-data/serializer/json' {
+  /// <reference types="ember-source/types" />
+  export default JSONSerializer;
+  /**
+   * <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
+    <p>
+      ⚠️ <strong>This is LEGACY documentation</strong> for a feature that is no longer encouraged to be used.
+      If starting a new app or thinking of implementing a new adapter, consider writing a
+      <a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
+    </p>
+    </blockquote>
+  
+    In EmberData 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.
+  
+    By default, EmberData uses and recommends the `JSONAPISerializer`.
+  
+    `JSONSerializer` is useful for simpler or legacy backends that may
+    not support the http://jsonapi.org/ spec.
+  
+    For example, given the following `User` model and JSON payload:
+  
+    ```app/models/user.js
+    import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
+  
+    export default class UserModel extends Model {
+      @hasMany('user') friends;
+      @belongsTo('location') house;
+  
+      @attr('string') name;
     }
-  }
-  ```
-
-  `JSONSerializer` will normalize the JSON payload to the JSON API format that the
-  Ember Data store expects.
-
-  You can customize how JSONSerializer processes its payload by passing options in
-  the `attrs` hash or by subclassing the `JSONSerializer` and overriding hooks:
-
-    - To customize how a single record is normalized, use the `normalize` hook.
-    - To customize how `JSONSerializer` normalizes the whole server response, use the
-      `normalizeResponse` hook.
-    - To customize how `JSONSerializer` normalizes a specific response from the server,
-      use one of the many specific `normalizeResponse` hooks.
-    - To customize how `JSONSerializer` normalizes your id, attributes or relationships,
-      use the `extractId`, `extractAttributes` and `extractRelationships` hooks.
-
-  The `JSONSerializer` normalization process follows these steps:
-
-    1. `normalizeResponse`
-        - entry method to the serializer.
-    2. `normalizeCreateRecordResponse`
-        - a `normalizeResponse` for a specific operation is called.
-    3. `normalizeSingleResponse`|`normalizeArrayResponse`
-        - for methods like `createRecord` we expect a single record back, while for methods like `findAll` we expect multiple records back.
-    4. `normalize`
-        - `normalizeArrayResponse` iterates and calls `normalize` for each of its records while `normalizeSingle`
-          calls it once. This is the method you most likely want to subclass.
-    5. `extractId` | `extractAttributes` | `extractRelationships`
-        - `normalize` delegates to these methods to
-          turn the record payload into the JSON API format.
-
-  @main @ember-data/serializer/json
-  @class JSONSerializer
-  @public
-  @extends Serializer
-*/
-declare const JSONSerializer: Readonly<typeof Serializer> & (new (owner?: import("@ember/-internals/owner").default | undefined) => Serializer) & {
-    /**
-      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
-  
-      ```app/serializers/application.js
-      import JSONSerializer from '@ember-data/serializer/json';
-  
-      export default class ApplicationSerializer extends JSONSerializer {
-        primaryKey = '_id'
-      }
-      ```
-  
-      @property primaryKey
-      @type {String}
-      @public
-      @default 'id'
-    */
-    primaryKey: string;
-    /**
-      The `attrs` object can be used to declare a simple mapping between
-      property names on `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
-  
-      ```app/models/person.js
-      import Model, { attr } from '@ember-data/model';
-  
-      export default class PersonModel extends Model {
-        @attr('string') firstName;
-        @attr('string') lastName;
-        @attr('string') occupation;
-        @attr('boolean') admin;
+    ```
+  
+    ```js
+    {
+      id: 1,
+      name: 'Sebastian',
+      friends: [3, 4],
+      links: {
+        house: '/houses/lefkada'
       }
-      ```
-  
-      ```app/serializers/person.js
-      import JSONSerializer from '@ember-data/serializer/json';
-  
-      export default class PersonSerializer extends JSONSerializer {
-        attrs = {
-          admin: 'is_admin',
-          occupation: { key: 'career' }
+    }
+    ```
+  
+    `JSONSerializer` will normalize the JSON payload to the JSON API format that the
+    Ember Data store expects.
+  
+    You can customize how JSONSerializer processes its payload by passing options in
+    the `attrs` hash or by subclassing the `JSONSerializer` and overriding hooks:
+  
+      - To customize how a single record is normalized, use the `normalize` hook.
+      - To customize how `JSONSerializer` normalizes the whole server response, use the
+        `normalizeResponse` hook.
+      - To customize how `JSONSerializer` normalizes a specific response from the server,
+        use one of the many specific `normalizeResponse` hooks.
+      - To customize how `JSONSerializer` normalizes your id, attributes or relationships,
+        use the `extractId`, `extractAttributes` and `extractRelationships` hooks.
+  
+    The `JSONSerializer` normalization process follows these steps:
+  
+      1. `normalizeResponse`
+          - entry method to the serializer.
+      2. `normalizeCreateRecordResponse`
+          - a `normalizeResponse` for a specific operation is called.
+      3. `normalizeSingleResponse`|`normalizeArrayResponse`
+          - for methods like `createRecord` we expect a single record back, while for methods like `findAll` we expect multiple records back.
+      4. `normalize`
+          - `normalizeArrayResponse` iterates and calls `normalize` for each of its records while `normalizeSingle`
+            calls it once. This is the method you most likely want to subclass.
+      5. `extractId` | `extractAttributes` | `extractRelationships`
+          - `normalize` delegates to these methods to
+            turn the record payload into the JSON API format.
+  
+    @main @ember-data/serializer/json
+    @class JSONSerializer
+    @public
+    @extends Serializer
+  */
+  declare const JSONSerializer: Readonly<typeof Serializer> & (new (owner?: import("@ember/-internals/owner").default | undefined) => Serializer) & {
+      /**
+        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
+    
+        ```app/serializers/application.js
+        import JSONSerializer from '@ember-data/serializer/json';
+    
+        export default class ApplicationSerializer extends JSONSerializer {
+          primaryKey = '_id'
         }
-      }
-      ```
-  
-      You can also remove attributes and relationships by setting the `serialize`
-      key to `false` in your mapping object.
-  
-      Example
-  
-      ```app/serializers/person.js
-      import JSONSerializer from '@ember-data/serializer/json';
-  
-      export default class PostSerializer extends JSONSerializer {
-        attrs = {
-          admin: { serialize: false },
-          occupation: { key: 'career' }
+        ```
+    
+        @property primaryKey
+        @type {String}
+        @public
+        @default 'id'
+      */
+      primaryKey: string;
+      /**
+        The `attrs` object can be used to declare a simple mapping between
+        property names on `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
+    
+        ```app/models/person.js
+        import Model, { attr } from '@ember-data/model';
+    
+        export default class PersonModel extends Model {
+          @attr('string') firstName;
+          @attr('string') lastName;
+          @attr('string') occupation;
+          @attr('boolean') admin;
         }
-      }
-      ```
-  
-      When serialized:
-  
-      ```javascript
-      {
-        "firstName": "Harry",
-        "lastName": "Houdini",
-        "career": "magician"
-      }
-      ```
-  
-      Note that the `admin` is now not included in the payload.
-  
-      Setting `serialize` to `true` enforces serialization for hasMany
-      relationships even if it's neither a many-to-many nor many-to-none
-      relationship.
-  
-      @property attrs
-      @public
-      @type {Object}
-    */
-    mergedProperties: Object;
-    /**
-     Given a subclass of `Model` and a JSON object this method will
-     iterate through each attribute of the `Model` and invoke the
-     `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 {Model} typeClass
-     @param {Object} data The data to transform
-     @return {Object} data The transformed data object
-    */
-    applyTransforms(typeClass: Model, data: Object): Object;
-    /**
-      The `normalizeResponse` method is used to normalize a payload from the
-      server to a JSON-API Document.
-  
-      http://jsonapi.org/format/#document-structure
-  
-      This method delegates to a more specific normalize method based on
-      the `requestType`.
-  
-      To override this method with a custom one, make sure to call
-      `return super.normalizeResponse(store, primaryModelClass, payload, id, requestType)` with your
-      pre-processed data.
-  
-      Here's an example of using `normalizeResponse` manually:
-  
-      ```javascript
-      socket.on('message', function(message) {
-        let data = message.data;
-        let modelClass = store.modelFor(data.modelName);
-        let serializer = store.serializerFor(data.modelName);
-        let normalized = serializer.normalizeSingleResponse(store, modelClass, data, data.id);
-  
-        store.push(normalized);
-      });
-      ```
-  
-      @since 1.13.0
-      @method normalizeResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `findRecord`
-  
-      @since 1.13.0
-      @method normalizeFindRecordResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeFindRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `queryRecord`
-  
-      @since 1.13.0
-      @method normalizeQueryRecordResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeQueryRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `findAll`
-  
-      @since 1.13.0
-      @method normalizeFindAllResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeFindAllResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `findBelongsTo`
-  
-      @since 1.13.0
-      @method normalizeFindBelongsToResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeFindBelongsToResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `findHasMany`
-  
-      @since 1.13.0
-      @method normalizeFindHasManyResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeFindHasManyResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `findMany`
-  
-      @since 1.13.0
-      @method normalizeFindManyResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeFindManyResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `query`
-  
-      @since 1.13.0
-      @method normalizeQueryResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeQueryResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `createRecord`
-  
-      @since 1.13.0
-      @method normalizeCreateRecordResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeCreateRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `deleteRecord`
-  
-      @since 1.13.0
-      @method normalizeDeleteRecordResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeDeleteRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `updateRecord`
-  
-      @since 1.13.0
-      @method normalizeUpdateRecordResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeUpdateRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-    /**
-      normalizeUpdateRecordResponse, normalizeCreateRecordResponse and
-      normalizeDeleteRecordResponse delegate to this method by default.
-  
-      @since 1.13.0
-      @method normalizeSaveResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeSaveResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-    /**
-      normalizeQueryResponse and normalizeFindRecordResponse delegate to this
-      method by default.
-  
-      @since 1.13.0
-      @method normalizeSingleResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeSingleResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string): Object;
-    /**
-      normalizeQueryResponse, normalizeFindManyResponse, and normalizeFindHasManyResponse delegate
-      to this method by default.
-  
-      @since 1.13.0
-      @method normalizeArrayResponse
-      @public
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @return {Object} JSON-API Document
-    */
-    normalizeArrayResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string): Object;
-    /**
-      @method _normalizeResponse
-      @param {Store} store
-      @param {Model} primaryModelClass
-      @param {Object} payload
-      @param {String|Number} id
-      @param {String} requestType
-      @param {Boolean} isSingle
-      @return {Object} JSON-API Document
-      @private
-    */
-    _normalizeResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, isSingle: boolean): Object;
-    /**
-      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 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
-  
-      ```app/serializers/application.js
-      import JSONSerializer from '@ember-data/serializer/json';
-      import { underscore } from '<app-name>/utils/string-utils';
-      import { get } from '@ember/object';
-  
-      export default class ApplicationSerializer extends JSONSerializer {
-        normalize(typeClass, hash) {
-          let fields = typeClass.fields;
-  
-          fields.forEach(function(type, field) {
-            let payloadField = underscore(field);
-            if (field === payloadField) { return; }
-  
-            hash[field] = hash[payloadField];
-            delete hash[payloadField];
-          });
-  
-          return super.normalize(...arguments);
+        ```
+    
+        ```app/serializers/person.js
+        import JSONSerializer from '@ember-data/serializer/json';
+    
+        export default class PersonSerializer extends JSONSerializer {
+          attrs = {
+            admin: 'is_admin',
+            occupation: { key: 'career' }
+          }
         }
-      }
-      ```
-  
-      @method normalize
-      @public
-      @param {Model} typeClass
-      @param {Object} hash
-      @return {Object}
-    */
-    normalize(modelClass: any, resourceHash: any): Object;
-    /**
-      Returns the resource's ID.
-  
-      @method extractId
-      @public
-      @param {Object} modelClass
-      @param {Object} resourceHash
-      @return {String}
-    */
-    extractId(modelClass: Object, resourceHash: Object): string;
-    /**
-      Returns the resource's attributes formatted as a JSON-API "attributes object".
-  
-      http://jsonapi.org/format/#document-resource-object-attributes
-  
-      @method extractAttributes
-      @public
-      @param {Object} modelClass
-      @param {Object} resourceHash
-      @return {Object}
-    */
-    extractAttributes(modelClass: Object, resourceHash: Object): Object;
-    /**
-      Returns a relationship formatted as a JSON-API "relationship object".
-  
-      http://jsonapi.org/format/#document-resource-object-relationships
-  
-      @method extractRelationship
-      @public
-      @param {Object} relationshipModelName
-      @param {Object} relationshipHash
-      @return {Object}
-    */
-    extractRelationship(relationshipModelName: Object, relationshipHash: Object): Object;
-    /**
-      Returns a polymorphic relationship formatted as a JSON-API "relationship object".
-  
-      http://jsonapi.org/format/#document-resource-object-relationships
-  
-      `relationshipOptions` is a hash which contains more information about the
-      polymorphic relationship which should be extracted:
-        - `resourceHash` complete hash of the resource the relationship should be
-          extracted from
-        - `relationshipKey` key under which the value for the relationship is
-          extracted from the resourceHash
-        - `relationshipMeta` meta information about the relationship
-  
-      @method extractPolymorphicRelationship
-      @public
-      @param {Object} relationshipModelName
-      @param {Object} relationshipHash
-      @param {Object} relationshipOptions
-      @return {Object}
-    */
-    extractPolymorphicRelationship(relationshipModelName: Object, relationshipHash: Object, relationshipOptions: Object): Object;
-    /**
-      Returns the resource's relationships formatted as a JSON-API "relationships object".
-  
-      http://jsonapi.org/format/#document-resource-object-relationships
-  
-      @method extractRelationships
-      @public
-      @param {Object} modelClass
-      @param {Object} resourceHash
-      @return {Object}
-    */
-    extractRelationships(modelClass: Object, resourceHash: Object): Object;
-    /**
-      Dasherizes the model name in the payload
-  
-      @method modelNameFromPayloadKey
-      @public
-      @param {String} key
-      @return {String} the model's modelName
-    */
-    modelNameFromPayloadKey(key: string): string;
-    /**
-      @method normalizeRelationships
-      @private
-    */
-    normalizeRelationships(typeClass: any, hash: any): void;
-    /**
-      @method normalizeUsingDeclaredMapping
-      @private
-    */
-    normalizeUsingDeclaredMapping(modelClass: any, hash: any): void;
-    /**
-      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(key: string, modelClass: any): string;
-    /**
-      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(key: string): boolean;
-    /**
-      When attrs.key.serialize is set to true then
-      it takes priority over the other checks and the related
-      attribute/relationship will be serialized
-  
-      @method _mustSerialize
-      @private
-      @param {String} key
-      @return {boolean} true if the key must be serialized
-    */
-    _mustSerialize(key: string): boolean;
-    /**
-      Check if the given hasMany relationship should be serialized
-  
-      By default only many-to-many and many-to-none relationships are serialized.
-      This could be configured per relationship by Serializer's `attrs` object.
-  
-      @method shouldSerializeHasMany
-      @public
-      @param {Snapshot} snapshot
-      @param {String} key
-      @param {RelationshipSchema} relationship
-      @return {boolean} true if the hasMany relationship should be serialized
-    */
-    shouldSerializeHasMany(snapshot: Snapshot, key: string, relationship: RelationshipSchema): boolean;
-    /**
-      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:
-  
-      ```app/models/comment.js
-      import Model, { attr, belongsTo } from '@ember-data/model';
-  
-      export default class CommentModel extends Model {
-        @attr title;
-        @attr body;
-  
-        @belongsTo('user') author;
-      }
-      ```
-  
-      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 (`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.
-  
-      ```app/serializers/post.js
-      import JSONSerializer from '@ember-data/serializer/json';
-  
-      export default class PostSerializer extends JSONSerializer {
-        serialize(snapshot, options) {
-          let json = {
-            POST_TTL: snapshot.attr('title'),
-            POST_BDY: snapshot.attr('body'),
-            POST_CMS: snapshot.hasMany('comments', { ids: true })
-          };
-  
-          if (options.includeId) {
-            json.POST_ID_ = snapshot.id;
+        ```
+    
+        You can also remove attributes and relationships by setting the `serialize`
+        key to `false` in your mapping object.
+    
+        Example
+    
+        ```app/serializers/person.js
+        import JSONSerializer from '@ember-data/serializer/json';
+    
+        export default class PostSerializer extends JSONSerializer {
+          attrs = {
+            admin: { serialize: false },
+            occupation: { key: 'career' }
           }
-  
-          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.
-  
-      ```app/serializers/application.js
-      import JSONSerializer from '@ember-data/serializer/json';
-      import { singularize } from '<app-name>/utils/string-utils';
-  
-      export default class ApplicationSerializer extends JSONSerializer {
-        serialize(snapshot, options) {
-          let json = {};
-  
-          snapshot.eachAttribute((name) => {
-            json[serverAttributeName(name)] = snapshot.attr(name);
-          });
-  
-          snapshot.eachRelationship((name, relationship) => {
-            if (relationship.kind === 'hasMany') {
-              json[serverHasManyName(name)] = snapshot.hasMany(name, { ids: true });
+        ```
+    
+        When serialized:
+    
+        ```javascript
+        {
+          "firstName": "Harry",
+          "lastName": "Houdini",
+          "career": "magician"
+        }
+        ```
+    
+        Note that the `admin` is now not included in the payload.
+    
+        Setting `serialize` to `true` enforces serialization for hasMany
+        relationships even if it's neither a many-to-many nor many-to-none
+        relationship.
+    
+        @property attrs
+        @public
+        @type {Object}
+      */
+      mergedProperties: Object;
+      /**
+       Given a subclass of `Model` and a JSON object this method will
+       iterate through each attribute of the `Model` and invoke the
+       `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 {Model} typeClass
+       @param {Object} data The data to transform
+       @return {Object} data The transformed data object
+      */
+      applyTransforms(typeClass: Model, data: Object): Object;
+      /**
+        The `normalizeResponse` method is used to normalize a payload from the
+        server to a JSON-API Document.
+    
+        http://jsonapi.org/format/#document-structure
+    
+        This method delegates to a more specific normalize method based on
+        the `requestType`.
+    
+        To override this method with a custom one, make sure to call
+        `return super.normalizeResponse(store, primaryModelClass, payload, id, requestType)` with your
+        pre-processed data.
+    
+        Here's an example of using `normalizeResponse` manually:
+    
+        ```javascript
+        socket.on('message', function(message) {
+          let data = message.data;
+          let modelClass = store.modelFor(data.modelName);
+          let serializer = store.serializerFor(data.modelName);
+          let normalized = serializer.normalizeSingleResponse(store, modelClass, data, data.id);
+    
+          store.push(normalized);
+        });
+        ```
+    
+        @since 1.13.0
+        @method normalizeResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      /**
+        Called by the default normalizeResponse implementation when the
+        type of request is `findRecord`
+    
+        @since 1.13.0
+        @method normalizeFindRecordResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeFindRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      /**
+        Called by the default normalizeResponse implementation when the
+        type of request is `queryRecord`
+    
+        @since 1.13.0
+        @method normalizeQueryRecordResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeQueryRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      /**
+        Called by the default normalizeResponse implementation when the
+        type of request is `findAll`
+    
+        @since 1.13.0
+        @method normalizeFindAllResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeFindAllResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      /**
+        Called by the default normalizeResponse implementation when the
+        type of request is `findBelongsTo`
+    
+        @since 1.13.0
+        @method normalizeFindBelongsToResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeFindBelongsToResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      /**
+        Called by the default normalizeResponse implementation when the
+        type of request is `findHasMany`
+    
+        @since 1.13.0
+        @method normalizeFindHasManyResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeFindHasManyResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      /**
+        Called by the default normalizeResponse implementation when the
+        type of request is `findMany`
+    
+        @since 1.13.0
+        @method normalizeFindManyResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeFindManyResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      /**
+        Called by the default normalizeResponse implementation when the
+        type of request is `query`
+    
+        @since 1.13.0
+        @method normalizeQueryResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeQueryResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      /**
+        Called by the default normalizeResponse implementation when the
+        type of request is `createRecord`
+    
+        @since 1.13.0
+        @method normalizeCreateRecordResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeCreateRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      /**
+        Called by the default normalizeResponse implementation when the
+        type of request is `deleteRecord`
+    
+        @since 1.13.0
+        @method normalizeDeleteRecordResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeDeleteRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      /**
+        Called by the default normalizeResponse implementation when the
+        type of request is `updateRecord`
+    
+        @since 1.13.0
+        @method normalizeUpdateRecordResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeUpdateRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      /**
+        normalizeUpdateRecordResponse, normalizeCreateRecordResponse and
+        normalizeDeleteRecordResponse delegate to this method by default.
+    
+        @since 1.13.0
+        @method normalizeSaveResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeSaveResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
+      /**
+        normalizeQueryResponse and normalizeFindRecordResponse delegate to this
+        method by default.
+    
+        @since 1.13.0
+        @method normalizeSingleResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeSingleResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string): Object;
+      /**
+        normalizeQueryResponse, normalizeFindManyResponse, and normalizeFindHasManyResponse delegate
+        to this method by default.
+    
+        @since 1.13.0
+        @method normalizeArrayResponse
+        @public
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @return {Object} JSON-API Document
+      */
+      normalizeArrayResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string): Object;
+      /**
+        @method _normalizeResponse
+        @param {Store} store
+        @param {Model} primaryModelClass
+        @param {Object} payload
+        @param {String|Number} id
+        @param {String} requestType
+        @param {Boolean} isSingle
+        @return {Object} JSON-API Document
+        @private
+      */
+      _normalizeResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, isSingle: boolean): Object;
+      /**
+        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 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
+    
+        ```app/serializers/application.js
+        import JSONSerializer from '@ember-data/serializer/json';
+        import { underscore } from '<app-name>/utils/string-utils';
+        import { get } from '@ember/object';
+    
+        export default class ApplicationSerializer extends JSONSerializer {
+          normalize(typeClass, hash) {
+            let fields = typeClass.fields;
+    
+            fields.forEach(function(type, field) {
+              let payloadField = underscore(field);
+              if (field === payloadField) { return; }
+    
+              hash[field] = hash[payloadField];
+              delete hash[payloadField];
+            });
+    
+            return super.normalize(...arguments);
+          }
+        }
+        ```
+    
+        @method normalize
+        @public
+        @param {Model} typeClass
+        @param {Object} hash
+        @return {Object}
+      */
+      normalize(modelClass: any, resourceHash: any): Object;
+      /**
+        Returns the resource's ID.
+    
+        @method extractId
+        @public
+        @param {Object} modelClass
+        @param {Object} resourceHash
+        @return {String}
+      */
+      extractId(modelClass: Object, resourceHash: Object): string;
+      /**
+        Returns the resource's attributes formatted as a JSON-API "attributes object".
+    
+        http://jsonapi.org/format/#document-resource-object-attributes
+    
+        @method extractAttributes
+        @public
+        @param {Object} modelClass
+        @param {Object} resourceHash
+        @return {Object}
+      */
+      extractAttributes(modelClass: Object, resourceHash: Object): Object;
+      /**
+        Returns a relationship formatted as a JSON-API "relationship object".
+    
+        http://jsonapi.org/format/#document-resource-object-relationships
+    
+        @method extractRelationship
+        @public
+        @param {Object} relationshipModelName
+        @param {Object} relationshipHash
+        @return {Object}
+      */
+      extractRelationship(relationshipModelName: Object, relationshipHash: Object): Object;
+      /**
+        Returns a polymorphic relationship formatted as a JSON-API "relationship object".
+    
+        http://jsonapi.org/format/#document-resource-object-relationships
+    
+        `relationshipOptions` is a hash which contains more information about the
+        polymorphic relationship which should be extracted:
+          - `resourceHash` complete hash of the resource the relationship should be
+            extracted from
+          - `relationshipKey` key under which the value for the relationship is
+            extracted from the resourceHash
+          - `relationshipMeta` meta information about the relationship
+    
+        @method extractPolymorphicRelationship
+        @public
+        @param {Object} relationshipModelName
+        @param {Object} relationshipHash
+        @param {Object} relationshipOptions
+        @return {Object}
+      */
+      extractPolymorphicRelationship(relationshipModelName: Object, relationshipHash: Object, relationshipOptions: Object): Object;
+      /**
+        Returns the resource's relationships formatted as a JSON-API "relationships object".
+    
+        http://jsonapi.org/format/#document-resource-object-relationships
+    
+        @method extractRelationships
+        @public
+        @param {Object} modelClass
+        @param {Object} resourceHash
+        @return {Object}
+      */
+      extractRelationships(modelClass: Object, resourceHash: Object): Object;
+      /**
+        Dasherizes the model name in the payload
+    
+        @method modelNameFromPayloadKey
+        @public
+        @param {String} key
+        @return {String} the model's modelName
+      */
+      modelNameFromPayloadKey(key: string): string;
+      /**
+        @method normalizeRelationships
+        @private
+      */
+      normalizeRelationships(typeClass: any, hash: any): void;
+      /**
+        @method normalizeUsingDeclaredMapping
+        @private
+      */
+      normalizeUsingDeclaredMapping(modelClass: any, hash: any): void;
+      /**
+        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(key: string, modelClass: any): string;
+      /**
+        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(key: string): boolean;
+      /**
+        When attrs.key.serialize is set to true then
+        it takes priority over the other checks and the related
+        attribute/relationship will be serialized
+    
+        @method _mustSerialize
+        @private
+        @param {String} key
+        @return {boolean} true if the key must be serialized
+      */
+      _mustSerialize(key: string): boolean;
+      /**
+        Check if the given hasMany relationship should be serialized
+    
+        By default only many-to-many and many-to-none relationships are serialized.
+        This could be configured per relationship by Serializer's `attrs` object.
+    
+        @method shouldSerializeHasMany
+        @public
+        @param {Snapshot} snapshot
+        @param {String} key
+        @param {RelationshipSchema} relationship
+        @return {boolean} true if the hasMany relationship should be serialized
+      */
+      shouldSerializeHasMany(snapshot: Snapshot, key: string, relationship: RelationshipSchema): boolean;
+      /**
+        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:
+    
+        ```app/models/comment.js
+        import Model, { attr, belongsTo } from '@ember-data/model';
+    
+        export default class CommentModel extends Model {
+          @attr title;
+          @attr body;
+    
+          @belongsTo('user') author;
+        }
+        ```
+    
+        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 (`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.
+    
+        ```app/serializers/post.js
+        import JSONSerializer from '@ember-data/serializer/json';
+    
+        export default class PostSerializer extends JSONSerializer {
+          serialize(snapshot, options) {
+            let json = {
+              POST_TTL: snapshot.attr('title'),
+              POST_BDY: snapshot.attr('body'),
+              POST_CMS: snapshot.hasMany('comments', { ids: true })
+            };
+    
+            if (options.includeId) {
+              json.POST_ID_ = snapshot.id;
             }
-          });
-  
-          if (options.includeId) {
-            json.ID_ = snapshot.id;
+    
+            return json;
           }
-  
-          return json;
         }
-      }
-  
-      function serverAttributeName(attribute) {
-        return attribute.underscore().toUpperCase();
-      }
-  
-      function serverHasManyName(name) {
-        return serverAttributeName(singularize(name)) + "_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.serialize` first and make the tweaks on
-      the returned JSON.
-  
-      ```app/serializers/post.js
-      import JSONSerializer from '@ember-data/serializer/json';
-  
-      export default class PostSerializer extends JSONSerializer {
-        serialize(snapshot, options) {
-          let json = super.serialize(...arguments);
-  
-          json.subject = json.title;
-          delete json.title;
-  
-          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.
+    
+        ```app/serializers/application.js
+        import JSONSerializer from '@ember-data/serializer/json';
+        import { singularize } from '<app-name>/utils/string-utils';
+    
+        export default class ApplicationSerializer extends JSONSerializer {
+          serialize(snapshot, options) {
+            let json = {};
+    
+            snapshot.eachAttribute((name) => {
+              json[serverAttributeName(name)] = snapshot.attr(name);
+            });
+    
+            snapshot.eachRelationship((name, relationship) => {
+              if (relationship.kind === 'hasMany') {
+                json[serverHasManyName(name)] = snapshot.hasMany(name, { ids: true });
+              }
+            });
+    
+            if (options.includeId) {
+              json.ID_ = snapshot.id;
+            }
+    
+            return json;
+          }
         }
-      }
-      ```
-  
-      @method serialize
-      @public
-      @param {Snapshot} snapshot
-      @param {Object} options
-      @return {Object} json
-    */
-    serialize(snapshot: Snapshot, options: Object): Object;
-    /**
-      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.
-      The hash property should be modified by reference.
-  
-      For example, your server may expect underscored root objects.
-  
-      ```app/serializers/application.js
-      import RESTSerializer from '@ember-data/serializer/rest';
-      import { decamelize } from '<app-name>/utils/string-utils';
-  
-      export default class ApplicationSerializer extends RESTSerializer {
-        serializeIntoHash(data, type, snapshot, options) {
-          let root = decamelize(type.modelName);
-          data[root] = this.serialize(snapshot, options);
+    
+        function serverAttributeName(attribute) {
+          return attribute.underscore().toUpperCase();
         }
-      }
-      ```
-  
-      @method serializeIntoHash
-      @public
-      @param {Object} hash
-      @param {Model} typeClass
-      @param {Snapshot} snapshot
-      @param {Object} options
-    */
-    serializeIntoHash(hash: Object, typeClass: Model, snapshot: Snapshot, options: Object): void;
-    /**
-      `serializeAttribute` can be used to customize how `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:
-  
-      ```app/serializers/application.js
-      import JSONSerializer from '@ember-data/serializer/json';
-  
-      export default class ApplicationSerializer extends JSONSerializer {
-        serializeAttribute(snapshot, json, key, attributes) {
-          json.attributes = json.attributes || {};
-          super.serializeAttribute(snapshot, json.attributes, key, attributes);
+    
+        function serverHasManyName(name) {
+          return serverAttributeName(singularize(name)) + "_IDS";
         }
-      }
-      ```
-  
-      @method serializeAttribute
-      @public
-      @param {Snapshot} snapshot
-      @param {Object} json
-      @param {String} key
-      @param {Object} attribute
-    */
-    serializeAttribute(snapshot: Snapshot, json: Object, key: string, attribute: Object): void;
-    /**
-      `serializeBelongsTo` can be used to customize how `belongsTo`
-      properties are serialized.
-  
-      Example
-  
-      ```app/serializers/post.js
-      import JSONSerializer from '@ember-data/serializer/json';
-  
-      export default class PostSerializer extends JSONSerializer {
-        serializeBelongsTo(snapshot, json, relationship) {
-          let key = relationship.name;
-          let belongsTo = snapshot.belongsTo(key);
-  
-          key = this.keyForRelationship ? this.keyForRelationship(key, "belongsTo", "serialize") : key;
-  
-          json[key] = !belongsTo ? null : belongsTo.record.toJSON();
+        ```
+    
+        This serializer will generate JSON that looks like this:
+    
+        ```javascript
+        {
+          "TITLE": "Rails is omakase",
+          "BODY": "Yep. Omakase.",
+          "COMMENT_IDS": [ "1", "2", "3" ]
         }
-      }
-      ```
-  
-      @method serializeBelongsTo
-      @public
-      @param {Snapshot} snapshot
-      @param {Object} json
-      @param {Object} relationship
-    */
-    serializeBelongsTo(snapshot: Snapshot, json: Object, relationship: Object): void;
-    /**
-     `serializeHasMany` can be used to customize how `hasMany`
-     properties are serialized.
-  
-     Example
-  
-     ```app/serializers/post.js
-     import JSONSerializer from '@ember-data/serializer/json';
-  
-     export default class PostSerializer extends JSONSerializer {
-       serializeHasMany(snapshot, json, relationship) {
-         let key = relationship.name;
-         if (key === 'comments') {
-           return;
-         } else {
-           super.serializeHasMany(...arguments);
-         }
-       }
-     }
-     ```
-  
-     @method serializeHasMany
-      @public
-     @param {Snapshot} snapshot
-     @param {Object} json
-     @param {Object} relationship
-    */
-    serializeHasMany(snapshot: Snapshot, json: Object, relationship: Object): void;
-    /**
-      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
-      `belongsTo` function.
-  
-      Example
-  
-      ```app/serializers/comment.js
-      import JSONSerializer from '@ember-data/serializer/json';
-  
-      export default class CommentSerializer extends JSONSerializer {
-        serializePolymorphicType(snapshot, json, relationship) {
-          let key = relationship.name;
-          let belongsTo = snapshot.belongsTo(key);
-  
-          key = this.keyForAttribute ? this.keyForAttribute(key, 'serialize') : key;
-  
-          if (!belongsTo) {
-            json[key + '_type'] = null;
-          } else {
-            json[key + '_type'] = belongsTo.modelName;
+        ```
+    
+        ## Tweaking the Default JSON
+    
+        If you just want to do some small tweaks on the default JSON,
+        you can call `super.serialize` first and make the tweaks on
+        the returned JSON.
+    
+        ```app/serializers/post.js
+        import JSONSerializer from '@ember-data/serializer/json';
+    
+        export default class PostSerializer extends JSONSerializer {
+          serialize(snapshot, options) {
+            let json = super.serialize(...arguments);
+    
+            json.subject = json.title;
+            delete json.title;
+    
+            return json;
           }
         }
-      }
-      ```
-  
-      @method serializePolymorphicType
-      @public
-      @param {Snapshot} snapshot
-      @param {Object} json
-      @param {Object} relationship
-    */
-    serializePolymorphicType(): void;
-    /**
-      `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
-  
-      ```app/serializers/post.js
-      import JSONSerializer from '@ember-data/serializer/json';
-  
-      export default class PostSerializer extends JSONSerializer {
-        extractMeta(store, typeClass, payload) {
-          if (payload && payload.hasOwnProperty('_pagination')) {
-            let meta = payload._pagination;
-            delete payload._pagination;
-            return meta;
+        ```
+    
+        @method serialize
+        @public
+        @param {Snapshot} snapshot
+        @param {Object} options
+        @return {Object} json
+      */
+      serialize(snapshot: Snapshot, options: Object): Object;
+      /**
+        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.
+        The hash property should be modified by reference.
+    
+        For example, your server may expect underscored root objects.
+    
+        ```app/serializers/application.js
+        import RESTSerializer from '@ember-data/serializer/rest';
+        import { decamelize } from '<app-name>/utils/string-utils';
+    
+        export default class ApplicationSerializer extends RESTSerializer {
+          serializeIntoHash(data, type, snapshot, options) {
+            let root = decamelize(type.modelName);
+            data[root] = this.serialize(snapshot, options);
           }
         }
-      }
-      ```
-  
-      @method extractMeta
-      @public
-      @param {Store} store
-      @param {Model} modelClass
-      @param {Object} payload
-    */
-    extractMeta(store: Store, modelClass: Model, payload: Object): any;
-    /**
-      `extractErrors` is used to extract model errors when a call
-      to `Model#save` fails with an `InvalidError`. By default
-      Ember Data expects error information to be located on the `errors`
-      property of the payload object.
-  
-      This serializer expects this `errors` object to be an Array similar
-      to the following, compliant with the https://jsonapi.org/format/#errors specification:
-  
-      ```js
-      {
-        "errors": [
-          {
-            "detail": "This username is already taken!",
-            "source": {
-              "pointer": "data/attributes/username"
-            }
-          }, {
-            "detail": "Doesn't look like a valid email.",
-            "source": {
-              "pointer": "data/attributes/email"
-            }
+        ```
+    
+        @method serializeIntoHash
+        @public
+        @param {Object} hash
+        @param {Model} typeClass
+        @param {Snapshot} snapshot
+        @param {Object} options
+      */
+      serializeIntoHash(hash: Object, typeClass: Model, snapshot: Snapshot, options: Object): void;
+      /**
+        `serializeAttribute` can be used to customize how `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:
+    
+        ```app/serializers/application.js
+        import JSONSerializer from '@ember-data/serializer/json';
+    
+        export default class ApplicationSerializer extends JSONSerializer {
+          serializeAttribute(snapshot, json, key, attributes) {
+            json.attributes = json.attributes || {};
+            super.serializeAttribute(snapshot, json.attributes, key, attributes);
           }
-        ]
-      }
-      ```
-  
-      The key `detail` provides a textual description of the problem.
-      Alternatively, the key `title` can be used for the same purpose.
-  
-      The nested keys `source.pointer` detail which specific element
-      of the request data was invalid.
-  
-      Note that JSON-API also allows for object-level errors to be placed
-      in an object with pointer `data`, signifying that the problem
-      cannot be traced to a specific attribute:
-  
-      ```javascript
-      {
-        "errors": [
-          {
-            "detail": "Some generic non property error message",
-            "source": {
-              "pointer": "data"
+        }
+        ```
+    
+        @method serializeAttribute
+        @public
+        @param {Snapshot} snapshot
+        @param {Object} json
+        @param {String} key
+        @param {Object} attribute
+      */
+      serializeAttribute(snapshot: Snapshot, json: Object, key: string, attribute: Object): void;
+      /**
+        `serializeBelongsTo` can be used to customize how `belongsTo`
+        properties are serialized.
+    
+        Example
+    
+        ```app/serializers/post.js
+        import JSONSerializer from '@ember-data/serializer/json';
+    
+        export default class PostSerializer extends JSONSerializer {
+          serializeBelongsTo(snapshot, json, relationship) {
+            let key = relationship.name;
+            let belongsTo = snapshot.belongsTo(key);
+    
+            key = this.keyForRelationship ? this.keyForRelationship(key, "belongsTo", "serialize") : key;
+    
+            json[key] = !belongsTo ? null : belongsTo.record.toJSON();
+          }
+        }
+        ```
+    
+        @method serializeBelongsTo
+        @public
+        @param {Snapshot} snapshot
+        @param {Object} json
+        @param {Object} relationship
+      */
+      serializeBelongsTo(snapshot: Snapshot, json: Object, relationship: Object): void;
+      /**
+       `serializeHasMany` can be used to customize how `hasMany`
+       properties are serialized.
+    
+       Example
+    
+       ```app/serializers/post.js
+       import JSONSerializer from '@ember-data/serializer/json';
+    
+       export default class PostSerializer extends JSONSerializer {
+         serializeHasMany(snapshot, json, relationship) {
+           let key = relationship.name;
+           if (key === 'comments') {
+             return;
+           } else {
+             super.serializeHasMany(...arguments);
+           }
+         }
+       }
+       ```
+    
+       @method serializeHasMany
+        @public
+       @param {Snapshot} snapshot
+       @param {Object} json
+       @param {Object} relationship
+      */
+      serializeHasMany(snapshot: Snapshot, json: Object, relationship: Object): void;
+      /**
+        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
+        `belongsTo` function.
+    
+        Example
+    
+        ```app/serializers/comment.js
+        import JSONSerializer from '@ember-data/serializer/json';
+    
+        export default class CommentSerializer extends JSONSerializer {
+          serializePolymorphicType(snapshot, json, relationship) {
+            let key = relationship.name;
+            let belongsTo = snapshot.belongsTo(key);
+    
+            key = this.keyForAttribute ? this.keyForAttribute(key, 'serialize') : key;
+    
+            if (!belongsTo) {
+              json[key + '_type'] = null;
+            } else {
+              json[key + '_type'] = belongsTo.modelName;
             }
           }
-        ]
-      }
-      ```
-  
-      When turn into a `Errors` object, you can read these errors
-      through the property `base`:
-  
-      ```handlebars
-      {{#each @model.errors.base as |error|}}
-        <div class="error">
-          {{error.message}}
-        </div>
-      {{/each}}
-      ```
-  
-      Example of alternative implementation, overriding the default
-      behavior to deal with a different format of errors:
-  
-      ```app/serializers/post.js
-      import JSONSerializer from '@ember-data/serializer/json';
-  
-      export default class PostSerializer extends JSONSerializer {
-        extractErrors(store, typeClass, payload, id) {
-          if (payload && typeof payload === 'object' && payload._problems) {
-            payload = payload._problems;
-            this.normalizeErrors(typeClass, payload);
+        }
+        ```
+    
+        @method serializePolymorphicType
+        @public
+        @param {Snapshot} snapshot
+        @param {Object} json
+        @param {Object} relationship
+      */
+      serializePolymorphicType(): void;
+      /**
+        `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
+    
+        ```app/serializers/post.js
+        import JSONSerializer from '@ember-data/serializer/json';
+    
+        export default class PostSerializer extends JSONSerializer {
+          extractMeta(store, typeClass, payload) {
+            if (payload && payload.hasOwnProperty('_pagination')) {
+              let meta = payload._pagination;
+              delete payload._pagination;
+              return meta;
+            }
           }
-          return payload;
         }
-      }
-      ```
-  
-      @method extractErrors
-      @public
-      @param {Store} store
-      @param {Model} typeClass
-      @param {Object} payload
-      @param {(String|Number)} id
-      @return {Object} json The deserialized errors
-    */
-    extractErrors(store: Store, typeClass: Model, payload: Object, id: (string | number)): Object;
-    /**
-      `keyForAttribute` can be used to define rules for how to convert an
-      attribute name in your model to a key in your JSON.
-  
-      Example
-  
-      ```app/serializers/application.js
-      import JSONSerializer from '@ember-data/serializer/json';
-      import { underscore } from '<app-name>/utils/string-utils';
-  
-      export default class ApplicationSerializer extends JSONSerializer {
-        keyForAttribute(attr, method) {
-          return underscore(attr).toUpperCase();
+        ```
+    
+        @method extractMeta
+        @public
+        @param {Store} store
+        @param {Model} modelClass
+        @param {Object} payload
+      */
+      extractMeta(store: Store, modelClass: Model, payload: Object): any;
+      /**
+        `extractErrors` is used to extract model errors when a call
+        to `Model#save` fails with an `InvalidError`. By default
+        Ember Data expects error information to be located on the `errors`
+        property of the payload object.
+    
+        This serializer expects this `errors` object to be an Array similar
+        to the following, compliant with the https://jsonapi.org/format/#errors specification:
+    
+        ```js
+        {
+          "errors": [
+            {
+              "detail": "This username is already taken!",
+              "source": {
+                "pointer": "data/attributes/username"
+              }
+            }, {
+              "detail": "Doesn't look like a valid email.",
+              "source": {
+                "pointer": "data/attributes/email"
+              }
+            }
+          ]
         }
-      }
-      ```
-  
-      @method keyForAttribute
-      @public
-      @param {String} key
-      @param {String} method
-      @return {String} normalized key
-    */
-    keyForAttribute(key: string, method: string): string;
-    /**
-      `keyForRelationship` can be used to define a custom key when
-      serializing and deserializing relationship properties. By default
-      `JSONSerializer` does not provide an implementation of this method.
-  
-      Example
-  
+        ```
+    
+        The key `detail` provides a textual description of the problem.
+        Alternatively, the key `title` can be used for the same purpose.
+    
+        The nested keys `source.pointer` detail which specific element
+        of the request data was invalid.
+    
+        Note that JSON-API also allows for object-level errors to be placed
+        in an object with pointer `data`, signifying that the problem
+        cannot be traced to a specific attribute:
+    
+        ```javascript
+        {
+          "errors": [
+            {
+              "detail": "Some generic non property error message",
+              "source": {
+                "pointer": "data"
+              }
+            }
+          ]
+        }
+        ```
+    
+        When turn into a `Errors` object, you can read these errors
+        through the property `base`:
+    
+        ```handlebars
+        {{#each @model.errors.base as |error|}}
+          <div class="error">
+            {{error.message}}
+          </div>
+        {{/each}}
+        ```
+    
+        Example of alternative implementation, overriding the default
+        behavior to deal with a different format of errors:
+    
         ```app/serializers/post.js
         import JSONSerializer from '@ember-data/serializer/json';
-        import { underscore } from '<app-name>/utils/string-utils';
-  
+    
         export default class PostSerializer extends JSONSerializer {
-          keyForRelationship(key, relationship, method) {
-            return `rel_${underscore(key)}`;
+          extractErrors(store, typeClass, payload, id) {
+            if (payload && typeof payload === 'object' && payload._problems) {
+              payload = payload._problems;
+              this.normalizeErrors(typeClass, payload);
+            }
+            return payload;
           }
         }
         ```
-  
-      @method keyForRelationship
-      @public
-      @param {String} key
-      @param {String} typeClass
-      @param {String} method
-      @return {String} normalized key
-    */
-    keyForRelationship(key: string, typeClass: string, method: string): string;
-    /**
-     `keyForLink` can be used to define a custom key when deserializing link
-     properties.
-  
-     @method keyForLink
-      @public
-     @param {String} key
-     @param {String} kind `belongsTo` or `hasMany`
-     @return {String} normalized key
-    */
-    keyForLink(key: string, kind: string): string;
-    /**
-     @method transformFor
-     @private
-     @param {String} attributeType
-     @param {Boolean} skipAssertion
-     @return {Transform} transform
-    */
-    transformFor(attributeType: string, skipAssertion: boolean): Transform;
-};
-import Serializer from '.';
-//# sourceMappingURL=json.d.ts.map
+    
+        @method extractErrors
+        @public
+        @param {Store} store
+        @param {Model} typeClass
+        @param {Object} payload
+        @param {(String|Number)} id
+        @return {Object} json The deserialized errors
+      */
+      extractErrors(store: Store, typeClass: Model, payload: Object, id: (string | number)): Object;
+      /**
+        `keyForAttribute` can be used to define rules for how to convert an
+        attribute name in your model to a key in your JSON.
+    
+        Example
+    
+        ```app/serializers/application.js
+        import JSONSerializer from '@ember-data/serializer/json';
+        import { underscore } from '<app-name>/utils/string-utils';
+    
+        export default class ApplicationSerializer extends JSONSerializer {
+          keyForAttribute(attr, method) {
+            return underscore(attr).toUpperCase();
+          }
+        }
+        ```
+    
+        @method keyForAttribute
+        @public
+        @param {String} key
+        @param {String} method
+        @return {String} normalized key
+      */
+      keyForAttribute(key: string, method: string): string;
+      /**
+        `keyForRelationship` can be used to define a custom key when
+        serializing and deserializing relationship properties. By default
+        `JSONSerializer` does not provide an implementation of this method.
+    
+        Example
+    
+          ```app/serializers/post.js
+          import JSONSerializer from '@ember-data/serializer/json';
+          import { underscore } from '<app-name>/utils/string-utils';
+    
+          export default class PostSerializer extends JSONSerializer {
+            keyForRelationship(key, relationship, method) {
+              return `rel_${underscore(key)}`;
+            }
+          }
+          ```
+    
+        @method keyForRelationship
+        @public
+        @param {String} key
+        @param {String} typeClass
+        @param {String} method
+        @return {String} normalized key
+      */
+      keyForRelationship(key: string, typeClass: string, method: string): string;
+      /**
+       `keyForLink` can be used to define a custom key when deserializing link
+       properties.
+    
+       @method keyForLink
+        @public
+       @param {String} key
+       @param {String} kind `belongsTo` or `hasMany`
+       @return {String} normalized key
+      */
+      keyForLink(key: string, kind: string): string;
+      /**
+       @method transformFor
+       @private
+       @param {String} attributeType
+       @param {Boolean} skipAssertion
+       @return {Transform} transform
+      */
+      transformFor(attributeType: string, skipAssertion: boolean): Transform;
+  };
+  import Serializer from '@ember-data/serializer';
+  //# sourceMappingURL=json.d.ts.map
+}