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

package/dist/model-62hn5_PD.d.ts

@@ -0,0 +1,3107 @@
+import { m as Snapshot } from "./compat-BbNNmTM-.js";
+import { Store } from "@warp-drive/core";
+import { LegacyManyArray, PrivateStore, RelatedCollection } from "@warp-drive/core/store/-private";
+import EmberObject from "@ember/object";
+import { RecordStore, Type } from "@warp-drive/core/types/symbols";
+import PromiseProxyMixin from "@ember/object/promise-proxy-mixin";
+import ObjectProxy from "@ember/object/proxy";
+import { NativeArray } from "@ember/array";
+import ArrayProxy from "@ember/array/proxy";
+import { BaseFinderOptions, ModelSchema, ResourceKey } from "@warp-drive/core/types";
+import { CollectionResourceDocument, CollectionResourceRelationship, ExistingResourceObject, Links, Meta, PaginationLinks, SingleResourceDocument, SingleResourceRelationship } from "@warp-drive/core/types/spec/json-api-raw";
+import { ChangedAttributesHash } from "@warp-drive/core/types/cache";
+import { ResourceKey as ResourceKey$1 } from "@warp-drive/core/types/identifier";
+import { OpaqueRecordInstance, TypeFromInstance, TypeFromInstanceOrString, TypedRecordInstance } from "@warp-drive/core/types/record";
+import { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
+import { CollectionEdge, Graph, ResourceEdge, UpgradedMeta } from "@warp-drive/core/graph/-private";
+import { CollectionRelationship } from "@warp-drive/core/types/cache/relationship";
+import { LocalRelationshipOperation } from "@warp-drive/core/types/graph";
+//#region src/model/-private/belongs-to.d.ts
+type IsUnknown<T> = unknown extends T ? true : false;
+type RelationshipOptions<T, Async extends boolean> = {
+  async: Async;
+  inverse: null | (IsUnknown<T> extends true ? string : keyof NoNull<T> & string);
+  polymorphic?: boolean;
+  as?: string;
+  linksMode?: true;
+  resetOnRemoteUpdate?: boolean;
+  /**
+   * The name of the field as returned by the API and inserted into the
+   * cache if it differs from the name of the decorated property.
+   *
+   * For instance, if the API returns:
+   *
+   * ```ts
+   * {
+   *   relationships: {
+   *     'best-friend': { data: { type: 'user', id: '1' } }
+   *   }
+   * }
+   * ```
+   *
+   * But the app desires to use `record.bestFriend`, then the property
+   * should be named `bestFriend` and `sourceKey` should be set to
+   * `'best-friend'`.
+   *
+   * This option is only needed when the value differs from the property name.
+   */
+  sourceKey?: string;
+};
+type NoNull<T> = Exclude<T, null>;
+type RelationshipDecorator<T> = <This>(target: This, key: string, desc?: PropertyDescriptor) => void;
+/**
+`belongsTo` is used to define One-To-One and One-To-Many, and One-To-None
+relationships on a {@link Model}.
+
+`belongsTo` takes a configuration hash as a second parameter, currently
+supported options are:
+
+- `async`: (*required*) A boolean value used to declare whether this is a sync (false) or async (true) relationship.
+- `inverse`: (*required*)  A string used to identify the inverse property on a related model, or `null`.
+- `polymorphic`: (*optional*) A boolean value to mark the relationship as polymorphic
+- `as`: (*optional*) A string used to declare the abstract type "this" record satisfies for polymorphism.
+
+### Examples
+
+To declare a **one-to-many** (or many-to-many) relationship, use
+`belongsTo` in combination with `hasMany`:
+
+```js
+// app/models/comment.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Comment extends Model {
+@belongsTo('post', { async: false, inverse: 'comments' }) post;
+}
+
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
+
+export default class Post extends Model {
+@hasMany('comment', { async: false, inverse: 'post' }) comments;
+}
+```
+
+To declare a **one-to-one** relationship with managed inverses, use `belongsTo` for both sides:
+
+```js
+// app/models/author.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Author extends Model {
+@belongsTo('address', { async: true, inverse: 'owner' }) address;
+}
+
+// app/models/address.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Address extends Model {
+@belongsTo('author', { async: true, inverse: 'address' }) owner;
+}
+```
+
+To declare a **one-to-one** relationship without managed inverses, use `belongsTo` for both sides
+with `null` as the inverse:
+
+```js
+// app/models/author.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Author extends Model {
+@belongsTo('address', { async: true, inverse: null }) address;
+}
+
+// app/models/address.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Address extends Model {
+@belongsTo('author', { async: true, inverse: null }) owner;
+}
+```
+
+To declare a one-to-none relationship between two models, use
+`belongsTo` with inverse set to `null` on just one side::
+
+```js
+// app/models/person.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Person extends Model {
+@belongsTo('person', { async: false, inverse: null }) bestFriend;
+}
+```
+
+#### Sync vs Async Relationships
+
+WarpDrive fulfills relationships using resource data available in
+the cache.
+
+Sync relationships point directly to the known related resources.
+
+When a relationship is declared as async, if any of the known related
+resources have not been loaded, they will be fetched. The property
+on the record when accessed provides a promise that resolves once
+all resources are loaded.
+
+Async relationships may take advantage of links. On access, if the related
+link has not been loaded, or if any known resources are not available in
+the cache, the fresh state will be fetched using the link.
+
+In contrast to async relationship, accessing a sync relationship
+will error on access when any of the known related resources have
+not been loaded.
+
+If you are using `links` with sync relationships, you have to use
+the BelongsTo reference API to fetch or refresh related resources
+that aren't loaded. For instance, for a `bestFriend` relationship:
+
+```js
+person.belongsTo('bestFriend').reload();
+```
+
+#### Polymorphic Relationships
+
+To declare a polymorphic relationship, use `hasMany` with the `polymorphic`
+option set to `true`:
+
+```js
+// app/models/comment.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
+
+export default class Comment extends Model {
+@belongsTo('commentable', { async: false, inverse: 'comments', polymorphic: true }) parent;
+}
+```
+
+`'commentable'` here is referred to as the "abstract type" for the polymorphic
+relationship.
+
+Polymorphic relationships with `inverse: null` will accept any type of record as their content.
+Polymorphic relationships with `inverse` set to a string will only accept records with a matching
+inverse relationships declaring itself as satisfying the abstract type.
+
+Below, 'as' is used to declare the that 'post' record satisfies the abstract type 'commentable'
+for this relationship.
+
+```js
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
+
+export default class Post extends Model {
+@hasMany('comment', { async: false, inverse: 'parent', as: 'commentable' }) comments;
+}
+```
+
+Note: every Model that declares an inverse to a polymorphic relationship must
+declare itself exactly the same. This is because polymorphism is based on structural
+traits.
+
+Polymorphic to polymorphic relationships are supported. Both sides of the relationship
+must be declared as polymorphic, and the `as` option must be used to declare the abstract
+type each record satisfies on both sides.
+
+@public
+@param type the name of the related resource
+@param options a hash of options
+*/
+declare function belongsTo$1(): never;
+declare function belongsTo$1(type: string): never;
+declare function belongsTo$1<T>(type: TypeFromInstance<NoNull<T>>, options: RelationshipOptions<T, boolean>): RelationshipDecorator<T>;
+declare function belongsTo$1(type: string, options: RelationshipOptions<unknown, boolean>): RelationshipDecorator<unknown>;
+//#endregion
+//#region src/model/-private/promise-many-array.d.ts
+interface HasManyProxyCreateArgs<T = unknown> {
+  promise: Promise<RelatedCollection<T>>;
+  content?: RelatedCollection<T>;
+}
+interface PromiseManyArray<T> {
+  /**
+   * A property signifying that this object implements the classic Ember
+   * `PromiseProxyMixin`-like API. See {@link LegacyPromiseProxy}.
+   */
+  [LegacyPromiseProxy]: true;
+}
+/**
+This class is returned as the result of accessing an async hasMany relationship
+on an instance of a Model extending from `@warp-drive/legacy/model`.
+
+A PromiseManyArray is an iterable proxy that allows templates to consume related
+ManyArrays and update once their contents are no longer pending.
+
+In your JS code you should resolve the promise first.
+
+```js
+const comments = await post.comments;
+```
+
+@public
+*/
+declare class PromiseManyArray<T = unknown> {
+  /**
+   * The promise for the relationship's content, or `null` once
+   * {@link PromiseManyArray.destroy | destroy} has been called.
+   */
+  promise: Promise<RelatedCollection<T>> | null;
+  /**
+   * Whether {@link PromiseManyArray.destroy | destroy} has been called.
+   */
+  isDestroyed: boolean;
+  /**
+   * The resolved `ManyArray` for the relationship, if the promise has
+   * resolved, else `null`.
+   */
+  content: RelatedCollection<T> | null;
+  constructor(promise: Promise<RelatedCollection<T>>, content?: RelatedCollection<T>);
+  /**
+   * Retrieve the length of the content
+   * @public
+   */
+  get length(): number;
+  /**
+   * @private
+   */
+  get "[]"(): 0 | RelatedCollection<T> | undefined;
+  /**
+   * Iterate the proxied content. Called by the glimmer iterator in #each
+   * We do not guarantee that forEach will always be available. This
+   * may eventually be made to use Symbol.Iterator once glimmer supports it.
+   *
+   * @param cb
+   * @return
+   * @private
+   */
+  forEach(cb: (item: T, index: number, array: T[]) => void): void;
+  /**
+   * Reload the relationship
+   * @public
+   */
+  reload(options: Omit<BaseFinderOptions, "">): this;
+  /**
+   * Whether the loading promise is still pending
+   *
+   * @public
+   */
+  isPending: boolean;
+  /**
+   * Whether the loading promise rejected
+   *
+   * @public
+   */
+  isRejected: boolean;
+  /**
+   * Whether the loading promise succeeded
+   *
+   * @public
+   */
+  isFulfilled: boolean;
+  /**
+   * Whether the loading promise completed (resolved or rejected)
+   *
+   * @public
+   */
+  isSettled: boolean;
+  /**
+   * chain this promise
+   *
+   * @public
+   */
+  then(success: Parameters<Promise<RelatedCollection<T>>["then"]>[0], rejected?: Parameters<Promise<RelatedCollection<T>>["then"]>[1]): Promise<unknown>;
+  /**
+   * catch errors thrown by this promise
+   * @public
+   */
+  catch(cb: Parameters<Promise<RelatedCollection<T>>["catch"]>[0]): Promise<unknown>;
+  /**
+   * run cleanup after this promise completes
+   *
+   * @public
+   */
+  finally(cb: Parameters<Promise<RelatedCollection<T>>["finally"]>[0]): Promise<unknown>;
+  /**
+   * Tears down this proxy, releasing its {@link PromiseManyArray.content | content} and
+   * {@link PromiseManyArray.promise | promise} and marking it as {@link PromiseManyArray.isDestroyed | destroyed}.
+   *
+   * @public
+   */
+  destroy(): void;
+  /**
+   * Retrieve the links for this relationship
+   * @public
+   */
+  get links(): Links | null | undefined;
+  /**
+   * Retrieve the meta for this relationship
+   * @public
+   */
+  get meta(): Record<string, unknown> | null | undefined;
+  /** @internal */
+  _update(promise: Promise<RelatedCollection<T>>, content?: RelatedCollection<T>): void;
+  static create<T>({ promise, content }: HasManyProxyCreateArgs<T>): PromiseManyArray<T>;
+}
+//#endregion
+//#region src/model/-private/references/has-many.d.ts
+type ArrayItemType<T> = T extends (infer U)[] ? U : never;
+/**
+A `HasManyReference` is a low-level API that allows access
+and manipulation of a hasMany relationship.
+
+It is especially useful when you're dealing with `async` relationships
+from `@warp-drive/legacy/model` as it allows synchronous access to
+the relationship data if loaded, as well as APIs for loading, reloading
+the data or accessing available information without triggering a load.
+
+It may also be useful when using `sync` relationships with `@warp-drive/legacy/model`
+that need to be loaded/reloaded with more precise timing than marking the
+relationship as `async` and relying on autofetch would have allowed.
+
+However,keep in mind that marking a relationship as `async: false` will introduce
+bugs into your application if the data is not always guaranteed to be available
+by the time the relationship is accessed. Ergo, it is recommended when using this
+approach to utilize `links` for unloaded relationship state instead of identifiers.
+
+Reference APIs are entangled with the relationship's underlying state,
+thus any getters or cached properties that utilize these will properly
+invalidate if the relationship state changes.
+
+References are "stable", meaning that multiple calls to retrieve the reference
+for a given relationship will always return the same HasManyReference.
+
+@class HasManyReference
+@public
+*/
+declare class HasManyReference<T = unknown, K extends string = IsUnknown<T> extends true ? string : MaybeHasManyFields<T>, Related = K extends keyof T ? ArrayItemType<Awaited<T[K]>> : unknown> {
+  graph: Graph;
+  store: Store;
+  hasManyRelationship: CollectionEdge;
+  /**
+   * The field name on the parent record for this has-many relationship.
+   *
+   * @property key
+   * @type {String}
+   * @public
+   */
+  key: K;
+  /**
+   * The type of resource this relationship will contain.
+   *
+   * @property type
+   * @type {String}
+   * @public
+   */
+  type: TypeFromInstanceOrString<Related>;
+  ___token: object;
+  ___identifier: ResourceKey$1<TypeFromInstanceOrString<T>>;
+  ___relatedTokenMap: Map<ResourceKey$1, object>;
+  _ref: number;
+  constructor(store: Store, graph: Graph, parentIdentifier: ResourceKey$1<TypeFromInstanceOrString<T>>, hasManyRelationship: CollectionEdge, key: K);
+  /**
+   * This method should never be called by user code.
+   *
+   * @internal
+   */
+  destroy(): void;
+  /**
+   * An array of identifiers for the records that this reference refers to.
+   *
+   * @property identifiers
+   * @type {ResourceKey[]}
+   * @public
+   */
+  get identifiers(): ResourceKey$1<TypeFromInstanceOrString<Related>>[];
+  _resource(): CollectionResourceRelationship;
+  /**
+	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
+	use the "link" otherwise it defaults to "id".
+	
+	Example
+	
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	
+	```javascript
+	let post = store.push({
+	data: {
+	type: 'post',
+	id: 1,
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: 1 }]
+	}
+	}
+	}
+	});
+	
+	let commentsRef = post.hasMany('comments');
+	
+	// get the identifier of the reference
+	if (commentsRef.remoteType() === "ids") {
+	let ids = commentsRef.ids();
+	} else if (commentsRef.remoteType() === "link") {
+	let link = commentsRef.link();
+	}
+	```
+	
+	@public
+	@return The name of the remote type. This should either be `link` or `ids`
+	*/
+  remoteType(): "link" | "ids";
+  /**
+	`ids()` returns an array of the record IDs in this relationship.
+	
+	Example
+	
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	
+	```javascript
+	let post = store.push({
+	data: {
+	type: 'post',
+	id: 1,
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: 1 }]
+	}
+	}
+	}
+	});
+	
+	let commentsRef = post.hasMany('comments');
+	
+	commentsRef.ids(); // ['1']
+	```
+	
+	@public
+	@return The ids in this has-many relationship
+	*/
+  ids(): Array<string | null>;
+  /**
+	The link WarpDrive will use to fetch or reload this belongs-to
+	relationship. By default it uses only the "related" resource linkage.
+	
+	Example
+	
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	export default Model.extend({
+	user: belongsTo('user', { async: true, inverse: null })
+	});
+	
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	links: {
+	related: '/articles/1/author'
+	}
+	}
+	}
+	}
+	});
+	let userRef = blog.belongsTo('user');
+	
+	// get the identifier of the reference
+	if (userRef.remoteType() === "link") {
+	let link = userRef.link();
+	}
+	```
+	
+	@public
+	@return The link WarpDrive will use to fetch or reload this belongs-to relationship.
+	*/
+  link(): string | null;
+  /**
+   * any links that have been received for this relationship
+   *
+   * @public
+   * @return
+   */
+  links(): PaginationLinks | null;
+  /**
+	The meta data for the has-many relationship.
+	
+	Example
+	
+	```javascript
+	// models/blog.js
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	export default Model.extend({
+	users: hasMany('user', { async: true, inverse: null })
+	});
+	
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	users: {
+	links: {
+	related: {
+	href: '/articles/1/authors'
+	},
+	},
+	meta: {
+	lastUpdated: 1458014400000
+	}
+	}
+	}
+	}
+	});
+	
+	let usersRef = blog.hasMany('user');
+	
+	usersRef.meta() // { lastUpdated: 1458014400000 }
+	```
+	
+	@public
+	@return The meta information for the belongs-to relationship.
+	*/
+  meta(): Meta | null;
+  /**
+	`push` can be used to update the data in the relationship and WarpDrive
+	will treat the new data as the canonical value of this relationship on
+	the backend. An empty array will signify the canonical value should be
+	empty.
+	
+	Example model
+	
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	
+	Setup some initial state, note we haven't loaded the comments yet:
+	
+	```js
+	const post = store.push({
+	data: {
+	type: 'post',
+	id: '1',
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: '1' }]
+	}
+	}
+	}
+	});
+	
+	const commentsRef = post.hasMany('comments');
+	commentsRef.ids(); // ['1']
+	```
+	
+	Update the state using `push`, note we can do this even without
+	having loaded these comments yet by providing resource identifiers.
+	
+	Both full resources and resource identifiers are supported.
+	
+	```js
+	await commentsRef.push({
+	data: [
+	{ type: 'comment', id: '2' },
+	{ type: 'comment', id: '3' },
+	]
+	});
+	
+	commentsRef.ids(); // ['2', '3']
+	```
+	
+	For convenience, you can also pass in an array of resources or resource identifiers
+	without wrapping them in the `data` property:
+	
+	```js
+	await commentsRef.push([
+	{ type: 'comment', id: '4' },
+	{ type: 'comment', id: '5' },
+	]);
+	
+	commentsRef.ids(); // ['4', '5']
+	```
+	
+	When using the `data` property, you may also include other resource data via included,
+	as well as provide new links and meta to the relationship.
+	
+	```js
+	await commentsRef.push({
+	links: {
+	related: '/posts/1/comments'
+	},
+	meta: {
+	total: 2
+	},
+	data: [
+	{ type: 'comment', id: '4' },
+	{ type: 'comment', id: '5' },
+	],
+	included: [
+	{ type: 'other-thing', id: '1', attributes: { foo: 'bar' },
+	]
+	});
+	```
+	
+	By default, the store will attempt to fetch any unloaded records before resolving
+	the returned promise with the ManyArray.
+	
+	Alternatively, pass `true` as the second argument to avoid fetching unloaded records
+	and instead the promise will resolve with void without attempting to fetch. This is
+	particularly useful if you want to update the state of the relationship without
+	forcing the load of all of the associated records.
+	
+	@public
+	@param doc a JSONAPI document object describing the new value of this relationship.
+	@param skipFetch [optional] if `true`, do not attempt to fetch unloaded records
+	*/
+  push(doc: ExistingResourceObject[] | CollectionResourceDocument, skipFetch?: boolean): Promise<RelatedCollection<Related> | void>;
+  _isLoaded(): boolean;
+  /**
+	`value()` synchronously returns the current value of the has-many
+	relationship. Unlike `record.relationshipName`, calling
+	`value()` on a reference does not trigger a fetch if the async
+	relationship is not yet loaded. If the relationship is not loaded
+	it will always return `null`.
+	
+	Example
+	
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	
+	```javascript
+	let post = store.push({
+	data: {
+	type: 'post',
+	id: 1,
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: 1 }]
+	}
+	}
+	}
+	});
+	
+	let commentsRef = post.hasMany('comments');
+	
+	post.comments.then(function(comments) {
+	commentsRef.value() === comments
+	})
+	```
+	
+	@public
+	*/
+  value(): RelatedCollection<Related> | null;
+  /**
+	Loads the relationship if it is not already loaded.  If the
+	relationship is already loaded this method does not trigger a new
+	load. This causes a request to the specified
+	relationship link or reloads all items currently in the relationship.
+	
+	Example
+	
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	
+	```javascript
+	let post = store.push({
+	data: {
+	type: 'post',
+	id: 1,
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: 1 }]
+	}
+	}
+	}
+	});
+	
+	let commentsRef = post.hasMany('comments');
+	
+	commentsRef.load().then(function(comments) {
+	//...
+	});
+	```
+	
+	You may also pass in an options object whose properties will be
+	fed forward. This enables you to pass `adapterOptions` into the
+	request given to the adapter via the reference.
+	
+	Example
+	
+	```javascript
+	commentsRef.load({ adapterOptions: { isPrivate: true } })
+	.then(function(comments) {
+	//...
+	});
+	```
+	
+	```js [app/adapters/comment.js]
+	export default ApplicationAdapter.extend({
+	findMany(store, type, id, snapshots) {
+	// In the adapter you will have access to adapterOptions.
+	let adapterOptions = snapshots[0].adapterOptions;
+	}
+	});
+	```
+	
+	@public
+	@param options the options to pass in.
+	@return a promise that resolves with the ManyArray in
+	this has-many relationship.
+	*/
+  load(options?: BaseFinderOptions): Promise<RelatedCollection<Related>>;
+  /**
+	Reloads this has-many relationship. This causes a request to the specified
+	relationship link or reloads all items currently in the relationship.
+	
+	Example
+	
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	
+	```javascript
+	let post = store.push({
+	data: {
+	type: 'post',
+	id: 1,
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: 1 }]
+	}
+	}
+	}
+	});
+	
+	let commentsRef = post.hasMany('comments');
+	
+	commentsRef.reload().then(function(comments) {
+	//...
+	});
+	```
+	
+	You may also pass in an options object whose properties will be
+	fed forward. This enables you to pass `adapterOptions` into the
+	request given to the adapter via the reference. A full example
+	can be found in the `load` method.
+	
+	Example
+	
+	```javascript
+	commentsRef.reload({ adapterOptions: { isPrivate: true } })
+	```
+	
+	@public
+	@param options the options to pass in.
+	@return a promise that resolves with the ManyArray in this has-many relationship.
+	*/
+  reload(options?: BaseFinderOptions): Promise<RelatedCollection<Related>>;
+}
+//#endregion
+//#region src/model/-private/legacy-relationships-support.d.ts
+declare const LEGACY_SUPPORT: Map<ResourceKey | MinimalLegacyRecord, LegacySupport>;
+declare function lookupLegacySupport(record: MinimalLegacyRecord): LegacySupport;
+/**
+ * @hideconstructor
+ */
+declare class LegacySupport {
+  /** @internal */
+  private record;
+  /** @internal */
+  store: PrivateStore;
+  /** @internal */
+  private graph;
+  /** @internal */
+  private cache;
+  /** @internal */
+  private references;
+  identifier: ResourceKey;
+  /** @internal */
+  _manyArrayCache: Record<string, LegacyManyArray>;
+  /** @internal */
+  _relationshipPromisesCache: Record<string, Promise<LegacyManyArray | OpaqueRecordInstance>>;
+  /** @internal */
+  _relationshipProxyCache: Record<string, PromiseManyArray | PromiseBelongsTo | undefined>;
+  /** @internal */
+  private _pending;
+  /** @internal */
+  private isDestroying;
+  /** @internal */
+  private isDestroyed;
+  constructor(record: MinimalLegacyRecord, identifier: ResourceKey);
+  /** @private */
+  _syncArray(array: LegacyManyArray): void;
+  mutate(mutation: LocalRelationshipOperation): void;
+  _findBelongsTo(key: string, resource: SingleResourceRelationship, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<OpaqueRecordInstance | null>;
+  reloadBelongsTo(key: string, options?: BaseFinderOptions): Promise<OpaqueRecordInstance | null>;
+  getBelongsTo(key: string, options?: BaseFinderOptions): PromiseBelongsTo | OpaqueRecordInstance | null;
+  setDirtyBelongsTo(key: string, value: OpaqueRecordInstance | null): void;
+  _getCurrentState<T>(identifier: ResourceKey, field: string): [ResourceKey<TypeFromInstanceOrString<T>>[], CollectionRelationship];
+  getManyArray<T>(key: string, definition?: UpgradedMeta): LegacyManyArray<T>;
+  fetchAsyncHasMany(key: string, relationship: CollectionEdge, manyArray: LegacyManyArray, options?: BaseFinderOptions): Promise<LegacyManyArray>;
+  reloadHasMany<T>(key: string, options?: BaseFinderOptions): Promise<LegacyManyArray<T>> | PromiseManyArray<T>;
+  getHasMany(key: string, options?: BaseFinderOptions): PromiseManyArray | LegacyManyArray;
+  _updatePromiseProxyFor(kind: "hasMany", key: string, args: HasManyProxyCreateArgs): PromiseManyArray;
+  _updatePromiseProxyFor(kind: "belongsTo", key: string, args: BelongsToProxyCreateArgs): PromiseBelongsTo;
+  _updatePromiseProxyFor(kind: "belongsTo", key: string, args: {
+    promise: Promise<OpaqueRecordInstance | null>;
+  }): PromiseBelongsTo;
+  referenceFor(kind: "belongsTo", key: string): BelongsToReference;
+  referenceFor(kind: "hasMany", key: string): HasManyReference;
+  _findHasManyByJsonApiResource(resource: CollectionResourceRelationship, parentIdentifier: ResourceKey, relationship: CollectionEdge, options?: BaseFinderOptions): Promise<void | unknown[]> | void;
+  _findBelongsToByJsonApiResource(resource: SingleResourceRelationship, parentIdentifier: ResourceKey, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<ResourceKey | null>;
+  destroy(): void;
+}
+//#endregion
+//#region src/model/-private/promise-belongs-to.d.ts
+interface BelongsToProxyMeta<T = unknown> {
+  key: string;
+  store: Store;
+  legacySupport: LegacySupport;
+  modelName: TypeFromInstanceOrString<T>;
+}
+interface BelongsToProxyCreateArgs<T = unknown> {
+  promise: Promise<T | null>;
+  content?: T | null;
+  _belongsToState: BelongsToProxyMeta<T>;
+}
+declare const LegacyPromiseProxy: unique symbol;
+interface PromiseObjectType<T> extends PromiseProxyMixin<T | null>, ObjectProxy<T> {
+  new <PT>(...args: unknown[]): PromiseObjectType<PT>;
+}
+declare class PromiseObjectType<T> {}
+declare const Extended: PromiseObjectType<OpaqueRecordInstance>;
+interface PromiseBelongsTo<T> {
+  [LegacyPromiseProxy]: true;
+}
+/**
+A PromiseBelongsTo is a PromiseObject that also proxies certain method calls
+to the underlying belongsTo model.
+Right now we proxy:
+* `reload()`
+@class PromiseBelongsTo
+@private
+*/
+declare class PromiseBelongsTo<T = unknown> extends Extended<T> {
+  _belongsToState: BelongsToProxyMeta<T>;
+  get id(): string | null;
+  get meta(): void;
+  reload(options: Record<string, unknown>): Promise<this>;
+}
+//#endregion
+//#region src/model/-private/type-utils.d.ts
+type ExcludeNull<T> = Exclude<T, null> extends never ? T : Exclude<T, null>;
+type GetMappedKey<M, V> = { [K in keyof M]-?: ExcludeNull<M[K]> extends V ? K : never; }[keyof M] & string;
+/**
+ * Get the keys of fields that are maybe defined as `belongsTo` relationships
+ *
+ * "Maybe" because getter/computed fields might be returning values that look
+ * like relationships, but are not.
+ *
+ */
+type MaybeBelongsToFields<ThisType> = _TrueKeys<ThisType> extends never ? string : _MaybeBelongsToFields<ThisType>;
+type _MaybeBelongsToFields<ThisType> = GetMappedKey<ThisType, PromiseBelongsTo | TypedRecordInstance>;
+/**
+ * Get the keys of fields that are maybe defined as `hasMany` relationships
+ *
+ * "Maybe" because getter/computed fields might be returning values that look
+ * like relationships, but are not.
+ *
+ */
+type MaybeHasManyFields<ThisType> = _TrueKeys<ThisType> extends never ? string : _MaybeHasManyFields<ThisType>;
+type _MaybeHasManyFields<ThisType> = GetMappedKey<ThisType, RelatedCollection | PromiseManyArray>;
+/**
+ * Get the keys of fields that are maybe defined as `attr` fields
+ *
+ * "Maybe" because getter/computed fields might be returning values that look
+ * like attributes, but are not.
+ *
+ * This is computed by excluding the keys that are defined as `belongsTo` or `hasMany`
+ * as well as the keys on EmberObject and the Model base class
+ *
+ */
+type MaybeAttrFields<ThisType> = Exclude<_TrueKeys<ThisType>, _MaybeBelongsToFields<ThisType> | _MaybeHasManyFields<ThisType>>;
+/**
+ * Get the keys of fields that are maybe defined as relationships
+ *
+ * "Maybe" because getter/computed fields might be returning values that look
+ * like relationships, but are not.
+ *
+ */
+type MaybeRelationshipFields<ThisType> = _TrueKeys<ThisType> extends never ? string : _MaybeBelongsToFields<ThisType> | _MaybeHasManyFields<ThisType>;
+type _TrueKeys<ThisType> = Exclude<keyof ThisType & string, (keyof Model & string) | typeof Type>;
+type isSubClass<ThisType> = _TrueKeys<ThisType> extends never ? false : true;
+//#endregion
+//#region src/model/-private/references/belongs-to.d.ts
+/**
+A `BelongsToReference` is a low-level API that allows access
+and manipulation of a belongsTo relationship.
+
+It is especially useful when you're dealing with `async` relationships
+from `@warp-drive/legacy/model` as it allows synchronous access to
+the relationship data if loaded, as well as APIs for loading, reloading
+the data or accessing available information without triggering a load.
+
+It may also be useful when using `sync` relationships with `@warp-drive/legacy/model`
+that need to be loaded/reloaded with more precise timing than marking the
+relationship as `async` and relying on autofetch would have allowed.
+
+However,keep in mind that marking a relationship as `async: false` will introduce
+bugs into your application if the data is not always guaranteed to be available
+by the time the relationship is accessed. Ergo, it is recommended when using this
+approach to utilize `links` for unloaded relationship state instead of identifiers.
+
+Reference APIs are entangled with the relationship's underlying state,
+thus any getters or cached properties that utilize these will properly
+invalidate if the relationship state changes.
+
+References are "stable", meaning that multiple calls to retrieve the reference
+for a given relationship will always return the same HasManyReference.
+
+@public
+*/
+declare class BelongsToReference<T = unknown, K extends string = IsUnknown<T> extends true ? string : MaybeBelongsToFields<T>, Related = K extends keyof T ? Exclude<Awaited<T[K]>, null> : unknown> {
+  graph: Graph;
+  store: Store;
+  belongsToRelationship: ResourceEdge;
+  /**
+   * The field name on the parent record for this has-many relationship.
+   *
+   */
+  key: K;
+  /**
+   * The type of resource this relationship will contain.
+   *
+   */
+  type: TypeFromInstanceOrString<Related>;
+  ___token: object;
+  ___identifier: ResourceKey$1<TypeFromInstanceOrString<T>>;
+  ___relatedToken: object | null;
+  _ref: number;
+  constructor(store: Store, graph: Graph, parentIdentifier: ResourceKey$1<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.
+   *
+   */
+  get identifier(): ResourceKey$1<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
+	map. This can be used to access the id of an async relationship
+	without triggering a fetch that would normally happen if you
+	attempted to use `record.relationship.id`.
+	
+	Example
+	
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	
+	export default class BlogModel extends Model {
+	@belongsTo('user', { async: true, inverse: null }) user;
+	}
+	
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	data: { type: 'user', id: 1 }
+	}
+	}
+	}
+	});
+	let userRef = blog.belongsTo('user');
+	
+	// get the identifier of the reference
+	if (userRef.remoteType() === "id") {
+	let id = userRef.id();
+	}
+	```
+	
+	@public
+	@return The id of the record in this belongsTo relationship.
+	*/
+  id(): string | null;
+  /**
+	The link WarpDrive will use to fetch or reload this belongs-to
+	relationship. By default it uses only the "related" resource linkage.
+	
+	Example
+	
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	export default Model.extend({
+	user: belongsTo('user', { async: true, inverse: null })
+	});
+	
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	links: {
+	related: '/articles/1/author'
+	}
+	}
+	}
+	}
+	});
+	let userRef = blog.belongsTo('user');
+	
+	// get the identifier of the reference
+	if (userRef.remoteType() === "link") {
+	let link = userRef.link();
+	}
+	```
+	
+	@public
+	@return The link WarpDrive will use to fetch or reload this belongs-to relationship.
+	*/
+  link(): string | null;
+  /**
+   * any links that have been received for this relationship
+   *
+   * @public
+   * @return
+   */
+  links(): Links | null;
+  /**
+	The meta data for the belongs-to relationship.
+	
+	Example
+	
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	export default Model.extend({
+	user: belongsTo('user', { async: true, inverse: null })
+	});
+	
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	links: {
+	related: {
+	href: '/articles/1/author'
+	},
+	},
+	meta: {
+	lastUpdated: 1458014400000
+	}
+	}
+	}
+	}
+	});
+	
+	let userRef = blog.belongsTo('user');
+	
+	userRef.meta() // { lastUpdated: 1458014400000 }
+	```
+	
+	@public
+	@return The meta information for the belongs-to relationship.
+	*/
+  meta(): Meta | null;
+  _resource(): SingleResourceRelationship<ResourceKey$1<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
+	use the "link" otherwise it defaults to "id".
+	
+	Example
+	
+	```js [app/models/post.js]
+	import Model, { hasMany } from '@warp-drive/legacy/model';
+	
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	
+	```javascript
+	let post = store.push({
+	data: {
+	type: 'post',
+	id: 1,
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: 1 }]
+	}
+	}
+	}
+	});
+	
+	let commentsRef = post.hasMany('comments');
+	
+	// get the identifier of the reference
+	if (commentsRef.remoteType() === "ids") {
+	let ids = commentsRef.ids();
+	} else if (commentsRef.remoteType() === "link") {
+	let link = commentsRef.link();
+	}
+	```
+	
+	@public
+	@return The name of the remote type. This should either be `link` or `id`
+	*/
+  remoteType(): "link" | "id";
+  /**
+	`push` can be used to update the data in the relationship and WarpDrive
+	will treat the new data as the canonical value of this relationship on
+	the backend. A value of `null` (e.g. `{ data: null }`) can be passed to
+	clear the relationship.
+	
+	Example model
+	
+	```js [app/models/blog.js]
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	
+	export default class BlogModel extends Model {
+	@belongsTo('user', { async: true, inverse: null }) user;
+	}
+	```
+	
+	Setup some initial state, note we haven't loaded the user yet:
+	
+	```js
+	const blog = store.push({
+	data: {
+	type: 'blog',
+	id: '1',
+	relationships: {
+	user: {
+	data: { type: 'user', id: '1' }
+	}
+	}
+	}
+	});
+	
+	const userRef = blog.belongsTo('user');
+	userRef.id(); // '1'
+	```
+	
+	Update the state using `push`, note we can do this even without
+	having loaded the user yet by providing a resource-identifier.
+	
+	Both full a resource and a resource-identifier are supported.
+	
+	```js
+	await userRef.push({
+	data: {
+	type: 'user',
+	id: '2',
+	}
+	});
+	
+	userRef.id(); // '2'
+	```
+	
+	You may also pass in links and meta fore the relationship, and sideload
+	additional resources that might be required.
+	
+	```js
+	await userRef.push({
+	data: {
+	type: 'user',
+	id: '2',
+	},
+	links: {
+	related: '/articles/1/author'
+	},
+	meta: {
+	lastUpdated: Date.now()
+	},
+	included: [
+	{
+	type: 'user-preview',
+	id: '2',
+	attributes: {
+	username: '@runspired'
+	}
+	}
+	]
+	});
+	```
+	
+	By default, the store will attempt to fetch the record if it is not loaded or its
+	resource data is not included in the call to `push` before resolving the returned
+	promise with the new state..
+	
+	Alternatively, pass `true` as the second argument to avoid fetching unloaded records
+	and instead the promise will resolve with void without attempting to fetch. This is
+	particularly useful if you want to update the state of the relationship without
+	forcing the load of all of the associated record.
+	
+	@public
+	@param doc a JSONAPI document object describing the new value of this relationship.
+	@param skipFetch [optional] if `true`, do not attempt to fetch unloaded records
+	@return a promise that resolves with the record in this belongs-to relationship after the push has completed.
+	*/
+  push(doc: SingleResourceDocument, skipFetch?: boolean): Promise<Related | null | void>;
+  /**
+	`value()` synchronously returns the current value of the belongs-to
+	relationship. Unlike `record.relationshipName`, calling
+	`value()` on a reference does not trigger a fetch if the async
+	relationship is not yet loaded. If the relationship is not loaded
+	it will always return `null`.
+	
+	Example
+	
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	
+	export default class BlogModel extends Model {
+	@belongsTo('user', { async: true, inverse: null }) user;
+	}
+	
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	data: { type: 'user', id: 1 }
+	}
+	}
+	}
+	});
+	let userRef = blog.belongsTo('user');
+	
+	userRef.value(); // null
+	
+	// provide data for reference
+	userRef.push({
+	data: {
+	type: 'user',
+	id: 1,
+	attributes: {
+	username: "@user"
+	}
+	}
+	}).then(function(user) {
+	userRef.value(); // user
+	});
+	```
+	
+	@public
+	@return the record in this relationship
+	*/
+  value(): Related | null;
+  /**
+	Loads a record in a belongs-to relationship if it is not already
+	loaded. If the relationship is already loaded this method does not
+	trigger a new load.
+	
+	Example
+	
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	
+	export default class BlogModel extends Model {
+	@belongsTo('user', { async: true, inverse: null }) user;
+	}
+	
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	data: { type: 'user', id: 1 }
+	}
+	}
+	}
+	});
+	let userRef = blog.belongsTo('user');
+	
+	userRef.value(); // null
+	
+	userRef.load().then(function(user) {
+	userRef.value() === user
+	});
+	```
+	
+	You may also pass in an options object whose properties will be
+	fed forward. This enables you to pass `adapterOptions` into the
+	request given to the adapter via the reference.
+	
+	Example
+	
+	```javascript
+	userRef.load({ adapterOptions: { isPrivate: true } }).then(function(user) {
+	userRef.value() === user;
+	});
+	```
+	```js [app/adapters/user.js]
+	import Adapter from '@warp-drive/legacy/adapter';
+	
+	export default class UserAdapter extends Adapter {
+	findRecord(store, type, id, snapshot) {
+	// In the adapter you will have access to adapterOptions.
+	let adapterOptions = snapshot.adapterOptions;
+	}
+	});
+	```
+	
+	@public
+	@param options the options to pass in.
+	@return a promise that resolves with the record in this belongs-to relationship.
+	*/
+  load(options?: Record<string, unknown>): Promise<Related | null>;
+  /**
+	Triggers a reload of the value in this relationship. If the
+	remoteType is `"link"` WarpDrive will use the relationship link to
+	reload the relationship. Otherwise it will reload the record by its
+	id.
+	
+	Example
+	
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	
+	export default class BlogModel extends Model {
+	@belongsTo('user', { async: true, inverse: null }) user;
+	}
+	
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	data: { type: 'user', id: 1 }
+	}
+	}
+	}
+	});
+	let userRef = blog.belongsTo('user');
+	
+	userRef.reload().then(function(user) {
+	userRef.value() === user
+	});
+	```
+	
+	You may also pass in an options object whose properties will be
+	fed forward. This enables you to pass `adapterOptions` into the
+	request given to the adapter via the reference. A full example
+	can be found in the `load` method.
+	
+	Example
+	
+	```javascript
+	userRef.reload({ adapterOptions: { isPrivate: true } })
+	```
+	
+	@public
+	@param options the options to pass in.
+	@return a promise that resolves with the record in this belongs-to relationship after the reload has completed.
+	*/
+  reload(options?: Record<string, unknown>): Promise<Related | null>;
+}
+//#endregion
+//#region src/model/-private/model-methods.d.ts
+interface MinimalLegacyRecord {
+  errors: Errors;
+  /** @internal */
+  ___recordState: RecordState;
+  currentState: RecordState;
+  isDestroyed: boolean;
+  isDestroying: boolean;
+  isReloading: boolean;
+  isValid: boolean;
+  /** @internal */
+  [RecordStore]: Store;
+  deleteRecord(): void;
+  unloadRecord(): void;
+  save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<this>;
+  destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<this>;
+}
+declare function belongsTo<T extends MinimalLegacyRecord, K extends MaybeBelongsToFields<T>>(this: T, prop: K): BelongsToReference<T, K>;
+declare function hasMany<T extends MinimalLegacyRecord, K extends MaybeHasManyFields<T>>(this: T, prop: K): HasManyReference<T, K>;
+//#endregion
+//#region src/model/-private/record-state.d.ts
+/**
+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
+*/
+declare class RecordState {
+  /** @internal */
+  private store;
+  /** @internal */
+  private identifier;
+  /** @internal */
+  private record;
+  /** @internal */
+  private rs;
+  /** @internal */
+  private pendingCount;
+  /** @internal */
+  private fulfilledCount;
+  /** @internal */
+  private rejectedCount;
+  /** @internal */
+  private cache;
+  /** @internal */
+  private _errorRequests;
+  /** @internal */
+  private _lastError;
+  /** @internal */
+  private handler;
+  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;
+  get isSaved(): boolean;
+  get isEmpty(): boolean;
+  get isNew(): boolean;
+  get isDeleted(): boolean;
+  get isValid(): boolean;
+  get isDirty(): boolean;
+  get isError(): boolean;
+  get adapterError(): unknown;
+  get isPreloaded(): boolean;
+  get stateName(): "root.loading" | "root.empty" | "root.deleted.inFlight" | "root.deleted.saved" | "root.deleted.invalid" | "root.deleted.uncommitted" | "root.loaded.created.inFlight" | "root.loaded.created.invalid" | "root.loaded.created.uncommitted" | "root.loaded.updated.inFlight" | "root.loaded.updated.invalid" | "root.loaded.updated.uncommitted" | "root.loaded.saved";
+  get dirtyType(): "" | "deleted" | "created" | "updated";
+}
+//#endregion
+//#region src/model/-private/errors.d.ts
+type ValidationError = {
+  attribute: string;
+  message: string;
+};
+interface ArrayProxyWithCustomOverrides<T> extends Omit<ArrayProxy<T>, "clear" | "content"> {
+  content: NativeArray<T>;
+  clear(): void;
+  _has(name: string): boolean;
+}
+declare const ArrayProxyWithCustomOverrides: new <T>() => ArrayProxyWithCustomOverrides<T>;
+/**
+Holds validation errors for a given record, organized by attribute names.
+
+This class is not directly instantiable.
+
+Every `Model` has an `errors` property that is an instance of
+`Errors`. This can be used to display validation error
+messages returned from the server when a `record.save()` rejects.
+
+For Example, if you had a `User` model that looked like this:
+
+```js [app/models/user.js]
+import { Model, attr } from '@warp-drive/legacy/model';
+
+export default class UserModel extends Model {
+@attr('string') username;
+@attr('string') email;
+}
+```
+And you attempted to save a record that did not validate on the backend:
+
+```javascript
+let user = store.createRecord('user', {
+username: 'tomster',
+email: 'invalidEmail'
+});
+user.save();
+```
+
+Your backend would be expected to return an error response that described
+the problem, so that error messages can be generated on the app.
+
+API responses will be translated into instances of `Errors` differently,
+depending on the specific combination of adapter and serializer used. You
+may want to check the documentation or the source code of the libraries
+that you are using, to know how they expect errors to be communicated.
+
+Errors can be displayed to the user by accessing their property name
+to get an array of all the error objects for that property. Each
+error object is a JavaScript object with two keys:
+
+- `message` A string containing the error message from the backend
+- `attribute` The name of the property associated with this error message
+
+```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}}
+```
+
+@class Errors
+@public
+*/
+declare class Errors extends ArrayProxyWithCustomOverrides<ValidationError> {
+  __record: {
+    currentState: RecordState;
+  };
+  /**
+	@property errorsByAttributeName
+	@type {MapWithDefault}
+	@private
+	*/
+  get errorsByAttributeName(): Map<string, NativeArray<ValidationError>>;
+  /**
+	Returns errors for a given attribute
+	
+	```javascript
+	let user = store.createRecord('user', {
+	username: 'tomster',
+	email: 'invalidEmail'
+	});
+	user.save().catch(function(){
+	user.errors.errorsFor('email'); // returns:
+	// [{attribute: "email", message: "Doesn't look like a valid email."}]
+	});
+	```
+	
+	@public
+	@param {String} attribute
+	@return {Array}
+	*/
+  errorsFor(attribute: string): NativeArray<ValidationError>;
+  /**
+	An array containing all of the error messages for this
+	record. This is useful for displaying all errors to the user.
+	
+	```handlebars
+	{{#each @model.errors.messages as |message|}}
+	<div class="error">
+	{{message}}
+	</div>
+	{{/each}}
+	```
+	
+	@property messages
+	@public
+	@type {Array}
+	*/
+  messages: string[];
+  /**
+	@property content
+	@type {Array}
+	@private
+	*/
+  get content(): NativeArray<ValidationError>;
+  /**
+	@private
+	*/
+  unknownProperty(attribute: string): NativeArray<ValidationError> | undefined;
+  /**
+	Total number of errors.
+	
+	@property length
+	@type {Number}
+	@public
+	@readonly
+	*/
+  /**
+	`true` if we have no errors.
+	
+	@property isEmpty
+	@type {Boolean}
+	@public
+	@readonly
+	*/
+  isEmpty: boolean;
+  /**
+	Manually adds errors to the record. This will trigger the `becameInvalid` event/ lifecycle method on
+	the record and transition the record into an `invalid` state.
+	
+	Example
+	```javascript
+	let errors = user.errors;
+	
+	// add multiple errors
+	errors.add('password', [
+	'Must be at least 12 characters',
+	'Must contain at least one symbol',
+	'Cannot contain your name'
+	]);
+	
+	errors.errorsFor('password');
+	// =>
+	// [
+	//   { attribute: 'password', message: 'Must be at least 12 characters' },
+	//   { attribute: 'password', message: 'Must contain at least one symbol' },
+	//   { attribute: 'password', message: 'Cannot contain your name' },
+	// ]
+	
+	// add a single error
+	errors.add('username', 'This field is required');
+	
+	errors.errorsFor('username');
+	// =>
+	// [
+	//   { attribute: 'username', message: 'This field is required' },
+	// ]
+	```
+	@public
+	@param {String} attribute - the property name of an attribute or relationship
+	@param {string[]|string} messages - an error message or array of error messages for the attribute
+	*/
+  add(attribute: string, messages: string[] | string): void;
+  /**
+	@private
+	*/
+  _findOrCreateMessages(attribute: string, messages: string | string[]): ValidationError[];
+  /**
+	Manually removes all errors for a given member from the record.
+	This will transition the record into a `valid` state, and
+	triggers the `becameValid` event and lifecycle method.
+	
+	Example:
+	
+	```javascript
+	let errors = user.errors;
+	errors.add('phone', ['error-1', 'error-2']);
+	
+	errors.errorsFor('phone');
+	// =>
+	// [
+	//   { attribute: 'phone', message: 'error-1' },
+	//   { attribute: 'phone', message: 'error-2' },
+	// ]
+	
+	errors.remove('phone');
+	
+	errors.errorsFor('phone');
+	// => undefined
+	```
+	@public
+	@param {String} member - the property name of an attribute or relationship
+	*/
+  remove(attribute: string): void;
+  /**
+	Manually clears all errors for the record.
+	This will transition the record into a `valid` state, and
+	will trigger the `becameValid` event and lifecycle method.
+	
+	Example:
+	
+	```javascript
+	let errors = user.errors;
+	errors.add('username', ['error-a']);
+	errors.add('phone', ['error-1', 'error-2']);
+	
+	errors.errorsFor('username');
+	// =>
+	// [
+	//   { attribute: 'username', message: 'error-a' },
+	// ]
+	
+	errors.errorsFor('phone');
+	// =>
+	// [
+	//   { attribute: 'phone', message: 'error-1' },
+	//   { attribute: 'phone', message: 'error-2' },
+	// ]
+	
+	errors.clear();
+	
+	errors.errorsFor('username');
+	// => undefined
+	
+	errors.errorsFor('phone');
+	// => undefined
+	
+	errors.messages
+	// => []
+	```
+	@public
+	*/
+  clear(): void;
+  /**
+	Checks if there are error messages for the given attribute.
+	
+	```js [app/controllers/user/edit.js]
+	export default class UserEditController extends Controller {
+	@action
+	save(user) {
+	if (user.errors.has('email')) {
+	return alert('Please update your email before attempting to save.');
+	}
+	user.save();
+	}
+	}
+	```
+	
+	@public
+	@param {String} attribute
+	@return {Boolean} true if there some errors on given attribute
+	*/
+  has(attribute: string): boolean;
+}
+//#endregion
+//#region src/model/-private/model.d.ts
+type ModelCreateArgs = {
+  _createProps: Record<string, unknown>;
+  _secretInit: {
+    identifier: ResourceKey;
+    store: Store;
+    cb: (record: Model, identifier: ResourceKey, store: Store) => void;
+  };
+};
+type StaticModel = typeof Model & {
+  create(options: ModelCreateArgs): Model;
+};
+type ModelFactory = {
+  class: StaticModel;
+};
+type FactoryCache = Record<string, ModelFactory>;
+type ModelStore = Store & {
+  _modelFactoryCache: FactoryCache;
+};
+interface Model {
+  /**
+   * The store service instance which created this record instance
+   */
+  store: Store;
+  /** @internal */
+  ___recordState: RecordState;
+  /** @internal */
+  ___private_notifications: object;
+  /** @internal */
+  _isReloading: boolean;
+  /** @internal */
+  [RecordStore]: Store;
+  /**
+	Create a JSON representation of the record, using the serialization
+	strategy of the store's adapter.
+	
+	`serialize` takes an optional hash as a parameter, currently
+	supported options are:
+	
+	- `includeId`: `true` if the record's ID should be included in the
+	JSON representation.
+	
+	@public
+	@param {Object} options
+	@return {Object} an object whose values are primitive JSON values only
+	*/
+  serialize<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): unknown;
+  /**
+	Same as `deleteRecord`, but saves the record immediately.
+	
+	Example
+	
+	```js
+	import Component from '@glimmer/component';
+	
+	export default class extends Component {
+	delete = () => {
+	this.args.model.destroyRecord().then(function() {
+	this.transitionToRoute('model.index');
+	});
+	}
+	}
+	```
+	
+	If you pass an object on the `adapterOptions` property of the options
+	argument it will be passed to your adapter via the snapshot
+	
+	```js
+	record.destroyRecord({ adapterOptions: { subscribe: false } });
+	```
+	
+	```js [app/adapters/post.js]
+	import MyCustomAdapter from './custom-adapter';
+	
+	export default class PostAdapter extends MyCustomAdapter {
+	deleteRecord(store, type, snapshot) {
+	if (snapshot.adapterOptions.subscribe) {
+	// ...
+	}
+	// ...
+	}
+	}
+	```
+	
+	@public
+	@param options
+	@return a promise that will be resolved when the adapter returns
+	successfully or rejected if the adapter returns with an error.
+	*/
+  destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<this>;
+  /**
+	Unloads the record from the store. This will not send a delete request
+	to your server, it just unloads the record from memory.
+	
+	@public
+	*/
+  unloadRecord<T extends MinimalLegacyRecord>(this: T): void;
+  /**
+	Returns an object, whose keys are changed properties, and value is
+	an [oldProp, newProp] array.
+	
+	The array represents the diff of the canonical state with the local state
+	of the model. Note: if the model is created locally, the canonical state is
+	empty since the adapter hasn't acknowledged the attributes yet:
+	
+	Example
+	
+	```js [app/models/mascot.js]
+	import { Model, attr } from '@warp-drive/legacy/model';
+	
+	export default class MascotModel extends Model {
+	@attr('string') name;
+	@attr('boolean', {
+	defaultValue: false
+	})
+	isAdmin;
+	}
+	```
+	
+	```javascript
+	let mascot = store.createRecord('mascot');
+	
+	mascot.changedAttributes(); // {}
+	
+	mascot.set('name', 'Tomster');
+	mascot.changedAttributes(); // { name: [undefined, 'Tomster'] }
+	
+	mascot.set('isAdmin', true);
+	mascot.changedAttributes(); // { isAdmin: [undefined, true], name: [undefined, 'Tomster'] }
+	
+	mascot.save().then(function() {
+	mascot.changedAttributes(); // {}
+	
+	mascot.set('isAdmin', false);
+	mascot.changedAttributes(); // { isAdmin: [true, false] }
+	});
+	```
+	
+	@public
+	@return {Object} an object, whose keys are changed properties,
+	and value is an [oldProp, newProp] array.
+	*/
+  changedAttributes<T extends MinimalLegacyRecord>(this: T): ChangedAttributesHash;
+  /**
+	If the model `hasDirtyAttributes` this function will discard any unsaved
+	changes. If the model `isNew` it will be removed from the store.
+	
+	Example
+	
+	```javascript
+	record.name; // 'Untitled Document'
+	record.set('name', 'Doc 1');
+	record.name; // 'Doc 1'
+	record.rollbackAttributes();
+	record.name; // 'Untitled Document'
+	```
+	
+	@since 1.13.0
+	@public
+	*/
+  rollbackAttributes<T extends MinimalLegacyRecord>(this: T): void;
+  /**
+	@private
+	*/
+  _createSnapshot<T extends MinimalLegacyRecord>(this: T): Snapshot<T>;
+  /**
+	Save the record and persist any changes to the record to an
+	external source via the adapter.
+	
+	Example
+	
+	```javascript
+	record.set('name', 'Tomster');
+	record.save().then(function() {
+	// Success callback
+	}, function() {
+	// Error callback
+	});
+	```
+	
+	If you pass an object using the `adapterOptions` property of the options
+	argument it will be passed to your adapter via the snapshot.
+	
+	```js
+	record.save({ adapterOptions: { subscribe: false } });
+	```
+	
+	```js [app/adapters/post.js]
+	import MyCustomAdapter from './custom-adapter';
+	
+	export default class PostAdapter extends MyCustomAdapter {
+	updateRecord(store, type, snapshot) {
+	if (snapshot.adapterOptions.subscribe) {
+	// ...
+	}
+	// ...
+	}
+	}
+	```
+	
+	@deprecated use {@link Store.request} instead
+	@public
+	@return a promise that will be resolved when the adapter returns
+	successfully or rejected if the adapter returns with an error.
+	*/
+  save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<this>;
+  /**
+	Reload the record from the adapter.
+	
+	This will only work if the record has already finished loading.
+	
+	Example
+	
+	```js
+	import Component from '@glimmer/component';
+	
+	export default class extends Component {
+	async reload = () => {
+	await this.args.model.reload();
+	// do something with the reloaded model
+	}
+	}
+	```
+	
+	@public
+	@param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter request
+	
+	@return {Promise} a promise that will be resolved with the record when the
+	adapter returns successfully or rejected if the adapter returns
+	with an error.
+	*/
+  reload<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+  /**
+	Get the reference for the specified belongsTo relationship.
+	
+	For instance, given the following model
+	
+	```js [app/models/blog-post.js]
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	
+	export default class BlogPost extends Model {
+	@belongsTo('user', { async: true, inverse: null }) author;
+	}
+	```
+	
+	Then the reference for the author relationship would be
+	retrieved from a record instance like so:
+	
+	```js
+	blogPost.belongsTo('author');
+	```
+	
+	A `BelongsToReference` is a low-level API that allows access
+	and manipulation of a belongsTo relationship.
+	
+	It is especially useful when you're dealing with `async` relationships
+	as it allows synchronous access to the relationship data if loaded, as
+	well as APIs for loading, reloading the data or accessing available
+	information without triggering a load.
+	
+	It may also be useful when using `sync` relationships that need to be
+	loaded/reloaded with more precise timing than marking the
+	relationship as `async` and relying on autofetch would have allowed.
+	
+	However,keep in mind that marking a relationship as `async: false` will introduce
+	bugs into your application if the data is not always guaranteed to be available
+	by the time the relationship is accessed. Ergo, it is recommended when using this
+	approach to utilize `links` for unloaded relationship state instead of identifiers.
+	
+	Reference APIs are entangled with the relationship's underlying state,
+	thus any getters or cached properties that utilize these will properly
+	invalidate if the relationship state changes.
+	
+	References are "stable", meaning that multiple calls to retrieve the reference
+	for a given relationship will always return the same HasManyReference.
+	
+	@public
+	@param prop - the name of the relationship
+	@since 2.5.0
+	@return reference for this relationship
+	*/
+  belongsTo<T extends Model, K extends keyof T & string>(this: T, prop: K & (K extends _MaybeBelongsToFields<T> ? K : never)): BelongsToReference<T, K>;
+  /**
+	Get the reference for the specified hasMany relationship.
+	
+	For instance, given the following model
+	
+	```js [app/models/blog-post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	
+	export default class BlogPost extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	
+	Then the reference for the comments relationship would be
+	retrieved from a record instance like so:
+	
+	```js
+	blogPost.hasMany('comments');
+	```
+	
+	A `HasManyReference` is a low-level API that allows access
+	and manipulation of a hasMany relationship.
+	
+	It is especially useful when you are dealing with `async` relationships
+	as it allows synchronous access to the relationship data if loaded, as
+	well as APIs for loading, reloading the data or accessing available
+	information without triggering a load.
+	
+	It may also be useful when using `sync` relationships with `@ember-data/model`
+	that need to be loaded/reloaded with more precise timing than marking the
+	relationship as `async` and relying on autofetch would have allowed.
+	
+	However,keep in mind that marking a relationship as `async: false` will introduce
+	bugs into your application if the data is not always guaranteed to be available
+	by the time the relationship is accessed. Ergo, it is recommended when using this
+	approach to utilize `links` for unloaded relationship state instead of identifiers.
+	
+	Reference APIs are entangled with the relationship's underlying state,
+	thus any getters or cached properties that utilize these will properly
+	invalidate if the relationship state changes.
+	
+	References are "stable", meaning that multiple calls to retrieve the reference
+	for a given relationship will always return the same HasManyReference.
+	
+	@public
+	@param prop - the name of the relationship
+	@since 2.5.0
+	@return reference for this relationship
+	*/
+  hasMany<T extends MinimalLegacyRecord, K extends MaybeHasManyFields<T>>(this: T, prop: K): HasManyReference<T, K>;
+  /**
+	Marks the record as deleted but does not save it. You must call
+	`save` afterwards if you want to persist it. You might use this
+	method if you want to allow the user to still `rollbackAttributes()`
+	after a delete was made.
+	
+	Example
+	
+	```js
+	import Component from '@glimmer/component';
+	
+	export default class extends Component {
+	softDelete = () => {
+	this.args.model.deleteRecord();
+	}
+	
+	confirm = () => {
+	this.args.model.save();
+	}
+	
+	undo = () => {
+	this.args.model.rollbackAttributes();
+	}
+	}
+	```
+	
+	@public
+	*/
+  deleteRecord<T extends MinimalLegacyRecord>(this: T): void;
+}
+/**
+ * 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
+ */
+declare class Model extends EmberObject implements MinimalLegacyRecord {
+  /** @internal */
+  init(options: ModelCreateArgs): void;
+  /** @private */
+  destroy(): this;
+  /**
+	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(): boolean;
+  /**
+	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
+	*/
+  get isLoading(): boolean;
+  /**
+	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
+	*/
+  get isLoaded(): boolean;
+  /**
+	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
+	*/
+  get hasDirtyAttributes(): boolean;
+  /**
+	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
+	*/
+  get isSaving(): boolean;
+  /**
+	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
+	*/
+  get isDeleted(): boolean;
+  /**
+	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
+	*/
+  get isNew(): boolean;
+  /**
+	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
+	*/
+  get isValid(): boolean;
+  /**
+	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
+	*/
+  get dirtyType(): "created" | "updated" | "deleted" | "";
+  /**
+	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
+	*/
+  get isError(): boolean;
+  /**
+   * `isError` is read-only and cannot be set directly.
+   */
+  set isError(v: boolean);
+  /**
+	If `true` the store is attempting to reload the record from the adapter.
+	
+	Example
+	
+	```javascript
+	record.isReloading; // false
+	record.reload();
+	record.isReloading; // true
+	```
+	
+	@public
+	*/
+  isReloading: boolean;
+  /**
+	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(): string | null;
+  /**
+   * Assigns the resource's primary key. Typically only used internally
+   * when a client-created record is assigned an id upon being saved.
+   */
+  set id(id: string | null);
+  toString(): string;
+  /**
+	@private
+	*/
+  get currentState(): RecordState;
+  /**
+   * `currentState` is read-only and cannot be set directly.
+   */
+  set currentState(_v: RecordState);
+  /**
+	The store service instance which created this record instance
+	
+	@public
+	*/
+  store: Store;
+  /**
+	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(): Errors;
+  /**
+	This property holds the `AdapterError` object with which
+	last adapter operation was rejected.
+	
+	@public
+	*/
+  get adapterError(): unknown;
+  /**
+   * `adapterError` is read-only and cannot be set directly.
+   */
+  set adapterError(v: unknown);
+  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
+	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<T>(callback: (this: NoInfer<T> | undefined, key: MaybeRelationshipFields<this>, meta: LegacyRelationshipField) => void, binding?: T): void;
+  /**
+   * Returns the relationship schema for the given relationship name, if any.
+   */
+  relationshipFor(name: string): LegacyRelationshipField | undefined;
+  /**
+   * Returns the inverse relationship schema for the given relationship
+   * name, if one exists. See {@link Model.inverseFor | the static inverseFor}.
+   */
+  inverseFor(name: string): LegacyRelationshipField | null;
+  /**
+   * 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<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.
+	
+	`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: string;
+  /**
+	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: string, store: Store): ModelSchema | undefined;
+  /**
+   * A cache of resolved inverse relationships by name, populated lazily by
+   * {@link Model.inverseFor | inverseFor}.
+   */
+  static get inverseMap(): Record<string, LegacyRelationshipField | 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 inverseFor(name: string, store: Store): LegacyRelationshipField | null;
+  /**
+   * @private
+   */
+  static _findInverseFor(name: string, store: Store): LegacyRelationshipField | 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(): Map<string, LegacyRelationshipField[]>;
+  /**
+	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 get relationshipNames(): {
+    /**
+     * the names of the model's `hasMany` relationships
+     */
+    hasMany: string[];
+    /**
+     * the names of the model's `belongsTo` relationships
+     */
+    belongsTo: string[];
+  };
+  /**
+	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 get relatedTypes(): string[];
+  /**
+	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 get relationshipsByName(): Map<string, LegacyRelationshipField>;
+  /**
+   * 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 get relationshipsObject(): Record<string, LegacyRelationshipField>;
+  /**
+	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 get fields(): Map<string, "attribute" | "belongsTo" | "hasMany">;
+  /**
+	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 eachRelationship<T, Schema extends Model>(callback: (this: T | undefined, key: MaybeRelationshipFields<Schema>, relationship: LegacyRelationshipField) => void, binding?: T): void;
+  /**
+	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<T>(callback: (this: T | undefined, type: string) => void, binding?: T): void;
+  /**
+   *
+   * @private
+   * @deprecated
+   */
+  static determineRelationshipType(knownSide: LegacyRelationshipField, store: Store): "oneToOne" | "oneToMany" | "manyToOne" | "manyToMany" | "oneToNone" | "manyToNone";
+  /**
+	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(): Map<string, LegacyAttributeField>;
+  /**
+	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 get transformedAttributes(): Map<string, string>;
+  /**
+	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 eachAttribute<T, Schema extends Model>(callback: (this: T | undefined, key: MaybeAttrFields<Schema>, attribute: LegacyAttributeField) => void, binding?: T): void;
+  /**
+	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<T, Schema extends Model>(callback: (this: T | undefined, key: Exclude<keyof Schema & string, keyof Model & string>, type: string) => void, binding?: T): void;
+  /**
+	Returns the name of the model class.
+	
+	@public
+	*/
+  static toString(): string;
+}
+/**
+ * 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.
+ */
+declare function restoreDeprecatedModelRequestBehaviors(ModelKlass: typeof Model): void;
+//#endregion
+export { belongsTo$1 as S, HasManyReference as _, RecordState as a, RelationshipDecorator as b, hasMany as c, MaybeHasManyFields as d, MaybeRelationshipFields as f, lookupLegacySupport as g, LEGACY_SUPPORT as h, Errors as i, BelongsToReference as l, PromiseBelongsTo as m, ModelStore as n, MinimalLegacyRecord as o, _MaybeBelongsToFields as p, restoreDeprecatedModelRequestBehaviors as r, belongsTo as s, Model as t, MaybeBelongsToFields as u, PromiseManyArray as v, RelationshipOptions as x, NoNull as y };
+//# sourceMappingURL=model-62hn5_PD.d.ts.map