@warp-drive/legacy 5.9.0-beta.0 → 5.9.0-beta.2

package/dist/unpkg/prod-deprecated/schema-provider-DyfSd9Cv.js

@@ -0,0 +1,1635 @@
+import { n as FetchManager, t as upgradeStore } from "./-private-SfXkkHKd.js";
+import { n as normalizeModelName } from "./util-CQQdHX3n.js";
+import { n as LEGACY_SUPPORT, r as lookupLegacySupport, t as Errors } from "./errors-9LXqpfRd.js";
+import { n as decorateMethodV2 } from "./runtime--fcdnjmJ-DMTJ0Kb3.js";
+import { recordIdentifierFor, storeFor } from "@warp-drive/core";
+import { getOwner } from "@ember/application";
+import { assertPrivateStore, coerceId, recordIdentifierFor as recordIdentifierFor$1 } from "@warp-drive/core/store/-private";
+import { Context } from "@warp-drive/core/reactive/-private";
+import EmberObject from "@ember/object";
+import { RecordStore } from "@warp-drive/core/types/symbols";
+import { defineGate, defineSignal, entangleSignal, gate, memoized, notifyInternalSignal, peekInternalSignal, withSignalStore } from "@warp-drive/core/signals/-leaked";
+import { cacheFor } from "@ember/object/internals";
+
+//#region src/model/-private/model-methods.ts
+function rollbackAttributes() {
+	const { currentState } = this;
+	const { isNew } = currentState;
+	const store = this[RecordStore];
+	assertPrivateStore(store);
+	store._join(() => {
+		store.cache.rollbackAttrs(recordIdentifierFor(this));
+		this.errors.clear();
+		currentState.cleanErrorRequests();
+		if (isNew) this.unloadRecord();
+	});
+}
+function unloadRecord() {
+	if (this.currentState.isNew && (this.isDestroyed || this.isDestroying)) return;
+	this[RecordStore].unloadRecord(this);
+}
+function belongsTo(prop) {
+	return lookupLegacySupport(this).referenceFor("belongsTo", prop);
+}
+function hasMany(prop) {
+	return lookupLegacySupport(this).referenceFor("hasMany", prop);
+}
+function reload(options = {}) {
+	return _reload.call(this, options);
+}
+function _reload(options = {}) {
+	options.isReloading = true;
+	options.reload = true;
+	const identifier = recordIdentifierFor(this);
+	this.isReloading = true;
+	return this[RecordStore].request({
+		op: "findRecord",
+		data: {
+			options,
+			record: identifier
+		},
+		cacheOptions: { [Symbol.for("wd:skip-cache")]: true }
+	}).then(() => this).finally(() => {
+		this.isReloading = false;
+	});
+}
+function changedAttributes() {
+	return this[RecordStore].cache.changedAttrs(recordIdentifierFor(this));
+}
+function serialize(options) {
+	/* @__PURE__ */ upgradeStore(this[RecordStore]);
+	return this[RecordStore].serializeRecord(this, options);
+}
+function deleteRecord() {
+	if (this.currentState) this[RecordStore].deleteRecord(this);
+}
+function save(options) {
+	return _save.call(this, options);
+}
+function _save(options) {
+	let promise;
+	if (this.currentState.isNew && this.currentState.isDeleted) promise = Promise.resolve(this);
+	else {
+		this.errors.clear();
+		promise = this[RecordStore].saveRecord(this, options);
+	}
+	return promise;
+}
+function destroyRecord(options) {
+	return _destroyRecord.call(this, options);
+}
+function _destroyRecord(options) {
+	const { isNew } = this.currentState;
+	this.deleteRecord();
+	if (isNew) return Promise.resolve(this);
+	return this.save(options).then((_) => {
+		this.unloadRecord();
+		return this;
+	});
+}
+function createSnapshot() {
+	const store = this[RecordStore];
+	/* @__PURE__ */ upgradeStore(store);
+	if (!store._fetchManager) store._fetchManager = new FetchManager(store);
+	return store._fetchManager.createSnapshot(recordIdentifierFor(this));
+}
+
+//#endregion
+//#region src/model/-private/notify-changes.ts
+function notifyChanges(identifier, value, key, record, store) {
+	switch (value) {
+		case "added":
+		case "attributes":
+			if (key) notifyAttribute(store, identifier, key, record);
+			else record.eachAttribute((name) => {
+				notifyAttribute(store, identifier, name, record);
+			});
+			break;
+		case "relationships":
+			if (key) notifyRelationship(identifier, key, record, record.constructor.relationshipsByName.get(key));
+			else record.eachRelationship((name, meta) => {
+				notifyRelationship(identifier, name, record, meta);
+			});
+			break;
+		case "identity": notifyInternalSignal(peekInternalSignal(withSignalStore(record), "id"));
+	}
+}
+function notifyRelationship(identifier, key, record, meta) {
+	if (meta.kind === "belongsTo") record.notifyPropertyChange(key);
+	else if (meta.kind === "hasMany") {
+		const support = LEGACY_SUPPORT.get(identifier);
+		const manyArray = support && support._manyArrayCache[key];
+		const hasPromise = support && support._relationshipPromisesCache[key];
+		if (manyArray && hasPromise) return;
+		if (manyArray) {
+			notifyInternalSignal(manyArray[Context].signal);
+			if (meta.options.async) record.notifyPropertyChange(key);
+		}
+	}
+}
+function notifyAttribute(store, identifier, key, record) {
+	if (cacheFor(record, key) !== store.cache.getAttr(identifier, key)) record.notifyPropertyChange(key);
+}
+
+//#endregion
+//#region src/model/-private/record-state.ts
+const SOURCE_POINTER_REGEXP = /^\/?data\/(attributes|relationships)\/(.*)/;
+const SOURCE_POINTER_PRIMARY_REGEXP = /^\/?data/;
+const PRIMARY_ATTRIBUTE_KEY = "base";
+function isInvalidError(error) {
+	return !!error && error instanceof Error && "isAdapterError" in error && error.isAdapterError === true && "code" in error && error.code === "InvalidError";
+}
+/**
+Historically WarpDrive managed a state machine
+for each record, the localState for which
+was reflected onto Model.
+
+This implements the flags and stateName for backwards compat
+with the state tree that used to be possible (listed below).
+
+stateName and dirtyType are candidates for deprecation.
+
+root
+empty
+deleted    // hidden from stateName
+preloaded  // hidden from stateName
+
+loading
+empty     // hidden from stateName
+preloaded // hidden from stateName
+
+loaded
+saved
+updated
+uncommitted
+invalid
+inFlight
+created
+uncommitted
+invalid
+inFlight
+
+deleted
+saved
+new      // hidden from stateName
+uncommitted
+invalid
+inFlight
+
+@hideconstructor
+@private
+*/
+var RecordState = class {
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	constructor(record) {
+		const store = storeFor(record, false);
+		const identity = recordIdentifierFor$1(record);
+		this.identifier = identity;
+		this.record = record;
+		this.cache = store.cache;
+		this.pendingCount = 0;
+		this.fulfilledCount = 0;
+		this.rejectedCount = 0;
+		this._errorRequests = [];
+		this._lastError = null;
+		const requests = store.getRequestStateService();
+		const notifications = store.notifications;
+		const handleRequest = (req) => {
+			if (req.type === "mutation") switch (req.state) {
+				case "pending":
+					this.isSaving = true;
+					break;
+				case "rejected":
+					this.isSaving = false;
+					this._lastError = req;
+					if (!(req.response && isInvalidError(req.response.data))) this._errorRequests.push(req);
+					notifyErrorsStateChanged(this);
+					break;
+				case "fulfilled":
+					this._errorRequests = [];
+					this._lastError = null;
+					this.isSaving = false;
+					this.notify("isDirty");
+					notifyErrorsStateChanged(this);
+			}
+			else switch (req.state) {
+				case "pending":
+					this.pendingCount++;
+					this.notify("isLoading");
+					break;
+				case "rejected":
+					this.pendingCount--;
+					this._lastError = req;
+					if (!(req.response && isInvalidError(req.response.data))) this._errorRequests.push(req);
+					this.notify("isLoading");
+					notifyErrorsStateChanged(this);
+					break;
+				case "fulfilled":
+					this.pendingCount--;
+					this.fulfilledCount++;
+					this.notify("isLoading");
+					this.notify("isDirty");
+					notifyErrorsStateChanged(this);
+					this._errorRequests = [];
+					this._lastError = null;
+			}
+		};
+		requests.subscribeForRecord(identity, handleRequest);
+		const lastRequest = requests.getLastRequestForRecord(identity);
+		if (lastRequest) handleRequest(lastRequest);
+		this.handler = notifications.subscribe(identity, (identifier, type, key) => {
+			switch (type) {
+				case "state":
+					this.notify("isSaved");
+					this.notify("isNew");
+					this.notify("isDeleted");
+					this.notify("isDirty");
+					break;
+				case "attributes":
+					this.notify("isEmpty");
+					this.notify("isDirty");
+					break;
+				case "errors":
+					this.updateInvalidErrors(this.record.errors);
+					this.notify("isValid");
+			}
+		});
+	}
+	/** @internal */
+	destroy() {
+		storeFor(this.record, false).notifications.unsubscribe(this.handler);
+	}
+	/** @internal */
+	notify(key) {
+		const signals = withSignalStore(this);
+		const signal = peekInternalSignal(signals, key);
+		if (signal) notifyInternalSignal(signal);
+	}
+	/** @internal */
+	updateInvalidErrors(errors) {
+		const jsonApiErrors = this.cache.getErrors(this.identifier);
+		errors.clear();
+		for (let i = 0; i < jsonApiErrors.length; i++) {
+			const error = jsonApiErrors[i];
+			if (error.source && error.source.pointer) {
+				const keyMatch = error.source.pointer.match(SOURCE_POINTER_REGEXP);
+				let key;
+				if (keyMatch) key = keyMatch[2];
+				else if (error.source.pointer.search(SOURCE_POINTER_PRIMARY_REGEXP) !== -1) key = PRIMARY_ATTRIBUTE_KEY;
+				if (key) {
+					const errMsg = error.detail || error.title;
+					errors.add(key, errMsg);
+				}
+			}
+		}
+	}
+	/** @internal */
+	cleanErrorRequests() {
+		this.notify("isValid");
+		this.notify("isError");
+		this.notify("adapterError");
+		this._errorRequests = [];
+		this._lastError = null;
+	}
+	get isLoading() {
+		return !this.isLoaded && this.pendingCount > 0 && this.fulfilledCount === 0;
+	}
+	static {
+		decorateMethodV2(this.prototype, "isLoading", [gate]);
+	}
+	get isLoaded() {
+		if (this.isNew) return true;
+		return this.fulfilledCount > 0 || !this.isEmpty;
+	}
+	static {
+		decorateMethodV2(this.prototype, "isLoaded", [gate]);
+	}
+	get isSaved() {
+		const rd = this.cache;
+		if (this.isDeleted) return rd.isDeletionCommitted(this.identifier);
+		if (this.isNew || this.isEmpty || !this.isValid || this.isDirty || this.isLoading) return false;
+		return true;
+	}
+	static {
+		decorateMethodV2(this.prototype, "isSaved", [gate]);
+	}
+	get isEmpty() {
+		const rd = this.cache;
+		return !this.isNew && rd.isEmpty(this.identifier);
+	}
+	static {
+		decorateMethodV2(this.prototype, "isEmpty", [gate]);
+	}
+	get isNew() {
+		return this.cache.isNew(this.identifier);
+	}
+	static {
+		decorateMethodV2(this.prototype, "isNew", [gate]);
+	}
+	get isDeleted() {
+		return this.cache.isDeleted(this.identifier);
+	}
+	static {
+		decorateMethodV2(this.prototype, "isDeleted", [gate]);
+	}
+	get isValid() {
+		return this.record.errors.length === 0;
+	}
+	static {
+		decorateMethodV2(this.prototype, "isValid", [gate]);
+	}
+	get isDirty() {
+		const rd = this.cache;
+		if (this.isEmpty || rd.isDeletionCommitted(this.identifier) || this.isDeleted && this.isNew) return false;
+		return this.isDeleted || this.isNew || rd.hasChangedAttrs(this.identifier);
+	}
+	static {
+		decorateMethodV2(this.prototype, "isDirty", [gate]);
+	}
+	get isError() {
+		if (!this._errorRequests[this._errorRequests.length - 1]) return false;
+		else return true;
+	}
+	static {
+		decorateMethodV2(this.prototype, "isError", [gate]);
+	}
+	get adapterError() {
+		const request = this._lastError;
+		if (!request) return null;
+		return request.state === "rejected" && request.response.data;
+	}
+	static {
+		decorateMethodV2(this.prototype, "adapterError", [gate]);
+	}
+	get isPreloaded() {
+		return !this.isEmpty && this.isLoading;
+	}
+	static {
+		decorateMethodV2(this.prototype, "isPreloaded", [memoized]);
+	}
+	get stateName() {
+		if (this.isLoading) return "root.loading";
+		else if (this.isEmpty) return "root.empty";
+		else if (this.isDeleted) {
+			if (this.isSaving) return "root.deleted.inFlight";
+			else if (this.isSaved) return "root.deleted.saved";
+			else if (!this.isValid) return "root.deleted.invalid";
+			else return "root.deleted.uncommitted";
+		} else if (this.isNew) {
+			if (this.isSaving) return "root.loaded.created.inFlight";
+			else if (!this.isValid) return "root.loaded.created.invalid";
+			return "root.loaded.created.uncommitted";
+		} else if (this.isSaving) return "root.loaded.updated.inFlight";
+		else if (!this.isValid) return "root.loaded.updated.invalid";
+		else if (this.isDirty) return "root.loaded.updated.uncommitted";
+		else return "root.loaded.saved";
+	}
+	static {
+		decorateMethodV2(this.prototype, "stateName", [memoized]);
+	}
+	get dirtyType() {
+		if (this.isLoading || this.isEmpty) return "";
+		else if (this.isDirty && this.isDeleted) return "deleted";
+		else if (this.isNew) return "created";
+		else if (this.isSaving || !this.isValid || this.isDirty) return "updated";
+		else return "";
+	}
+	static {
+		decorateMethodV2(this.prototype, "dirtyType", [memoized]);
+	}
+};
+defineSignal(RecordState.prototype, "isSaving", false);
+function notifyErrorsStateChanged(state) {
+	state.notify("isValid");
+	state.notify("isError");
+	state.notify("adapterError");
+}
+
+//#endregion
+//#region src/model/-private/model.ts
+function computeOnce(target, propertyName, desc) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	const getter = desc.get;
+	desc.get = function() {
+		let meta = cache.get(this);
+		if (!meta) {
+			meta = {
+				hasComputed: false,
+				value: void 0
+			};
+			cache.set(this, meta);
+		}
+		if (!meta.hasComputed) {
+			meta.value = getter.call(this);
+			meta.hasComputed = true;
+		}
+		return meta.value;
+	};
+	return desc;
+}
+/**
+* Base class from which Models can be defined.
+*
+* ::: code-group
+*
+* ```js [app/models/user.js]
+* import { Model, attr, belongsTo, hasMany } from '@warp-drive/legacy/model';
+*
+* export default class User extends Model {
+*   @attr name;
+*   @attr('number') age;
+*   @hasMany('post', { async: true, inverse: null }) posts;
+*   @belongsTo('group', { async: false, inverse: 'users' }) group;
+* }
+* ```
+*
+* ```ts [app/models/user.ts]
+* import { Model, attr, belongsTo, hasMany, type AsyncHasMany } from '@warp-drive/legacy/model';
+* import type { NumberTransform } from '@ember-data/serializer/transform';
+* import type Group from './group';
+* import type Post from './post';
+*
+* export default class User extends Model {
+*   @attr declare name: string;
+*
+*   @attr<NumberTransform>('number')
+*   declare age: number;
+*
+*   @hasMany('post', { async: true, inverse: null })
+*   declare posts: AsyncHasMany<Post>;
+*
+*   @belongsTo('group', { async: false, inverse: 'users' })
+*   declare group: Group | null;
+* }
+* ```
+*
+* :::
+*
+* Models both define the schema for a resource type and provide
+* the class to use as the reactive object for data of resource
+* of that type.
+*
+* @public
+* @noInheritDoc
+* @hideconstructor
+* @legacy
+*/
+var Model = class extends EmberObject {
+	/** @internal */
+	init(options) {
+		const createProps = options._createProps;
+		const _secretInit = options._secretInit;
+		options._createProps = null;
+		options._secretInit = null;
+		const store = this.store = _secretInit.store;
+		super.init(options);
+		this[RecordStore] = store;
+		const identity = _secretInit.identifier;
+		_secretInit.cb(this, identity, _secretInit.store);
+		this.___recordState = null;
+		this.setProperties(createProps);
+		const notifications = store.notifications;
+		this.___private_notifications = notifications.subscribe(identity, (identifier, type, field) => {
+			notifyChanges(identifier, type, field, this, store);
+		});
+	}
+	/** @private */
+	destroy() {
+		const identifier = recordIdentifierFor(this);
+		this.___recordState?.destroy();
+		storeFor(this, false).notifications.unsubscribe(this.___private_notifications);
+		const support = LEGACY_SUPPORT.get(identifier);
+		if (support) {
+			support.destroy();
+			LEGACY_SUPPORT.delete(identifier);
+		}
+		super.destroy();
+	}
+	/**
+	If this property is `true` the record is in the `empty`
+	state. Empty is the first state all records enter after they have
+	been created. Most records created by the store will quickly
+	transition to the `loading` state if data needs to be fetched from
+	the server or the `created` state if the record is created on the
+	client. A record can also enter the empty state if the adapter is
+	unable to locate the record.
+	@public
+	*/
+	get isEmpty() {
+		return this.currentState.isEmpty;
+	}
+	/**
+	If this property is `true` the record is in the `loading` state. A
+	record enters this state when the store asks the adapter for its
+	data. It remains in this state until the adapter provides the
+	requested data.
+	@public
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isEmpty", [memoized]);
+	}
+	get isLoading() {
+		return this.currentState.isLoading;
+	}
+	/**
+	If this property is `true` the record is in the `loaded` state. A
+	record enters this state when its data is populated. Most of a
+	record's lifecycle is spent inside substates of the `loaded`
+	state.
+	Example
+	```javascript
+	let record = store.createRecord('model');
+	record.isLoaded; // true
+	const { content: { data: model } } = await store.request(findRecord({ type: 'model', id: '1' }));
+	model.isLoaded;
+	```
+	@public
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isLoading", [memoized]);
+	}
+	get isLoaded() {
+		return this.currentState.isLoaded;
+	}
+	/**
+	If this property is `true` the record is in the `dirty` state. The
+	record has local changes that have not yet been saved by the
+	adapter. This includes records that have been created (but not yet
+	saved) or deleted.
+	Example
+	```javascript
+	let record = store.createRecord('model');
+	record.hasDirtyAttributes; // true
+	const { content: { data: model } } = await store.request(findRecord({ type: 'model', id: '1' }));
+	model.hasDirtyAttributes; // false
+	model.foo = 'some value';
+	model.hasDirtyAttributes; // true
+	```
+	@since 1.13.0
+	@public
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isLoaded", [memoized]);
+	}
+	get hasDirtyAttributes() {
+		return this.currentState.isDirty;
+	}
+	/**
+	If this property is `true` the record is in the `saving` state. A
+	record enters the saving state when `save` is called, but the
+	adapter has not yet acknowledged that the changes have been
+	persisted to the backend.
+	Example
+	```javascript
+	let record = store.createRecord('model');
+	record.isSaving; // false
+	let promise = record.save();
+	record.isSaving; // true
+	promise.then(function() {
+	record.isSaving; // false
+	});
+	```
+	@public
+	*/
+	static {
+		decorateMethodV2(this.prototype, "hasDirtyAttributes", [memoized]);
+	}
+	get isSaving() {
+		return this.currentState.isSaving;
+	}
+	/**
+	If this property is `true` the record is in the `deleted` state
+	and has been marked for deletion. When `isDeleted` is true and
+	`hasDirtyAttributes` is true, the record is deleted locally but the deletion
+	was not yet persisted. When `isSaving` is true, the change is
+	in-flight. When both `hasDirtyAttributes` and `isSaving` are false, the
+	change has persisted.
+	Example
+	```javascript
+	let record = store.createRecord('model');
+	record.isDeleted;    // false
+	record.deleteRecord();
+	// Locally deleted
+	record.isDeleted;           // true
+	record.hasDirtyAttributes;  // true
+	record.isSaving;            // false
+	// Persisting the deletion
+	let promise = record.save();
+	record.isDeleted;    // true
+	record.isSaving;     // true
+	// Deletion Persisted
+	promise.then(function() {
+	record.isDeleted;          // true
+	record.isSaving;           // false
+	record.hasDirtyAttributes; // false
+	});
+	```
+	@public
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isSaving", [memoized]);
+	}
+	get isDeleted() {
+		return this.currentState.isDeleted;
+	}
+	/**
+	If this property is `true` the record is in the `new` state. A
+	record will be in the `new` state when it has been created on the
+	client and the adapter has not yet report that it was successfully
+	saved.
+	Example
+	```javascript
+	let record = store.createRecord('model');
+	record.isNew; // true
+	record.save().then(function(model) {
+	model.isNew; // false
+	});
+	```
+	@public
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isDeleted", [memoized]);
+	}
+	get isNew() {
+		return this.currentState.isNew;
+	}
+	/**
+	If this property is `true` the record is in the `valid` state.
+	A record will be in the `valid` state when the adapter did not report any
+	server-side validation failures.
+	@public
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isNew", [memoized]);
+	}
+	get isValid() {
+		return this.currentState.isValid;
+	}
+	/**
+	If the record is in the dirty state this property will report what
+	kind of change has caused it to move into the dirty
+	state. Possible values are:
+	- `created` The record has been created by the client and not yet saved to the adapter.
+	- `updated` The record has been updated by the client and not yet saved to the adapter.
+	- `deleted` The record has been deleted by the client and not yet saved to the adapter.
+	Example
+	```javascript
+	let record = store.createRecord('model');
+	record.dirtyType; // 'created'
+	```
+	@public
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isValid", [memoized]);
+	}
+	get dirtyType() {
+		return this.currentState.dirtyType;
+	}
+	/**
+	If `true` the adapter reported that it was unable to save local
+	changes to the backend for any reason other than a server-side
+	validation error.
+	Example
+	```javascript
+	record.isError; // false
+	record.set('foo', 'valid value');
+	record.save().then(null, function() {
+	record.isError; // true
+	});
+	```
+	@public
+	*/
+	static {
+		decorateMethodV2(this.prototype, "dirtyType", [memoized]);
+	}
+	get isError() {
+		return this.currentState.isError;
+	}
+	/**
+	* `isError` is read-only and cannot be set directly.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isError", [memoized]);
+	}
+	set isError(v) {}
+	/**
+	If `true` the store is attempting to reload the record from the adapter.
+	Example
+	```javascript
+	record.isReloading; // false
+	record.reload();
+	record.isReloading; // true
+	```
+	@public
+	*/
+	/**
+	All ember models have an id property. This is an identifier
+	managed by an external source. These are always coerced to be
+	strings before being used internally. Note when declaring the
+	attributes for a model it is an error to declare an id
+	attribute.
+	```javascript
+	let record = store.createRecord('model');
+	record.id; // null
+	const { content: { data: model } } = await store.request(findRecord({ type: 'model', id: '1' }));
+	model.id; // '1'
+	```
+	@public
+	*/
+	get id() {
+		return recordIdentifierFor(this).id;
+	}
+	/**
+	* Assigns the resource's primary key. Typically only used internally
+	* when a client-created record is assigned an id upon being saved.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "id", [gate]);
+	}
+	set id(id) {
+		const normalizedId = coerceId(id);
+		const identifier = recordIdentifierFor(this);
+		const didChange = normalizedId !== identifier.id;
+		assertPrivateStore(this.store);
+		if (normalizedId !== null && didChange) {
+			this.store._instanceCache.setRecordId(identifier, normalizedId);
+			this.store.notifications.notify(identifier, "identity", null);
+		}
+	}
+	toString() {
+		return `<model::${this.constructor.modelName}:${this.id}>`;
+	}
+	/**
+	@private
+	*/
+	get currentState() {
+		if (!this.___recordState) this.___recordState = new RecordState(this);
+		return this.___recordState;
+	}
+	/**
+	* `currentState` is read-only and cannot be set directly.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "currentState", [gate]);
+	}
+	set currentState(_v) {
+		throw new Error("cannot set currentState");
+	}
+	/**
+	The store service instance which created this record instance
+	@public
+	*/
+	/**
+	When the record is in the `invalid` state this object will contain
+	any errors returned by the adapter. When present the errors hash
+	contains keys corresponding to the invalid property names
+	and values which are arrays of Javascript objects with two keys:
+	- `message` A string containing the error message from the backend
+	- `attribute` The name of the property associated with this error message
+	```javascript
+	record.errors.length; // 0
+	record.set('foo', 'invalid value');
+	record.save().catch(function() {
+	record.errors.foo;
+	// [{message: 'foo should be a number.', attribute: 'foo'}]
+	});
+	```
+	The `errors` property is useful for displaying error messages to
+	the user.
+	```handlebars
+	<label>Username: <Input @value={{@model.username}} /> </label>
+	{{#each @model.errors.username as |error|}}
+	<div class="error">
+	{{error.message}}
+	</div>
+	{{/each}}
+	<label>Email: <Input @value={{@model.email}} /> </label>
+	{{#each @model.errors.email as |error|}}
+	<div class="error">
+	{{error.message}}
+	</div>
+	{{/each}}
+	```
+	You can also access the special `messages` property on the error
+	object to get an array of all the error strings.
+	```handlebars
+	{{#each @model.errors.messages as |message|}}
+	<div class="error">
+	{{message}}
+	</div>
+	{{/each}}
+	```
+	@public
+	*/
+	get errors() {
+		const errors = Errors.create({ __record: this });
+		this.currentState.updateInvalidErrors(errors);
+		return errors;
+	}
+	/**
+	This property holds the `AdapterError` object with which
+	last adapter operation was rejected.
+	@public
+	*/
+	static {
+		decorateMethodV2(this.prototype, "errors", [computeOnce]);
+	}
+	get adapterError() {
+		return this.currentState.adapterError;
+	}
+	/**
+	* `adapterError` is read-only and cannot be set directly.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "adapterError", [memoized]);
+	}
+	set adapterError(v) {
+		throw new Error(`adapterError is not directly settable`);
+	}
+	notifyPropertyChange(prop) {
+		const signals = withSignalStore(this);
+		entangleSignal(signals, this, prop, void 0);
+		super.notifyPropertyChange(prop);
+	}
+	/** @internal */
+	attr() {}
+	/**
+	Given a callback, iterates over each of the relationships in the model,
+	invoking the callback with the name of each relationship and its relationship
+	descriptor.
+	The callback method you provide should have the following signature (all
+	parameters are optional):
+	```javascript
+	function(name, descriptor);
+	```
+	- `name` the name of the current property in the iteration
+	- `descriptor` the meta object that describes this relationship
+	The relationship descriptor argument is an object with the following properties.
+	- **name** <span class="type">String</span> the name of this relationship on the Model
+	- **kind** <span class="type">String</span> "hasMany" or "belongsTo"
+	- **options** <span class="type">Object</span> the original options hash passed when the relationship was declared
+	- **parentType** <span class="type">Model</span> the type of the Model that owns this relationship
+	- **type** <span class="type">String</span> the type name of the related Model
+	Note that in addition to a callback, you can also pass an optional target
+	object that will be set as `this` on the context.
+	Example
+	```js [app/serializers/application.js]
+	import JSONSerializer from '@ember-data/serializer/json';
+	export default class ApplicationSerializer extends JSONSerializer {
+	serialize(record, options) {
+	let json = {};
+	record.eachRelationship(function(name, descriptor) {
+	if (descriptor.kind === 'hasMany') {
+	let serializedHasManyName = name.toUpperCase() + '_IDS';
+	json[serializedHasManyName] = record.get(name).map(r => r.id);
+	}
+	});
+	return json;
+	}
+	}
+	```
+	@public
+	@param callback the callback to invoke
+	@param binding the value to which the callback's `this` should be bound
+	*/
+	eachRelationship(callback, binding) {
+		this.constructor.eachRelationship(callback, binding);
+	}
+	/**
+	* Returns the relationship schema for the given relationship name, if any.
+	*/
+	relationshipFor(name) {
+		return this.constructor.relationshipsByName.get(name);
+	}
+	/**
+	* Returns the inverse relationship schema for the given relationship
+	* name, if one exists. See {@link Model.inverseFor | the static inverseFor}.
+	*/
+	inverseFor(name) {
+		return this.constructor.inverseFor(name, storeFor(this, false));
+	}
+	/**
+	* Iterates over the attributes defined on this record's class, calling
+	* `callback` for each one. See {@link Model.eachAttribute | the static eachAttribute}.
+	*
+	* @param callback the callback to invoke
+	* @param binding the value to which the callback's `this` should be bound
+	*/
+	eachAttribute(callback, binding) {
+		this.constructor.eachAttribute(callback, binding);
+	}
+	/**
+	* @internal
+	*/
+	static isModel = true;
+	/**
+	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.
+	`modelName` is generated for you by WarpDrive. It will be a lowercased, dasherized string.
+	For example:
+	```javascript
+	store.modelFor('post').modelName; // 'post'
+	store.modelFor('blog-post').modelName; // 'blog-post'
+	```
+	The most common place you'll want to access `modelName` is in your serializer's `payloadKeyFromModelName` method. For example, to change payload
+	keys to underscore (instead of dasherized), you might use the following code:
+	```javascript
+	import RESTSerializer from '@ember-data/serializer/rest';
+	import { underscore } from '<app-name>/utils/string-utils';
+	export default const PostSerializer = RESTSerializer.extend({
+	payloadKeyFromModelName(modelName) {
+	return underscore(modelName);
+	}
+	});
+	```
+	@public
+	*/
+	static modelName = null;
+	/**
+	For a given relationship name, returns the model type of the relationship.
+	For example, if you define a model like this:
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	export default class PostModel extends Model {
+	@hasMany('comment') comments;
+	}
+	```
+	Calling `store.modelFor('post').typeForRelationship('comments', store)` will return `Comment`.
+	@public
+	@param name the name of the relationship
+	@param store an instance of Store
+	@return the type of the relationship, or undefined
+	*/
+	static typeForRelationship(name, store) {
+		const relationship = this.relationshipsByName.get(name);
+		return relationship && store.modelFor(relationship.type);
+	}
+	/**
+	* A cache of resolved inverse relationships by name, populated lazily by
+	* {@link Model.inverseFor | inverseFor}.
+	*/
+	static get inverseMap() {
+		return Object.create(null);
+	}
+	/**
+	Find the relationship which is the inverse of the one asked for.
+	For example, if you define models like this:
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	export default class PostModel extends Model {
+	@hasMany('message') comments;
+	}
+	```
+	```js [app/models/message.js]
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	export default class MessageModel extends Model {
+	@belongsTo('post') owner;
+	}
+	```
+	``` js
+	store.modelFor('post').inverseFor('comments', store) // { type: 'message', name: 'owner', kind: 'belongsTo' }
+	store.modelFor('message').inverseFor('owner', store) // { type: 'post', name: 'comments', kind: 'hasMany' }
+	```
+	@public
+	@param name the name of the relationship
+	@param store
+	@return the inverse relationship, or null
+	*/
+	static {
+		decorateMethodV2(this, "inverseMap", [computeOnce]);
+	}
+	static inverseFor(name, store) {
+		const inverseMap = this.inverseMap;
+		if (inverseMap[name]) return inverseMap[name];
+		else {
+			const inverse = this._findInverseFor(name, store);
+			inverseMap[name] = inverse;
+			return inverse;
+		}
+	}
+	/**
+	* @private
+	*/
+	static _findInverseFor(name, store) {
+		const relationship = this.relationshipsByName.get(name);
+		if (!relationship) return null;
+		const { options } = relationship;
+		if (options.inverse === null) return null;
+		if (!store.schema.hasResource(relationship)) return null;
+		return store.schema.fields(relationship).get(options.inverse) || null;
+	}
+	/**
+	The model's relationships as a map, keyed on the type of the
+	relationship. The value of each entry is an array containing a descriptor
+	for each relationship with that type, describing the name of the relationship
+	as well as the type.
+	For example, given the following model definition:
+	```js [app/models/blog.js]
+	import { Model, belongsTo, hasMany } from '@warp-drive/legacy/model';
+	export default class BlogModel extends Model {
+	@hasMany('user') users;
+	@belongsTo('user') owner;
+	@hasMany('post') posts;
+	}
+	```
+	This computed property would return a map describing these
+	relationships, like this:
+	```javascript
+	import Blog from 'app/models/blog';
+	import User from 'app/models/user';
+	import Post from 'app/models/post';
+	let relationships = Blog.relationships;
+	relationships.user;
+	//=> [ { name: 'users', kind: 'hasMany' },
+	//     { name: 'owner', kind: 'belongsTo' } ]
+	relationships.post;
+	//=> [ { name: 'posts', kind: 'hasMany' } ]
+	```
+	@public
+	*/
+	static get relationships() {
+		const map = /* @__PURE__ */ new Map();
+		this.relationshipsByName.forEach((desc) => {
+			const { type } = desc;
+			if (!map.has(type)) map.set(type, []);
+			map.get(type).push(desc);
+		});
+		return map;
+	}
+	/**
+	A hash containing lists of the model's relationships, grouped
+	by the relationship kind. For example, given a model with this
+	definition:
+	```js [app/models/blog.js]
+	import { Model, belongsTo, hasMany } from '@warp-drive/legacy/model';
+	export default class BlogModel extends Model {
+	@hasMany('user') users;
+	@belongsTo('user') owner;
+	@hasMany('post') posts;
+	}
+	```
+	This property would contain the following:
+	```javascript
+	import Blog from 'app/models/blog';
+	let relationshipNames = Blog.relationshipNames;
+	relationshipNames.hasMany;
+	//=> ['users', 'posts']
+	relationshipNames.belongsTo;
+	//=> ['owner']
+	```
+	@public
+	*/
+	static {
+		decorateMethodV2(this, "relationships", [computeOnce]);
+	}
+	static get relationshipNames() {
+		const names = {
+			hasMany: [],
+			belongsTo: []
+		};
+		this.eachComputedProperty((name, meta) => {
+			if (isRelationshipSchema(meta)) names[meta.kind].push(name);
+		});
+		return names;
+	}
+	/**
+	An array of types directly related to a model. Each type will be
+	included once, regardless of the number of relationships it has with
+	the model.
+	For example, given a model with this definition:
+	```js [app/models/blog.js]
+	import { Model, belongsTo, hasMany } from '@warp-drive/legacy/model';
+	export default class BlogModel extends Model {
+	@hasMany('user') users;
+	@belongsTo('user') owner;
+	@hasMany('post') posts;
+	}
+	```
+	This property would contain the following:
+	```javascript
+	import Blog from 'app/models/blog';
+	let relatedTypes = Blog.relatedTypes');
+	//=> ['user', 'post']
+	```
+	@public
+	*/
+	static {
+		decorateMethodV2(this, "relationshipNames", [computeOnce]);
+	}
+	static get relatedTypes() {
+		const types = [];
+		const rels = this.relationshipsObject;
+		const relationships = Object.keys(rels);
+		for (let i = 0; i < relationships.length; i++) {
+			const modelName = rels[relationships[i]].type;
+			if (!types.includes(modelName)) types.push(modelName);
+		}
+		return types;
+	}
+	/**
+	A map whose keys are the relationships of a model and whose values are
+	relationship descriptors.
+	For example, given a model with this
+	definition:
+	```js [app/models/blog.js]
+	import { Model, belongsTo, hasMany } from '@warp-drive/legacy/model';
+	export default class BlogModel extends Model {
+	@hasMany('user') users;
+	@belongsTo('user') owner;
+	@hasMany('post') posts;
+	}
+	```
+	This property would contain the following:
+	```javascript
+	import Blog from 'app/models/blog';
+	let relationshipsByName = Blog.relationshipsByName;
+	relationshipsByName.users;
+	//=> { name: 'users', kind: 'hasMany', type: 'user', options: Object }
+	relationshipsByName.owner;
+	//=> { name: 'owner', kind: 'belongsTo', type: 'user', options: Object }
+	```
+	@public
+	*/
+	static {
+		decorateMethodV2(this, "relatedTypes", [computeOnce]);
+	}
+	static get relationshipsByName() {
+		const map = /* @__PURE__ */ new Map();
+		const rels = this.relationshipsObject;
+		const relationships = Object.keys(rels);
+		for (let i = 0; i < relationships.length; i++) {
+			const value = rels[relationships[i]];
+			map.set(value.name, value);
+		}
+		return map;
+	}
+	/**
+	* A hash of the model's relationship schemas keyed by relationship name.
+	* See also {@link Model.relationshipsByName | relationshipsByName}, which
+	* provides the same information as a `Map`.
+	*/
+	static {
+		decorateMethodV2(this, "relationshipsByName", [computeOnce]);
+	}
+	static get relationshipsObject() {
+		const relationships = Object.create(null);
+		this.modelName;
+		this.eachComputedProperty((name, meta) => {
+			if (!isRelationshipSchema(meta)) return;
+			meta.key = name;
+			meta.name = name;
+			relationships[name] = meta;
+		});
+		return relationships;
+	}
+	/**
+	A map whose keys are the fields of the model and whose values are strings
+	describing the kind of the field. A model's fields are the union of all of its
+	attributes and relationships.
+	For example:
+	```js [app/models/blog.js]
+	import { Model, attr, belongsTo, hasMany } from '@warp-drive/legacy/model';
+	export default class BlogModel extends Model {
+	@hasMany('user') users;
+	@belongsTo('user') owner;
+	@hasMany('post') posts;
+	@attr('string') title;
+	}
+	```
+	```js
+	import Blog from 'app/models/blog'
+	let fields = Blog.fields;
+	fields.forEach(function(kind, field) {
+	// do thing
+	});
+	// prints:
+	// users, hasMany
+	// owner, belongsTo
+	// posts, hasMany
+	// title, attribute
+	```
+	@public
+	*/
+	static {
+		decorateMethodV2(this, "relationshipsObject", [computeOnce]);
+	}
+	static get fields() {
+		const map = /* @__PURE__ */ new Map();
+		this.eachComputedProperty((name, meta) => {
+			if (isRelationshipSchema(meta)) map.set(name, meta.kind);
+			else if (isAttributeSchema(meta)) map.set(name, "attribute");
+		});
+		return map;
+	}
+	/**
+	Given a callback, iterates over each of the relationships in the model,
+	invoking the callback with the name of each relationship and its relationship
+	descriptor.
+	@public
+	@param callback the callback to invoke
+	@param binding the value to which the callback's `this` should be bound
+	*/
+	static {
+		decorateMethodV2(this, "fields", [computeOnce]);
+	}
+	static eachRelationship(callback, binding) {
+		this.relationshipsByName.forEach((relationship, name) => {
+			callback.call(binding, name, relationship);
+		});
+	}
+	/**
+	Given a callback, iterates over each of the types related to a model,
+	invoking the callback with the related type's class. Each type will be
+	returned just once, regardless of how many different relationships it has
+	with a model.
+	@public
+	@param callback the callback to invoke
+	@param binding the value to which the callback's `this` should be bound
+	*/
+	static eachRelatedType(callback, binding) {
+		const relationshipTypes = this.relatedTypes;
+		for (let i = 0; i < relationshipTypes.length; i++) {
+			const type = relationshipTypes[i];
+			callback.call(binding, type);
+		}
+	}
+	/**
+	*
+	* @private
+	* @deprecated
+	*/
+	static determineRelationshipType(knownSide, store) {
+		const knownKey = knownSide.name;
+		const knownKind = knownSide.kind;
+		const inverse = this.inverseFor(knownKey, store);
+		if (!inverse) return knownKind === "belongsTo" ? "oneToNone" : "manyToNone";
+		if (inverse.kind === "belongsTo") return knownKind === "belongsTo" ? "oneToOne" : "manyToOne";
+		else return knownKind === "belongsTo" ? "oneToMany" : "manyToMany";
+	}
+	/**
+	A map whose keys are the attributes of the model (properties
+	described by attr) and whose values are the meta object for the
+	property.
+	Example
+	```js [app/models/person.js]
+	import { Model, attr } from '@warp-drive/legacy/model';
+	export default class PersonModel extends Model {
+	@attr('string') firstName;
+	@attr('string') lastName;
+	@attr('date') birthday;
+	}
+	```
+	```javascript
+	import Person from 'app/models/person'
+	let attributes = Person.attributes
+	attributes.forEach(function(meta, name) {
+	// do thing
+	});
+	// prints:
+	// firstName {type: "string", kind: 'attribute', options: Object, parentType: function, name: "firstName"}
+	// lastName {type: "string", kind: 'attribute', options: Object, parentType: function, name: "lastName"}
+	// birthday {type: "date", kind: 'attribute', options: Object, parentType: function, name: "birthday"}
+	```
+	@public
+	*/
+	static get attributes() {
+		const map = /* @__PURE__ */ new Map();
+		this.eachComputedProperty((name, meta) => {
+			if (isAttributeSchema(meta)) {
+				meta.key = name;
+				meta.name = name;
+				map.set(name, meta);
+			}
+		});
+		return map;
+	}
+	/**
+	A map whose keys are the attributes of the model (properties
+	described by attr) and whose values are type of transformation
+	applied to each attribute. This map does not include any
+	attributes that do not have an transformation type.
+	Example
+	```js [app/models/person.js]
+	import { Model, attr } from '@warp-drive/legacy/model';
+	export default class PersonModel extends Model {
+	@attr firstName;
+	@attr('string') lastName;
+	@attr('date') birthday;
+	}
+	```
+	```javascript
+	import Person from 'app/models/person';
+	let transformedAttributes = Person.transformedAttributes
+	transformedAttributes.forEach(function(field, type) {
+	// do thing
+	});
+	// prints:
+	// lastName string
+	// birthday date
+	```
+	@public
+	*/
+	static {
+		decorateMethodV2(this, "attributes", [computeOnce]);
+	}
+	static get transformedAttributes() {
+		const map = /* @__PURE__ */ new Map();
+		this.eachAttribute((name, meta) => {
+			if (meta.type) map.set(name, meta.type);
+		});
+		return map;
+	}
+	/**
+	Iterates through the attributes of the model, calling the passed function on each
+	attribute.
+	The callback method you provide should have the following signature (all
+	parameters are optional):
+	```javascript
+	function(name, meta);
+	```
+	- `name` the name of the current property in the iteration
+	- `meta` the meta object for the attribute property in the iteration
+	Note that in addition to a callback, you can also pass an optional target
+	object that will be set as `this` on the context.
+	Example
+	```javascript
+	import { Model, attr } from '@warp-drive/legacy/model';
+	class PersonModel extends Model {
+	@attr('string') firstName;
+	@attr('string') lastName;
+	@attr('date') birthday;
+	}
+	PersonModel.eachAttribute(function(name, meta) {
+	// do thing
+	});
+	// prints:
+	// firstName {type: "string", kind: 'attribute', options: Object, parentType: function, name: "firstName"}
+	// lastName {type: "string", kind: 'attribute', options: Object, parentType: function, name: "lastName"}
+	// birthday {type: "date", kind: 'attribute', options: Object, parentType: function, name: "birthday"}
+	```
+	@public
+	@param callback The callback to execute
+	@param binding [optional] the value to which the callback's `this` should be bound
+	*/
+	static {
+		decorateMethodV2(this, "transformedAttributes", [computeOnce]);
+	}
+	static eachAttribute(callback, binding) {
+		this.attributes.forEach((meta, name) => {
+			callback.call(binding, name, meta);
+		});
+	}
+	/**
+	Iterates through the transformedAttributes of the model, calling
+	the passed function on each attribute. Note the callback will not be
+	called for any attributes that do not have an transformation type.
+	The callback method you provide should have the following signature (all
+	parameters are optional):
+	```javascript
+	function(name, type);
+	```
+	- `name` the name of the current property in the iteration
+	- `type` a string containing the name of the type of transformed
+	applied to the attribute
+	Note that in addition to a callback, you can also pass an optional target
+	object that will be set as `this` on the context.
+	Example
+	```javascript
+	import { Model, attr } from '@warp-drive/legacy/model';
+	let Person = Model.extend({
+	firstName: attr(),
+	lastName: attr('string'),
+	birthday: attr('date')
+	});
+	Person.eachTransformedAttribute(function(name, type) {
+	// do thing
+	});
+	// prints:
+	// lastName string
+	// birthday date
+	```
+	@public
+	@param callback The callback to execute
+	@param binding [optional] the value to which the callback's `this` should be bound
+	*/
+	static eachTransformedAttribute(callback, binding) {
+		this.transformedAttributes.forEach((type, name) => {
+			callback.call(binding, name, type);
+		});
+	}
+	/**
+	Returns the name of the model class.
+	@public
+	*/
+	static toString() {
+		return `model:${this.modelName}`;
+	}
+};
+Model.prototype.save = save;
+Model.prototype.destroyRecord = destroyRecord;
+Model.prototype.unloadRecord = unloadRecord;
+Model.prototype.hasMany = hasMany;
+Model.prototype.belongsTo = belongsTo;
+Model.prototype.serialize = serialize;
+Model.prototype._createSnapshot = createSnapshot;
+Model.prototype.deleteRecord = deleteRecord;
+Model.prototype.changedAttributes = changedAttributes;
+Model.prototype.rollbackAttributes = rollbackAttributes;
+Model.prototype.reload = reload;
+defineGate(Model.prototype, "isReloading", {
+	get() {
+		return this._isReloading ?? false;
+	},
+	set(v) {
+		this._isReloading = v;
+	},
+	configurable: true,
+	isLocal: true
+});
+/**
+* Restores the pre-`RequestManager` implementations of `save`,
+* `destroyRecord`, and `reload` onto the given `Model` subclass, for
+* apps that have not yet migrated off of the deprecated
+* `ENABLE_LEGACY_REQUEST_METHODS` behaviors.
+*/
+function restoreDeprecatedModelRequestBehaviors(ModelKlass) {
+	ModelKlass.prototype.save = _save;
+	ModelKlass.prototype.destroyRecord = _destroyRecord;
+	ModelKlass.prototype.reload = _reload;
+	defineGate(Model.prototype, "isReloading", {
+		get() {
+			return this._isReloading ?? false;
+		},
+		set(v) {
+			this._isReloading = v;
+		},
+		isLocal: true
+	});
+}
+Model.prototype._createProps = null;
+Model.prototype._secretInit = null;
+function isRelationshipSchema(meta) {
+	return typeof meta === "object" && meta !== null && "kind" in meta && "options" in meta && (meta.kind === "hasMany" || meta.kind === "belongsTo");
+}
+function isAttributeSchema(meta) {
+	return typeof meta === "object" && meta !== null && "kind" in meta && meta.kind === "attribute";
+}
+
+//#endregion
+//#region src/model/-private/model-for-mixin.ts
+function modelForMixin(store, normalizedModelName) {
+	const owner = getOwner(store);
+	const MaybeMixin = owner.factoryFor(`mixin:${normalizedModelName}`);
+	const mixin = MaybeMixin && MaybeMixin.class;
+	if (mixin) {
+		const ModelForMixin = Model.extend(mixin);
+		ModelForMixin.__isMixin = true;
+		ModelForMixin.__mixin = mixin;
+		owner.register(`model:${normalizedModelName}`, ModelForMixin);
+	}
+	return owner.factoryFor(`model:${normalizedModelName}`);
+}
+
+//#endregion
+//#region src/model/-private/schema-provider.ts
+var ModelSchemaProvider = class {
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	constructor(store) {
+		this.store = store;
+		this._schemas = /* @__PURE__ */ new Map();
+		this._typeMisses = /* @__PURE__ */ new Set();
+	}
+	resourceTypes() {
+		return Array.from(this._schemas.keys());
+	}
+	hasTrait(type) {
+		return false;
+	}
+	resourceHasTrait(resource, trait) {
+		return false;
+	}
+	transformation(field) {}
+	derivation(field) {}
+	hashFn(field) {}
+	resource(resource) {
+		const type = normalizeModelName(resource.type);
+		if (!this._schemas.has(type)) this._loadModelSchema(type);
+		return this._schemas.get(type).schema;
+	}
+	registerResources(schemas) {}
+	registerResource(schema) {}
+	registerTransformation(transform) {}
+	registerDerivation(derivation) {}
+	registerHashFn(hashFn) {}
+	/** @internal */
+	_loadModelSchema(type) {
+		const factory = getModelFactory(this.store, type);
+		if (!factory) throw new Error(`No model was found for '${type}'`);
+		const modelClass = factory.class;
+		const attributeMap = modelClass.attributes;
+		const attributes = Object.create(null);
+		attributeMap.forEach((meta, name) => attributes[name] = meta);
+		const relationships = modelClass.relationshipsObject || null;
+		const fields = /* @__PURE__ */ new Map();
+		for (const attr of Object.values(attributes)) fields.set(attr.name, attr);
+		for (const rel of Object.values(relationships)) fields.set(rel.name, rel);
+		const schema = {
+			legacy: true,
+			identity: {
+				name: "id",
+				kind: "@id"
+			},
+			type,
+			fields: Array.from(fields.values())
+		};
+		const cacheFields = /* @__PURE__ */ new Map();
+		for (const field of fields.values()) {
+			const cacheKey = field.sourceKey ?? field.name;
+			cacheFields.set(cacheKey, field);
+		}
+		const internalSchema = {
+			schema,
+			attributes,
+			relationships,
+			fields,
+			cacheFields
+		};
+		this._schemas.set(type, internalSchema);
+		return internalSchema;
+	}
+	fields(resource) {
+		const type = normalizeModelName(resource.type);
+		if (!this._schemas.has(type)) this._loadModelSchema(type);
+		return this._schemas.get(type).fields;
+	}
+	cacheFields(resource) {
+		const type = normalizeModelName(resource.type);
+		if (!this._schemas.has(type)) this._loadModelSchema(type);
+		return this._schemas.get(type).cacheFields;
+	}
+	hasResource(resource) {
+		const type = normalizeModelName(resource.type);
+		if (this._schemas.has(type)) return true;
+		if (this._typeMisses.has(type)) return false;
+		if (!(getModelFactory(this.store, type) !== null)) {
+			this._typeMisses.add(type);
+			return false;
+		}
+		return true;
+	}
+};
+ModelSchemaProvider.prototype.doesTypeExist = function(type) {
+	return this.hasResource({ type });
+};
+ModelSchemaProvider.prototype.attributesDefinitionFor = function(resource) {
+	const type = normalizeModelName(resource.type);
+	if (!this._schemas.has(type)) this._loadModelSchema(type);
+	return this._schemas.get(type).attributes;
+};
+ModelSchemaProvider.prototype.relationshipsDefinitionFor = function(resource) {
+	const type = normalizeModelName(resource.type);
+	if (!this._schemas.has(type)) this._loadModelSchema(type);
+	return this._schemas.get(type).relationships;
+};
+/**
+* The `createSchemaService` implementation for use with `Model`. Pass
+* the result of this to your store's `createSchemaService` method when
+* configuring the store to use `Model` for schema information.
+*
+* @public
+*/
+function buildSchema(store) {
+	return new ModelSchemaProvider(store);
+}
+function getModelFactory(store, type) {
+	if (!store._modelFactoryCache) store._modelFactoryCache = Object.create(null);
+	const cache = store._modelFactoryCache;
+	let factory = cache[type];
+	if (!factory) {
+		factory = getOwner(store).factoryFor(`model:${type}`);
+		if (!factory) factory = modelForMixin(store, type);
+		if (!factory) return null;
+		const klass = factory.class;
+		if (klass.isModel) {
+			if (!(klass.modelName && Object.prototype.hasOwnProperty.call(klass, "modelName"))) Object.defineProperty(klass, "modelName", { value: type });
+		}
+		cache[type] = factory;
+	}
+	return factory;
+}
+
+//#endregion
+export { save as _, RecordState as a, _save as c, createSnapshot as d, deleteRecord as f, rollbackAttributes as g, reload as h, restoreDeprecatedModelRequestBehaviors as i, belongsTo as l, hasMany as m, getModelFactory as n, _destroyRecord as o, destroyRecord as p, Model as r, _reload as s, buildSchema as t, changedAttributes as u, serialize as v, unloadRecord as y };
+//# sourceMappingURL=schema-provider-DyfSd9Cv.js.map