@warp-drive/legacy 5.6.0-alpha.11

package/declarations/model/migration-support.d.ts

@@ -0,0 +1,287 @@
+/**
+ * This module provides support for migrating away from @ember-data/model
+ * to @warp-drive/schema-record.
+ *
+ * It includes:
+ *
+ * - A `withDefaults` function to assist in creating a schema in LegacyMode
+ * - A `registerDerivations` function to register the derivations necessary to support LegacyMode
+ * - A `DelegatingSchemaService` that can be used to provide a schema service that works with both
+ *   @ember-data/model and @warp-drive/schema-record simultaneously for migration purposes.
+ * - A `WithLegacy` type util that can be used to create a type that includes the legacy
+ *   properties and methods of a record.
+ *
+ * Using LegacyMode features on a ReactiveResource *requires* the use of these derivations and schema
+ * additions. LegacyMode is not intended to be a long-term solution, but rather a stepping stone
+ * to assist in more rapidly adopting modern WarpDrive features.
+ *
+ * @module
+ */
+import type { Store } from '@warp-drive/core';
+import type { SchemaService } from '@warp-drive/core/types';
+import type { ChangedAttributesHash } from '@warp-drive/core/types/cache';
+import type { StableRecordIdentifier } from '@warp-drive/core/types/identifier';
+import type { ObjectValue } from '@warp-drive/core/types/json/raw';
+import type { TypedRecordInstance, TypeFromInstance } from '@warp-drive/core/types/record';
+import type { Derivation, HashFn, Transformation } from '@warp-drive/core/types/schema/concepts';
+import type { ArrayField, DerivedField, FieldSchema, GenericField, HashField, LegacyResourceSchema, ObjectField, ObjectSchema, ResourceSchema } from '@warp-drive/core/types/schema/fields';
+import type { WithPartial } from '@warp-drive/core/types/utils';
+import type { Snapshot } from '../compat/-private.ts';
+import type { MinimalLegacyRecord } from './-private/model-methods.ts';
+import { belongsTo, hasMany } from './-private/model-methods.ts';
+import RecordState from './-private/record-state.ts';
+import type BelongsToReference from './-private/references/belongs-to.ts';
+import type HasManyReference from './-private/references/has-many.ts';
+import type { _MaybeBelongsToFields, MaybeHasManyFields } from './-private/type-utils.ts';
+export type WithLegacyDerivations<T extends TypedRecordInstance> = T & MinimalLegacyRecord & {
+    belongsTo: typeof belongsTo;
+    hasMany: typeof hasMany;
+};
+type AttributesSchema = ReturnType<Exclude<SchemaService['attributesDefinitionFor'], undefined>>;
+type RelationshipsSchema = ReturnType<Exclude<SchemaService['relationshipsDefinitionFor'], undefined>>;
+interface LegacyModeRecord<T extends TypedRecordInstance> {
+    id: string | null;
+    serialize(options?: Record<string, unknown>): unknown;
+    destroyRecord(options?: Record<string, unknown>): Promise<this>;
+    unloadRecord(): void;
+    changedAttributes(): ChangedAttributesHash;
+    rollbackAttributes(): void;
+    _createSnapshot(): Snapshot<T>;
+    save(options?: Record<string, unknown>): Promise<this>;
+    reload(options?: Record<string, unknown>): Promise<T>;
+    belongsTo<K extends _MaybeBelongsToFields<T>>(prop: K): BelongsToReference<T, K>;
+    hasMany<K extends MaybeHasManyFields<T>>(prop: K): HasManyReference<T, K>;
+    deleteRecord(): void;
+    adapterError: unknown;
+    constructor: {
+        modelName: TypeFromInstance<T>;
+    };
+    currentState: RecordState;
+    dirtyType: 'deleted' | 'created' | 'updated' | '';
+    errors: unknown;
+    hasDirtyAttributes: boolean;
+    isDeleted: boolean;
+    isEmpty: boolean;
+    isError: boolean;
+    isLoaded: boolean;
+    isLoading: boolean;
+    isDestroying: boolean;
+    isDestroyed: boolean;
+    isNew: boolean;
+    isSaving: boolean;
+    isValid: boolean;
+}
+/**
+ * A Type utility that enables quickly adding type information for the fields
+ * defined by `import { withDefaults } from '@ember-data/model/migration-support'`.
+ *
+ * Example:
+ *
+ * ```ts
+ * import { withDefaults, WithLegacy } from '@ember-data/model/migration-support';
+ * import { Type } from '@warp-drive/core-types/symbols';
+ * import type { HasMany } from '@ember-data/model';
+ *
+ * export const UserSchema = withDefaults({
+ *   type: 'user',
+ *   fields: [
+ *     { name: 'firstName', kind: 'attribute' },
+ *     { name: 'lastName', kind: 'attribute' },
+ *     { name: 'age', kind: 'attribute' },
+ *     { name: 'friends',
+ *       kind: 'hasMany',
+ *       type: 'user',
+ *       options: { inverse: 'friends', async: false }
+ *     },
+ *     { name: 'bestFriend',
+ *       kind: 'belongsTo',
+ *       type: 'user',
+ *       options: { inverse: null, async: false }
+ *     },
+ *   ],
+ * });
+ *
+ * export type User = WithLegacy<{
+ *   firstName: string;
+ *   lastName: string;
+ *   age: number;
+ *   friends: HasMany<User>;
+ *   bestFriend: User | null;
+ *   [Type]: 'user';
+ * }>
+ * ```
+ *
+ */
+export type WithLegacy<T extends TypedRecordInstance> = T & LegacyModeRecord<T>;
+/**
+ * A function which adds the necessary fields to a schema and marks it as
+ * being in LegacyMode. This is used to support the legacy features of
+ * @ember-data/model while migrating to WarpDrive.
+ *
+ * Example:
+ *
+ * ```ts
+ * import { withDefaults, WithLegacy } from '@ember-data/model/migration-support';
+ * import { Type } from '@warp-drive/core-types/symbols';
+ * import type { HasMany } from '@ember-data/model';
+ *
+ * export const UserSchema = withDefaults({
+ *   type: 'user',
+ *   fields: [
+ *     { name: 'firstName', kind: 'attribute' },
+ *     { name: 'lastName', kind: 'attribute' },
+ *     { name: 'age', kind: 'attribute' },
+ *     { name: 'friends',
+ *       kind: 'hasMany',
+ *       type: 'user',
+ *       options: { inverse: 'friends', async: false }
+ *     },
+ *     { name: 'bestFriend',
+ *       kind: 'belongsTo',
+ *       type: 'user',
+ *       options: { inverse: null, async: false }
+ *     },
+ *   ],
+ * });
+ *
+ * export type User = WithLegacy<{
+ *   firstName: string;
+ *   lastName: string;
+ *   age: number;
+ *   friends: HasMany<User>;
+ *   bestFriend: User | null;
+ *   [Type]: 'user';
+ * }>
+ * ```
+ *
+ * Using this function require registering the derivations
+ * it requires with the schema service.
+ *
+ * ```ts
+ * import { registerDerivations } from '@ember-data/model/migration-support';
+ *
+ * registerDerivations(schema);
+ * ```
+ *
+ * @param {LegacyResourceSchema} schema The schema to add legacy support to.
+ * @return {LegacyResourceSchema} The schema with legacy support added.
+ * @public
+ */
+export declare function withDefaults(schema: WithPartial<LegacyResourceSchema, 'legacy' | 'identity'>): LegacyResourceSchema;
+/**
+ * A function which registers the necessary derivations to support
+ * the LegacyMode features of @ember-data/model while migrating to WarpDrive.
+ *
+ * This must be called in order to use the fields added by:
+ *
+ * ```ts
+ * import { withDefaults } from '@ember-data/model/migration-support';
+ * ```
+ *
+ * @param {SchemaService} schema The schema service to register the derivations with.
+ * @return {void}
+ * @public
+ */
+export declare function registerDerivations(schema: SchemaService): void;
+/**
+ * A class which provides a schema service that delegates between
+ * a primary schema service and one that supports legacy model
+ * classes as its schema source.
+ *
+ * When the primary schema service has a schema for the given
+ * resource, it will be used. Otherwise, the fallback schema
+ * service will be used.
+ *
+ * This can be used when incrementally migrating from Models to
+ * ReactiveResources by enabling unmigrated Models to continue to
+ * provide their own schema information to the application.
+ *
+ * ```ts
+ * import { DelegatingSchemaService } from '@ember-data/model/migration-support';
+ * import { SchemaService } from '@warp-drive/schema-record';
+ *
+ * class AppStore extends Store {
+ *   createSchemaService() {
+ *     const schema = new SchemaService();
+ *     return new DelegatingSchemaService(this, schema);
+ *   }
+ * }
+ * ```
+ *
+ * All calls to register resources, derivations, transformations, hash functions
+ * etc. will be delegated to the primary schema service.
+ *
+ * @class DelegatingSchemaService
+ * @public
+ */
+export interface DelegatingSchemaService {
+    attributesDefinitionFor?(resource: StableRecordIdentifier | {
+        type: string;
+    }): AttributesSchema;
+    relationshipsDefinitionFor?(resource: StableRecordIdentifier | {
+        type: string;
+    }): RelationshipsSchema;
+    doesTypeExist?(type: string): boolean;
+}
+export declare class DelegatingSchemaService implements SchemaService {
+    _preferred: SchemaService;
+    _secondary: SchemaService;
+    constructor(store: Store, schema: SchemaService);
+    isDelegated(resource: StableRecordIdentifier | {
+        type: string;
+    }): boolean;
+    resourceTypes(): Readonly<string[]>;
+    hasResource(resource: StableRecordIdentifier | {
+        type: string;
+    }): boolean;
+    hasTrait(type: string): boolean;
+    resourceHasTrait(resource: StableRecordIdentifier | {
+        type: string;
+    }, trait: string): boolean;
+    fields(resource: StableRecordIdentifier | {
+        type: string;
+    }): Map<string, FieldSchema>;
+    transformation(field: GenericField | ObjectField | ArrayField | {
+        type: string;
+    }): Transformation;
+    hashFn(field: HashField | {
+        type: string;
+    }): HashFn;
+    derivation(field: DerivedField | {
+        type: string;
+    }): Derivation;
+    resource(resource: StableRecordIdentifier | {
+        type: string;
+    }): ResourceSchema | ObjectSchema;
+    registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
+    registerResource(schema: ResourceSchema | ObjectSchema): void;
+    registerTransformation(transform: Transformation): void;
+    registerDerivation<R, T, FM extends ObjectValue | null>(derivation: Derivation<R, T, FM>): void;
+    registerHashFn(hashFn: HashFn): void;
+    /**
+     * This is an internal method used to register behaviors for legacy mode.
+     * It is not intended for public use.
+     *
+     * We do think a generalized `kind` registration system would be useful,
+     * but we have not yet designed it.
+     *
+     * See https://github.com/emberjs/data/issues/9534
+     *
+     * @internal
+     */
+    _registerMode(mode: string, kinds: unknown): void;
+    /**
+     * This is an internal method used to enable legacy behaviors for legacy mode.
+     * It is not intended for public use.
+     *
+     * We do think a generalized `kind` registration system would be useful,
+     * but we have not yet designed it.
+     *
+     * See https://github.com/emberjs/data/issues/9534
+     *
+     * @internal
+     */
+    _kind(mode: string, kind: 'belongsTo' | 'hasMany'): () => unknown;
+}
+export {};
+//# sourceMappingURL=migration-support.d.ts.map

