@ember-data-types/serializer 5.6.0-alpha.5 → 5.6.0-beta.1

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

@@ -1,557 +1,4 @@
 declare module '@ember-data/serializer/rest' {
-  export { EmbeddedRecordsMixin } from "./-private/embedded-records-mixin";
-  export default RESTSerializer;
-  /**
-   * <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 { RESTSerializer as default, EmbeddedRecordsMixin } from "@warp-drive/legacy/serializer/rest";
   
-    Normally, applications will use the `RESTSerializer` by implementing
-    the `normalize` method.
-  
-    This allows you to do whatever kind of munging you need and is
-    especially useful if your server is inconsistent and you need to
-    do munging differently for many different kinds of responses.
-  
-    See the `normalize` documentation for more information.
-  
-    ## Across the Board Normalization
-  
-    There are also a number of hooks that you might find useful to define
-    across-the-board rules for your payload. These rules will be useful
-    if your server is consistent, or if you're building an adapter for
-    an infrastructure service, like Firebase, and want to encode service
-    conventions.
-  
-    For example, if all of your keys are underscored and all-caps, but
-    otherwise consistent with the names you use in your models, you
-    can implement across-the-board rules for how to convert an attribute
-    name in your model to a key in your JSON.
-  
-    ```js [app/serializers/application.js]
-    import RESTSerializer from '@ember-data/serializer/rest';
-    import { underscore } from '<app-name>/utils/string-utils';
-  
-    export default class ApplicationSerializer extends RESTSerializer {
-      keyForAttribute(attr, method) {
-        return underscore(attr).toUpperCase();
-      }
-    }
-    ```
-  
-    You can also implement `keyForRelationship`, which takes the name
-    of the relationship as the first parameter, the kind of
-    relationship (`hasMany` or `belongsTo`) as the second parameter, and
-    the method (`serialize` or `deserialize`) as the third parameter.
-  
-    @class RESTSerializer
-    @public
-  */
-  const RESTSerializer: Readonly<Readonly<typeof import("@ember-data/serializer").default> & (new (owner?: import("@ember/-internals/owner").default) => import(".").default) & {
-      primaryKey: string;
-      mergedProperties: Object;
-      applyTransforms(typeClass: Model, data: Object): Object;
-      normalizeResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-      normalizeFindRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-      normalizeQueryRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-      normalizeFindAllResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-      normalizeFindBelongsToResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-      normalizeFindHasManyResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-      normalizeFindManyResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-      normalizeQueryResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-      normalizeCreateRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-      normalizeDeleteRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-      normalizeUpdateRecordResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-      normalizeSaveResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, ...args: any[]): Object;
-      normalizeSingleResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string): Object;
-      normalizeArrayResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string): Object;
-      _normalizeResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, isSingle: boolean): Object;
-      normalize(modelClass: any, resourceHash: any): Object;
-      extractId(modelClass: Object, resourceHash: Object): string;
-      extractAttributes(modelClass: Object, resourceHash: Object): Object;
-      extractRelationship(relationshipModelName: Object, relationshipHash: Object): Object;
-      extractPolymorphicRelationship(relationshipModelName: Object, relationshipHash: Object, relationshipOptions: Object): Object;
-      extractRelationships(modelClass: Object, resourceHash: Object): Object;
-      modelNameFromPayloadKey(key: string): string;
-      normalizeRelationships(typeClass: any, hash: any): void;
-      normalizeUsingDeclaredMapping(modelClass: any, hash: any): void;
-      _getMappedKey(key: string, modelClass: any): string;
-      _canSerialize(key: string): boolean;
-      _mustSerialize(key: string): boolean;
-      shouldSerializeHasMany(snapshot: Snapshot, key: string, relationship: RelationshipSchema): boolean;
-      serialize(snapshot: Snapshot, options: Object): Object;
-      serializeIntoHash(hash: Object, typeClass: Model, snapshot: Snapshot, options: Object): void;
-      serializeAttribute(snapshot: Snapshot, json: Object, key: string, attribute: Object): void;
-      serializeBelongsTo(snapshot: Snapshot, json: Object, relationship: Object): void;
-      serializeHasMany(snapshot: Snapshot, json: Object, relationship: Object): void;
-      serializePolymorphicType(): void;
-      extractMeta(store: Store, modelClass: Model, payload: Object): any;
-      extractErrors(store: Store, typeClass: Model, payload: Object, id: (string | number)): Object;
-      keyForAttribute(key: string, method: string): string;
-      keyForRelationship(key: string, typeClass: string, method: string): string;
-      keyForLink(key: string, kind: string): string;
-      transformFor(attributeType: string, skipAssertion: boolean): Transform;
-  }> & (new (owner?: import("@ember-data/serializer/@ember/-internals/owner").default) => import(".").default) & {
-      /**
-       `keyForPolymorphicType` can be used to define a custom key when
-       serializing and deserializing a polymorphic type. By default, the
-       returned key is `${key}Type`.
-    
-       Example
-    
-        ```js [app/serializers/post.js]
-        import RESTSerializer from '@ember-data/serializer/rest';
-    
-        export default class ApplicationSerializer extends RESTSerializer {
-          keyForPolymorphicType(key, relationship) {
-            let relationshipKey = this.keyForRelationship(key);
-    
-            return 'type-' + relationshipKey;
-          }
-        }
-        ```
-    
-        @public
-       @param {String} key
-       @param {String} typeClass
-       @param {String} method
-       @return {String} normalized key
-      */
-      keyForPolymorphicType(key: string, typeClass: string, method: string): string;
-      /**
-        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.
-    
-        For example, if you have a payload that looks like this:
-    
-        ```js
-        {
-          "post": {
-            "id": 1,
-            "title": "Rails is omakase",
-            "comments": [ 1, 2 ]
-          },
-          "comments": [{
-            "id": 1,
-            "body": "FIRST"
-          }, {
-            "id": 2,
-            "body": "Rails is unagi"
-          }]
-        }
-        ```
-    
-        The `normalize` method will be called three times:
-    
-        * With `App.Post`, `"posts"` and `{ id: 1, title: "Rails is omakase", ... }`
-        * With `App.Comment`, `"comments"` and `{ id: 1, body: "FIRST" }`
-        * With `App.Comment`, `"comments"` and `{ id: 2, body: "Rails is unagi" }`
-    
-        You can use this method, for example, to normalize underscored keys to camelized
-        or other general-purpose normalizations. You will only need to implement
-        `normalize` and manipulate the payload as desired.
-    
-        For example, if the `IDs` under `"comments"` are provided as `_id` instead of
-        `id`, you can specify how to normalize just the comments:
-    
-        ```js [app/serializers/post.js]
-        import RESTSerializer from '@ember-data/serializer/rest';
-    
-        export default class ApplicationSerializer extends RESTSerializer {
-          normalize(model, hash, prop) {
-            if (prop === 'comments') {
-              hash.id = hash._id;
-              delete hash._id;
-            }
-    
-            return super.normalize(...arguments);
-          }
-        }
-        ```
-    
-        On each call to the `normalize` method, the third parameter (`prop`) is always
-        one of the keys that were in the original payload or in the result of another
-        normalization as `normalizeResponse`.
-    
-        @public
-        @param {Model} modelClass
-        @param {Object} resourceHash
-        @param {String} prop
-        @return {Object}
-      */
-      /**
-        Normalizes an array of resource payloads and returns a JSON-API Document
-        with primary data and, if any, included data as `{ data, included }`.
-    
-        @param {Store} store
-        @param {String} modelName
-        @param {Object} arrayHash
-        @param {String} prop
-        @return {Object}
-        @private
-      */
-      _normalizeArray(store: Store, modelName: string, arrayHash: Object, prop: string): Object;
-      _normalizePolymorphicRecord(store: any, hash: any, prop: any, primaryModelClass: any, primarySerializer: any): 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: Object, id: string | number, requestType: string, isSingle: boolean): Object;
-      isPrimaryType(store: any, modelName: any, primaryModelClass: any): boolean;
-      /**
-        This method allows you to push a payload containing top-level
-        collections of records organized per type.
-    
-        ```js
-        {
-          "posts": [{
-            "id": "1",
-            "title": "Rails is omakase",
-            "author", "1",
-            "comments": [ "1" ]
-          }],
-          "comments": [{
-            "id": "1",
-            "body": "FIRST"
-          }],
-          "users": [{
-            "id": "1",
-            "name": "@d2h"
-          }]
-        }
-        ```
-    
-        It will first normalize the payload, so you can use this to push
-        in data streaming in from your server structured the same way
-        that fetches and saves are structured.
-    
-        @public
-        @param {Store} store
-        @param {Object} payload
-      */
-      pushPayload(store: Store, payload: Object): void;
-      /**
-        This method is used to convert each JSON root key in the payload
-        into a modelName that it can use to look up the appropriate model for
-        that part of the payload.
-    
-        For example, your server may send a model name that does not correspond with
-        the name of the model in your app. Let's take a look at an example model,
-        and an example payload:
-    
-        ```js [app/models/post.js]
-        import Model from '@ember-data/model';
-    
-        export default class Post extends Model {}
-        ```
-    
-        ```javascript
-          {
-            "blog/post": {
-              "id": "1
-            }
-          }
-        ```
-    
-        Ember Data is going to normalize the payload's root key for the modelName. As a result,
-        it will try to look up the "blog/post" model. Since we don't have a model called "blog/post"
-        (or a file called app/models/blog/post.js in ember-cli), Ember Data will throw an error
-        because it cannot find the "blog/post" model.
-    
-        Since we want to remove this namespace, we can define a serializer for the application that will
-        remove "blog/" from the payload key whenver it's encountered by Ember Data:
-    
-        ```js [app/serializers/application.js]
-        import RESTSerializer from '@ember-data/serializer/rest';
-    
-        export default class ApplicationSerializer extends RESTSerializer {
-          modelNameFromPayloadKey(payloadKey) {
-            if (payloadKey === 'blog/post') {
-              return super.modelNameFromPayloadKey(payloadKey.replace('blog/', ''));
-            } else {
-             return super.modelNameFromPayloadKey(payloadKey);
-            }
-          }
-        }
-        ```
-    
-        After refreshing, Ember Data will appropriately look up the "post" model.
-    
-        By default the modelName for a model is its
-        name in dasherized form. This means that a payload key like "blogPost" would be
-        normalized to "blog-post" when Ember Data looks up the model. Usually, Ember Data
-        can use the correct inflection to do this for you. Most of the time, you won't
-        need to override `modelNameFromPayloadKey` for this purpose.
-    
-        @public
-        @param {String} key
-        @return {String} the model's modelName
-      */
-      modelNameFromPayloadKey(key: string): string;
-      /**
-        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 Comment extends Model {
-          @attr title
-          @attr body
-    
-          @belongsTo('user') author
-        }
-        ```
-    
-        The default serialization would create a JSON object like:
-    
-        ```js
-        {
-          "title": "Rails is unagi",
-          "body": "Rails? Omakase? O_O",
-          "author": 12
-        }
-        ```
-    
-        By default, attributes are passed through as-is, unless
-        you specified an attribute type (`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 RESTSerializer from '@ember-data/serializer/rest';
-    
-        export default class ApplicationSerializer extends RESTSerializer {
-          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 RESTSerializer from '@ember-data/serializer/rest';
-        import { pluralize } from '<app-name>/utils/string-utils';
-    
-        export default class ApplicationSerializer extends RESTSerializer {
-          serialize(snapshot, options) {
-            let json = {};
-    
-            snapshot.eachAttribute(function(name) {
-              json[serverAttributeName(name)] = snapshot.attr(name);
-            });
-    
-            snapshot.eachRelationship(function(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:
-    
-        ```js
-        {
-          "TITLE": "Rails is omakase",
-          "BODY": "Yep. Omakase.",
-          "COMMENT_IDS": [ 1, 2, 3 ]
-        }
-        ```
-    
-        ## Tweaking the Default JSON
-    
-        If you just want to do some small tweaks on the default JSON,
-        you can call super first and make the tweaks on the returned
-        JSON.
-    
-        ```js [app/serializers/post.js]
-        import RESTSerializer from '@ember-data/serializer/rest';
-    
-        export default class ApplicationSerializer extends RESTSerializer {
-          serialize(snapshot, options) {
-            let json = super.serialize(snapshot, options);
-    
-            json.subject = json.title;
-            delete json.title;
-    
-            return json;
-          }
-        }
-        ```
-    
-        @public
-        @param {Snapshot} snapshot
-        @param {Object} options
-        @return {Object} json
-      */
-      serialize(snapshot: Snapshot, options: Object, ...args: any[]): Object;
-      /**
-        You can use this method to customize the root keys serialized into the JSON.
-        The hash property should be modified by reference (possibly using something like _.extend)
-        By default the REST Serializer sends the modelName of a model, which is a camelized
-        version of the name.
-    
-        For example, your server may expect underscored root objects.
-    
-        ```js [app/serializers/application.js]
-        import RESTSerializer from '@ember-data/serializer/rest';
-        import { underscore } from '<app-name>/utils/string-utils';
-    
-        export default class ApplicationSerializer extends RESTSerializer {
-          serializeIntoHash(data, type, record, options) {
-            let root = underscore(type.modelName);
-            data[root] = this.serialize(record, options);
-          }
-        }
-        ```
-    
-        @public
-        @param {Object} hash
-        @param {Model} typeClass
-        @param {Snapshot} snapshot
-        @param {Object} options
-      */
-      serializeIntoHash(hash: Object, typeClass: Model, snapshot: Snapshot, options: Object): void;
-      /**
-        You can use `payloadKeyFromModelName` to override the root key for an outgoing
-        request. By default, the RESTSerializer returns a camelized version of the
-        model's name.
-    
-        For a model called TacoParty, its `modelName` would be the string `taco-party`. The RESTSerializer
-        will send it to the server with `tacoParty` as the root key in the JSON payload:
-    
-        ```js
-        {
-          "tacoParty": {
-            "id": "1",
-            "location": "Matthew Beale's House"
-          }
-        }
-        ```
-    
-        For example, your server may expect dasherized root objects:
-    
-        ```js [app/serializers/application.js]
-        import RESTSerializer from '@ember-data/serializer/rest';
-        import { dasherize } from '<app-name>/utils/string-utils';
-    
-        export default class ApplicationSerializer extends RESTSerializer {
-          payloadKeyFromModelName(modelName) {
-            return dasherize(modelName);
-          }
-        }
-        ```
-    
-        Given a `TacoParty` model, calling `save` on it would produce an outgoing
-        request like:
-    
-        ```js
-        {
-          "taco-party": {
-            "id": "1",
-            "location": "Matthew Beale's House"
-          }
-        }
-        ```
-    
-        @public
-        @param {String} modelName
-        @return {String}
-      */
-      payloadKeyFromModelName(modelName: string): string;
-      /**
-        You can use this method to customize how polymorphic objects are serialized.
-        By default the REST Serializer creates the key by appending `Type` to
-        the attribute and value from the model's camelcased model name.
-    
-        @public
-        @param {Snapshot} snapshot
-        @param {Object} json
-        @param {Object} relationship
-      */
-      serializePolymorphicType(snapshot: Snapshot, json: Object, relationship: Object): void;
-      /**
-        You can use this method to customize how a polymorphic relationship should
-        be extracted.
-    
-        @public
-        @param {Object} relationshipType
-        @param {Object} relationshipHash
-        @param {Object} relationshipOptions
-        @return {Object}
-       */
-      extractPolymorphicRelationship(relationshipType: Object, relationshipHash: Object, relationshipOptions: Object, ...args: any[]): Object;
-  };
-}
-//# sourceMappingURL=rest.d.ts.map
+}

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

