@warp-drive/legacy 5.8.0-alpha.9 → 5.8.0-beta.1

package/declarations/model/-private/references/belongs-to.d.ts

@@ -10,11 +10,11 @@ A `BelongsToReference` is a low-level API that allows access
 and manipulation of a belongsTo relationship.
 
 It is especially useful when you're dealing with `async` relationships
-from `@ember-data/model` as it allows synchronous access to
+from `@warp-drive/legacy/model` as it allows synchronous access to
 the relationship data if loaded, as well as APIs for loading, reloading
 the data or accessing available information without triggering a load.
 
-It may also be useful when using `sync` relationships with `@ember-data/model`
+It may also be useful when using `sync` relationships with `@warp-drive/legacy/model`
 that need to be loaded/reloaded with more precise timing than marking the
 relationship as `async` and relying on autofetch would have allowed.
 
@@ -30,7 +30,6 @@ invalidate if the relationship state changes.
 References are "stable", meaning that multiple calls to retrieve the reference
 for a given relationship will always return the same HasManyReference.
 
-@class BelongsToReference
 @public
 */
 export default class BelongsToReference<
@@ -44,17 +43,11 @@ export default class BelongsToReference<
 	/**
 	* The field name on the parent record for this has-many relationship.
 	*
-	* @property key
-	* @type {String}
-	* @public
 	*/
 	key: K;
 	/**
 	* The type of resource this relationship will contain.
 	*
-	* @property type
-	* @type {String}
-	* @public
 	*/
 	type: TypeFromInstanceOrString<Related>;
 	___token: object;
@@ -67,9 +60,6 @@ export default class BelongsToReference<
 	* The identifier of the record that this reference refers to.
 	* `null` if no related record is known.
 	*
-	* @property identifier
-	* @type {ResourceKey | null}
-	* @public
 	*/
 	get identifier(): ResourceKey<TypeFromInstanceOrString<Related>> | null;
 	/**
@@ -109,11 +99,11 @@ export default class BelongsToReference<
 	```
 	
 	@public
-	@return {String} The id of the record in this belongsTo relationship.
+	@return The id of the record in this belongsTo relationship.
 	*/
 	id(): string | null;
 	/**
-	The link Ember Data will use to fetch or reload this belongs-to
+	The link WarpDrive will use to fetch or reload this belongs-to
 	relationship. By default it uses only the "related" resource linkage.
 	
 	Example
@@ -147,7 +137,7 @@ export default class BelongsToReference<
 	```
 	
 	@public
-	@return {String} The link Ember Data will use to fetch or reload this belongs-to relationship.
+	@return The link WarpDrive will use to fetch or reload this belongs-to relationship.
 	*/
 	link(): string | null;
 	/**
@@ -194,7 +184,7 @@ export default class BelongsToReference<
 	```
 	
 	@public
-	@return {Object} The meta information for the belongs-to relationship.
+	@return The meta information for the belongs-to relationship.
 	*/
 	meta(): Meta | null;
 	_resource(): SingleResourceRelationship<ResourceKey<TypeFromInstance<Related>>>;
@@ -206,7 +196,7 @@ export default class BelongsToReference<
 	Example
 	
 	```js [app/models/post.js]
-	import Model, { hasMany } from '@ember-data/model';
+	import Model, { hasMany } from '@warp-drive/legacy/model';
 	
 	export default class PostModel extends Model {
 	@hasMany('comment', { async: true, inverse: null }) comments;
@@ -237,7 +227,7 @@ export default class BelongsToReference<
 	```
 	
 	@public
