@ember-data-mirror/serializer 5.6.0-alpha.1 → 5.6.0-alpha.11

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

@@ -1 +1 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,OAAO,EAAE,MAAM,oCAAoC,CAAC"}

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

@@ -1,570 +1,4 @@
 declare module '@ember-data-mirror/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>
-  
-    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.
-  
-    ```app/serializers/application.js
-    import RESTSerializer from '@ember-data-mirror/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
-    @main @ember-data-mirror/serializer/rest
-    @public
-    @extends JSONSerializer
-  */
-  const RESTSerializer: Readonly<Readonly<typeof import("@ember-data-mirror/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-mirror/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
-    
-        ```app/serializers/post.js
-        import RESTSerializer from '@ember-data-mirror/serializer/rest';
-    
-        export default class ApplicationSerializer extends RESTSerializer {
-          keyForPolymorphicType(key, relationship) {
-            let relationshipKey = this.keyForRelationship(key);
-    
-            return 'type-' + relationshipKey;
-          }
-        }
-        ```
-    
-       @method keyForPolymorphicType
-        @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:
-    
-        ```app/serializers/post.js
-        import RESTSerializer from '@ember-data-mirror/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`.
-    
-        @method normalize
-        @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 }`.
-    
-        @method _normalizeArray
-        @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;
-      /**
-        @method _normalizeResponse
-        @param {Store} store
-        @param {Model} primaryModelClass
-        @param {Object} payload
-        @param {String|Number} id
-        @param {String} requestType
-        @param {Boolean} isSingle
-        @return {Object} JSON-API Document
-        @private
-      */
-      _normalizeResponse(store: Store, primaryModelClass: Model, payload: Object, id: string | number, requestType: string, isSingle: boolean): Object;
-      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.
-    
-        @method pushPayload
-        @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:
-    
-        ```app/models/post.js
-        import Model from '@ember-data-mirror/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:
-    
-        ```app/serializers/application.js
-        import RESTSerializer from '@ember-data-mirror/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.
-    
-        @method modelNameFromPayloadKey
-        @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:
-    
-        ```app/models/comment.js
-        import Model, { attr, belongsTo } from '@ember-data-mirror/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.
-    
-        ```app/serializers/post.js
-        import RESTSerializer from '@ember-data-mirror/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.
-    
-        ```app/serializers/application.js
-        import RESTSerializer from '@ember-data-mirror/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.
-    
-        ```app/serializers/post.js
-        import RESTSerializer from '@ember-data-mirror/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;
-          }
-        }
-        ```
-    
-        @method serialize
-        @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.
-    
-        ```app/serializers/application.js
-        import RESTSerializer from '@ember-data-mirror/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);
-          }
-        }
-        ```
-    
-        @method serializeIntoHash
-        @public
-        @param {Object} hash
-        @param {Model} typeClass
-        @param {Snapshot} snapshot
-        @param {Object} options
-      */
-      serializeIntoHash(hash: Object, typeClass: Model, snapshot: Snapshot, options: Object): void;
-      /**
-        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:
-    
-        ```app/serializers/application.js
-        import RESTSerializer from '@ember-data-mirror/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"
-          }
-        }
-        ```
-    
-        @method payloadKeyFromModelName
-        @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.
-    
-        @method serializePolymorphicType
-        @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.
-    
-        @method extractPolymorphicRelationship
-        @public
-        @param {Object} relationshipType
-        @param {Object} relationshipHash
-        @param {Object} relationshipOptions
-        @return {Object}
-       */
-      extractPolymorphicRelationship(relationshipType: Object, relationshipHash: Object, relationshipOptions: Object, ...args: any[]): Object;
-  };
+  export { RESTSerializer as default, EmbeddedRecordsMixin } from '@warp-drive-mirror/legacy/serializer/rest';
 }
 //# sourceMappingURL=rest.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"rest.d.ts","sourceRoot":"","sources":["../src/rest.js"],"names":[],"mappings":";;AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDE;AACF;;;+BAgII,KACJ;6BAmDmD,KAAK,qBACzC,KAAK;uCAgDN,KAAK,qBAAqB,KAAI;wCAkBV,KAAK,qBAAoB,KAAK;oCAmBrC,KAAK,qBAAoB,KAAK;0CAejD,KAAG,qBACG,KAAK;wCAuBD,KAClB,qBAAoB,KAAK;qCAuBb,KAAK,qBACP,KAAK;kCAewD,KAErE,qBAAoB,KAAK;yCAiBvB,KAAE,qBAAoB,KAAK;yCAmBJ,KAAI,qBAAoB,KAAK;yCAU3B,KAAK,qBAAqB,KAAI;iCAetC,KAAK,qBAAoB,KAAK;mCAiBrC,KAAK,qBAEH,KAAK;kCA0BP,KAAK,qBAAoB,KAAK;8BAWjB,KAAK,qBAAoB,KAAK;;;;;;;;;;;;;qCAiS2zI,QAAQ,6BAA+C,kBAAkB;wBAA24I,QAAQ;+CAA2tD,KAAK,YAAwB,QAAQ;iCAAq1B,QAAQ;iCAAi6C,QAAQ;+BAAq9C,QAAQ;;uBAAm7E,KAAK,cAAoB,KAAK;yBAAk8E,KAAK,aAAoB,KAAK;;;;iEAAuhH,SAAS;;IAhvBlwtB;;;;;;;;;;;;;;;;;;;;;;;;;MAyBE;;IAOF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkEE;IAEF;;;;;;;;;;;MAWE;2BANQ,KAAK,gCAEL,MAAM,iBAEL,MAAM;;IA0CjB;;;;;;;;;;MAUE;8BARQ,KAAK,qBACL,KAAK,WACL,MAAM,MACN,eAAa,2CAGZ,MAAM;;IAwIjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;uBAFQ,KAAK,WACL,MAAM;IAiChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyDE;;IAOF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwJE;wBAHQ,QAAQ,WACR,MAAM,mBACL,MAAM;IAMjB;;;;;;;;;;;;;;;;;;;;;;;;;;MA0BE;4BAJQ,MAAM,aACN,KAAK,YACL,QAAQ,WACR,MAAM;IAOhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8CE;;IAKF;;;;;;;;;;MAUE;uCAHQ,QAAQ,QACR,MAAM,gBACN,MAAM;IAchB;;;;;;;;;;OAUG;qDAJO,MAAM,oBACN,MAAM,uBACN,MAAM,mBACL,MAAM;EAmChB"}
+{"version":3,"file":"rest.d.ts","sourceRoot":"","sources":["../src/rest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,IAAI,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AAAA;;EAEE;AACF,OAAO,EAAE,SAAS,IAAI,OAAO,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,IAAI,OAAO,EACpB,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,aAAa,GACd,MAAM,yCAAyC,CAAC"}