@warp-drive/legacy 5.6.0-beta.1 → 5.6.0-beta.2

package/declarations/model/-private/model-methods.d.ts

@@ -1,6 +1,4 @@
-import type { Store } from "@warp-drive/core";
 import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
-import { RecordStore } from "@warp-drive/core/types/symbols";
 import type { Snapshot } from "../../compat/-private.js";
 import type { Errors } from "./errors.js";
 import type RecordState from "./record-state.js";
@@ -9,13 +7,11 @@ import type HasManyReference from "./references/has-many.js";
 import type { MaybeBelongsToFields, MaybeHasManyFields } from "./type-utils.js";
 export interface MinimalLegacyRecord {
 	errors: Errors;
-	___recordState: RecordState;
 	currentState: RecordState;
 	isDestroyed: boolean;
 	isDestroying: boolean;
 	isReloading: boolean;
 	isValid: boolean;
-	[RecordStore]: Store;
 	deleteRecord(): void;
 	unloadRecord(): void;
 	save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<this>;
@@ -32,9 +28,12 @@ export declare function hasMany<
 	K extends MaybeHasManyFields<T>
 >(this: T, prop: K): HasManyReference<T, K>;
 export declare function reload<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+export declare function _reload<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
 export declare function changedAttributes<T extends MinimalLegacyRecord>(this: T): ChangedAttributesHash;
 export declare function serialize<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): unknown;
 export declare function deleteRecord<T extends MinimalLegacyRecord>(this: T): void;
 export declare function save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+export declare function _save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
 export declare function destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+export declare function _destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
 export declare function createSnapshot<T extends MinimalLegacyRecord>(this: T): Snapshot<T>;

package/declarations/model/-private/model.d.ts

@@ -1,9 +1,8 @@
 import EmberObject from "@ember/object";
 import type { Store } from "@warp-drive/core";