-	@return {String} The name of the remote type. This should either be `link` or `id`
+	@return The name of the remote type. This should either be `link` or `id`
 	*/
 	remoteType(): "link" | "id";
 	/**
@@ -328,9 +318,9 @@ export default class BelongsToReference<
 	forcing the load of all of the associated record.
 	
 	@public
-	@param {Object} doc a JSONAPI document object describing the new value of this relationship.
-	@param {Boolean} [skipFetch] if `true`, do not attempt to fetch unloaded records
-	@return {Promise<OpaqueRecordInstance | null | void>}
+	@param doc a JSONAPI document object describing the new value of this relationship.
+	@param skipFetch [optional] if `true`, do not attempt to fetch unloaded records
+	@return a promise that resolves with the record in this belongs-to relationship after the push has completed.
 	*/
 	push(doc: SingleResourceDocument, skipFetch?: boolean): Promise<Related | null | void>;
 	/**
@@ -380,7 +370,7 @@ export default class BelongsToReference<
 	```
 	
 	@public
-	@return {Model} the record in this relationship
+	@return the record in this relationship
 	*/
 	value(): Related | null;
 	/**
@@ -430,7 +420,7 @@ export default class BelongsToReference<
 	});
 	```
 	```js [app/adapters/user.js]
-	import Adapter from '@ember-data/adapter';
+	import Adapter from '@warp-drive/legacy/adapter';
 	
 	export default class UserAdapter extends Adapter {
 	findRecord(store, type, id, snapshot) {
@@ -441,13 +431,13 @@ export default class BelongsToReference<
 	```
 	
 	@public
-	@param {Object} options the options to pass in.
-	@return {Promise} a promise that resolves with the record in this belongs-to relationship.
+	@param options the options to pass in.
+	@return a promise that resolves with the record in this belongs-to relationship.
 	*/
 	load(options?: Record<string, unknown>): Promise<Related | null>;
 	/**
 	Triggers a reload of the value in this relationship. If the
-	remoteType is `"link"` Ember Data will use the relationship link to
+	remoteType is `"link"` WarpDrive will use the relationship link to
 	reload the relationship. Otherwise it will reload the record by its
 	id.
 	
@@ -491,8 +481,8 @@ export default class BelongsToReference<
 	```
 	
 	@public
-	@param {Object} options the options to pass in.
-	@return {Promise} a promise that resolves with the record in this belongs-to relationship after the reload has completed.
+	@param options the options to pass in.
+	@return a promise that resolves with the record in this belongs-to relationship after the reload has completed.
 	*/
 	reload(options?: Record<string, unknown>): Promise<Related | null>;
 }

package/declarations/model/-private/references/has-many.d.ts

@@ -19,11 +19,11 @@ A `HasManyReference` is a low-level API that allows access
 and manipulation of a hasMany relationship.
 
 It is especially useful when you're dealing with `async` relationships
-from `@ember-data/model` as it allows synchronous access to
+from `@warp-drive/legacy/model` as it allows synchronous access to
 the relationship data if loaded, as well as APIs for loading, reloading
 the data or accessing available information without triggering a load.
 
-It may also be useful when using `sync` relationships with `@ember-data/model`
+It may also be useful when using `sync` relationships with `@warp-drive/legacy/model`
 that need to be loaded/reloaded with more precise timing than marking the
 relationship as `async` and relying on autofetch would have allowed.
 
@@ -119,7 +119,7 @@ export default class HasManyReference<
 	```
 	
 	@public
-	@return {String} The name of the remote type. This should either be `link` or `ids`
+	@return The name of the remote type. This should either be `link` or `ids`
 	*/
 	remoteType(): "link" | "ids";
 	/**
@@ -154,11 +154,11 @@ export default class HasManyReference<
 	```
 	
 	@public
