@ember-data/serializer 5.4.0-alpha.30 → 5.4.0-alpha.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ember-data/serializer",
-  "version": "5.4.0-alpha.30",
+  "version": "5.4.0-alpha.31",
   "description": "Provides Legacy JSON, JSON:API and REST Implementations of the Serializer Interface for use with @ember-data/store",
   "keywords": [
     "ember-addon"
@@ -19,6 +19,7 @@
     "version": 1
   },
   "files": [
+    "unstable-preview-types",
     "blueprints",
     "addon-main.js",
     "addon",
@@ -29,7 +30,7 @@
   ],
   "peerDependencies": {
     "@ember/string": "^3.1.1",
-    "@warp-drive/core-types": "0.0.0-alpha.16",
+    "@warp-drive/core-types": "0.0.0-alpha.17",
     "ember-inflector": "^4.0.2"
   },
   "dependenciesMeta": {
@@ -56,7 +57,7 @@
     }
   },
   "dependencies": {
-    "@ember-data/private-build-infra": "5.4.0-alpha.30",
+    "@ember-data/private-build-infra": "5.4.0-alpha.31",
     "@embroider/macros": "^1.13.5",
     "ember-cli-babel": "^8.2.0",
     "ember-cli-test-info": "^1.0.0",
@@ -73,16 +74,16 @@
     "@babel/preset-env": "^7.23.9",
     "@babel/preset-typescript": "^7.23.3",
     "@babel/runtime": "^7.23.9",
-    "@ember-data/request": "5.4.0-alpha.30",
-    "@ember-data/store": "5.4.0-alpha.30",
-    "@ember-data/tracking": "5.4.0-alpha.30",
+    "@ember-data/request": "5.4.0-alpha.31",
+    "@ember-data/store": "5.4.0-alpha.31",
+    "@ember-data/tracking": "5.4.0-alpha.31",
     "@ember/string": "^3.1.1",
     "@embroider/addon-dev": "^4.1.2",
     "@glimmer/component": "^1.1.2",
     "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-node-resolve": "^15.2.3",
-    "@warp-drive/core-types": "0.0.0-alpha.16",
-    "@warp-drive/internal-config": "5.4.0-alpha.30",
+    "@warp-drive/core-types": "0.0.0-alpha.17",
+    "@warp-drive/internal-config": "5.4.0-alpha.31",
     "ember-inflector": "^4.0.2",
     "ember-source": "~5.6.0",
     "rollup": "^4.9.6",
@@ -99,7 +100,7 @@
   "packageManager": "pnpm@8.6.0",
   "scripts": {
     "lint": "eslint . --quiet --cache --cache-strategy=content --ext .js,.ts,.mjs,.cjs --report-unused-disable-directives",
-    "build:types": "echo \"Types are private\" && exit 0",
+    "build:types": "tsc --build",
     "build:client": "rollup --config && babel ./addon --out-dir addon --plugins=../private-build-infra/src/transforms/babel-plugin-transform-ext.js",
     "_build": "bun run build:client && bun run build:types",
     "_syncPnpm": "bun run sync-dependencies-meta-injected"

package/unstable-preview-types/-private/embedded-records-mixin.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="ember-source/types" />
+declare const _default: Mixin;
+export default _default;
+import Mixin from '@ember/object/mixin';
+//# sourceMappingURL=embedded-records-mixin.d.ts.map

package/unstable-preview-types/-private/embedded-records-mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedded-records-mixin.d.ts","sourceRoot":"","sources":["../../src/-private/embedded-records-mixin.js"],"names":[],"mappings":";;;kBACkB,qBAAqB"}

package/unstable-preview-types/-private/transforms/boolean.d.ts

@@ -0,0 +1,48 @@
+/**
+  @module @ember-data/serializer
+*/
+/**
+  The `BooleanTransform` class is used to serialize and deserialize
+  boolean attributes on Ember Data record objects. This transform is
+  used when `boolean` is passed as the type parameter to the
+  [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
+
+  Usage
+
+  ```app/models/user.js
+  import Model, { attr } from '@ember-data/model';
+
+  export default class UserModel extends Model {
+    @attr('boolean') isAdmin;
+    @attr('string') name;
+    @attr('string') email;
+  }
+  ```
+
+  By default, the boolean transform only allows for values of `true` or
+  `false`. You can opt into allowing `null` values for
+  boolean attributes via `attr('boolean', { allowNull: true })`
+
+  ```app/models/user.js
+  import Model, { attr } from '@ember-data/model';
+
+  export default class UserModel extends Model {
+    @attr('string') email;
+    @attr('string') username;
+    @attr('boolean', { allowNull: true }) wantsWeeklyEmail;
+  }
+  ```
+
+  @class BooleanTransform
+  @public
+ */
+export default class BooleanTransform {
+    deserialize(serialized: boolean | null | number | string, options?: {
+        allowNull?: boolean;
+    }): boolean | null;
+    serialize(deserialized: boolean | null, options?: {
+        allowNull?: boolean;
+    }): boolean | null;
+    static create(): BooleanTransform;
+}
+//# sourceMappingURL=boolean.d.ts.map

package/unstable-preview-types/-private/transforms/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../../src/-private/transforms/boolean.ts"],"names":[],"mappings":"AAAA;;EAEE;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC,WAAW,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,GAAG,IAAI;IAgB5G,SAAS,CAAC,YAAY,EAAE,OAAO,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,GAAG,IAAI;IAQ1F,MAAM,CAAC,MAAM;CAGd"}

package/unstable-preview-types/-private/transforms/date.d.ts

@@ -0,0 +1,29 @@
+/**
+  @module @ember-data/serializer
+*/
+/**
+ The `DateTransform` class is used to serialize and deserialize
+ date attributes on Ember Data record objects. This transform is used
+ when `date` is passed as the type parameter to the
+ [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function. It uses the [`ISO 8601`](https://en.wikipedia.org/wiki/ISO_8601)
+ standard.
+
+ ```app/models/score.js
+ import Model, { attr, belongsTo } from '@ember-data/model';
+
+ export default class ScoreModel extends Model {
+    @attr('number') value;
+    @belongsTo('player') player;
+    @attr('date') date;
+  }
+ ```
+
+ @class DateTransform
+  @public
+ */
+export default class DateTransform {
+    deserialize(serialized: string | number | null, _options?: Record<string, unknown>): Date | null;
+    serialize(date: Date, _options?: Record<string, unknown>): string | null;
+    static create(): DateTransform;
+}
+//# sourceMappingURL=date.d.ts.map

package/unstable-preview-types/-private/transforms/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../src/-private/transforms/date.ts"],"names":[],"mappings":"AAAA;;EAEE;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAoBlF,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IASxE,MAAM,CAAC,MAAM;CAGd"}

package/unstable-preview-types/-private/transforms/number.d.ts

@@ -0,0 +1,30 @@
+/**
+  @module @ember-data/serializer
+*/
+/**
+  The `NumberTransform` class is used to serialize and deserialize
+  numeric attributes on Ember Data record objects. This transform is
+  used when `number` is passed as the type parameter to the
+  [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
+
+  Usage
+
+  ```app/models/score.js
+  import Model, { attr, belongsTo } from '@ember-data/model';
+
+  export default class ScoreModel extends Model {
+    @attr('number') value;
+    @belongsTo('player') player;
+    @attr('date') date;
+  }
+  ```
+
+  @class NumberTransform
+  @public
+ */
+export default class NumberTransform {
+    deserialize(serialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
+    serialize(deserialized: string | number | null | undefined, _options?: Record<string, unknown>): number | null;
+    static create(): NumberTransform;
+}
+//# sourceMappingURL=number.d.ts.map

package/unstable-preview-types/-private/transforms/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../../src/-private/transforms/number.ts"],"names":[],"mappings":"AAAA;;EAEE;AAMF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,OAAO,OAAO,eAAe;IAClC,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAU9G,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAU9G,MAAM,CAAC,MAAM;CAGd"}

package/unstable-preview-types/-private/transforms/string.d.ts

@@ -0,0 +1,30 @@
+/**
+  @module @ember-data/serializer
+*/
+/**
+  The `StringTransform` class is used to serialize and deserialize
+  string attributes on Ember Data record objects. This transform is
+  used when `string` is passed as the type parameter to the
+  [attr](/ember-data/release/functions/@ember-data%2Fmodel/attr) function.
+
+  Usage
+
+  ```app/models/user.js
+  import Model, { attr, belongsTo } from '@ember-data/model';
+
+  export default class UserModel extends Model {
+    @attr('boolean') isAdmin;
+    @attr('string') name;
+    @attr('string') email;
+  }
+  ```
+
+  @class StringTransform
+  @public
+ */
+export default class StringTransform {
+    deserialize(serialized: unknown, _options?: Record<string, unknown>): string | null;
+    serialize(deserialized: unknown, _options?: Record<string, unknown>): string | null;
+    static create(): StringTransform;
+}
+//# sourceMappingURL=string.d.ts.map

package/unstable-preview-types/-private/transforms/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../src/-private/transforms/string.ts"],"names":[],"mappings":"AAAA;;EAEE;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,OAAO,OAAO,eAAe;IAClC,WAAW,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAGnF,SAAS,CAAC,YAAY,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAInF,MAAM,CAAC,MAAM;CAGd"}

package/unstable-preview-types/-private/transforms/transform.d.ts

@@ -0,0 +1,126 @@
+/// <reference types="ember-source/types" />
+/**
+  @module @ember-data/serializer
+*/
+import EmberObject from '@ember/object';
+import type { AttributeSchema } from '@warp-drive/core-types/schema';
+/**
+  The `Transform` class is used to serialize and deserialize model
+  attributes when they are saved or loaded from an
+  adapter. Subclassing `Transform` is useful for creating custom
+  attributes. All subclasses of `Transform` must implement a
+  `serialize` and a `deserialize` method.
+
+  Example
+
+  ```app/transforms/temperature.js
+
+  // Converts centigrade in the JSON to fahrenheit in the app
+  export default class TemperatureTransform {
+    deserialize(serialized, options) {
+      return (serialized *  1.8) + 32;
+    }
+
+    serialize(deserialized, options) {
+      return (deserialized - 32) / 1.8;
+    }
+
+    static create() {
+      return new this();
+    }
+  }
+  ```
+
+  Usage
+
+  ```app/models/requirement.js
+  import Model, { attr } from '@ember-data/model';
+
+  export default class RequirementModel extends Model {
+    @attr('string') name;
+    @attr('temperature') temperature;
+  }
+  ```
+
+  The options passed into the `attr` function when the attribute is
+  declared on the model is also available in the transform.
+
+  ```app/models/post.js
+  import Model, { attr } from '@ember-data/model';
+
+  export default class PostModel extends Model {
+    @attr('string') title;
+    @attr('markdown', {
+      markdown: {
+        gfm: false,
+        sanitize: true
+      }
+    })
+    markdown;
+  }
+  ```
+
+  ```app/transforms/markdown.js
+  export default class MarkdownTransform {
+    serialize(deserialized, options) {
+      return deserialized.raw;
+    }
+
+    deserialize(serialized, options) {
+      let markdownOptions = options.markdown || {};
+
+      return marked(serialized, markdownOptions);
+    }
+
+    static create() {
+      return new this();
+    }
+  }
+  ```
+
+  @class Transform
+  @public
+ */
+/**
+  When given a deserialized value from a record attribute this
+  method must return the serialized value.
+
+  Example
+
+  ```javascript
+  serialize(deserialized, options) {
+    return deserialized ? null : Number(deserialized);
+  }
+  ```
+
+  @method serialize
+  @public
+  @param deserialized The deserialized value
+  @param options hash of options passed to `attr`
+  @return The serialized value
+*/
+/**
+  When given a serialized value from a JSON object this method must
+  return the deserialized value for the record attribute.
+
+  Example
+
+  ```javascript
+  deserialize(serialized, options) {
+    return empty(serialized) ? null : Number(serialized);
+  }
+  ```
+
+  @method deserialize
+  @public
+  @param serialized The serialized value
+  @param options hash of options passed to `attr`
+  @return The deserialized value
+*/
+interface Transform {
+    serialize(value: unknown, options: AttributeSchema['options']): unknown;
+    deserialize(value: unknown, options: AttributeSchema['options']): unknown;
+}
+declare const Transform: typeof EmberObject;
+export default Transform;
+//# sourceMappingURL=transform.d.ts.map

package/unstable-preview-types/-private/transforms/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/-private/transforms/transform.ts"],"names":[],"mappings":";AAAA;;EAEE;AACF,OAAO,WAAW,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH;;;;;;;;;;;;;;;;;EAiBE;AACF;;;;;;;;;;;;;;;;;EAiBE;AACF,UAAU,SAAS;IACjB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC;IACxE,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC;CAC3E;AACD,QAAA,MAAM,SAAS,oBAAc,CAAC;AAE9B,eAAe,SAAS,CAAC"}

package/unstable-preview-types/-private/utils.d.ts

@@ -0,0 +1,4 @@
+type Coercable = string | number | boolean | null | undefined | symbol;
+export declare function coerceId(id: Coercable): string | null;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/unstable-preview-types/-private/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/-private/utils.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC;AAEvE,wBAAgB,QAAQ,CAAC,EAAE,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CAUrD"}

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

@@ -0,0 +1,11 @@
+/**
+  @module @ember-data/serializer
+*/
+export { default as EmbeddedRecordsMixin } from './-private/embedded-records-mixin';
+export { default as Transform } from './-private/transforms/transform';
+export { default as BooleanTransform } from './-private/transforms/boolean';
+export { default as DateTransform } from './-private/transforms/date';
+export { default as NumberTransform } from './-private/transforms/number';
+export { default as StringTransform } from './-private/transforms/string';
+export { coerceId } from './-private/utils';
+//# sourceMappingURL=-private.d.ts.map

package/unstable-preview-types/-private.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"-private.d.ts","sourceRoot":"","sources":["../src/-private.ts"],"names":[],"mappings":"AAAA;;EAEE;AAEF,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAEpF,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC"}

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

@@ -0,0 +1,263 @@
+/**
+  ## Overview
+
+  <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 serializer, 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 order to properly manage and present your data, EmberData
+  needs to understand the structure of data it receives.
+
+  `Serializers` convert data between the server's API format and
+  the format EmberData understands.
+
+  Data received from an API response is **normalized** into
+  [JSON:API](https://jsonapi.org/) (the format used internally
+  by EmberData), while data sent to an API is **serialized**
+  into the format the API expects.
+
+  ### Implementing a Serializer
+
+  There are only two required serializer methods, one for
+  normalizing data from the server API format into JSON:API, and
+  another for serializing records via `Snapshots` into the expected
+  server API format.
+
+  To implement a serializer, export a class that conforms to the structure
+  described by [<Interface> Serializer](/ember-data/release/classes/%3CInterface%3E%20Serializer)
+  from the `app/serializers/` directory. An example is below.
+
+  ```ts
+  import EmberObject from '@ember/object';
+
+  export default class ApplicationSerializer extends EmberObject {
+    normalizeResponse(store, schema, rawPayload) {
+      return rawPayload;
+    }
+
+    serialize(snapshot, options) {
+      const serializedResource = {
+        id: snapshot.id,
+        type: snapshot.modelName,
+        attributes: snapshot.attributes()
+      };
+
+      return serializedResource;
+    }
+  }
+ ```
+
+
+  ### Serializer Resolution
+
+  `store.serializerFor(name)` will lookup serializers defined in
+  `app/serializers/` and return an instance. If no serializer is found, an
+  error will be thrown.
+
+  `serializerFor` first attempts to find a serializer with an exact match on `name`,
+  then falls back to checking for the presence of a serializer named `application`.
+
+  ```ts
+  store.serializerFor('author');
+
+  // lookup paths (in order) =>
+  //   app/serializers/author.js
+  //   app/serializers/application.js
+  ```
+
+  Most requests in EmberData are made with respect to a particular `type` (or `modelName`)
+  (e.g., "get me the full collection of **books**" or "get me the **employee** whose id is 37"). We
+  refer to this as the **primary** resource `type`.
+
+  Typically `serializerFor` will be used to find a serializer with a name matching that of the primary
+  resource `type` for the request, falling back to the `application` serializer for those types that
+  do not have a defined serializer. This is often described as a `per-model` or `per-type` strategy
+  for defining serializers. However, because APIs rarely format payloads per-type but rather
+  per-API-version, this may not be a desired strategy.
+
+  It is recommended that applications define only a single `application` adapter and serializer
+  where possible.
+
+  If you have multiple API formats and the per-type strategy is not viable, one strategy is to
+  write an `application` adapter and serializer that make use of `options` to specify the desired
+  format when making a request.
+
+  ### Using a Serializer
+
+  Any serializer in `app/serializers/` can be looked up by `name` using `store.serializerFor(name)`.
+
+  ### Default Serializers
+
+  For applications whose APIs are *very close to* or *exactly* the **REST** format or **JSON:API**
+  format the `@ember-data/serializer` package contains implementations these applications can
+  extend. It also contains a simple `JSONSerializer` for serializing to/from very basic JSON objects.
+
+  Many applications will find writing their own serializer to be more performant and less
+  complex than extending these classes even when their API format is very close to that expected
+  by these serializers.
+
+  It is recommended that apps write their own serializer to best suit the needs of their API and
+  application.
+
+  @module @ember-data/serializer
+  @main @ember-data/serializer
+*/
+/// <reference types="ember-source/types" />
+import EmberObject from '@ember/object';
+import type Store from '@ember-data/store';
+import type { ModelSchema } from '@ember-data/store/-types/q/ds-model';
+/**
+  > ⚠️ CAUTION you likely want the docs for [<Interface> Serializer](/ember-data/release/classes/%3CInterface%3E%20Serializer)
+  > as extending this abstract class is unnecessary.
+
+  `Serializer` is an abstract base class that you may override in your
+  application to customize it for your backend. The minimum set of methods
+  that you should implement is:
+
+    * `normalizeResponse()`
+    * `serialize()`
+
+  And you can optionally override the following methods:
+
+    * `normalize()`
+
+  For an example implementation, see
+  [JSONSerializer](JSONSerializer), the included JSON serializer.
+
+  @class Serializer
+  @public
+  @extends Ember.EmberObject
+*/
+export default class extends EmberObject {
+    store: Store;
+    /**
+      The `store` property is the application's `store` that contains
+      all records. It can be used to look up serializers for other model
+      types that may be nested inside the payload response.
+  
+      Example:
+  
+      ```js
+      Serializer.extend({
+        extractRelationship(relationshipModelName, relationshipHash) {
+          let modelClass = this.store.modelFor(relationshipModelName);
+          let relationshipSerializer = this.store.serializerFor(relationshipModelName);
+          return relationshipSerializer.normalize(modelClass, relationshipHash);
+        }
+      });
+      ```
+  
+      @property store
+      @type {Store}
+      @public
+    */
+    /**
+      The `normalizeResponse` method is used to normalize a payload from the
+      server to a JSON-API Document.
+  
+      http://jsonapi.org/format/#document-structure
+  
+      Example:
+  
+      ```js
+      Serializer.extend({
+        normalizeResponse(store, primaryModelClass, payload, id, requestType) {
+          if (requestType === 'findRecord') {
+            return this.normalize(primaryModelClass, payload);
+          } else {
+            return payload.reduce(function(documentHash, item) {
+              let { data, included } = this.normalize(primaryModelClass, item);
+              documentHash.included.push(...included);
+              documentHash.data.push(data);
+              return documentHash;
+            }, { data: [], included: [] })
+          }
+        }
+      });
+      ```
+  
+      @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
+    */
+    /**
+      The `serialize` method is used when a record is saved in order to convert
+      the record into the form that your external data source expects.
+  
+      `serialize` takes an optional `options` hash with a single option:
+  
+      - `includeId`: If this is `true`, `serialize` should include the ID
+        in the serialized object it builds.
+  
+      Example:
+  
+      ```js
+      Serializer.extend({
+        serialize(snapshot, options) {
+          let json = {
+            id: snapshot.id
+          };
+  
+          snapshot.eachAttribute((key, attribute) => {
+            json[key] = snapshot.attr(key);
+          });
+  
+          snapshot.eachRelationship((key, relationship) => {
+            if (relationship.kind === 'belongsTo') {
+              json[key] = snapshot.belongsTo(key, { id: true });
+            } else if (relationship.kind === 'hasMany') {
+              json[key] = snapshot.hasMany(key, { ids: true });
+            }
+          });
+  
+          return json;
+        },
+      });
+      ```
+  
+      @method serialize
+      @public
+      @param {Snapshot} snapshot
+      @param {Object} [options]
+      @return {Object}
+    */
+    /**
+      The `normalize` method is used to convert a payload received from your
+      external data source into the normalized form `store.push()` expects. You
+      should override this method, munge the hash and return the normalized
+      payload.
+  
+      Example:
+  
+      ```js
+      Serializer.extend({
+        normalize(modelClass, resourceHash) {
+          let data = {
+            id:            resourceHash.id,
+            type:          modelClass.modelName,
+            attributes:    resourceHash
+          };
+          return { data: data };
+        }
+      })
+      ```
+  
+      @method normalize
+      @public
+      @param {Model} typeClass
+      @param {Object} hash
+      @return {Object}
+    */
+    normalize(_typeClass: ModelSchema, hash: Record<string, unknown>): Record<string, unknown>;
+}
+//# sourceMappingURL=index.d.ts.map

package/unstable-preview-types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2GE;;AAEF,OAAO,WAAW,MAAM,eAAe,CAAC;AAGxC,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;EAqBE;AAEF,MAAM,CAAC,OAAO,MAAO,SAAQ,WAAW;IACrB,KAAK,EAAE,KAAK,CAAC;IAC9B;;;;;;;;;;;;;;;;;;;;MAoBE;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkCE;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwCE;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;MA0BE;IACF,SAAS,CAAC,UAAU,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG3F"}