@warp-drive/legacy 5.8.0-alpha.30 → 5.8.0-alpha.34

package/dist/unpkg/dev/declarations/model/migration-support.d.ts

@@ -0,0 +1,280 @@
+import type { Store } from "@warp-drive/core";
+import type { CAUTION_MEGA_DANGER_ZONE_Extension, ProcessedExtension } from "@warp-drive/core/reactive";
+import type { ExtensibleField } from "@warp-drive/core/reactive/-private/schema";
+import type { SchemaService } from "@warp-drive/core/types";
+import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
+import type { ResourceKey } 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, CacheableFieldSchema, DerivedField, FieldSchema, GenericField, HashField, IdentityField, 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.js";
+import type { MinimalLegacyRecord } from "./-private/model-methods.js";
+import { belongsTo, hasMany } from "./-private/model-methods.js";
+import RecordState from "./-private/record-state.js";
+import type BelongsToReference from "./-private/references/belongs-to.js";
+import type HasManyReference from "./-private/references/has-many.js";
+import type { _MaybeBelongsToFields, MaybeHasManyFields } from "./-private/type-utils.js";
+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 '@warp-drive/legacy/model/migration-support'`.
+*
+* Example:
+*
+* ```ts
+* import { withDefaults, WithLegacy } from '@warp-drive/legacy/model/migration-support';
+* import { Type } from '@warp-drive/core/types/symbols';
+* import type { HasMany } from '@@warp-drive/legacy/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
+* @warp-drive/legacy/model while migrating to WarpDrive.
+*
+* Example:
+*
+* ```ts
+* import { withDefaults, WithLegacy } from '@warp-drive/legacy/model/migration-support';
+* import { Type } from '@warp-drive/core/types/symbols';
+* import type { HasMany } from '@warp-drive/legacy/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 '@warp-drive/legacy/model/migration-support';
+*
+* registerDerivations(schema);
+* ```
+*
+* @param schema The schema to add legacy support to.
+* @return The schema with legacy support added.
+* @public
+*/
+export declare function withDefaults(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): LegacyResourceSchema;
+/**
+* Adds the necessasary fields to the schema for supporting
+* the deprecated request methods on LegacyMode schemas.
+*
+* Use this instead of `withDefaults` to add the fields
+* and behaviors necessary to support Model-Like capabilities.
+*
+* ```ts
+* import { withRestoredDeprecatedModelRequestBehaviors } from '@warp-drive/legacy/model/migration-support';
+*
+* export const UserSchema = withRestoredDeprecatedModelRequestBehaviors({
+*   type: 'user',
+*   fields: [
+*     { name: 'firstName', kind: 'attribute' },
+*     { name: 'lastName', kind: 'attribute' },
+*   ]
+* });
+* ```
+*/
+export declare function withRestoredDeprecatedModelRequestBehaviors(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): LegacyResourceSchema;
+/**
+* A function which registers the necessary derivations to support
+* the LegacyMode features of @warp-drive/legacy/model while migrating to WarpDrive.
+*
+* This must be called in order to use the fields added by {@link withDefaults} or
+* {@link withRestoredDeprecatedModelRequestBehaviors}.
+*
+* @param schema The schema service to register the derivations with.
+* @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 '@warp-drive/legacy/model/migration-support';
+* import { SchemaService } from '@warp-drive/core/reactive';
+*
+* 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: ResourceKey | {
+		type: string;
+	}): AttributesSchema;
+	relationshipsDefinitionFor?(resource: ResourceKey | {
+		type: string;
+	}): RelationshipsSchema;
+	doesTypeExist?(type: string): boolean;
+}
+export declare class DelegatingSchemaService implements SchemaService {
+	constructor(store: Store, schema: SchemaService);
+	isDelegated(resource: ResourceKey | {
+		type: string;
+	}): boolean;
+	resourceTypes(): Readonly<string[]>;
+	hasResource(resource: ResourceKey | {
+		type: string;
+	}): boolean;
+	hasTrait(type: string): boolean;
+	resourceHasTrait(resource: ResourceKey | {
+		type: string;
+	}, trait: string): boolean;
+	fields(resource: ResourceKey | {
+		type: string;
+	}): Map<string, FieldSchema>;
+	cacheFields?(resource: {
+		type: string;
+	}): Map<string, Exclude<CacheableFieldSchema, IdentityField>>;
+	transformation(field: GenericField | ObjectField | ArrayField | {
+		type: string;
+	}): Transformation;
+	hashFn(field: HashField | {
+		type: string;
+	}): HashFn;
+	derivation(field: DerivedField | {
+		type: string;
+	}): Derivation;
+	resource(resource: ResourceKey | {
+		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;
+	CAUTION_MEGA_DANGER_ZONE_hasExtension(ext: {
+		kind: "object" | "array";
+		name: string;
+	}): boolean;
+	CAUTION_MEGA_DANGER_ZONE_registerExtension(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
+	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: ResourceKey | {
+		type: string;
+	}): null | ProcessedExtension["features"];
+	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField, resolvedType: string | null): null | ProcessedExtension["features"];
+	CAUTION_MEGA_DANGER_ZONE_arrayExtensions(field: ExtensibleField): null | ProcessedExtension["features"];
+}
+export interface PrivateDelegatingSchemaService extends DelegatingSchemaService {
+	_preferred: SchemaService;
+	_secondary: SchemaService;
+}
+export {};

package/dist/unpkg/dev/declarations/model-fragments/extensions/fragment-array.d.ts

@@ -0,0 +1,16 @@
+import type { Fragment } from "./fragment.js";
+export declare class FragmentArray<T extends Fragment> {
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	get hasDirtyAttributes(): boolean;
+	addFragment(fragment?: T): Fragment[] | undefined;
+	createFragment(fragment?: T): Fragment | undefined;
+	removeFragment(fragment?: T): void;
+	rollbackAttributes(): void;
+}
+export declare const FragmentArrayExtension: {
+	kind: "array";
+	name: "fragment-array";
+	features: typeof FragmentArray;
+};
+export default FragmentArrayExtension;

package/dist/unpkg/dev/declarations/model-fragments/extensions/fragment.d.ts

@@ -0,0 +1,15 @@
+import type { PrivateReactiveResource } from "@warp-drive/core/reactive/-private";
+export declare class Fragment {
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	get hasDirtyAttributes(): boolean;
+	get isFragment(): boolean;
+	get $type(): string | null | undefined;
+	rollbackAttributes(this: PrivateReactiveResource): void;
+}
+export declare const FragmentExtension: {
+	kind: "object";
+	name: "fragment";
+	features: typeof Fragment;
+};
+export default FragmentExtension;

package/dist/unpkg/dev/declarations/model-fragments/hooks/model-for.d.ts

@@ -0,0 +1,20 @@
+import type { Store } from "@warp-drive/core";
+import type { ModelSchema } from "@warp-drive/core/types";
+import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
+import type { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
+type KeyOrString<T> = keyof T & string extends never ? string : keyof T & string;
+export declare function getShimClass<T>(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+export declare class ShimModelClass<T = unknown> implements ModelSchema<T> {
+	__store: Store;
+	modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+	constructor(store: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string);
+	get fields(): Map<KeyOrString<T>, "attribute" | "belongsTo" | "hasMany">;
+	get attributes(): Map<KeyOrString<T>, LegacyAttributeField>;
+	get relationshipsByName(): Map<KeyOrString<T>, LegacyRelationshipField>;
+	eachAttribute<K extends KeyOrString<T>>(callback: (key: K, attribute: LegacyAttributeField) => void, binding?: T): void;
+	eachRelationship<K extends KeyOrString<T>>(callback: (key: K, relationship: LegacyRelationshipField) => void, binding?: T): void;
+	eachTransformedAttribute<K extends KeyOrString<T>>(callback: (key: K, type: string | null) => void, binding?: T): void;
+}
+export declare function fragmentsModelFor<T extends TypedRecordInstance>(this: Store, modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string): ShimModelClass<T>;
+export declare const modelFor: typeof fragmentsModelFor;
+export {};

package/dist/unpkg/dev/declarations/model-fragments/index.d.ts

@@ -0,0 +1,5 @@
+import type { WithArrayLike, WithEmberObject } from "../compat/extensions.js";
+import type { Fragment } from "./extensions/fragment.js";
+import type { FragmentArray } from "./extensions/fragment-array.js";
+export type WithFragment<T> = T & WithEmberObject<T> & Fragment;
+export type WithFragmentArray<T extends Fragment> = T & WithArrayLike<T> & FragmentArray<T>;

package/dist/unpkg/dev/declarations/model-fragments/instance-initializers/fragment-extensions.d.ts

@@ -0,0 +1,9 @@
+import type ApplicationInstance from "@ember/application/instance";
+import type { SchemaService } from "@warp-drive/core/types";
+export declare function registerFragmentExtensions(schema: SchemaService): void;
+export declare function initialize(application: ApplicationInstance): void;
+declare const _default: {
+	name: string;
+	initialize: (application: ApplicationInstance) => void;
+};
+export default _default;

package/dist/unpkg/dev/declarations/model-fragments/utilities/with-array-defaults.d.ts

@@ -0,0 +1,15 @@
+/**
+* Used as a helper to setup the relevant parts of an array
+* schema and add extensions etc.
+*
+* @param arrayName The name of the array
+* @returns The schema for an array
+*/
+export declare function withArrayDefaults<ArrayName extends string>(arrayName: ArrayName): {
+	kind: "array";
+	name: ArrayName;
+	type: `array:${string}`;
+	options: {
+		arrayExtensions: string[];
+	};
+};

