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

package/dist/unpkg/dev/errors-DngRU-If.js

@@ -1,2585 +0,0 @@
-import { Context } from '@warp-drive/core/reactive/-private';
-import { memoized, defineSignal, defineNonEnumerableSignal, notifyInternalSignal } from '@warp-drive/core/signals/-leaked';
-import { assertPrivateStore, isResourceKey, recordIdentifierFor, isPrivateStore, storeFor, fastPush, createLegacyManyArray } from '@warp-drive/core/store/-private';
-import { getOrSetGlobal } from '@warp-drive/core/types/-private';
-import { EnableHydration } from '@warp-drive/core/types/request';
-import { u as upgradeStore } from "./-private-DtjBbEgy.js";
-import { computed, get } from '@ember/object';
-import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
-import ObjectProxy from '@ember/object/proxy';
-import { d as decorateMethodV2, a as decorateFieldV2, i as initializeDeferredDecorator } from "./runtime-BPCpkOf1-BKOwiRJp.js";
-import { A } from '@ember/array';
-import ArrayProxy from '@ember/array/proxy';
-import { mapBy, not } from '@ember/object/computed';
-const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
-const LegacyPromiseProxy = Symbol.for('LegacyPromiseProxy');
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-extraneous-class
-
-const Extended = PromiseObject;
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-
-/**
-  A PromiseBelongsTo is a PromiseObject that also proxies certain method calls
-  to the underlying belongsTo model.
-  Right now we proxy:
-    * `reload()`
-  @class PromiseBelongsTo
-  @private
-*/
-class PromiseBelongsTo extends Extended {
-  get id() {
-    const {
-      key,
-      legacySupport
-    } = this._belongsToState;
-    const ref = legacySupport.referenceFor('belongsTo', key);
-    return ref.id();
-  }
-
-  // we don't proxy meta because we would need to proxy it to the relationship state container
-  //  however, meta on relationships does not trigger change notifications.
-  //  if you need relationship meta, you should do `record.belongsTo(relationshipName).meta()`
-  static {
-    decorateMethodV2(this.prototype, "id", [memoized]);
-  }
-  get meta() {
-    // eslint-disable-next-line no-constant-condition
-    {
-      (test => {
-        {
-          throw new Error('You attempted to access meta on the promise for the async belongsTo relationship ' + `${this._belongsToState.modelName}:${this._belongsToState.key}'.` + '\nUse `record.belongsTo(relationshipName).meta()` instead.');
-        }
-      })();
-    }
-    return;
-  }
-  static {
-    decorateMethodV2(this.prototype, "meta", [computed()]);
-  }
-  async reload(options) {
-    (test => {
-      if (!test) {
-        throw new Error('You are trying to reload an async belongsTo before it has been created');
-      }
-    })(this.content !== undefined);
-    const {
-      key,
-      legacySupport
-    } = this._belongsToState;
-    await legacySupport.reloadBelongsTo(key, options);
-    return this;
-  }
-}
-PromiseBelongsTo.prototype[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
-*/
-class PromiseManyArray {
-  /**
-   * The promise for the relationship's content, or `null` once
-   * {@link PromiseManyArray.destroy | destroy} has been called.
-   */
-
-  /**
-   * Whether {@link PromiseManyArray.destroy | destroy} has been called.
-   */
-
-  /**
-   * The resolved `ManyArray` for the relationship, if the promise has
-   * resolved, else `null`.
-   */
-
-  constructor(promise, content) {
-    this._update(promise, content);
-    this.isDestroyed = false;
-    this[LegacyPromiseProxy] = true;
-  }
-
-  /**
-   * Retrieve the length of the content
-   * @public
-   */
-  get length() {
-    // shouldn't be needed, but ends up being needed
-    // for computed chains even in 4.x
-
-    return this.content ? this.content.length : 0;
-  }
-
-  /**
-   * @private
-   */
-  // this will error if someone tries to call
-  // A(identifierArray) since it is not configurable
-  // which is preferrable to the `meta` override we used
-  // before which required importing all of Ember
-  static {
-    decorateMethodV2(this.prototype, "length", [memoized]);
-  }
-  get '[]'() {
-    // ember-source < 3.23 (e.g. 3.20 lts)
-    // requires that the tag `'[]'` be notified
-    // on the ArrayProxy in order for `{{#each}}`
-    // to recompute. We entangle content.
-    return this.content?.length && this.content;
-  }
-
-  /**
-   * 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
-   */
-  static {
-    decorateMethodV2(this.prototype, '[]', [memoized]);
-  }
-  forEach(cb) {
-    if (this.content && this.length) {
-      this.content.forEach(cb);
-    }
-  }
-
-  /**
-   * Reload the relationship
-   * @public
-   */
-  reload(options) {
-    (test => {
-      if (!test) {
-        throw new Error('You are trying to reload an async manyArray before it has been created');
-      }
-    })(this.content);
-    void this.content.reload(options);
-    return this;
-  }
-
-  //----  Properties/Methods from the PromiseProxyMixin that we will keep as our API
-
-  /**
-   * Whether the loading promise is still pending
-   *
-   * @public
-   */
-
-  /**
-   * Whether the loading promise rejected
-   *
-   * @public
-   */
-
-  /**
-   * Whether the loading promise succeeded
-   *
-   * @public
-   */
-
-  /**
-   * Whether the loading promise completed (resolved or rejected)
-   *
-   * @public
-   */
-
-  /**
-   * chain this promise
-   *
-   * @public
-   */
-  then(success, rejected) {
-    return this.promise.then(success, rejected);
-  }
-
-  /**
-   * catch errors thrown by this promise
-   * @public
-   */
-  catch(cb) {
-    return this.promise.catch(cb);
-  }
-
-  /**
-   * run cleanup after this promise completes
-   *
-   * @public
-   */
-  finally(cb) {
-    return this.promise.finally(cb);
-  }
-
-  //---- Methods on EmberObject that we should keep
-
-  /**
-   * 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() {
-    this.isDestroyed = true;
-    this.content = null;
-    this.promise = null;
-  }
-
-  //---- Methods/Properties on ManyArray that we own and proxy to
-
-  /**
-   * Retrieve the links for this relationship
-   * @public
-   */
-  get links() {
-    return this.content ? this.content.links : undefined;
-  }
-
-  /**
-   * Retrieve the meta for this relationship
-   * @public
-   */
-  static {
-    decorateMethodV2(this.prototype, "links", [memoized]);
-  }
-  get meta() {
-    return this.content ? this.content.meta : undefined;
-  }
-
-  //---- Our own stuff
-
-  /** @internal */
-  static {
-    decorateMethodV2(this.prototype, "meta", [memoized]);
-  }
-  _update(promise, content) {
-    if (content !== undefined) {
-      this.content = content;
-    }
-    this.promise = tapPromise(this, promise);
-  }
-  static create({
-    promise,
-    content
-  }) {
-    return new this(promise, content);
-  }
-}
-defineSignal(PromiseManyArray.prototype, 'content', null);
-defineSignal(PromiseManyArray.prototype, 'isPending', false);
-defineSignal(PromiseManyArray.prototype, 'isRejected', false);
-defineSignal(PromiseManyArray.prototype, 'isFulfilled', false);
-defineSignal(PromiseManyArray.prototype, 'isSettled', false);
-function tapPromise(proxy, promise) {
-  proxy.isPending = true;
-  proxy.isSettled = false;
-  proxy.isFulfilled = false;
-  proxy.isRejected = false;
-  return Promise.resolve(promise).then(content => {
-    proxy.isPending = false;
-    proxy.isFulfilled = true;
-    proxy.isSettled = true;
-    proxy.content = content;
-    return content;
-  }, error => {
-    proxy.isPending = false;
-    proxy.isFulfilled = false;
-    proxy.isRejected = true;
-    proxy.isSettled = true;
-    throw error;
-  });
-}
-
-/*
-  Assert that `addedRecord` has a valid type so it can be added to the
-  relationship of the `record`.
-
-  The assert basically checks if the `addedRecord` can be added to the
-  relationship (specified via `relationshipMeta`) of the `record`.
-
-  This utility should only be used internally, as both record parameters must
-  be stable record identifiers and the `relationshipMeta` needs to be the meta
-  information about the relationship, retrieved via
-  `record.relationshipFor(key)`.
-*/
-let assertPolymorphicType;
-{
-  // eslint-disable-next-line @typescript-eslint/no-shadow
-  assertPolymorphicType = function assertPolymorphicType(parentIdentifier, parentDefinition, addedIdentifier, store) {
-    if (parentDefinition.inverseIsImplicit) {
-      return;
-    }
-    if (parentDefinition.isPolymorphic) {
-      const meta = store.schema.fields(addedIdentifier)?.get(parentDefinition.inverseKey);
-      if (meta) {
-        (test => {
-          if (!test) {
-            throw new Error(`Expected the schema for the field ${parentDefinition.inverseKey} on ${addedIdentifier.type} to be for a legacy relationship`);
-          }
-        })(meta.kind === 'belongsTo' || meta.kind === 'hasMany');
-        (test => {
-          if (!test) {
-            throw new Error(`The schema for the relationship '${parentDefinition.inverseKey}' on '${addedIdentifier.type}' type does not implement '${parentDefinition.type}' and thus cannot be assigned to the '${parentDefinition.key}' relationship in '${parentIdentifier.type}'. The definition should specify 'as: "${parentDefinition.type}"' in options.`);
-          }
-        })(meta?.options?.as === parentDefinition.type);
-      }
-    }
-  };
-}
-function isResourceIdentiferWithRelatedLinks$1(value) {
-  return Boolean(value && value.links && value.links.related);
-}
-/**
- 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
- */
-class HasManyReference {
-  /**
-   * The field name on the parent record for this has-many relationship.
-   *
-   * @property key
-   * @type {String}
-   * @public
-   */
-
-  /**
-   * The type of resource this relationship will contain.
-   *
-   * @property type
-   * @type {String}
-   * @public
-   */
-
-  // unsubscribe tokens given to us by the notification manager
-  ___token;
-  ___identifier;
-  ___relatedTokenMap;
-  constructor(store, graph, parentIdentifier, hasManyRelationship, key) {
-    this.graph = graph;
-    this.key = key;
-    this.hasManyRelationship = hasManyRelationship;
-    this.type = hasManyRelationship.definition.type;
-    this.store = store;
-    this.___identifier = parentIdentifier;
-    this.___token = store.notifications.subscribe(parentIdentifier, (_, bucket, notifiedKey) => {
-      if (bucket === 'relationships' && notifiedKey === key) {
-        this._ref++;
-      }
-    });
-    this.___relatedTokenMap = new Map();
-    // TODO inverse
-  }
-
-  /**
-   * This method should never be called by user code.
-   *
-   * @internal
-   */
-  destroy() {
-    this.store.notifications.unsubscribe(this.___token);
-    this.___relatedTokenMap.forEach(token => {
-      this.store.notifications.unsubscribe(token);
-    });
-    this.___relatedTokenMap.clear();
-  }
-
-  /**
-   * An array of identifiers for the records that this reference refers to.
-   *
-   * @property identifiers
-   * @type {ResourceKey[]}
-   * @public
-   */
-  get identifiers() {
-    ensureRefCanSubscribe(this);
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    this._ref;
-    const resource = this._resource();
-    const map = this.___relatedTokenMap;
-    this.___relatedTokenMap = new Map();
-    if (resource && resource.data) {
-      return resource.data.map(resourceIdentifier => {
-        const identifier = this.store.cacheKeyManager.getOrCreateRecordIdentifier(resourceIdentifier);
-        let token = map.get(identifier);
-        if (token) {
-          map.delete(identifier);
-        } else {
-          token = this.store.notifications.subscribe(identifier, (_, bucket, notifiedKey) => {
-            if (bucket === 'identity' || bucket === 'attributes' && notifiedKey === 'id') {
-              this._ref++;
-            }
-          });
-        }
-        this.___relatedTokenMap.set(identifier, token);
-        return identifier;
-      });
-    }
-    map.forEach(token => {
-      this.store.notifications.unsubscribe(token);
-    });
-    map.clear();
-    return [];
-  }
-  static {
-    decorateMethodV2(this.prototype, "identifiers", [memoized]);
-  }
-  _resource() {
-    const cache = this.store.cache;
-    return cache.getRelationship(this.___identifier, this.key);
-  }
-
-  /**
-   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() {
-    const value = this._resource();
-    if (value && value.links && value.links.related) {
-      return 'link';
-    }
-    return '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() {
-    return this.identifiers.map(identifier => identifier.id);
-  }
-
-  /**
-   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() {
-    const resource = this._resource();
-    if (isResourceIdentiferWithRelatedLinks$1(resource)) {
-      if (resource.links) {
-        const related = resource.links.related;
-        return !related || typeof related === 'string' ? related : related.href;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * any links that have been received for this relationship
-   *
-   * @public
-   * @return
-   */
-  links() {
-    const resource = this._resource();
-    return resource && resource.links ? resource.links : 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() {
-    let meta = null;
-    const resource = this._resource();
-    if (resource && resource.meta && typeof resource.meta === 'object') {
-      meta = resource.meta;
-    }
-    return meta;
-  }
-
-  /**
-   `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
-  */
-  async push(doc, skipFetch) {
-    const {
-      store
-    } = this;
-    const dataDoc = Array.isArray(doc) ? {
-      data: doc
-    } : doc;
-    const isResourceData = Array.isArray(dataDoc.data) && dataDoc.data.length > 0 && isMaybeResource(dataDoc.data[0]);
-
-    // enforce that one of links, meta or data is present
-    (test => {
-      if (!test) {
-        throw new Error(`You must provide at least one of 'links', 'meta' or 'data' when calling hasManyReference.push`);
-      }
-    })('links' in dataDoc || 'meta' in dataDoc || 'data' in dataDoc);
-    const identifiers = !Array.isArray(dataDoc.data) ? [] : isResourceData ? store._push(dataDoc, true) : dataDoc.data.map(i => store.cacheKeyManager.getOrCreateRecordIdentifier(i));
-    const {
-      identifier
-    } = this.hasManyRelationship;
-    {
-      const relationshipMeta = this.hasManyRelationship.definition;
-      identifiers.forEach(added => {
-        assertPolymorphicType(identifier, relationshipMeta, added, store);
-      });
-    }
-    const newData = {};
-    // only set data if it was passed in
-    if (Array.isArray(dataDoc.data)) {
-      newData.data = identifiers;
-    }
-    if ('links' in dataDoc) {
-      newData.links = dataDoc.links;
-    }
-    if ('meta' in dataDoc) {
-      newData.meta = dataDoc.meta;
-    }
-    assertPrivateStore(store);
-    store._join(() => {
-      this.graph.push({
-        op: 'updateRelationship',
-        record: identifier,
-        field: this.key,
-        value: newData
-      });
-    });
-    if (!skipFetch) return this.load();
-  }
-  _isLoaded() {
-    const hasRelationshipDataProperty = this.hasManyRelationship.state.hasReceivedData;
-    if (!hasRelationshipDataProperty) {
-      return false;
-    }
-    const relationship = this.graph.getData(this.hasManyRelationship.identifier, this.key);
-    return relationship.data ? relationship.data.every(identifier => {
-      assertPrivateStore(this.store);
-      return this.store._instanceCache.recordIsLoaded(identifier, true) === true;
-    }) : false;
-  }
-
-  /**
-   `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() {
-    const support = LEGACY_SUPPORT.get(this.___identifier);
-    if (!ensureRefCanSubscribe(this)) {
-      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-      this._ref;
-      return null;
-    }
-    return support.getManyArray(this.key);
-  }
-
-  /**
-   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.
-   */
-  async load(options) {
-    const support = LEGACY_SUPPORT.get(this.___identifier);
-    const fetchSyncRel = !this.hasManyRelationship.definition.isAsync && !areAllInverseRecordsLoaded(this.store, this._resource());
-    return fetchSyncRel ? support.reloadHasMany(this.key, options) :
-    // we cast to fix the return type since typescript and eslint don't understand async functions
-    // properly
-    support.getHasMany(this.key, options);
-  }
-
-  /**
-   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) {
-    const support = LEGACY_SUPPORT.get(this.___identifier);
-    return support.reloadHasMany(this.key, options);
-  }
-}
-defineNonEnumerableSignal(HasManyReference.prototype, '_ref', 0);
-function isMaybeResource(object) {
-  const keys = Object.keys(object).filter(k => k !== 'id' && k !== 'type' && k !== 'lid');
-  return keys.length > 0;
-}
-function ensureRefCanSubscribe(rel) {
-  const loaded = rel._isLoaded();
-  if (!loaded) {
-    // subscribe to changes
-    // for when we are not loaded yet
-    //
-    // because the graph optimizes the case where a relationship has never been subscribed,
-    // we force accessed to be true here. When we make the graph public we should create a
-    // subscribe/unsubscribe API
-    const edge = rel.graph.get(rel.___identifier, rel.key);
-    (test => {
-      if (!test) {
-        throw new Error(`Expected a hasMany relationship for ${rel.___identifier.type}:${rel.key}`);
-      }
-    })('accessed' in edge);
-    edge.accessed = true;
-    return false;
-  }
-  return true;
-}
-function isResourceIdentiferWithRelatedLinks(value) {
-  return Boolean(value && value.links && value.links.related);
-}
-
-/**
- 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
- */
-class BelongsToReference {
-  /**
-   * The field name on the parent record for this has-many relationship.
-   *
-   */
-
-  /**
-   * The type of resource this relationship will contain.
-   *
-   */
-
-  // unsubscribe tokens given to us by the notification manager
-
-  constructor(store, graph, parentIdentifier, belongsToRelationship, key) {
-    this.graph = graph;
-    this.key = key;
-    this.belongsToRelationship = belongsToRelationship;
-    this.type = belongsToRelationship.definition.type;
-    this.store = store;
-    this.___identifier = parentIdentifier;
-    this.___relatedToken = null;
-    this.___token = store.notifications.subscribe(parentIdentifier, (_, bucket, notifiedKey) => {
-      if (bucket === 'relationships' && notifiedKey === key) {
-        this._ref++;
-      }
-    });
-
-    // TODO inverse
-  }
-  destroy() {
-    // TODO @feature we need the notification manager often enough
-    // we should potentially just expose it fully public
-    this.store.notifications.unsubscribe(this.___token);
-    this.___token = null;
-    if (this.___relatedToken) {
-      this.store.notifications.unsubscribe(this.___relatedToken);
-      this.___relatedToken = null;
-    }
-  }
-
-  /**
-   * The identifier of the record that this reference refers to.
-   * `null` if no related record is known.
-   *
-   */
-  get identifier() {
-    if (this.___relatedToken) {
-      this.store.notifications.unsubscribe(this.___relatedToken);
-      this.___relatedToken = null;
-    }
-    const resource = this._resource();
-    if (resource && resource.data) {
-      const identifier = this.store.cacheKeyManager.getOrCreateRecordIdentifier(resource.data);
-      this.___relatedToken = this.store.notifications.subscribe(identifier, (_, bucket, notifiedKey) => {
-        if (bucket === 'identity' || bucket === 'attributes' && notifiedKey === 'id') {
-          this._ref++;
-        }
-      });
-      return identifier;
-    }
-    return 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.
-   */
-  static {
-    decorateMethodV2(this.prototype, "identifier", [memoized]);
-  }
-  id() {
-    return this.identifier?.id || 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() {
-    const resource = this._resource();
-    if (isResourceIdentiferWithRelatedLinks(resource)) {
-      if (resource.links) {
-        const related = resource.links.related;
-        return !related || typeof related === 'string' ? related : related.href;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * any links that have been received for this relationship
-   *
-   * @public
-   * @return
-   */
-  links() {
-    const resource = this._resource();
-    return resource && resource.links ? resource.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() {
-    let meta = null;
-    const resource = this._resource();
-    if (resource && resource.meta && typeof resource.meta === 'object') {
-      meta = resource.meta;
-    }
-    return meta;
-  }
-  _resource() {
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    this._ref; // subscribe
-    const cache = this.store.cache;
-    return cache.getRelationship(this.___identifier, this.key);
-  }
-
-  /**
-   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() {
-    const value = this._resource();
-    if (isResourceIdentiferWithRelatedLinks(value)) {
-      return 'link';
-    }
-    return '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.
-  */
-  async push(doc, skipFetch) {
-    const {
-      store
-    } = this;
-    const isResourceData = doc.data && isMaybeResource(doc.data);
-    const added = isResourceData ? store._push(doc, true) : doc.data ? store.cacheKeyManager.getOrCreateRecordIdentifier(doc.data) : null;
-    const {
-      identifier
-    } = this.belongsToRelationship;
-    {
-      if (added) {
-        assertPolymorphicType(identifier, this.belongsToRelationship.definition, added, store);
-      }
-    }
-    const newData = {};
-
-    // only set data if it was passed in
-    if (doc.data || doc.data === null) {
-      newData.data = added;
-    }
-    if ('links' in doc) {
-      newData.links = doc.links;
-    }
-    if ('meta' in doc) {
-      newData.meta = doc.meta;
-    }
-    assertPrivateStore(store);
-    store._join(() => {
-      this.graph.push({
-        op: 'updateRelationship',
-        record: identifier,
-        field: this.key,
-        value: newData
-      });
-    });
-    if (!skipFetch) return this.load();
-  }
-
-  /**
-   `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() {
-    const resource = this._resource();
-    return resource && resource.data ? this.store.peekRecord(resource.data) : 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.
-   */
-  async load(options) {
-    const support = LEGACY_SUPPORT.get(this.___identifier);
-    const fetchSyncRel = !this.belongsToRelationship.definition.isAsync && !areAllInverseRecordsLoaded(this.store, this._resource());
-    return fetchSyncRel ? support.reloadBelongsTo(this.key, options).then(() => this.value()) :
-    // we cast to fix the return type since typescript and eslint don't understand async functions
-    // properly
-    support.getBelongsTo(this.key, options);
-  }
-
-  /**
-   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) {
-    const support = LEGACY_SUPPORT.get(this.___identifier);
-    return support.reloadBelongsTo(this.key, options).then(() => this.value());
-  }
-}
-defineNonEnumerableSignal(BelongsToReference.prototype, '_ref', 0);
-const LEGACY_SUPPORT = getOrSetGlobal('LEGACY_SUPPORT', new Map());
-function lookupLegacySupport(record) {
-  const identifier = recordIdentifierFor(record);
-  (test => {
-    if (!test) {
-      throw new Error(`Expected a record`);
-    }
-  })(identifier);
-  let support = LEGACY_SUPPORT.get(identifier);
-  if (!support) {
-    (test => {
-      if (!test) {
-        throw new Error(`Memory Leak Detected`);
-      }
-    })(!record.isDestroyed && !record.isDestroying);
-    support = new LegacySupport(record, identifier);
-    LEGACY_SUPPORT.set(identifier, support);
-  }
-  return support;
-}
-
-/**
- * @hideconstructor
- */
-class LegacySupport {
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  /** @internal */
-
-  constructor(record, identifier) {
-    this.record = record;
-    this.store = isPrivateStore(storeFor(record, false));
-    this.identifier = identifier;
-    this.cache = this.store.cache;
-    if (this.store._graph) {
-      this.graph = this.store._graph;
-    }
-    this._manyArrayCache = Object.create(null);
-    this._relationshipPromisesCache = Object.create(null);
-    this._relationshipProxyCache = Object.create(null);
-    this._pending = Object.create(null);
-    this.references = Object.create(null);
-  }
-
-  /** @private */
-  _syncArray(array) {
-    // It’s possible the parent side of the relationship may have been destroyed by this point
-    if (this.isDestroyed || this.isDestroying) {
-      return;
-    }
-    const currentState = array[Context].source;
-    const identifier = this.identifier;
-    const [identifiers, jsonApi] = this._getCurrentState(identifier, array.key);
-    if (jsonApi.meta) {
-      array.meta = jsonApi.meta;
-    }
-    if (jsonApi.links) {
-      array.links = jsonApi.links;
-    }
-    currentState.length = 0;
-    fastPush(currentState, identifiers);
-  }
-  mutate(mutation) {
-    this.cache.mutate(mutation);
-  }
-  _findBelongsTo(key, resource, relationship, options) {
-    const name = getRealFieldName(this, key);
-
-    // TODO @runspired follow up if parent isNew then we should not be attempting load here
-    // TODO @runspired follow up on whether this should be in the relationship requests cache
-    return this._findBelongsToByJsonApiResource(resource, this.identifier, relationship, options).then(identifier => handleCompletedRelationshipRequest(this, name, relationship, identifier), e => handleCompletedRelationshipRequest(this, name, relationship, null, e));
-  }
-  reloadBelongsTo(key, options) {
-    const loadingPromise = this._relationshipPromisesCache[key];
-    if (loadingPromise) {
-      return loadingPromise;
-    }
-    const name = getRealFieldName(this, key);
-    const resource = this.store.cache.getRelationship(this.identifier, name);
-    const relationship = this.graph.get(this.identifier, name);
-    (test => {
-      if (!test) {
-        throw new Error(`Expected ${key === name ? name : `${key} (source: ${name})`} to be a belongs-to relationship`);
-      }
-    })(isBelongsTo(relationship));
-    relationship.state.hasFailedLoadAttempt = false;
-    relationship.state.shouldForceReload = true;
-    const promise = this._findBelongsTo(name, resource, relationship, options);
-    if (this._relationshipProxyCache[name]) {
-      // @ts-expect-error
-      return this._updatePromiseProxyFor('belongsTo', name, {
-        promise
-      });
-    }
-    return promise;
-  }
-  getBelongsTo(key, options) {
-    const {
-      identifier
-    } = this;
-    const name = getRealFieldName(this, key);
-    const resource = this.store.cache.getRelationship(this.identifier, name);
-    const relatedIdentifier = resource && resource.data ? resource.data : null;
-    (test => {
-      if (!test) {
-        throw new Error(`Expected a stable identifier`);
-      }
-    })(!relatedIdentifier || isResourceKey(relatedIdentifier));
-    const store = this.store;
-    const relationship = this.graph.get(this.identifier, name);
-    (test => {
-      if (!test) {
-        throw new Error(`Expected ${key === name ? name : `${key} (source: ${name})`} to be a belongs-to relationship`);
-      }
-    })(isBelongsTo(relationship));
-    const isAsync = relationship.definition.isAsync;
-    const _belongsToState = {
-      key,
-      store,
-      legacySupport: this,
-      modelName: relationship.definition.type
-    };
-    if (isAsync) {
-      if (relationship.state.hasFailedLoadAttempt) {
-        return this._relationshipProxyCache[name];
-      }
-      const promise = this._findBelongsTo(name, resource, relationship, options);
-      const isLoaded = relatedIdentifier && store._instanceCache.recordIsLoaded(relatedIdentifier);
-      return this._updatePromiseProxyFor('belongsTo', name, {
-        promise,
-        content: isLoaded ? store._instanceCache.getRecord(relatedIdentifier) : null,
-        _belongsToState
-      });
-    } else {
-      if (relatedIdentifier === null) {
-        return null;
-      } else {
-        (test => {
-          if (!test) {
-            throw new Error(`You looked up the '${key === name ? name : `${key} (source: ${name})`}' relationship on a '${identifier.type}' with id ${identifier.id || 'null'} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async (\`belongsTo(<type>, { async: true, inverse: <inverse> })\`)`);
-          }
-        })(store._instanceCache.recordIsLoaded(relatedIdentifier, true));
-        return store._instanceCache.getRecord(relatedIdentifier);
-      }
-    }
-  }
-  setDirtyBelongsTo(key, value) {
-    const name = getRealFieldName(this, key);
-    return this.cache.mutate({
-      op: 'replaceRelatedRecord',
-      record: this.identifier,
-      field: name,
-      value: extractIdentifierFromRecord(value)
-    },
-    // @ts-expect-error
-    true);
-  }
-  _getCurrentState(identifier, field) {
-    const jsonApi = this.cache.getRelationship(identifier, field);
-    const cache = this.store._instanceCache;
-    const identifiers = [];
-    if (jsonApi.data) {
-      for (let i = 0; i < jsonApi.data.length; i++) {
-        const relatedIdentifier = jsonApi.data[i];
-        (test => {
-          if (!test) {
-            throw new Error(`Expected a stable identifier`);
-          }
-        })(isResourceKey(relatedIdentifier));
-        if (cache.recordIsLoaded(relatedIdentifier, true)) {
-          identifiers.push(relatedIdentifier);
-        }
-      }
-    }
-    return [identifiers, jsonApi];
-  }
-  getManyArray(key, definition) {
-    const name = getRealFieldName(this, key);
-    if (this.graph) {
-      let manyArray = this._manyArrayCache[name];
-      if (!definition) {
-        definition = this.graph.get(this.identifier, name).definition;
-      }
-      if (!manyArray) {
-        const [identifiers, doc] = this._getCurrentState(this.identifier, name);
-        const field = getField(this, name);
-        manyArray = createLegacyManyArray({
-          store: this.store,
-          // @ts-expect-error Typescript doesn't have a way for us to thread the generic backwards so it infers unknown instead of T
-          manager: this,
-          source: identifiers,
-          type: definition.type,
-          isLoaded: !definition.isAsync,
-          editable: true,
-          isAsync: definition.isAsync,
-          isPolymorphic: definition.isPolymorphic,
-          field: field,
-          identifier: this.identifier,
-          links: doc.links || null,
-          meta: doc.meta || null
-        });
-        this._manyArrayCache[name] = manyArray;
-      }
-      return manyArray;
-    }
-    (test => {
-      {
-        throw new Error('hasMany only works with the JSONAPICache');
-      }
-    })();
-  }
-  fetchAsyncHasMany(key, relationship, manyArray, options) {
-    const name = getRealFieldName(this, key);
-    if (this.graph) {
-      let loadingPromise = this._relationshipPromisesCache[name];
-      if (loadingPromise) {
-        return loadingPromise;
-      }
-      const jsonApi = this.cache.getRelationship(this.identifier, name);
-      const promise = this._findHasManyByJsonApiResource(jsonApi, this.identifier, relationship, options);
-      if (!promise) {
-        manyArray.isLoaded = true;
-        return Promise.resolve(manyArray);
-      }
-      loadingPromise = promise.then(() => handleCompletedRelationshipRequest(this, name, relationship, manyArray), e => handleCompletedRelationshipRequest(this, name, relationship, manyArray, e));
-      this._relationshipPromisesCache[name] = loadingPromise;
-      return loadingPromise;
-    }
-    (test => {
-      {
-        throw new Error('hasMany only works with the JSONAPICache');
-      }
-    })();
-  }
-  reloadHasMany(key, options) {
-    const name = getRealFieldName(this, key);
-    if (this.graph) {
-      const loadingPromise = this._relationshipPromisesCache[name];
-      if (loadingPromise) {
-        return loadingPromise;
-      }
-      const relationship = this.graph.get(this.identifier, name);
-      const {
-        definition,
-        state
-      } = relationship;
-      state.hasFailedLoadAttempt = false;
-      state.shouldForceReload = true;
-      const manyArray = this.getManyArray(name, definition);
-      const promise = this.fetchAsyncHasMany(name, relationship, manyArray, options);
-      if (this._relationshipProxyCache[name]) {
-        return this._updatePromiseProxyFor('hasMany', name, {
-          promise
-        });
-      }
-      return promise;
-    }
-    (test => {
-      {
-        throw new Error(`hasMany only works with the JSONAPICache`);
-      }
-    })();
-  }
-  getHasMany(key, options) {
-    const name = getRealFieldName(this, key);
-    if (this.graph) {
-      const relationship = this.graph.get(this.identifier, name);
-      const {
-        definition,
-        state
-      } = relationship;
-      const manyArray = this.getManyArray(name, definition);
-      if (definition.isAsync) {
-        if (state.hasFailedLoadAttempt) {
-          return this._relationshipProxyCache[name];
-        }
-        const promise = this.fetchAsyncHasMany(name, relationship, manyArray, options);
-        return this._updatePromiseProxyFor('hasMany', name, {
-          promise,
-          content: manyArray
-        });
-      } else {
-        (test => {
-          if (!test) {
-            throw new Error(`You looked up the '${key === name ? name : `${key} (source: ${name})`}' relationship on a '${this.identifier.type}' with id ${this.identifier.id || 'null'} but some of the associated records were not loaded. Either make sure they are all loaded together with the parent record, or specify that the relationship is async ('hasMany(<type>, { async: true, inverse: <inverse> })')`);
-          }
-        })(!anyUnloaded(this.store, relationship));
-        return manyArray;
-      }
-    }
-    (test => {
-      {
-        throw new Error(`hasMany only works with the JSONAPICache`);
-      }
-    })();
-  }
-  _updatePromiseProxyFor(kind, key, args) {
-    let promiseProxy = this._relationshipProxyCache[key];
-    if (kind === 'hasMany') {
-      const {
-        promise,
-        content
-      } = args;
-      if (promiseProxy) {
-        (test => {
-          if (!test) {
-            throw new Error(`Expected a PromiseManyArray`);
-          }
-        })('_update' in promiseProxy);
-        promiseProxy._update(promise, content);
-      } else {
-        promiseProxy = this._relationshipProxyCache[key] = new PromiseManyArray(promise, content);
-      }
-      return promiseProxy;
-    }
-    if (promiseProxy) {
-      const {
-        promise,
-        content
-      } = args;
-      (test => {
-        if (!test) {
-          throw new Error(`Expected a PromiseBelongsTo`);
-        }
-      })('_belongsToState' in promiseProxy);
-      if (content !== undefined) {
-        promiseProxy.set('content', content);
-      }
-      void promiseProxy.set('promise', promise);
-    } else {
-      promiseProxy = PromiseBelongsTo.create(args);
-      this._relationshipProxyCache[key] = promiseProxy;
-    }
-    return promiseProxy;
-  }
-  referenceFor(kind, key) {
-    const name = getRealFieldName(this, key);
-    let reference = this.references[name];
-    if (!reference) {
-      if (!this.graph) {
-        // TODO @runspired while this feels odd, it is not a regression in capability because we do
-        // not today support references pulling from RecordDatas other than our own
-        // because of the intimate API access involved. This is something we will need to redesign.
-        (test => {
-          {
-            throw new Error(`snapshot.belongsTo only supported when using the JSONAPICache`);
-          }
-        })();
-      }
-      const {
-        graph,
-        identifier
-      } = this;
-      const relationship = graph.get(identifier, name);
-      {
-        if (kind) {
-          const modelName = identifier.type;
-          const actualRelationshipKind = relationship.definition.kind;
-          (test => {
-            if (!test) {
-              throw new Error(`You tried to get the '${key === name ? name : `${key} (source: ${name})`}' relationship on a '${modelName}' via record.${kind}('${key}'), but the relationship is of kind '${actualRelationshipKind}'. Use record.${actualRelationshipKind}('${key}') instead.`);
-            }
-          })(actualRelationshipKind === kind);
-        }
-      }
-      const relationshipKind = relationship.definition.kind;
-      if (relationshipKind === 'belongsTo') {
-        reference = new BelongsToReference(this.store, graph, identifier, relationship, key);
-      } else if (relationshipKind === 'hasMany') {
-        reference = new HasManyReference(this.store, graph, identifier, relationship, key);
-      }
-      this.references[name] = reference;
-    }
-    return reference;
-  }
-  _findHasManyByJsonApiResource(resource, parentIdentifier, relationship, options = {}) {
-    if (this.graph) {
-      if (!resource) {
-        return;
-      }
-      const {
-        definition,
-        state
-      } = relationship;
-      upgradeStore(this.store);
-      const adapter = this.store.adapterFor?.(definition.type);
-      const {
-        isStale,
-        hasDematerializedInverse,
-        hasReceivedData,
-        isEmpty,
-        shouldForceReload
-      } = state;
-      const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
-      const identifiers = resource.data;
-      const shouldFindViaLink = resource.links && resource.links.related && (typeof adapter?.findHasMany === 'function' || typeof identifiers === 'undefined') && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
-      const field = this.store.schema.fields({
-        type: definition.inverseType
-      }).get(definition.key);
-      (test => {
-        if (!test) {
-          throw new Error(`Expected a hasMany field definition for ${definition.inverseType}.${definition.key}`);
-        }
-      })(field && field.kind === 'hasMany');
-      const request = {
-        useLink: shouldFindViaLink,
-        field,
-        links: resource.links,
-        meta: resource.meta,
-        options,
-        record: parentIdentifier
-      };
-
-      // fetch via link
-      if (shouldFindViaLink) {
-        (test => {
-          if (!test) {
-            throw new Error(`Expected collection to be an array`);
-          }
-        })(!identifiers || Array.isArray(identifiers));
-        (test => {
-          if (!test) {
-            throw new Error(`Expected stable identifiers`);
-          }
-        })(!identifiers || identifiers.every(isResourceKey));
-        const req = field.options.linksMode ? {
-          url: getRelatedLink(resource),
-          op: 'findHasMany',
-          method: 'GET',
-          records: identifiers || [],
-          data: request,
-          [EnableHydration]: false
-        } : {
-          op: 'findHasMany',
-          records: identifiers || [],
-          data: request,
-          cacheOptions: {
-            [Symbol.for('wd:skip-cache')]: true
-          }
-        };
-        return this.store.request(req);
-      }
-      const preferLocalCache = hasReceivedData && !isEmpty;
-      const hasLocalPartialData = hasDematerializedInverse || isEmpty && Array.isArray(identifiers) && identifiers.length > 0;
-      const attemptLocalCache = !shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData);
-      if (attemptLocalCache && allInverseRecordsAreLoaded) {
-        return;
-      }
-      const hasData = hasReceivedData && !isEmpty;
-      if (attemptLocalCache || hasData || hasLocalPartialData) {
-        (test => {
-          if (!test) {
-            throw new Error(`Expected collection to be an array`);
-          }
-        })(Array.isArray(identifiers));
-        (test => {
-          if (!test) {
-            throw new Error(`Expected stable identifiers`);
-          }
-        })(identifiers.every(isResourceKey));
-        options.reload = options.reload || !attemptLocalCache || undefined;
-        return this.store.request({
-          op: 'findHasMany',
-          records: identifiers,
-          data: request,
-          cacheOptions: {
-            [Symbol.for('wd:skip-cache')]: true
-          }
-        });
-      }
-
-      // we were explicitly told we have no data and no links.
-      //   TODO if the relationshipIsStale, should we hit the adapter anyway?
-      return;
-    }
-    (test => {
-      {
-        throw new Error(`hasMany only works with the JSONAPICache`);
-      }
-    })();
-  }
-  _findBelongsToByJsonApiResource(resource, parentIdentifier, relationship, options = {}) {
-    if (!resource) {
-      return Promise.resolve(null);
-    }
-    const key = relationship.definition.key;
-    const name = getRealFieldName(this, key);
-
-    // interleaved promises mean that we MUST cache this here
-    // in order to prevent infinite re-render if the request
-    // fails.
-    if (this._pending[name]) {
-      return this._pending[name];
-    }
-    const identifier = resource.data ? resource.data : null;
-    (test => {
-      if (!test) {
-        throw new Error(`Expected a stable identifier`);
-      }
-    })(!identifier || isResourceKey(identifier));
-    const {
-      isStale,
-      hasDematerializedInverse,
-      hasReceivedData,
-      isEmpty,
-      shouldForceReload
-    } = relationship.state;
-    const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
-    const shouldFindViaLink = resource.links?.related && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
-    const field = this.store.schema.fields(this.identifier).get(relationship.definition.key);
-    (test => {
-      if (!test) {
-        throw new Error(`Attempted to access a belongsTo relationship but no definition exists for it`);
-      }
-    })(field && field.kind === 'belongsTo');
-    const request = {
-      useLink: shouldFindViaLink,
-      field,
-      links: resource.links,
-      meta: resource.meta,
-      options,
-      record: parentIdentifier
-    };
-
-    // fetch via link
-    if (shouldFindViaLink) {
-      const req = field.options.linksMode ? {
-        url: getRelatedLink(resource),
-        op: 'findBelongsTo',
-        method: 'GET',
-        records: identifier ? [identifier] : [],
-        data: request,
-        [EnableHydration]: false
-      } : {
-        op: 'findBelongsTo',
-        records: identifier ? [identifier] : [],
-        data: request,
-        cacheOptions: {
-          [Symbol.for('wd:skip-cache')]: true
-        }
-      };
-      const future = this.store.request(req);
-      this._pending[name] = future.then(doc => field.options.linksMode ? doc.content.data : doc.content).finally(() => {
-        this._pending[name] = undefined;
-      });
-      return this._pending[name];
-    }
-    const preferLocalCache = hasReceivedData && allInverseRecordsAreLoaded && !isEmpty;
-    const hasLocalPartialData = hasDematerializedInverse || isEmpty && resource.data;
-    // null is explicit empty, undefined is "we don't know anything"
-    const localDataIsEmpty = !identifier;
-    const attemptLocalCache = !shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData);
-
-    // we dont need to fetch and are empty
-    if (attemptLocalCache && localDataIsEmpty) {
-      return Promise.resolve(null);
-    }
-
-    // we dont need to fetch because we are local state
-    const resourceIsLocal = identifier?.id === null;
-    if (attemptLocalCache && allInverseRecordsAreLoaded || resourceIsLocal) {
-      return Promise.resolve(identifier);
-    }
-
-    // we may need to fetch
-    if (identifier) {
-      (test => {
-        if (!test) {
-          throw new Error(`Cannot fetch belongs-to relationship with no information`);
-        }
-      })(identifier);
-      options.reload = options.reload || !attemptLocalCache || undefined;
-      this._pending[name] = this.store.request({
-        op: 'findBelongsTo',
-        records: [identifier],
-        data: request,
-        cacheOptions: {
-          [Symbol.for('wd:skip-cache')]: true
-        }
-      }).then(doc => doc.content).finally(() => {
-        this._pending[name] = undefined;
-      });
-      return this._pending[name];
-    }
-
-    // we were explicitly told we have no data and no links.
-    //   TODO if the relationshipIsStale, should we hit the adapter anyway?
-    return Promise.resolve(null);
-  }
-  destroy() {
-    this.isDestroying = true;
-    let cache = this._manyArrayCache;
-    this._manyArrayCache = Object.create(null);
-    Object.keys(cache).forEach(key => {
-      cache[key].destroy();
-    });
-    cache = this._relationshipProxyCache;
-    this._relationshipProxyCache = Object.create(null);
-    Object.keys(cache).forEach(key => {
-      const proxy = cache[key];
-      if (proxy.destroy) {
-        proxy.destroy();
-      }
-    });
-    cache = this.references;
-    this.references = Object.create(null);
-    Object.keys(cache).forEach(key => {
-      cache[key].destroy();
-    });
-    this.isDestroyed = true;
-  }
-}
-function getRelatedLink(resource) {
-  const related = resource.links?.related;
-  (test => {
-    if (!test) {
-      throw new Error(`Expected a related link`);
-    }
-  })(related);
-  return typeof related === 'object' ? related.href : related;
-}
-function handleCompletedRelationshipRequest(recordExt, key, relationship, value, error) {
-  delete recordExt._relationshipPromisesCache[key];
-  relationship.state.shouldForceReload = false;
-  const isHasMany = relationship.definition.kind === 'hasMany';
-  if (isHasMany) {
-    // we don't notify the record property here to avoid refetch
-    // only the many array
-    notifyInternalSignal(value[Context].signal);
-  }
-  if (error) {
-    relationship.state.hasFailedLoadAttempt = true;
-    const proxy = recordExt._relationshipProxyCache[key];
-    // belongsTo relationships are sometimes unloaded
-    // when a load fails, in this case we need
-    // to make sure that we aren't proxying
-    // to destroyed content
-    // for the sync belongsTo reload case there will be no proxy
-    // for the async reload case there will be no proxy if the ui
-    // has never been accessed
-    if (proxy && !isHasMany) {
-      // @ts-expect-error unsure why this is not resolving the boolean but async belongsTo is weird
-      if (proxy.content && proxy.content.isDestroying) {
-        proxy.set('content', null);
-      }
-      recordExt.store.notifications._flush();
-    }
-    throw error;
-  }
-  if (isHasMany) {
-    value.isLoaded = true;
-  } else {
-    recordExt.store.notifications._flush();
-  }
-  relationship.state.hasFailedLoadAttempt = false;
-  // only set to not stale if no error is thrown
-  relationship.state.isStale = false;
-  return isHasMany || !value ? value : recordExt.store.peekRecord(value);
-}
-function extractIdentifierFromRecord(record) {
-  if (!record) {
-    return null;
-  }
-  return recordIdentifierFor(record);
-}
-function anyUnloaded(store, relationship) {
-  assertPrivateStore(store);
-  const graph = store._graph;
-  (test => {
-    if (!test) {
-      throw new Error(`Expected a Graph instance to be available`);
-    }
-  })(graph);
-  const relationshipData = graph.getData(relationship.identifier, relationship.definition.key);
-  const state = relationshipData.data;
-  const cache = store._instanceCache;
-  const unloaded = state?.find(s => {
-    const isLoaded = cache.recordIsLoaded(s, true);
-    return !isLoaded;
-  });
-  return unloaded || false;
-}
-function areAllInverseRecordsLoaded(store, resource) {
-  assertPrivateStore(store);
-  const instanceCache = store._instanceCache;
-  const identifiers = resource.data;
-  if (Array.isArray(identifiers)) {
-    (test => {
-      if (!test) {
-        throw new Error(`Expected stable identifiers`);
-      }
-    })(identifiers.every(isResourceKey));
-    // treat as collection
-    // check for unloaded records
-    return identifiers.every(identifier => instanceCache.recordIsLoaded(identifier));
-  }
-
-  // treat as single resource
-  if (!identifiers) return true;
-  (test => {
-    if (!test) {
-      throw new Error(`Expected stable identifiers`);
-    }
-  })(isResourceKey(identifiers));
-  return instanceCache.recordIsLoaded(identifiers);
-}
-function isBelongsTo(relationship) {
-  return relationship.definition.kind === 'belongsTo';
-}
-function getField(context, key) {
-  const {
-    identifier,
-    store
-  } = context;
-  return store.schema.fields(identifier).get(key) ?? store.schema.cacheFields?.(identifier).get(key);
-}
-function getRealFieldName(context, key) {
-  const field = getField(context, key);
-  return field ? field.sourceKey ?? field.name : key;
-}
-
-// we force the type here to our own construct because mixin and extend patterns
-// lose generic signatures. We also do this because we need to Omit `clear` from
-// the type of ArrayProxy as we override it's signature.
-const ArrayProxyWithCustomOverrides = ArrayProxy;
-
-/**
-  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
- */
-class Errors extends ArrayProxyWithCustomOverrides {
-  /**
-    @property errorsByAttributeName
-    @type {MapWithDefault}
-    @private
-  */
-  get errorsByAttributeName() {
-    return new Map();
-  }
-
-  /**
-    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}
-  */
-  static {
-    decorateMethodV2(this.prototype, "errorsByAttributeName", [computed()]);
-  }
-  errorsFor(attribute) {
-    const map = this.errorsByAttributeName;
-    let errors = map.get(attribute);
-    if (errors === undefined) {
-      errors = A();
-      map.set(attribute, errors);
-    }
-
-    // Errors may be a native array with extensions turned on. Since we access
-    // the array via a method, and not a computed or using `Ember.get`, it does
-    // not entangle properly with autotracking, so we entangle manually by
-    // getting the `[]` property.
-    get(errors, '[]');
-    return errors;
-  }
-
-  /**
-    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}
-  */
-  static {
-    decorateFieldV2(this.prototype, "messages", [mapBy('content', 'message')]);
-  }
-  #messages = (initializeDeferredDecorator(this, "messages"), void 0);
-  /**
-    @property content
-    @type {Array}
-    @private
-  */
-  get content() {
-    return A();
-  }
-
-  /**
-    @private
-  */
-  static {
-    decorateMethodV2(this.prototype, "content", [computed()]);
-  }
-  unknownProperty(attribute) {
-    const errors = this.errorsFor(attribute);
-    if (errors.length === 0) {
-      return undefined;
-    }
-    return errors;
-  }
-
-  /**
-    Total number of errors.
-     @property length
-    @type {Number}
-    @public
-    @readonly
-  */
-
-  /**
-    `true` if we have no errors.
-     @property isEmpty
-    @type {Boolean}
-    @public
-    @readonly
-  */
-  static {
-    decorateFieldV2(this.prototype, "isEmpty", [not('length')]);
-  }
-  #isEmpty = (initializeDeferredDecorator(this, "isEmpty"), void 0);
-  /**
-   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, messages) {
-    const errors = this._findOrCreateMessages(attribute, messages);
-    this.addObjects(errors);
-    this.errorsFor(attribute).addObjects(errors);
-    this.__record.currentState.notify('isValid');
-    this.notifyPropertyChange(attribute);
-  }
-
-  /**
-    @private
-  */
-  _findOrCreateMessages(attribute, messages) {
-    const errors = this.errorsFor(attribute);
-    const messagesArray = Array.isArray(messages) ? messages : [messages];
-    const _messages = new Array(messagesArray.length);
-    for (let i = 0; i < messagesArray.length; i++) {
-      const message = messagesArray[i];
-      const err = errors.findBy('message', message);
-      if (err) {
-        _messages[i] = err;
-      } else {
-        _messages[i] = {
-          attribute: attribute,
-          message
-        };
-      }
-    }
-    return _messages;
-  }
-
-  /**
-   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) {
-    if (this.isEmpty) {
-      return;
-    }
-    const content = this.rejectBy('attribute', attribute);
-    this.content.setObjects(content);
-
-    // Although errorsByAttributeName.delete is technically enough to sync errors state, we also
-    // must mutate the array as well for autotracking
-    const errors = this.errorsFor(attribute);
-    for (let i = 0; i < errors.length; i++) {
-      if (errors[i].attribute === attribute) {
-        // .replace from Ember.NativeArray is necessary. JS splice will not work.
-        errors.replace(i, 1);
-      }
-    }
-    this.errorsByAttributeName.delete(attribute);
-    this.__record.currentState.notify('isValid');
-    this.notifyPropertyChange(attribute);
-    this.notifyPropertyChange('length');
-  }
-
-  /**
-   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() {
-    if (this.isEmpty) {
-      return;
-    }
-    const errorsByAttributeName = this.errorsByAttributeName;
-    const attributes = [];
-    errorsByAttributeName.forEach(function (_, attribute) {
-      attributes.push(attribute);
-    });
-    errorsByAttributeName.clear();
-    attributes.forEach(attribute => {
-      this.notifyPropertyChange(attribute);
-    });
-    this.__record.currentState.notify('isValid');
-    super.clear();
-  }
-
-  /**
-    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) {
-    return this.errorsFor(attribute).length > 0;
-  }
-}
-export { Errors as E, LEGACY_SUPPORT as L, PromiseBelongsTo as P, PromiseManyArray as a, lookupLegacySupport as l };