@ember-data-mirror/serializer 5.6.0-beta.0 → 5.6.0-beta.1

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

@@ -1,1093 +1,4 @@
 declare module '@ember-data-mirror/serializer/json' {
-  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>
+  export { JSONSerializer as default } from "@warp-drive-mirror/legacy/serializer/json";
   
-    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-mirror/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'
-      }
-    }
-    ```
-  
-    `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-mirror/serializer/json
-    @class JSONSerializer
-    @public
-    @extends Serializer
-  */
-  const JSONSerializer: Readonly<typeof Serializer> & (new (owner?: import("@ember/-internals/owner").default) => 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-mirror/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 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-mirror/model';
-    
-        export default class PersonModel extends Model {
-          @attr('string') firstName;
-          @attr('string') lastName;
-          @attr('string') occupation;
-          @attr('boolean') admin;
-        }
-        ```
-    
-        ```app/serializers/person.js
-        import JSONSerializer from '@ember-data-mirror/serializer/json';
-    
-        export default class PersonSerializer extends JSONSerializer {
-          attrs = {
-            admin: 'is_admin',
-            occupation: { key: 'career' }
-          }
-        }
-        ```
-    
-        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-mirror/serializer/json';
-    
-        export default class PostSerializer extends JSONSerializer {
-          attrs = {
-            admin: { serialize: false },
-            occupation: { key: 'career' }
-          }
-        }
-        ```
-    
-        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-mirror/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-mirror/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-mirror/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;
-            }
-    
-            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-mirror/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;
-          }
-        }
-    
-        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-mirror/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 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-mirror/serializer/rest';
-        import { underscoren} from '<app-name>/utils/string-utils';
-    
-        export default class ApplicationSerializer extends RESTSerializer {
-          serializeIntoHash(data, type, snapshot, options) {
-            let root = underscore(type.modelName);
-            data[root] = this.serialize(snapshot, options);
-          }
-        }
-        ```
-    
-        @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-mirror/serializer/json';
-    
-        export default class ApplicationSerializer extends JSONSerializer {
-          serializeAttribute(snapshot, json, key, attributes) {
-            json.attributes = json.attributes || {};
-            super.serializeAttribute(snapshot, json.attributes, key, attributes);
-          }
-        }
-        ```
-    
-        @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-mirror/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-mirror/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-mirror/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;
-            }
-          }
-        }
-        ```
-    
-        @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-mirror/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 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"
-              }
-            }
-          ]
-        }
-        ```
-    
-        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-mirror/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);
-            }
-            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-mirror/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-mirror/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-mirror/serializer';
-}
-//# sourceMappingURL=json.d.ts.map
+}