package/dist/unpkg/dev/declarations/model-fragments/utilities/with-fragment-array-defaults.d.ts

@@ -0,0 +1,20 @@
+/**
+* Used as a helper to setup the relevant parts of a fragment-array
+* schema and add extensions etc.
+*
+* @param fragmentArrayType The type of the fragment-array
+* @param fragmentArrayName The name of the fragment-array
+* @returns The schema for a fragment-array
+*/
+export declare function withFragmentArrayDefaults<
+	FragmentArrayType extends string,
+	FragmentArrayName extends string
+>(fragmentArrayType: FragmentArrayType, fragmentArrayName?: FragmentArrayName): {
+	kind: "schema-array";
+	type: `fragment:${string}`;
+	name: string;
+	options: {
+		arrayExtensions: string[];
+		defaultValue: boolean;
+	};
+};

package/dist/unpkg/dev/declarations/model-fragments/utilities/with-fragment-defaults.d.ts

@@ -0,0 +1,19 @@
+/**
+* Used as a helper to setup the relevant parts of a fragment schema
+* and add extensions etc.
+*
+* @param fragmentType The type of the fragment
+* @param fragmentName The optional name of the fragment. If not provided, it will default to the fragmentType.
+* @returns The schema for a fragment
+*/
+export declare function withFragmentDefaults<
+	FragmentType extends string,
+	FragmentName extends string
+>(fragmentType: FragmentType, fragmentName?: FragmentName): {
+	kind: "schema-object";
+	type: `fragment:${FragmentType}`;
+	name: FragmentType | FragmentName;
+	options: {
+		objectExtensions: string[];
+	};
+};