package/declarations/model/migration-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-support.d.ts","sourceRoot":"","sources":["../../src/model/migration-support.ts"],"names":[],"mappings":"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"}

package/declarations/model/migration-support.type-test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=migration-support.type-test.d.ts.map

package/declarations/model/migration-support.type-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-support.type-test.d.ts","sourceRoot":"","sources":["../../src/model/migration-support.type-test.ts"],"names":[],"mappings":""}

package/declarations/model.d.ts

@@ -0,0 +1,50 @@
+/**
+ * This package provides a Presentation Model for resource data in an WarpDrive Cache.
+ *
+ * Models are defined as classes extending from `import Model from '@ember-data/model';` and the
+ * attributes and relationships on these classes are parsed at runtime to supply static "schema"
+ * to WarpDrive's SchemaService.
+ *
+ * Resource data for individual resources fetched from your API is presented to the UI via instances
+ * of the `Model`s you define. An instantiated `Model` is referred to as a `record`.
+
+  When we refer to the `ModelClass` as opposed to a `Model` or `Record` we are referring
+  specifically to the class definition and the static schema methods present on it.
+
+  When we refer to a `record` we refer to a specific class instance presenting
+  the resource data for a given `type` and `id`.
+
+  ### Defining a Model
+
+  ```js [app/models/person.js]
+  import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
+
+  export default class PersonModel extends Model {
+    @attr name;
+
+    @belongsTo('pet', { inverse: 'owners', async: false }) dog;
+
+    @hasMany('person', { inverse: 'friends', async: true }) friends;
+  }
+  ```
+
+  ### modelName convention
+
+  By convention, the name of a given model (its `type`) matches the name
+  of the file in the `app/models` folder and should be lowercase, singular
+  and dasherized.
+
+  @module
+ */
+export { attr } from './model/-private/attr';
+export { belongsTo } from './model/-private/belongs-to';
+export { hasMany } from './model/-private/has-many';
+export { Model } from './model/-private/model';
+export { Model as default } from './model/-private/model';
+export type { PromiseBelongsTo as AsyncBelongsTo } from './model/-private/promise-belongs-to';
+export type { PromiseManyArray as AsyncHasMany } from './model/-private/promise-many-array';
+export type { RelatedCollection as ManyArray } from '@warp-drive/core/store/-private';
+export type { RelatedCollection as HasMany } from '@warp-drive/core/store/-private';
+export { instantiateRecord, teardownRecord, modelFor } from './model/-private/hooks';
+export { buildSchema } from './model/-private/schema-provider';
+//# sourceMappingURL=model.d.ts.map