-	@return {Array} The ids in this has-many relationship
+	@return The ids in this has-many relationship
 	*/
 	ids(): Array<string | null>;
 	/**
-	The link Ember Data will use to fetch or reload this belongs-to
+	The link WarpDrive will use to fetch or reload this belongs-to
 	relationship. By default it uses only the "related" resource linkage.
 	
 	Example
@@ -192,7 +192,7 @@ export default class HasManyReference<
 	```
 	
 	@public
-	@return {String} The link Ember Data will use to fetch or reload this belongs-to relationship.
+	@return The link WarpDrive will use to fetch or reload this belongs-to relationship.
 	*/
 	link(): string | null;
 	/**
@@ -239,7 +239,7 @@ export default class HasManyReference<
 	```
 	
 	@public
-	@return {Object|null} The meta information for the belongs-to relationship.
+	@return The meta information for the belongs-to relationship.
 	*/
 	meta(): Meta | null;
 	/**
@@ -335,9 +335,8 @@ export default class HasManyReference<
 	forcing the load of all of the associated records.
 	
 	@public
-	@param {Array|Object} doc a JSONAPI document object describing the new value of this relationship.
-	@param {Boolean} [skipFetch] if `true`, do not attempt to fetch unloaded records
-	@return {Promise<ManyArray | void>}
+	@param doc a JSONAPI document object describing the new value of this relationship.
+	@param skipFetch [optional] if `true`, do not attempt to fetch unloaded records
 	*/
 	push(doc: ExistingResourceObject[] | CollectionResourceDocument, skipFetch?: boolean): Promise<ManyArray<Related> | void>;
 	_isLoaded(): boolean;
@@ -379,7 +378,6 @@ export default class HasManyReference<
 	```
 	
 	@public
-	@return {ManyArray}
 	*/
 	value(): ManyArray<Related> | null;
 	/**
@@ -441,8 +439,8 @@ export default class HasManyReference<
 	```
 	
 	@public
-	@param {Object} options the options to pass in.
-	@return {Promise} a promise that resolves with the ManyArray in
+	@param options the options to pass in.
+	@return a promise that resolves with the ManyArray in
 	this has-many relationship.
 	*/
 	load(options?: BaseFinderOptions): Promise<ManyArray<Related>>;
@@ -492,8 +490,8 @@ export default class HasManyReference<
 	```
 	
 	@public
-	@param {Object} options the options to pass in.
-	@return {Promise} a promise that resolves with the ManyArray in this has-many relationship.
+	@param options the options to pass in.
+	@return a promise that resolves with the ManyArray in this has-many relationship.
 	*/
 	reload(options?: BaseFinderOptions): Promise<ManyArray<Related>>;
 }

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

@@ -7,7 +7,7 @@ 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, DerivedField, FieldSchema, GenericField, HashField, LegacyResourceSchema, ObjectField, ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
+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";
@@ -56,14 +56,14 @@ interface LegacyModeRecord<T extends TypedRecordInstance> {
 }
 /**
 * A Type utility that enables quickly adding type information for the fields
-* defined by `import { withDefaults } from '@ember-data/model/migration-support'`.
+* defined by `import { withDefaults } from '@warp-drive/legacy/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';
+* 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',
@@ -99,14 +99,14 @@ 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.
+* @warp-drive/legacy/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';
+* 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',
@@ -141,26 +141,42 @@ export type WithLegacy<T extends TypedRecordInstance> = T & LegacyModeRecord<T>;
 * it requires with the schema service.
 *
 * ```ts
-* import { registerDerivations } from '@ember-data/model/migration-support';
+* import { registerDerivations } from '@warp-drive/legacy/model/migration-support';
 *
 * registerDerivations(schema);
 * ```
 *