package/dist/unpkg/dev/declarations/model-fragments/utilities/with-legacy.d.ts

@@ -0,0 +1,3 @@
+import type { LegacyResourceSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
+import type { WithPartial } from "@warp-drive/core/types/utils";
+export declare function withLegacy(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): ResourceSchema;

package/dist/unpkg/dev/declarations/model-fragments.d.ts

@@ -0,0 +1,9 @@
+export { withArrayDefaults } from "./model-fragments/utilities/with-array-defaults.js";
+export { withFragmentDefaults } from "./model-fragments/utilities/with-fragment-defaults.js";
+export { withFragmentArrayDefaults } from "./model-fragments/utilities/with-fragment-array-defaults.js";
+export { withLegacy } from "./model-fragments/utilities/with-legacy.js";
+export { registerFragmentExtensions } from "./model-fragments/instance-initializers/fragment-extensions.js";
+export { modelFor } from "./model-fragments/hooks/model-for.js";
+export { FragmentArray, FragmentArrayExtension } from "./model-fragments/extensions/fragment-array.js";
+export { Fragment, FragmentExtension } from "./model-fragments/extensions/fragment.js";
+export type { WithFragment, WithFragmentArray } from "./model-fragments/index.js";

package/dist/unpkg/dev/declarations/model.d.ts

@@ -0,0 +1,49 @@
+/**
+* This package provides a Presentation Model for resource data in an WarpDrive Cache.
+*
+* Models are defined as classes extending from `import Model from '@warp-drive/legacy/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 '@warp-drive/legacy/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.js";
+export { belongsTo } from "./model/-private/belongs-to.js";
+export { hasMany } from "./model/-private/has-many.js";
+export { Model, restoreDeprecatedModelRequestBehaviors } from "./model/-private/model.js";
+export { Model as default } from "./model/-private/model.js";
+export type { PromiseBelongsTo as AsyncBelongsTo } from "./model/-private/promise-belongs-to.js";
+export type { PromiseManyArray as AsyncHasMany } from "./model/-private/promise-many-array.js";
+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.js";
+export { buildSchema } from "./model/-private/schema-provider.js";

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

@@ -0,0 +1,91 @@
+import Mixin from "@ember/object/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 '@warp-drive/legacy/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.**
+
+@class EmbeddedRecordsMixin
+@public
+*/
+export declare const EmbeddedRecordsMixin: Mixin;

package/dist/unpkg/dev/declarations/serializer/-private/transforms/boolean.d.ts

@@ -0,0 +1,47 @@
+import type { TransformName } from "@warp-drive/core/types/symbols";
+export interface BooleanTransform {
+	[TransformName]: "boolean";
+}
+/**
+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
+{@link 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;
+}
+```
+
+@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;
+	static create(): BooleanTransform;
+}

package/dist/unpkg/dev/declarations/serializer/-private/transforms/date.d.ts

@@ -0,0 +1,28 @@
+import type { TransformName } from "@warp-drive/core/types/symbols";
+export interface DateTransform {
+	[TransformName]: "date";
+}
+/**
+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
+{@link 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;
+}
+```
+
+@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;
+	static create(): DateTransform;
+}

package/dist/unpkg/dev/declarations/serializer/-private/transforms/number.d.ts

@@ -0,0 +1,29 @@
+import type { TransformName } from "@warp-drive/core/types/symbols";
+export interface NumberTransform {
+	[TransformName]: "number";
+}
+/**
+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
+{@link 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;
+}
+```
+
+@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;
+	static create(): NumberTransform;
+}