package/declarations/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAC/C,OAAO,EAAE,KAAK,IAAI,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAE1D,YAAY,EAAE,gBAAgB,IAAI,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAC9F,YAAY,EAAE,gBAAgB,IAAI,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAC5F,YAAY,EAAE,iBAAiB,IAAI,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACtF,YAAY,EAAE,iBAAiB,IAAI,OAAO,EAAE,MAAM,iCAAiC,CAAC;AACpF,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACrF,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC"}

package/declarations/serializer/-private/embedded-records-mixin.d.ts

@@ -0,0 +1,97 @@
+/**
+  ## 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/declarations/serializer/-private/embedded-records-mixin.d.ts.map

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

package/declarations/serializer/-private/transforms/boolean.d.ts

@@ -0,0 +1,47 @@
+import type { TransformName } from '@warp-drive/core/types/symbols';
+/**
+  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
+
+  ```js [app/models/user.js]
+  import { Model, attr } from '@warp-drive/legacy/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 })`
+
+  ```js [app/models/user.js]
+  import { Model, attr } from '@warp-drive/legacy/model';
+
+  export default class UserModel extends Model {
+    @attr('string') email;
+    @attr('string') username;
+    @attr('boolean', { allowNull: true }) wantsWeeklyEmail;
+  }
+  ```
+
+  @class BooleanTransform
+  @public
+ */
+export declare class BooleanTransform {
+    deserialize(serialized: boolean | null | number | string, options?: {
+        allowNull?: boolean;
+    }): boolean | null;
+    serialize(deserialized: boolean | null, options?: {
+        allowNull?: boolean;
+    }): boolean | null;
+    [TransformName]: 'boolean';
+    static create(): BooleanTransform;
+}
+//# sourceMappingURL=boolean.d.ts.map