-* @param {LegacyResourceSchema} schema The schema to add legacy support to.
-* @return {LegacyResourceSchema} The schema with legacy support added.
+* @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;
-export declare function withRestoredDeprecatedModelRequestBehaviors(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.
+* Adds the necessasary fields to the schema for supporting
+* the deprecated request methods on LegacyMode schemas.
 *
-* This must be called in order to use the fields added by:
+* Use this instead of `withDefaults` to add the fields
+* and behaviors necessary to support Model-Like capabilities.
 *
 * ```ts
-* import { withDefaults } from '@ember-data/model/migration-support';
+* 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
@@ -180,8 +196,8 @@ export declare function registerDerivations(schema: SchemaService): void;
 * provide their own schema information to the application.
 *
 * ```ts
-* import { DelegatingSchemaService } from '@ember-data/model/migration-support';
-* import { SchemaService } from '@warp-drive/schema-record';
+* import { DelegatingSchemaService } from '@warp-drive/legacy/model/migration-support';
+* import { SchemaService } from '@warp-drive/core/reactive';
 *
 * class AppStore extends Store {
 *   createSchemaService() {
@@ -222,6 +238,9 @@ export declare class DelegatingSchemaService implements SchemaService {
 	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;
@@ -243,6 +262,10 @@ export declare class DelegatingSchemaService implements SchemaService {
 		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;

package/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/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/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/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/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/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/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/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/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/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/declarations/model.d.ts

@@ -1,7 +1,7 @@
 /**
 * 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
+* 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.
 *
@@ -17,7 +17,7 @@ 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';
+import Model, { attr, belongsTo, hasMany } from '@warp-drive/legacy/model';
 
 export default class PersonModel extends Model {
 @attr name;

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

@@ -14,7 +14,7 @@ Note also that this mixin does not work with JSONAPISerializer because the JSON:
 Below is an example of a per-type serializer (`post` type).
 
 ```js [app/serializers/post.js]
-import RESTSerializer, { EmbeddedRecordsMixin } from '@ember-data/serializer/rest';
+import RESTSerializer, { EmbeddedRecordsMixin } from '@warp-drive/legacy/serializer/rest';
 
 export default class PostSerializer extends RESTSerializer.extend(EmbeddedRecordsMixin) {
 attrs = {

package/declarations/serializer/json-api.d.ts

@@ -10,13 +10,14 @@ records when they are transferred in and out of an external source.
 This process involves normalizing property names, transforming
 attribute values and serializing relationships.
 
-`JSONAPISerializer` supports the http://jsonapi.org/ spec and is the
-serializer recommended by Ember Data.
+`JSONAPISerializer` supports the http://jsonapi.org/ spec, though
+even compliant {json:api} servers may find writing an application
+specific serializer better suited to their needs and more performant.
 
 This serializer normalizes a JSON API payload that looks like:
 
 ```js [app/models/player.js]
-import Model, { attr, belongsTo } from '@ember-data/model';
+import Model, { attr, belongsTo } from '@warp-drive/legacy/model';
 
 export default class Player extends Model {
 @attr('string') name;
@@ -27,7 +28,7 @@ export default class Player extends Model {
 ```
 
 ```js [app/models/club.js]
-import Model, { attr, hasMany } from '@ember-data/model';
+import Model, { attr, hasMany } from '@warp-drive/legacy/model';
 
 export default class Club extends Model {
 @attr('string') name;
@@ -80,7 +81,7 @@ export default class Club extends Model {
 }
 ```
 
-to the format that the Ember Data store expects.
+to the format that the JSONAPICache expects.
 
 ### Customizing meta
 
@@ -92,7 +93,7 @@ below shows how this could be done using `normalizeArrayResponse` and
 `extractRelationship`.
 
 ```js [app/serializers/application.js]
-import JSONAPISerializer from '@ember-data/serializer/json-api';
+import JSONAPISerializer from '@warp-drive/legacy/serializer/json-api';
 
 export default class ApplicationSerializer extends JSONAPISerializer {
 normalizeArrayResponse(store, primaryModelClass, payload, id, requestType) {

package/declarations/serializer/json.d.ts

@@ -18,7 +18,7 @@ not support the http://jsonapi.org/ spec.
 For example, given the following `User` model and JSON payload:
 
 ```js [app/models/user.js]
-import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
+import Model, { attr, belongsTo, hasMany } from '@warp-drive/legacy/model';
 
 export default class UserModel extends Model {
 @hasMany('user') friends;
@@ -39,8 +39,8 @@ house: '/houses/lefkada'
 }
 ```
 
-`JSONSerializer` will normalize the JSON payload to the JSON API format that the
-Ember Data store expects.
+`JSONSerializer` will normalize the JSON payload to the {json:api} format that the
+JSONAPICache uses to cache data in the Store.
 
 You can customize how JSONSerializer processes its payload by passing options in
 the `attrs` hash or by subclassing the `JSONSerializer` and overriding hooks: