@warp-drive/legacy 5.6.0-alpha.15 → 5.6.0-alpha.18

package/declarations/serializer/json.d.ts

@@ -1,1047 +1,78 @@
 /**
- * <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>
+* <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.
+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`.
+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.
+`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:
+For example, given the following `User` model and JSON payload:
 
-  ```js [app/models/user.js]
-  import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
+```js [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;
+export default class UserModel extends Model {
+@hasMany('user') friends;
+@belongsTo('location') house;
 
-    @attr('string') name;
-  }
-  ```
+@attr('string') name;
+}
+```
 
-  ```js
-  {
-    id: 1,
-    name: 'Sebastian',
-    friends: [3, 4],
-    links: {
-      house: '/houses/lefkada'
-    }
-  }
-  ```
+```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.
+`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:
+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.
+- 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:
+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.
+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.
 
-  @class JSONSerializer
-  @public
+@class JSONSerializer
+@public
 */
-export 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
-  
-      ```js [app/serializers/application.js]
-      import { JSONSerializer } from '@warp-drive/legacy/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
-  
-      ```js [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 [app/serializers/person.js]
-      import { JSONSerializer } from '@warp-drive/legacy/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
-  
-      ```js [app/serializers/person.js]
-      import { JSONSerializer } from '@warp-drive/legacy/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: any;
-    /**
-     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.
-  
-     @private
-     @param {Model} typeClass
-     @param {Object} data The data to transform
-     @return {Object} data The transformed data object
-    */
-    applyTransforms(typeClass: Model, data: any): any;
-    /**
-      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
-      @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: any, id: string | number, requestType: string, ...args: any[]): any;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `findRecord`
-  
-      @since 1.13.0
-      @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: any, id: string | number, requestType: string, ...args: any[]): any;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `queryRecord`
-  
-      @since 1.13.0
-      @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: any, id: string | number, requestType: string, ...args: any[]): any;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `findAll`
-  
-      @since 1.13.0
-      @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: any, id: string | number, requestType: string, ...args: any[]): any;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `findBelongsTo`
-  
-      @since 1.13.0
-      @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: any, id: string | number, requestType: string, ...args: any[]): any;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `findHasMany`
-  
-      @since 1.13.0
-      @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: any, id: string | number, requestType: string, ...args: any[]): any;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `findMany`
-  
-      @since 1.13.0
-      @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: any, id: string | number, requestType: string, ...args: any[]): any;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `query`
-  
-      @since 1.13.0
-      @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: any, id: string | number, requestType: string, ...args: any[]): any;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `createRecord`
-  
-      @since 1.13.0
-      @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: any, id: string | number, requestType: string, ...args: any[]): any;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `deleteRecord`
-  
-      @since 1.13.0
-      @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: any, id: string | number, requestType: string, ...args: any[]): any;
-    /**
-      Called by the default normalizeResponse implementation when the
-      type of request is `updateRecord`
-  
-      @since 1.13.0
-      @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: any, id: string | number, requestType: string, ...args: any[]): any;
-    /**
-      normalizeUpdateRecordResponse, normalizeCreateRecordResponse and
-      normalizeDeleteRecordResponse delegate to this method by default.
-  
-      @since 1.13.0
-      @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: any, id: string | number, requestType: string, ...args: any[]): any;
-    /**
-      normalizeQueryResponse and normalizeFindRecordResponse delegate to this
-      method by default.
-  
-      @since 1.13.0
-      @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: any, id: string | number, requestType: string): any;
-    /**
-      normalizeQueryResponse, normalizeFindManyResponse, and normalizeFindHasManyResponse delegate
-      to this method by default.
-  
-      @since 1.13.0
-      @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: any, id: string | number, requestType: string): any;
-    /**
-      @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: any, id: string | number, requestType: string, isSingle: boolean): any;
-    /**
-      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
-  
-      ```js [app/serializers/application.js]
-      import { JSONSerializer } from '@warp-drive/legacy/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);
-        }
-      }
-      ```
-  
-      @public
-      @param {Model} typeClass
-      @param {Object} hash
-      @return {Object}
-    */
-    normalize(modelClass: any, resourceHash: any): any;
-    /**
-      Returns the resource's ID.
-  
-      @public
-      @param {Object} modelClass
-      @param {Object} resourceHash
-      @return {String}
-    */
-    extractId(modelClass: any, resourceHash: any): string;
-    /**
-      Returns the resource's attributes formatted as a JSON-API "attributes object".
-  
-      http://jsonapi.org/format/#document-resource-object-attributes
-  
-      @public
-      @param {Object} modelClass
-      @param {Object} resourceHash
-      @return {Object}
-    */
-    extractAttributes(modelClass: any, resourceHash: any): any;
-    /**
-      Returns a relationship formatted as a JSON-API "relationship object".
-  
-      http://jsonapi.org/format/#document-resource-object-relationships
-  
-      @public
-      @param {Object} relationshipModelName
-      @param {Object} relationshipHash
-      @return {Object}
-    */
-    extractRelationship(relationshipModelName: any, relationshipHash: any): any;
-    /**
-      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
-  
-      @public
-      @param {Object} relationshipModelName
-      @param {Object} relationshipHash
-      @param {Object} relationshipOptions
-      @return {Object}
-    */
-    extractPolymorphicRelationship(relationshipModelName: any, relationshipHash: any, relationshipOptions: any): any;
-    /**
-      Returns the resource's relationships formatted as a JSON-API "relationships object".
-  
-      http://jsonapi.org/format/#document-resource-object-relationships
-  
-      @public
-      @param {Object} modelClass
-      @param {Object} resourceHash
-      @return {Object}
-    */
-    extractRelationships(modelClass: any, resourceHash: any): any;
-    /**
-      Dasherizes the model name in the payload
-  
-      @public
-      @param {String} key
-      @return {String} the model's modelName
-    */
-    modelNameFromPayloadKey(key: string): string;
-    /**
-      @private
-    */
-    normalizeRelationships(typeClass: any, hash: any): void;
-    /**
-      @private
-    */
-    normalizeUsingDeclaredMapping(modelClass: any, hash: any): void;
-    /**
-      Looks up the property key that was set by the custom `attr` mapping
-      passed to the serializer.
-  
-      @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
-  
-      @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
-  
-      @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.
-  
-      @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:
-  
-      ```js [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.
-  
-      ```js [app/serializers/post.js]
-      import { JSONSerializer } from '@warp-drive/legacy/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.
-  
-      ```js [app/serializers/application.js]
-      import { JSONSerializer } from '@warp-drive/legacy/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.
-  
-      ```js [app/serializers/post.js]
-      import { JSONSerializer } from '@warp-drive/legacy/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;
-        }
-      }
-      ```
-  
-      @public
-      @param {Snapshot} snapshot
-      @param {Object} options
-      @return {Object} json
-    */
-    serialize(snapshot: Snapshot, options: any): any;
-    /**
-      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.
-  
-      ```js [app/serializers/application.js]
-      import RESTSerializer from '@ember-data/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);
-        }
-      }
-      ```
-  
-      @public
-      @param {Object} hash
-      @param {Model} typeClass
-      @param {Snapshot} snapshot
-      @param {Object} options
-    */
-    serializeIntoHash(hash: any, typeClass: Model, snapshot: Snapshot, options: any): 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:
-  
-      ```js [app/serializers/application.js]
-      import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
-  
-      export default class ApplicationSerializer extends JSONSerializer {
-        serializeAttribute(snapshot, json, key, attributes) {
-          json.attributes = json.attributes || {};
-          super.serializeAttribute(snapshot, json.attributes, key, attributes);
-        }
-      }
-      ```
-  
-      @public
-      @param {Snapshot} snapshot
-      @param {Object} json
-      @param {String} key
-      @param {Object} attribute
-    */
-    serializeAttribute(snapshot: Snapshot, json: any, key: string, attribute: any): void;
-    /**
-      `serializeBelongsTo` can be used to customize how `belongsTo`
-      properties are serialized.
-  
-      Example
-  
-      ```js [app/serializers/post.js]
-      import { JSONSerializer } from '@warp-drive/legacy/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();
-        }
-      }
-      ```
-  
-      @public
-      @param {Snapshot} snapshot
-      @param {Object} json
-      @param {Object} relationship
-    */
-    serializeBelongsTo(snapshot: Snapshot, json: any, relationship: any): void;
-    /**
-     `serializeHasMany` can be used to customize how `hasMany`
-     properties are serialized.
-  
-     Example
-  
-     ```js [app/serializers/post.js]
-     import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
-  
-     export default class PostSerializer extends JSONSerializer {
-       serializeHasMany(snapshot, json, relationship) {
-         let key = relationship.name;
-         if (key === 'comments') {
-           return;
-         } else {
-           super.serializeHasMany(...arguments);
-         }
-       }
-     }
-     ```
-  
-      @public
-     @param {Snapshot} snapshot
-     @param {Object} json
-     @param {Object} relationship
-    */
-    serializeHasMany(snapshot: Snapshot, json: any, relationship: any): 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
-  
-      ```js [app/serializers/comment.js]
-      import { JSONSerializer } from '@warp-drive/legacy/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;
-          }
-        }
-      }
-      ```
-  
-      @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
-  
-      ```js [app/serializers/post.js]
-      import { JSONSerializer } from '@warp-drive/legacy/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;
-          }
-        }
-      }
-      ```
-  
-      @public
-      @param {Store} store
-      @param {Model} modelClass
-      @param {Object} payload
-    */
-    extractMeta(store: Store, modelClass: Model, payload: any): 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:
-  
-      ```js [app/serializers/post.js]
-      import { JSONSerializer } from '@warp-drive/legacy/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;
-        }
-      }
-      ```
-  
-      @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: any, id: (string | number)): any;
-    /**
-      `keyForAttribute` can be used to define rules for how to convert an
-      attribute name in your model to a key in your JSON.
-  
-      Example
-  
-      ```js [app/serializers/application.js]
-      import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
-      import { underscore } from '<app-name>/utils/string-utils';
-  
-      export default class ApplicationSerializer extends JSONSerializer {
-        keyForAttribute(attr, method) {
-          return underscore(attr).toUpperCase();
-        }
-      }
-      ```
-  
-      @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
-  
-        ```js [app/serializers/post.js]
-        import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
-        import { underscore } from '<app-name>/utils/string-utils';
-  
-        export default class PostSerializer extends JSONSerializer {
-          keyForRelationship(key, relationship, method) {
-            return `rel_${underscore(key)}`;
-          }
-        }
-        ```
-  
-      @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.
-  
-      @public
-     @param {String} key
-     @param {String} kind `belongsTo` or `hasMany`
-     @return {String} normalized key
-    */
-    keyForLink(key: string, kind: string): string;
-    /**
-     @private
-     @param {String} attributeType
-     @param {Boolean} skipAssertion
-     @return {Transform} transform
-    */
-    transformFor(attributeType: string, skipAssertion: boolean): Transform;
-};
-import { Serializer } from '../serializer.ts';
-//# sourceMappingURL=json.d.ts.map
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare const JSONSerializer: any;
+export { JSONSerializer };