@@ -1,8 +1,4 @@
 declare module '@ember-data/serializer/transform' {
-  export { Transform as default } from '@ember-data/serializer/-private/transforms/transform';
-  export { BooleanTransform } from '@ember-data/serializer/-private/transforms/boolean';
-  export { DateTransform } from '@ember-data/serializer/-private/transforms/date';
-  export { NumberTransform } from '@ember-data/serializer/-private/transforms/number';
-  export { StringTransform } from '@ember-data/serializer/-private/transforms/string';
-}
-//# sourceMappingURL=transform.d.ts.map
+  export { Transform as default, BooleanTransform, StringTransform, NumberTransform, DateTransform } from "@warp-drive/legacy/serializer/transform";
+  
+}

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

@@ -1,99 +0,0 @@
-declare module '@ember-data/serializer/-private/embedded-records-mixin' {
-  /**
-    ## Using Embedded Records
-  
-    `EmbeddedRecordsMixin` supports serializing embedded records.
-  
-    To set up embedded records, include the mixin when extending a serializer,
-    then define and configure embedded (model) relationships.
-  
-    Note that embedded records will serialize with the serializer for their model instead of the serializer in which they are defined.
-  
-    Note also that this mixin does not work with JSONAPISerializer because the JSON:API specification does not describe how to format embedded resources.
-  
-    Below is an example of a per-type serializer (`post` type).
-  
-    ```js [app/serializers/post.js]
-    import RESTSerializer, { EmbeddedRecordsMixin } from '@ember-data/serializer/rest';
-  
-    export default class PostSerializer extends RESTSerializer.extend(EmbeddedRecordsMixin) {
-      attrs = {
-        author: { embedded: 'always' },
-        comments: { serialize: 'ids' }
-      }
-    }
-    ```
-    Note that this use of `{ embedded: 'always' }` is unrelated to
-    the `{ embedded: 'always' }` that is defined as an option on `attr` as part of
-    defining a model while working with the `ActiveModelSerializer`.  Nevertheless,
-    using `{ embedded: 'always' }` as an option to `attr` is not a valid way to set up
-    embedded records.
-  
-    The `attrs` option for a resource `{ embedded: 'always' }` is shorthand for:
-  
-    ```js
-    {
-      serialize: 'records',
-      deserialize: 'records'
-    }
-    ```
-  
-    ### Configuring Attrs
-  
-    A resource's `attrs` option may be set to use `ids`, `records` or false for the
-    `serialize`  and `deserialize` settings.
-  
-    The `attrs` property can be set on the `ApplicationSerializer` or a per-type
-    serializer.
-  
-    In the case where embedded JSON is expected while extracting a payload (reading)
-    the setting is `deserialize: 'records'`, there is no need to use `ids` when
-    extracting as that is the default behaviour without this mixin if you are using
-    the vanilla `EmbeddedRecordsMixin`. Likewise, to embed JSON in the payload while
-    serializing `serialize: 'records'` is the setting to use. There is an option of
-    not embedding JSON in the serialized payload by using `serialize: 'ids'`. If you
-    do not want the relationship sent at all, you can use `serialize: false`.
-  
-  
-    ### EmbeddedRecordsMixin defaults
-    If you do not overwrite `attrs` for a specific relationship, the `EmbeddedRecordsMixin`
-    will behave in the following way:
-  
-    BelongsTo: `{ serialize: 'id', deserialize: 'id' }`
-    HasMany:   `{ serialize: false, deserialize: 'ids' }`
-  
-    ### Model Relationships
-  
-    Embedded records must have a model defined to be extracted and serialized. Note that
-    when defining any relationships on your model such as `belongsTo` and `hasMany`, you
-    should not both specify `async: true` and also indicate through the serializer's
-    `attrs` attribute that the related model should be embedded for deserialization.
-    If a model is declared embedded for deserialization (`embedded: 'always'` or `deserialize: 'records'`),
-    then do not use `async: true`.
-  
-    To successfully extract and serialize embedded records the model relationships
-    must be set up correctly. See the
-    [defining relationships](https://guides.emberjs.com/current/models/relationships)
-    section of the **Defining Models** guide page.
-  
-    Records without an `id` property are not considered embedded records, model
-    instances must have an `id` property to be used with Ember Data.
-  
-    ### Example JSON payloads, Models and Serializers
-  
-    **When customizing a serializer it is important to grok what the customizations
-    are. Please read the docs for the methods this mixin provides, in case you need
-    to modify it to fit your specific needs.**
-  
-    For example, review the docs for each method of this mixin:
-    * [normalize](/ember-data/release/classes/EmbeddedRecordsMixin/methods/normalize?anchor=normalize)
-    * [serializeBelongsTo](/ember-data/release/classes/EmbeddedRecordsMixin/methods/serializeBelongsTo?anchor=serializeBelongsTo)
-    * [serializeHasMany](/ember-data/release/classes/EmbeddedRecordsMixin/methods/serializeHasMany?anchor=serializeHasMany)
-  
-    @class EmbeddedRecordsMixin
-    @public
-  */
-  export const EmbeddedRecordsMixin: Mixin;
-  import Mixin from '@ember/object/mixin';
-}
-//# sourceMappingURL=embedded-records-mixin.d.ts.map

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

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