package/declarations/serializer/-private/transforms/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../../../src/serializer/-private/transforms/boolean.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,gBAAgB;IAC3B,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;IAQlF,CAAC,aAAa,CAAC,EAAE,SAAS,CAAC;IAEnC,MAAM,CAAC,MAAM;CAGd"}

package/declarations/serializer/-private/transforms/boolean.type-test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=boolean.type-test.d.ts.map

package/declarations/serializer/-private/transforms/boolean.type-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.type-test.d.ts","sourceRoot":"","sources":["../../../../src/serializer/-private/transforms/boolean.type-test.ts"],"names":[],"mappings":""}

package/declarations/serializer/-private/transforms/date.d.ts

@@ -0,0 +1,28 @@
+import { TransformName } from '@warp-drive/core/types/symbols';
+/**
+ 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.
+
+ ```js [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 declare class DateTransform {
+    deserialize(serialized: string | number | null, _options?: Record<string, unknown>): Date | null;
+    serialize(date: Date, _options?: Record<string, unknown>): string | null;
+    [TransformName]: "date";
+    static create(): DateTransform;
+}
+//# sourceMappingURL=date.d.ts.map

package/declarations/serializer/-private/transforms/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../../src/serializer/-private/transforms/date.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,qBAAa,aAAa;IACxB,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,CAAC,aAAa,CAAC,EAAG,MAAM,CAAU;IAElC,MAAM,CAAC,MAAM;CAGd"}

package/declarations/serializer/-private/transforms/number.d.ts

@@ -0,0 +1,29 @@
+import { TransformName } from '@warp-drive/core/types/symbols';
+/**
+  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
+
+  ```js [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 declare 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;
+    [TransformName]: "number";
+    static create(): NumberTransform;
+}
+//# sourceMappingURL=number.d.ts.map

package/declarations/serializer/-private/transforms/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../../../src/serializer/-private/transforms/number.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAM/D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,eAAe;IAC1B,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,CAAC,aAAa,CAAC,EAAG,QAAQ,CAAU;IAEpC,MAAM,CAAC,MAAM;CAGd"}

package/declarations/serializer/-private/transforms/string.d.ts

@@ -0,0 +1,29 @@
+import { TransformName } from '@warp-drive/core/types/symbols';
+/**
+  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
+
+  ```js [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 declare class StringTransform {
+    deserialize(serialized: unknown, _options?: Record<string, unknown>): string | null;
+    serialize(deserialized: unknown, _options?: Record<string, unknown>): string | null;
+    [TransformName]: "string";
+    static create(): StringTransform;
+}
+//# sourceMappingURL=string.d.ts.map

package/declarations/serializer/-private/transforms/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../../src/serializer/-private/transforms/string.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,eAAe;IAC1B,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,CAAC,aAAa,CAAC,EAAG,QAAQ,CAAU;IAEpC,MAAM,CAAC,MAAM;CAGd"}