@warp-drive/legacy 5.9.0-alpha.21 → 5.9.0-alpha.22

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

@@ -1,306 +0,0 @@
-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";
-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";
-/**
-* Adds the `Model`-style `belongsTo`/`hasMany` reference methods to a
-* {@link TypedRecordInstance}, for use when migrating a resource from
-* `Model` to a schema-based record while preserving these APIs.
-*/
-export type WithLegacyDerivations<T extends TypedRecordInstance> = T & MinimalLegacyRecord & {
-	/**
-	* see {@link belongsTo}
-	*/
-	belongsTo: typeof belongsTo;
-	/**
-	* see {@link hasMany}
-	*/
-	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 {
-	/**
-	* Delegates to whichever of the primary/fallback schema services has a
-	* schema for the resource, preferring the primary. See {@link DelegatingSchemaService.isDelegated | isDelegated}.
-	*/
-	attributesDefinitionFor?(resource: ResourceKey | {
-		type: string;
-	}): AttributesSchema;
-	/**
-	* Delegates to whichever of the primary/fallback schema services has a
-	* schema for the resource, preferring the primary. See {@link DelegatingSchemaService.isDelegated | isDelegated}.
-	*/
-	relationshipsDefinitionFor?(resource: ResourceKey | {
-		type: string;
-	}): RelationshipsSchema;
-	/**
-	* Whether either the primary or fallback schema service has a schema
-	* for the given type.
-	*/
-	doesTypeExist?(type: string): boolean;
-}
-/**
-* See the {@link DelegatingSchemaService | class documentation above} for usage.
-*/
-export declare class DelegatingSchemaService implements SchemaService {
-	constructor(store: Store, schema: SchemaService);
-	/**
-	* Whether the given resource's schema is being served by the fallback
-	* (legacy Model-derived) schema service rather than the primary one.
-	*/
-	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 {};

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

@@ -1,54 +0,0 @@
-import type { Fragment } from "./fragment.js";
-/**
-* The features added to an array resource by {@link FragmentArrayExtension}, providing
-* a subset of the legacy `ModelFragments` fragment-array API for migrated resources.
-*/
-export declare class FragmentArray<T extends Fragment> {
-	/**
-	* Whether this fragment array is in the process of being destroyed.
-	*/
-	isDestroying: boolean;
-	/**
-	* Whether this fragment array has been destroyed.
-	*/
-	isDestroyed: boolean;
-	/**
-	* Whether this fragment array (or any of its members) has uncommitted changes.
-	*/
-	get hasDirtyAttributes(): boolean;
-	/**
-	* Adds an existing fragment to this array, if one was given.
-	*/
-	addFragment(fragment?: T): Fragment[] | undefined;
-	/**
-	* Appends a new fragment to the end of this array, if one was given.
-	*/
-	createFragment(fragment?: T): Fragment | undefined;
-	/**
-	* Removes the given fragment from this array, if present.
-	*/
-	removeFragment(fragment?: T): void;
-	/**
-	* Reverts each member fragment's attribute back to its last known remote value.
-	*/
-	rollbackAttributes(): void;
-}
-/**
-* A schema extension that adds the {@link FragmentArray} API to migrated
-* `ModelFragments` array resources.
-*/
-export declare const FragmentArrayExtension: {
-	/**
-	* This extension applies to `'array'` schemas.
-	*/
-	kind: "array";
-	/**
-	* The registered name of this extension.
-	*/
-	name: "fragment-array";
-	/**
-	* The features ({@link FragmentArray}) added by this extension.
-	*/
-	features: typeof FragmentArray;
-};
-export default FragmentArrayExtension;

package/declarations/model-fragments/extensions/fragment.d.ts

@@ -1,50 +0,0 @@
-import type { PrivateReactiveResource } from "@warp-drive/core/reactive/-private";
-/**
-* The features added to an object resource by {@link FragmentExtension}, providing
-* a subset of the legacy `ModelFragments` fragment API for migrated resources.
-*/
-export declare class Fragment {
-	/**
-	* Whether this fragment is in the process of being destroyed.
-	*/
-	isDestroying: boolean;
-	/**
-	* Whether this fragment has been destroyed.
-	*/
-	isDestroyed: boolean;
-	/**
-	* Whether this fragment (or the attribute it is rooted at) has uncommitted changes.
-	*/
-	get hasDirtyAttributes(): boolean;
-	/**
-	* Always `true`. Used to distinguish fragments from other resources.
-	*/
-	get isFragment(): boolean;
-	/**
-	* The resource type of this fragment, if known.
-	*/
-	get $type(): string | null | undefined;
-	/**
-	* Reverts this fragment's attribute back to its last known remote value.
-	*/
-	rollbackAttributes(this: PrivateReactiveResource): void;
-}
-/**
-* A schema extension that adds the {@link Fragment} API to migrated
-* `ModelFragments` object resources.
-*/
-export declare const FragmentExtension: {
-	/**
-	* This extension applies to `'object'` schemas.
-	*/
-	kind: "object";
-	/**
-	* The registered name of this extension.
-	*/
-	name: "fragment";
-	/**
-	* The features ({@link Fragment}) added by this extension.
-	*/
-	features: typeof Fragment;
-};
-export default FragmentExtension;

package/declarations/model-fragments/hooks/model-for.d.ts

@@ -1,27 +0,0 @@
-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>;
-/**
-* The `modelFor` fallback used to construct a `ShimModelClass` schema for a
-* type when ModelFragments support is enabled and no real `Model` subclass
-* is registered for that type.
-*
-* @public
-*/
-export declare const modelFor: typeof fragmentsModelFor;
-export {};

package/declarations/model-fragments/index.d.ts

@@ -1,13 +0,0 @@
-import type { WithArrayLike, WithEmberObject } from "../compat/extensions.js";
-import type { Fragment } from "./extensions/fragment.js";
-import type { FragmentArray } from "./extensions/fragment-array.js";
-/**
-* Adds the classic `EmberObject` API (via {@link WithEmberObject}) and the
-* {@link Fragment} API to the type of a migrated single-fragment resource.
-*/
-export type WithFragment<T> = T & WithEmberObject<T> & Fragment;
-/**
-* Adds Ember's classic array-like API (via {@link WithArrayLike}) and the
-* {@link FragmentArray} API to the type of a migrated fragment-array resource.
-*/
-export type WithFragmentArray<T extends Fragment> = T & WithArrayLike<T> & FragmentArray<T>;

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

@@ -1,15 +0,0 @@
-import type ApplicationInstance from "@ember/application/instance";
-import type { SchemaService } from "@warp-drive/core/types";
-/**
-* Registers the {@link FragmentExtension}/{@link FragmentArrayExtension} schema
-* extensions on the given `SchemaService`, enabling ModelFragments migration support.
-*
-* @public
-*/
-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

@@ -1,56 +0,0 @@
-/**
-* Used as a helper to setup the relevant parts of an array
-* schema and add extensions etc.
-*
-* @param arrayName The name of the array
-* @param primitiveType The primitive type of items in the array (optional)
-* @returns The schema for an array
-*/
-export declare function withArrayDefaults<
-	ArrayName extends string,
-	PrimitiveType extends string
->(arrayName: ArrayName, primitiveType?: PrimitiveType): PrimitiveType extends undefined ? {
-	/**
-	* This field is an `'array'` schema field.
-	*/
-	kind: "array";
-	/**
-	* The name of the array field.
-	*/
-	name: ArrayName;
-	/**
-	* The array's item type, `'array'` since no `primitiveType` was given.
-	*/
-	type: "array";
-	/**
-	* The schema options for this array field.
-	*/
-	options: {
-		/**
-		* The registered array-schema extensions to apply to this array.
-		*/
-		arrayExtensions: string[];
-	};
-} : {
-	/**
-	* This field is an `'array'` schema field.
-	*/
-	kind: "array";
-	/**
-	* The name of the array field.
-	*/
-	name: ArrayName;
-	/**
-	* The array's item type, derived from `primitiveType`.
-	*/
-	type: `array:${PrimitiveType}`;
-	/**
-	* The schema options for this array field.
-	*/
-	options: {
-		/**
-		* The registered array-schema extensions to apply to this array.
-		*/
-		arrayExtensions: string[];
-	};
-};

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

@@ -1,38 +0,0 @@
-/**
-* 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): {
-	/**
-	* This field is a `'schema-array'` field, an array of fragments.
-	*/
-	kind: "schema-array";
-	/**
-	* The resource type of the fragments contained in this array.
-	*/
-	type: `fragment:${string}`;
-	/**
-	* The name of the fragment-array field.
-	*/
-	name: string;
-	/**
-	* The schema options for this fragment-array field.
-	*/
-	options: {
-		/**
-		* The registered array-schema extensions to apply to this array.
-		*/
-		arrayExtensions: string[];
-		/**
-		* Whether the array defaults to a non-null empty array when unset.
-		*/
-		defaultValue: boolean;
-	};
-};

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

@@ -1,34 +0,0 @@
-/**
-* 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): {
-	/**
-	* This field is a `'schema-object'` field, a single fragment.
-	*/
-	kind: "schema-object";
-	/**
-	* The resource type of the fragment.
-	*/
-	type: `fragment:${FragmentType}`;
-	/**
-	* The name of the fragment field.
-	*/
-	name: FragmentType | FragmentName;
-	/**
-	* The schema options for this fragment field.
-	*/
-	options: {
-		/**
-		* The registered object-schema extensions to apply to this fragment.
-		*/
-		objectExtensions: string[];
-	};
-};

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

@@ -1,11 +0,0 @@
-import type { LegacyResourceSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
-import type { WithPartial } from "@warp-drive/core/types/utils";
-/**
-* Used as a helper to setup the relevant parts of a legacy resource schema
-* migrated from `Model`, applying the `ember-object` and `fragment` object
-* extensions and a default `@id` identity field.
-*
-* @param schema the partial legacy resource schema to complete
-* @returns the completed resource schema
-*/
-export declare function withLegacy(schema: WithPartial<LegacyResourceSchema, "legacy" | "identity">): ResourceSchema;

package/declarations/model-fragments.d.ts

@@ -1,9 +0,0 @@
-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,49 +0,0 @@
-/**
-* 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";