-import type { ModelSchema, StableRecordIdentifier } from "@warp-drive/core/types";
-import type { Cache, ChangedAttributesHash } from "@warp-drive/core/types/cache";
+import type { ModelSchema, ResourceKey } from "@warp-drive/core/types";
+import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
 import type { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
-import { RecordStore } from "@warp-drive/core/types/symbols";
 import type { Snapshot } from "../../compat/-private.js";
 import { Errors } from "./errors.js";
 import type { MinimalLegacyRecord } from "./model-methods.js";
@@ -15,10 +14,9 @@ export type ModelCreateArgs = {
 	_createProps: Record<string, unknown>;
 	// TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
 	_secretInit: {
-		identifier: StableRecordIdentifier;
-		cache: Cache;
+		identifier: ResourceKey;
 		store: Store;
-		cb: (record: Model, cache: Cache, identifier: StableRecordIdentifier, store: Store) => void;
+		cb: (record: Model, identifier: ResourceKey, store: Store) => void;
 	};
 };
 export type StaticModel = typeof Model & {
@@ -42,12 +40,6 @@ interface Model {
 	* The store service instance which created this record instance
 	*/
 	store: Store;
-	/** @internal */
-	___recordState: RecordState;
-	/** @internal */
-	___private_notifications: object;
-	/** @internal */
-	[RecordStore]: Store;
 	/**
 	Create a JSON representation of the record, using the serialization
 	strategy of the store's adapter.
@@ -434,9 +426,7 @@ interface Model {
 * @noInheritDoc
 */
 declare class Model extends EmberObject implements MinimalLegacyRecord {
-	/** @internal */
-	init(options: ModelCreateArgs): void;
-	/** @internal */
+	/** @private */
 	// @ts-expect-error destroy should not return a value, but ember's types force it to
 	destroy(): this;
 	/**
@@ -768,8 +758,6 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	*/
 	// @ts-expect-error no return is necessary, but Ember's types are forcing it
 	notifyPropertyChange(prop: string): this;
-	/** @internal */
-	attr(): void;
 	/**
 	Given a callback, iterates over each of the relationships in the model,
 	invoking the callback with the name of each relationship and its relationship
@@ -819,18 +807,14 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	```
 	
 	@public
-	@param {Function} callback the callback to invoke
-	@param {any} binding the value to which the callback's `this` should be bound
+	@param callback the callback to invoke
+	@param binding the value to which the callback's `this` should be bound
 	*/
 	eachRelationship<T>(callback: (this: NoInfer<T> | undefined, key: MaybeRelationshipFields<this>, meta: LegacyRelationshipField) => void, binding?: T): void;
 	relationshipFor(name: string): LegacyRelationshipField | undefined;
 	inverseFor(name: string): LegacyRelationshipField | null;
 	eachAttribute<T>(callback: (this: NoInfer<T> | undefined, key: isSubClass<this> extends true ? MaybeAttrFields<this> : string, meta: LegacyAttributeField) => void, binding?: T): void;
 	/**
-	* @internal
-	*/
-	static isModel: boolean;
-	/**
 	Represents the model's class name as a string. This can be used to look up the model's class name through
 	`Store`'s modelFor method.
 	
@@ -892,9 +876,9 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	Calling `store.modelFor('post').typeForRelationship('comments', store)` will return `Comment`.
 	
 	@public
-	@param {String} name the name of the relationship
-	@param {store} store an instance of Store
-	@return {Model} the type of the relationship, or undefined
+	@param name the name of the relationship
+	@param store an instance of Store
+	@return the type of the relationship, or undefined
 	*/
 	static typeForRelationship(name: string, store: Store): ModelSchema | undefined;
 	static get inverseMap(): Record<string, LegacyRelationshipField | null>;
@@ -925,9 +909,9 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	```
 	
 	@public
-	@param {String} name the name of the relationship
-	@param {Store} store
-	@return {Object} the inverse relationship, or null
+	@param name the name of the relationship
+	@param store
+	@return the inverse relationship, or null
 	*/
 	static inverseFor(name: string, store: Store): LegacyRelationshipField | null;
 	//Calculate the inverse, ignoring the cache
@@ -1319,4 +1303,5 @@ declare class Model extends EmberObject implements MinimalLegacyRecord {
 	*/
 	static toString(): string;
 }
+export declare function restoreDeprecatedModelRequestBehaviors(ModelKlass: typeof Model): void;
 export { Model };

package/declarations/model/-private/notify-changes.d.ts

@@ -1,4 +1,4 @@
 import type { NotificationType, Store } from "@warp-drive/core";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { Model } from "./model.js";
-export default function notifyChanges(identifier: StableRecordIdentifier, value: NotificationType, key: string | undefined, record: Model, store: Store): void;
+export default function notifyChanges(identifier: ResourceKey, value: NotificationType, key: string | undefined, record: Model, store: Store): void;

package/declarations/model/-private/promise-many-array.d.ts

@@ -128,8 +128,5 @@ export declare class PromiseManyArray<T = unknown> {
 	* @public
 	*/
 	get meta(): Record<string, unknown> | null | undefined;
-	//---- Our own stuff
-	/** @internal */
-	_update(promise: Promise<ManyArray<T>>, content?: ManyArray<T>): void;
 	static create<T>({ promise, content }: HasManyProxyCreateArgs<T>): PromiseManyArray<T>;
 }

package/declarations/model/-private/record-state.d.ts

@@ -1,8 +1,3 @@
-import type { Store } from "@warp-drive/core";
-import type { RequestCacheRequestState, RequestStateService } from "@warp-drive/core/store/-private";
-import type { Cache } from "@warp-drive/core/types/cache";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
-import type { Errors } from "./errors.js";
 import type { MinimalLegacyRecord } from "./model-methods.js";
 /**
 Historically EmberData managed a state machine
@@ -41,29 +36,11 @@ uncommitted
 invalid
 inFlight
 
-@internal
+@hideconstructor
+@private
 */
 export default class RecordState {
-	store: Store;
-	identifier: StableRecordIdentifier;
-	record: MinimalLegacyRecord;
-	rs: RequestStateService;
-	pendingCount: number;
-	fulfilledCount: number;
-	rejectedCount: number;
-	cache: Cache;
-	_errorRequests: RequestCacheRequestState[];
-	_lastError: RequestCacheRequestState | null;
-	handler: object;
 	constructor(record: MinimalLegacyRecord);
-	/** @internal */
-	destroy(): void;
-	/** @internal */
-	notify(key: keyof this & string): void;
-	/** @internal */
-	updateInvalidErrors(errors: Errors): void;
-	/** @internal */
-	cleanErrorRequests(): void;
 	isSaving: boolean;
 	get isLoading(): boolean;
 	get isLoaded(): boolean;

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

@@ -1,6 +1,6 @@
 import type { Store } from "@warp-drive/core";
 import type { Graph, ResourceEdge } from "@warp-drive/core/graph/-private";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstance, TypeFromInstanceOrString } from "@warp-drive/core/types/record";
 import type { Links, Meta, SingleResourceDocument, SingleResourceRelationship } from "@warp-drive/core/types/spec/json-api-raw";
 import type { IsUnknown } from "../belongs-to.js";
@@ -59,20 +59,20 @@ export default class BelongsToReference<
 	type: TypeFromInstanceOrString<Related>;
 	// unsubscribe tokens given to us by the notification manager
 	___token: object;
-	___identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>;
+	___identifier: ResourceKey<TypeFromInstanceOrString<T>>;
 	___relatedToken: object | null;
 	_ref: number;
-	constructor(store: Store, graph: Graph, parentIdentifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>, belongsToRelationship: ResourceEdge, key: K);
+	constructor(store: Store, graph: Graph, parentIdentifier: ResourceKey<TypeFromInstanceOrString<T>>, belongsToRelationship: ResourceEdge, key: K);
 	destroy(): void;
 	/**
 	* The identifier of the record that this reference refers to.
 	* `null` if no related record is known.
 	*
 	* @property identifier
-	* @type {StableRecordIdentifier | null}
+	* @type {ResourceKey | null}
 	* @public
 	*/
-	get identifier(): StableRecordIdentifier<TypeFromInstanceOrString<Related>> | null;
+	get identifier(): ResourceKey<TypeFromInstanceOrString<Related>> | null;
 	/**
 	The `id` of the record that this reference refers to. Together, the
 	`type()` and `id()` methods form a composite key for the identity
@@ -198,7 +198,7 @@ export default class BelongsToReference<
 	@return {Object} The meta information for the belongs-to relationship.
 	*/
 	meta(): Meta | null;
-	_resource(): SingleResourceRelationship<StableRecordIdentifier<TypeFromInstance<Related>>>;
+	_resource(): SingleResourceRelationship<ResourceKey<TypeFromInstance<Related>>>;
 	/**
 	This returns a string that represents how the reference will be
 	looked up when it is loaded. If the relationship has a link it will

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

@@ -2,7 +2,7 @@ import type { Store } from "@warp-drive/core";
 import type { CollectionEdge, Graph } from "@warp-drive/core/graph/-private";
 import type { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
 import type { BaseFinderOptions } from "@warp-drive/core/types";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstanceOrString } from "@warp-drive/core/types/record";
 import type { CollectionResourceDocument, CollectionResourceRelationship, ExistingResourceObject, LinkObject, Meta, PaginationLinks } from "@warp-drive/core/types/spec/json-api-raw";
 import type { IsUnknown } from "../belongs-to.js";
@@ -68,24 +68,18 @@ export default class HasManyReference<
 	type: TypeFromInstanceOrString<Related>;
 	// unsubscribe tokens given to us by the notification manager
 	___token: object;
-	___identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>;
-	___relatedTokenMap: Map<StableRecordIdentifier, object>;
+	___identifier: ResourceKey<TypeFromInstanceOrString<T>>;
+	___relatedTokenMap: Map<ResourceKey, object>;
 	_ref: number;
-	constructor(store: Store, graph: Graph, parentIdentifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>, hasManyRelationship: CollectionEdge, key: K);
-	/**
-	* This method should never be called by user code.
-	*
-	* @internal
-	*/
-	destroy(): void;
+	constructor(store: Store, graph: Graph, parentIdentifier: ResourceKey<TypeFromInstanceOrString<T>>, hasManyRelationship: CollectionEdge, key: K);
 	/**
 	* An array of identifiers for the records that this reference refers to.
 	*
 	* @property identifiers
-	* @type {StableRecordIdentifier[]}
+	* @type {ResourceKey[]}
 	* @public
 	*/
-	get identifiers(): StableRecordIdentifier<TypeFromInstanceOrString<Related>>[];
+	get identifiers(): ResourceKey<TypeFromInstanceOrString<Related>>[];
 	_resource(): CollectionResourceRelationship;
 	/**
 	This returns a string that represents how the reference will be

package/declarations/model/-private/schema-provider.d.ts

@@ -1,6 +1,6 @@
 import type { Store } from "@warp-drive/core";
 import type { SchemaService } from "@warp-drive/core/types";
-import type { RecordIdentifier, StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { ObjectValue } from "@warp-drive/core/types/json/raw";
 import type { Derivation, HashFn, Transformation } from "@warp-drive/core/types/schema/concepts";
 import type { ArrayField, DerivedField, GenericField, HashField, LegacyField, ObjectField, ObjectSchema, ResourceSchema } from "@warp-drive/core/types/schema/fields";
@@ -8,22 +8,19 @@ import type { ModelFactory, ModelStore } from "./model.js";
 type AttributesSchema = ReturnType<Exclude<SchemaService["attributesDefinitionFor"], undefined>>;
 type RelationshipsSchema = ReturnType<Exclude<SchemaService["relationshipsDefinitionFor"], undefined>>;
 export interface ModelSchemaProvider {
-	attributesDefinitionFor(resource: RecordIdentifier | {
+	attributesDefinitionFor(resource: ResourceKey | {
 		type: string;
 	}): AttributesSchema;
-	relationshipsDefinitionFor(resource: RecordIdentifier | {
+	relationshipsDefinitionFor(resource: ResourceKey | {
 		type: string;
 	}): RelationshipsSchema;
 	doesTypeExist(type: string): boolean;
 }
 export declare class ModelSchemaProvider implements SchemaService {
-	private store;
-	private _schemas;
-	private _typeMisses;
 	constructor(store: ModelStore);
 	resourceTypes(): Readonly<string[]>;
 	hasTrait(type: string): boolean;
-	resourceHasTrait(resource: StableRecordIdentifier | {
+	resourceHasTrait(resource: ResourceKey | {
 		type: string;
 	}, trait: string): boolean;
 	transformation(field: GenericField | ObjectField | ArrayField | {
@@ -35,7 +32,7 @@ export declare class ModelSchemaProvider implements SchemaService {
 	hashFn(field: HashField | {
 		type: string;
 	}): HashFn;
-	resource(resource: StableRecordIdentifier | {
+	resource(resource: ResourceKey | {
 		type: string;
 	}): ResourceSchema | ObjectSchema;
 	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
@@ -47,8 +44,7 @@ export declare class ModelSchemaProvider implements SchemaService {
 		FM extends ObjectValue | null
 	>(derivation: Derivation<R, T, FM>): void;
 	registerHashFn(hashFn: HashFn): void;
-	private _loadModelSchema;
-	fields(resource: RecordIdentifier | {
+	fields(resource: ResourceKey | {
 		type: string;
 	}): Map<string, LegacyField>;
 	hasResource(resource: {

package/declarations/model/-private.d.ts

@@ -1,8 +1,9 @@
 export { type MinimalLegacyRecord } from "./-private/model-methods.js";
 export type { ModelStore } from "./-private/model.js";
 export { Errors } from "./-private/errors.js";
-export { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
+export type { LegacyManyArray as ManyArray } from "@warp-drive/core/store/-private";
 export { PromiseBelongsTo } from "./-private/promise-belongs-to.js";
 export { PromiseManyArray } from "./-private/promise-many-array.js";
 // // Used by tests, migration support
 export { lookupLegacySupport, LEGACY_SUPPORT } from "./-private/legacy-relationships-support.js";
+export type { MaybeHasManyFields, MaybeBelongsToFields, MaybeRelationshipFields } from "./-private/type-utils.js";

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

@@ -1,28 +1,9 @@
-/**
-* 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 { 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 { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+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";
@@ -170,6 +151,7 @@ export type WithLegacy<T extends TypedRecordInstance> = T & LegacyModeRecord<T>;
 * @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.
@@ -216,10 +198,10 @@ export declare function registerDerivations(schema: SchemaService): void;
 * @public
 */
 export interface DelegatingSchemaService {
-	attributesDefinitionFor?(resource: StableRecordIdentifier | {
+	attributesDefinitionFor?(resource: ResourceKey | {
 		type: string;
 	}): AttributesSchema;
-	relationshipsDefinitionFor?(resource: StableRecordIdentifier | {
+	relationshipsDefinitionFor?(resource: ResourceKey | {
 		type: string;
 	}): RelationshipsSchema;
 	doesTypeExist?(type: string): boolean;
@@ -228,18 +210,18 @@ export declare class DelegatingSchemaService implements SchemaService {
 	_preferred: SchemaService;
 	_secondary: SchemaService;
 	constructor(store: Store, schema: SchemaService);
-	isDelegated(resource: StableRecordIdentifier | {
+	isDelegated(resource: ResourceKey | {
 		type: string;
 	}): boolean;
 	resourceTypes(): Readonly<string[]>;
-	hasResource(resource: StableRecordIdentifier | {
+	hasResource(resource: ResourceKey | {
 		type: string;
 	}): boolean;
 	hasTrait(type: string): boolean;
-	resourceHasTrait(resource: StableRecordIdentifier | {
+	resourceHasTrait(resource: ResourceKey | {
 		type: string;
 	}, trait: string): boolean;
-	fields(resource: StableRecordIdentifier | {
+	fields(resource: ResourceKey | {
 		type: string;
 	}): Map<string, FieldSchema>;
 	transformation(field: GenericField | ObjectField | ArrayField | {
@@ -251,7 +233,7 @@ export declare class DelegatingSchemaService implements SchemaService {
 	derivation(field: DerivedField | {
 		type: string;
 	}): Derivation;
-	resource(resource: StableRecordIdentifier | {
+	resource(resource: ResourceKey | {
 		type: string;
 	}): ResourceSchema | ObjectSchema;
 	registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
@@ -264,34 +246,10 @@ export declare class DelegatingSchemaService implements SchemaService {
 	>(derivation: Derivation<R, T, FM>): void;
 	registerHashFn(hashFn: HashFn): void;
 	CAUTION_MEGA_DANGER_ZONE_registerExtension(extension: CAUTION_MEGA_DANGER_ZONE_Extension): void;
-	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: StableRecordIdentifier | {
+	CAUTION_MEGA_DANGER_ZONE_resourceExtensions(resource: ResourceKey | {
 		type: string;
 	}): null | ProcessedExtension["features"];
-	CAUTION_MEGA_DANGER_ZONE_objectExtensions(field: ExtensibleField): 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"];
-	/**
-	* 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 {};

package/declarations/model.d.ts

@@ -39,7 +39,7 @@ and dasherized.
 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 } from "./model/-private/model.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";