@ember-data/model 4.12.0-beta.0 → 4.12.0-beta.10

package/addon/{has-many-a275fe0d.js → has-many-2eb0dc13.js}

@@ -1,20 +1,19 @@
-import { macroCondition, isDevelopingApp, getOwnConfig, importSync, moduleExists } from '@embroider/macros';
-import { assert, deprecate, warn, inspect } from '@ember/debug';
+import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
+import { assert, warn } from '@ember/debug';
 import EmberObject, { computed, get } from '@ember/object';
-import { recordIdentifierFor, storeFor } from '@ember-data/store';
-import { recordDataFor, RecordArray, MUTATE, SOURCE, recordIdentifierFor as recordIdentifierFor$1, IDENTIFIER_ARRAY_TAG, isStableIdentifier, storeFor as storeFor$1, fastPush, coerceId } from '@ember-data/store/-private';
+import { recordIdentifierFor, storeFor as storeFor$1 } from '@ember-data/store';
+import { peekCache, RecordArray, MUTATE, SOURCE, recordIdentifierFor as recordIdentifierFor$1, IDENTIFIER_ARRAY_TAG, notifyArray, isStableIdentifier, storeFor, fastPush, coerceId } from '@ember-data/store/-private';
 import { dasherize } from '@ember/string';
-import ArrayMixin, { A, NativeArray } from '@ember/array';
+import { A } from '@ember/array';
 import { singularize } from 'ember-inflector';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { run } from '@ember/runloop';
 import { cached, tracked } from '@glimmer/tracking';
 import Ember from 'ember';
-import { resolve, all } from 'rsvp';
-import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
-import ObjectProxy from '@ember/object/proxy';
 import ArrayProxy from '@ember/array/proxy';
 import { mapBy, not } from '@ember/object/computed';
+import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
+import ObjectProxy from '@ember/object/proxy';
 import { cacheFor } from '@ember/object/internals';
 import { addToTransaction, subscribe } from '@ember-data/tracking/-private';
 function isElementDescriptor(args) {
@@ -103,9 +102,7 @@ function computedMacroWithOptionalParams(fn) {
   ```
 
   ```app/transforms/text.js
-  import Transform from '@ember-data/serializer/transform';
-
-  export default class TextTransform extends Transform {
+  export default class TextTransform {
     serialize(value, options) {
       if (options.uppercase) {
         return value.toUpperCase();
@@ -117,6 +114,10 @@ function computedMacroWithOptionalParams(fn) {
     deserialize(value) {
       return value;
     }
+
+    static create() {
+      return new this();
+    }
   }
   ```
 
@@ -142,7 +143,7 @@ function attr(type, options) {
   };
   return computed({
     get(key) {
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (['currentState'].indexOf(key) !== -1) {
           throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`);
         }
@@ -150,20 +151,20 @@ function attr(type, options) {
       if (this.isDestroyed || this.isDestroying) {
         return;
       }
-      return recordDataFor(this).getAttr(recordIdentifierFor(this), key);
+      return peekCache(this).getAttr(recordIdentifierFor(this), key);
     },
     set(key, value) {
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (['currentState'].indexOf(key) !== -1) {
           throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your attr on ${this.constructor.toString()}`);
         }
       }
       assert(`Attempted to set '${key}' on the deleted record ${recordIdentifierFor(this)}`, !this.currentState.isDeleted);
       const identifier = recordIdentifierFor(this);
-      const recordData = storeFor(this)._instanceCache.getRecordData(identifier);
-      let currentValue = recordData.getAttr(identifier, key);
+      const cache = peekCache(this);
+      let currentValue = cache.getAttr(identifier, key);
       if (currentValue !== value) {
-        recordData.setAttr(identifier, key, value);
+        cache.setAttr(identifier, key, value);
         if (!this.isValid) {
           const {
             errors
@@ -211,63 +212,12 @@ function _applyDecoratedDescriptor(target, property, decorators, descriptor, con
   }
   return desc;
 }
-const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
-function promiseObject(promise) {
-  return PromiseObject.create({
-    promise: resolve(promise)
-  });
-}
-
-// constructor is accessed in some internals but not including it in the copyright for the deprecation
-const ALLOWABLE_METHODS = ['constructor', 'then', 'catch', 'finally'];
-const ALLOWABLE_PROPS = ['__ec_yieldable__', '__ec_cancel__'];
-const PROXIED_OBJECT_PROPS = ['content', 'isPending', 'isSettled', 'isRejected', 'isFulfilled', 'promise', 'reason'];
-const ProxySymbolString = String(Symbol.for('PROXY_CONTENT'));
-function deprecatedPromiseObject(promise) {
-  const promiseObjectProxy = promiseObject(promise);
-  if (macroCondition(!isDevelopingApp())) {
-    return promiseObjectProxy;
-  }
-  const handler = {
-    get(target, prop, receiver) {
-      if (typeof prop === 'symbol') {
-        if (String(prop) === ProxySymbolString) {
-          return;
-        }
-        return Reflect.get(target, prop, receiver);
-      }
-      if (prop === 'constructor') {
-        return target.constructor;
-      }
-      if (ALLOWABLE_PROPS.includes(prop)) {
-        return target[prop];
-      }
-      if (!ALLOWABLE_METHODS.includes(prop)) {
-        deprecate(`Accessing ${prop} is deprecated. The return type is being changed from PromiseObjectProxy to a Promise. The only available methods to access on this promise are .then, .catch and .finally`, false, {
-          id: 'ember-data:model-save-promise',
-          until: '5.0',
-          for: '@ember-data/store',
-          since: {
-            available: '4.4',
-            enabled: '4.4'
-          }
-        });
-      } else {
-        return target[prop].bind(target);
-      }
-      if (PROXIED_OBJECT_PROPS.includes(prop)) {
-        return target[prop];
-      }
-      const value = get(target, prop);
-      if (value && typeof value === 'function' && typeof value.bind === 'function') {
-        return value.bind(receiver);
-      }
-      return undefined;
-    }
-  };
-  return new Proxy(promiseObjectProxy, handler);
-}
 var _dec$1, _dec2, _dec3, _dec4, _class$6, _descriptor$5, _descriptor2$2;
+
+/**
+  @module @ember-data/model
+*/
+
 // 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.
@@ -632,385 +582,10 @@ let Errors = (_dec$1 = computed(), _dec2 = mapBy('content', 'message'), _dec3 =
   writable: true,
   initializer: null
 })), _class$6));
-function iterateData(data, fn) {
-  if (Array.isArray(data)) {
-    return data.map(fn);
-  } else {
-    return fn(data);
-  }
-}
-function assertIdentifierHasId(identifier) {
-  assert(`Attempted to schedule a fetch for a record without an id.`, identifier.id !== null);
-}
-function normalizeResponseHelper(serializer, store, modelClass, payload, id, requestType) {
-  let normalizedResponse = serializer ? serializer.normalizeResponse(store, modelClass, payload, id, requestType) : payload;
-  validateDocumentStructure(normalizedResponse);
-  return normalizedResponse;
-}
-function validateDocumentStructure(doc) {
-  if (macroCondition(isDevelopingApp())) {
-    let errors = [];
-    if (!doc || typeof doc !== 'object') {
-      errors.push('Top level of a JSON API document must be an object');
-    } else {
-      if (!('data' in doc) && !('errors' in doc) && !('meta' in doc)) {
-        errors.push('One or more of the following keys must be present: "data", "errors", "meta".');
-      } else {
-        if ('data' in doc && 'errors' in doc) {
-          errors.push('Top level keys "errors" and "data" cannot both be present in a JSON API document');
-        }
-      }
-      if ('data' in doc) {
-        if (!(doc.data === null || Array.isArray(doc.data) || typeof doc.data === 'object')) {
-          errors.push('data must be null, an object, or an array');
-        }
-      }
-      if ('meta' in doc) {
-        if (typeof doc.meta !== 'object') {
-          errors.push('meta must be an object');
-        }
-      }
-      if ('errors' in doc) {
-        if (!Array.isArray(doc.errors)) {
-          errors.push('errors must be an array');
-        }
-      }
-      if ('links' in doc) {
-        if (typeof doc.links !== 'object') {
-          errors.push('links must be an object');
-        }
-      }
-      if ('jsonapi' in doc) {
-        if (typeof doc.jsonapi !== 'object') {
-          errors.push('jsonapi must be an object');
-        }
-      }
-      if ('included' in doc) {
-        if (typeof doc.included !== 'object') {
-          errors.push('included must be an array');
-        }
-      }
-    }
-    assert(`Response must be normalized to a valid JSON API document:\n\t* ${errors.join('\n\t* ')}`, errors.length === 0);
-  }
-}
-function _findHasMany(adapter, store, identifier, link, relationship, options) {
-  const record = store._instanceCache.getRecord(identifier);
-  const snapshot = store._instanceCache.createSnapshot(identifier, options);
-  let modelClass = store.modelFor(relationship.type);
-  let useLink = !link || typeof link === 'string';
-  let relatedLink = useLink ? link : link.href;
-  let promise = adapter.findHasMany(store, snapshot, relatedLink, relationship);
-  let label = `DS: Handle Adapter#findHasMany of '${identifier.type}' : '${relationship.type}'`;
-  promise = guardDestroyedStore(promise, store, label);
-  promise = promise.then(adapterPayload => {
-    if (!_objectIsAlive(record)) {
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
-        deprecate(`A Promise for fetching ${relationship.type} did not resolve by the time your model was destroyed. This will error in a future release.`, false, {
-          id: 'ember-data:rsvp-unresolved-async',
-          until: '5.0',
-          for: '@ember-data/store',
-          since: {
-            available: '4.5',
-            enabled: '4.5'
-          }
-        });
-      }
-    }
-    assert(`You made a 'findHasMany' request for a ${identifier.type}'s '${relationship.key}' relationship, using link '${link}' , but the adapter's response did not have any data`, payloadIsNotBlank(adapterPayload));
-    let serializer = store.serializerFor(relationship.type);
-    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findHasMany');
-    assert(`fetched the hasMany relationship '${relationship.name}' for ${identifier.type}:${identifier.id} with link '${link}', but no data member is present in the response. If no data exists, the response should set { data: [] }`, 'data' in payload && Array.isArray(payload.data));
-    payload = syncRelationshipDataFromLink(store, payload, identifier, relationship);
-    return store._push(payload);
-  }, null, `DS: Extract payload of '${identifier.type}' : hasMany '${relationship.type}'`);
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
-    promise = _guard(promise, _bind(_objectIsAlive, record));
-  }
-  return promise;
-}
-function _findBelongsTo(store, identifier, link, relationship, options) {
-  const record = store._instanceCache.getRecord(identifier);
-  let adapter = store.adapterFor(identifier.type);
-  assert(`You tried to load a belongsTo relationship but you have no adapter (for ${identifier.type})`, adapter);
-  assert(`You tried to load a belongsTo relationship from a specified 'link' in the original payload but your adapter does not implement 'findBelongsTo'`, typeof adapter.findBelongsTo === 'function');
-  let snapshot = store._instanceCache.createSnapshot(identifier, options);
-  let modelClass = store.modelFor(relationship.type);
-  let useLink = !link || typeof link === 'string';
-  let relatedLink = useLink ? link : link.href;
-  let promise = adapter.findBelongsTo(store, snapshot, relatedLink, relationship);
-  let label = `DS: Handle Adapter#findBelongsTo of ${identifier.type} : ${relationship.type}`;
-  promise = guardDestroyedStore(promise, store, label);
-  promise = _guard(promise, _bind(_objectIsAlive, record));
-  promise = promise.then(adapterPayload => {
-    if (!_objectIsAlive(record)) {
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
-        deprecate(`A Promise for fetching ${relationship.type} did not resolve by the time your model was destroyed. This will error in a future release.`, false, {
-          id: 'ember-data:rsvp-unresolved-async',
-          until: '5.0',
-          for: '@ember-data/store',
-          since: {
-            available: '4.5',
-            enabled: '4.5'
-          }
-        });
-      }
-    }
-    let serializer = store.serializerFor(relationship.type);
-    let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, 'findBelongsTo');
-    assert(`fetched the belongsTo relationship '${relationship.name}' for ${identifier.type}:${identifier.id} with link '${link}', but no data member is present in the response. If no data exists, the response should set { data: null }`, 'data' in payload && (payload.data === null || typeof payload.data === 'object' && !Array.isArray(payload.data)));
-    if (!payload.data && !payload.links && !payload.meta) {
-      return null;
-    }
-    payload = syncRelationshipDataFromLink(store, payload, identifier, relationship);
-    return store._push(payload);
-  }, null, `DS: Extract payload of ${identifier.type} : ${relationship.type}`);
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
-    promise = _guard(promise, _bind(_objectIsAlive, record));
-  }
-  return promise;
-}
-
-// sync
-// iterate over records in payload.data
-// for each record
-//   assert that record.relationships[inverse] is either undefined (so we can fix it)
-//     or provide a data: {id, type} that matches the record that requested it
-//   return the relationship data for the parent
-function syncRelationshipDataFromLink(store, payload, parentIdentifier, relationship) {
-  // ensure the right hand side (incoming payload) points to the parent record that
-  // requested this relationship
-  let relationshipData = payload.data ? iterateData(payload.data, (data, index) => {
-    const {
-      id,
-      type
-    } = data;
-    ensureRelationshipIsSetToParent(data, parentIdentifier, store, relationship, index);
-    return {
-      id,
-      type
-    };
-  }) : null;
-  const relatedDataHash = {};
-  if ('meta' in payload) {
-    relatedDataHash.meta = payload.meta;
-  }
-  if ('links' in payload) {
-    relatedDataHash.links = payload.links;
-  }
-  if ('data' in payload) {
-    relatedDataHash.data = relationshipData;
-  }
-
-  // now, push the left hand side (the parent record) to ensure things are in sync, since
-  // the payload will be pushed with store._push
-  const parentPayload = {
-    id: parentIdentifier.id,
-    type: parentIdentifier.type,
-    relationships: {
-      [relationship.key]: relatedDataHash
-    }
-  };
-  if (!Array.isArray(payload.included)) {
-    payload.included = [];
-  }
-  payload.included.push(parentPayload);
-  return payload;
-}
-function ensureRelationshipIsSetToParent(payload, parentIdentifier, store, parentRelationship, index) {
-  let {
-    id,
-    type
-  } = payload;
-  if (!payload.relationships) {
-    payload.relationships = {};
-  }
-  let {
-    relationships
-  } = payload;
-  let inverse = getInverse(store, parentIdentifier, parentRelationship, type);
-  if (inverse) {
-    let {
-      inverseKey,
-      kind
-    } = inverse;
-    let relationshipData = relationships[inverseKey] && relationships[inverseKey].data;
-    if (macroCondition(isDevelopingApp())) {
-      if (typeof relationshipData !== 'undefined' && !relationshipDataPointsToParent(relationshipData, parentIdentifier)) {
-        let inspect = function inspect(thing) {
-          return `'${JSON.stringify(thing)}'`;
-        };
-        let quotedType = inspect(type);
-        let quotedInverse = inspect(inverseKey);
-        let expected = inspect({
-          id: parentIdentifier.id,
-          type: parentIdentifier.type
-        });
-        let expectedModel = `${parentIdentifier.type}:${parentIdentifier.id}`;
-        let got = inspect(relationshipData);
-        let prefix = typeof index === 'number' ? `data[${index}]` : `data`;
-        let path = `${prefix}.relationships.${inverseKey}.data`;
-        let other = relationshipData ? `<${relationshipData.type}:${relationshipData.id}>` : null;
-        let relationshipFetched = `${expectedModel}.${parentRelationship.kind}("${parentRelationship.name}")`;
-        let includedRecord = `<${type}:${id}>`;
-        let message = [`Encountered mismatched relationship: Ember Data expected ${path} in the payload from ${relationshipFetched} to include ${expected} but got ${got} instead.\n`, `The ${includedRecord} record loaded at ${prefix} in the payload specified ${other} as its ${quotedInverse}, but should have specified ${expectedModel} (the record the relationship is being loaded from) as its ${quotedInverse} instead.`, `This could mean that the response for ${relationshipFetched} may have accidentally returned ${quotedType} records that aren't related to ${expectedModel} and could be related to a different ${parentIdentifier.type} record instead.`, `Ember Data has corrected the ${includedRecord} record's ${quotedInverse} relationship to ${expectedModel} so that ${relationshipFetched} will include ${includedRecord}.`, `Please update the response from the server or change your serializer to either ensure that the response for only includes ${quotedType} records that specify ${expectedModel} as their ${quotedInverse}, or omit the ${quotedInverse} relationship from the response.`].join('\n');
-        assert(message);
-      }
-    }
-    if (kind !== 'hasMany' || typeof relationshipData !== 'undefined') {
-      relationships[inverseKey] = relationships[inverseKey] || {};
-      relationships[inverseKey].data = fixRelationshipData(relationshipData, kind, parentIdentifier);
-    }
-  }
-}
-function metaIsRelationshipDefinition(meta) {
-  return typeof meta._inverseKey === 'function';
-}
-function inverseForRelationship(store, identifier, key) {
-  const definition = store.getSchemaDefinitionService().relationshipsDefinitionFor(identifier)[key];
-  if (!definition) {
-    return null;
-  }
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE)) {
-    if (metaIsRelationshipDefinition(definition)) {
-      const modelClass = store.modelFor(identifier.type);
-      return definition._inverseKey(store, modelClass);
-    }
-  }
-  assert(`Expected the relationship defintion to specify the inverse type or null.`, definition.options?.inverse === null || typeof definition.options?.inverse === 'string' && definition.options.inverse.length > 0);
-  return definition.options.inverse;
-}
-function getInverse(store, parentIdentifier, parentRelationship, type) {
-  let {
-    name: lhs_relationshipName
-  } = parentRelationship;
-  let {
-    type: parentType
-  } = parentIdentifier;
-  let inverseKey = inverseForRelationship(store, {
-    type: parentType
-  }, lhs_relationshipName);
-  if (inverseKey) {
-    const definition = store.getSchemaDefinitionService().relationshipsDefinitionFor({
-      type
-    });
-    let {
-      kind
-    } = definition[inverseKey];
-    return {
-      inverseKey,
-      kind
-    };
-  }
-}
-function relationshipDataPointsToParent(relationshipData, identifier) {
-  if (relationshipData === null) {
-    return false;
-  }
-  if (Array.isArray(relationshipData)) {
-    if (relationshipData.length === 0) {
-      return false;
-    }
-    for (let i = 0; i < relationshipData.length; i++) {
-      let entry = relationshipData[i];
-      if (validateRelationshipEntry(entry, identifier)) {
-        return true;
-      }
-    }
-  } else {
-    return validateRelationshipEntry(relationshipData, identifier);
-  }
-  return false;
-}
-function fixRelationshipData(relationshipData, relationshipKind, {
-  id,
-  type
-}) {
-  let parentRelationshipData = {
-    id,
-    type
-  };
-  let payload;
-  if (relationshipKind === 'hasMany') {
-    payload = relationshipData || [];
-    if (relationshipData) {
-      // these arrays could be massive so this is better than filter
-      // Note: this is potentially problematic if type/id are not in the
-      // same state of normalization.
-      let found = relationshipData.find(v => {
-        return v.type === parentRelationshipData.type && v.id === parentRelationshipData.id;
-      });
-      if (!found) {
-        payload.push(parentRelationshipData);
-      }
-    } else {
-      payload.push(parentRelationshipData);
-    }
-  } else {
-    payload = relationshipData || {};
-    Object.assign(payload, parentRelationshipData);
-  }
-  return payload;
-}
-function validateRelationshipEntry({
-  id
-}, {
-  id: parentModelID
-}) {
-  return id && id.toString() === parentModelID;
-}
-function _bind(fn, ...args) {
-  return function () {
-    return fn.apply(undefined, args);
-  };
-}
-function _guard(promise, test) {
-  let guarded = promise.finally(() => {
-    if (!test()) {
-      guarded._subscribers.length = 0;
-    }
-  });
-  return guarded;
-}
-function _objectIsAlive(object) {
-  return !(object.isDestroyed || object.isDestroying);
-}
-function payloadIsNotBlank(adapterPayload) {
-  if (Array.isArray(adapterPayload)) {
-    return true;
-  } else {
-    return Object.keys(adapterPayload || {}).length;
-  }
-}
-function guardDestroyedStore(promise, store, label) {
-  let token;
-  if (macroCondition(isDevelopingApp())) {
-    token = store._trackAsyncRequestStart(label);
-  }
-  let wrapperPromise = resolve(promise, label).then(_v => {
-    if (!_objectIsAlive(store)) {
-      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
-        deprecate(`A Promise did not resolve by the time the store was destroyed. This will error in a future release.`, false, {
-          id: 'ember-data:rsvp-unresolved-async',
-          until: '5.0',
-          for: '@ember-data/store',
-          since: {
-            available: '4.5',
-            enabled: '4.5'
-          }
-        });
-      }
-    }
-    return promise;
-  });
-  return _guard(wrapperPromise, () => {
-    if (macroCondition(isDevelopingApp())) {
-      store._trackAsyncRequestEnd(token);
-    }
-    return _objectIsAlive(store);
-  });
-}
 
+/**
+  @module @ember-data/store
+*/
 /**
   A `ManyArray` is a `MutableArray` that represents the contents of a has-many
   relationship.
@@ -1118,7 +693,7 @@ class RelatedCollection extends RecordArray {
     switch (prop) {
       case 'length 0':
         {
-          this._manager.updateCache({
+          this._manager.mutate({
             op: 'replaceRelatedRecords',
             record: this.identifier,
             field: this.key,
@@ -1129,7 +704,7 @@ class RelatedCollection extends RecordArray {
       case 'replace cell':
         {
           const [index, prior, value] = args;
-          this._manager.updateCache({
+          this._manager.mutate({
             op: 'replaceRelatedRecord',
             record: this.identifier,
             field: this.key,
@@ -1140,7 +715,7 @@ class RelatedCollection extends RecordArray {
           break;
         }
       case 'push':
-        this._manager.updateCache({
+        this._manager.mutate({
           op: 'addToRelatedRecords',
           record: this.identifier,
           field: this.key,
@@ -1149,7 +724,7 @@ class RelatedCollection extends RecordArray {
         break;
       case 'pop':
         if (result) {
-          this._manager.updateCache({
+          this._manager.mutate({
             op: 'removeFromRelatedRecords',
             record: this.identifier,
             field: this.key,
@@ -1158,7 +733,7 @@ class RelatedCollection extends RecordArray {
         }
         break;
       case 'unshift':
-        this._manager.updateCache({
+        this._manager.mutate({
           op: 'addToRelatedRecords',
           record: this.identifier,
           field: this.key,
@@ -1168,7 +743,7 @@ class RelatedCollection extends RecordArray {
         break;
       case 'shift':
         if (result) {
-          this._manager.updateCache({
+          this._manager.mutate({
             op: 'removeFromRelatedRecords',
             record: this.identifier,
             field: this.key,
@@ -1178,7 +753,7 @@ class RelatedCollection extends RecordArray {
         }
         break;
       case 'sort':
-        this._manager.updateCache({
+        this._manager.mutate({
           op: 'sortRelatedRecords',
           record: this.identifier,
           field: this.key,
@@ -1190,7 +765,7 @@ class RelatedCollection extends RecordArray {
           const [start, removeCount, ...adds] = args;
           // detect a full replace
           if (removeCount > 0 && adds.length === this[SOURCE].length) {
-            this._manager.updateCache({
+            this._manager.mutate({
               op: 'replaceRelatedRecords',
               record: this.identifier,
               field: this.key,
@@ -1199,7 +774,7 @@ class RelatedCollection extends RecordArray {
             return;
           }
           if (removeCount > 0) {
-            this._manager.updateCache({
+            this._manager.mutate({
               op: 'removeFromRelatedRecords',
               record: this.identifier,
               field: this.key,
@@ -1208,7 +783,7 @@ class RelatedCollection extends RecordArray {
             });
           }
           if (adds?.length) {
-            this._manager.updateCache({
+            this._manager.mutate({
               op: 'addToRelatedRecords',
               record: this.identifier,
               field: this.key,
@@ -1224,8 +799,9 @@ class RelatedCollection extends RecordArray {
   }
   notify() {
     const tag = this[IDENTIFIER_ARRAY_TAG];
-    tag.ref = null;
     tag.shouldReset = true;
+    // @ts-expect-error
+    notifyArray(this);
   }
 
   /**
@@ -1277,6 +853,7 @@ class RelatedCollection extends RecordArray {
     const {
       store
     } = this;
+    assert(`Expected modelName to be set`, this.modelName);
     const record = store.createRecord(this.modelName, hash);
     this.push(record);
     return record;
@@ -1285,7 +862,7 @@ class RelatedCollection extends RecordArray {
 RelatedCollection.prototype.isAsync = false;
 RelatedCollection.prototype.isPolymorphic = false;
 RelatedCollection.prototype.identifier = null;
-RelatedCollection.prototype.recordData = null;
+RelatedCollection.prototype.cache = null;
 RelatedCollection.prototype._inverseIsAsync = false;
 RelatedCollection.prototype.key = '';
 RelatedCollection.prototype.DEPRECATED_CLASS_NAME = 'ManyArray';
@@ -1303,30 +880,14 @@ function extractIdentifiersFromRecords(records) {
   return records.map(extractIdentifierFromRecord$1);
 }
 function extractIdentifierFromRecord$1(recordOrPromiseRecord) {
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-    if (isPromiseRecord$1(recordOrPromiseRecord)) {
-      let content = recordOrPromiseRecord.content;
-      assert('You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo relationship.', content !== undefined && content !== null);
-      deprecate(`You passed in a PromiseProxy to a Relationship API that now expects a resolved value. await the value before setting it.`, false, {
-        id: 'ember-data:deprecate-promise-proxies',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        },
-        for: 'ember-data'
-      });
-      assertRecordPassedToHasMany(content);
-      return recordIdentifierFor$1(content);
-    }
-  }
   assertRecordPassedToHasMany(recordOrPromiseRecord);
   return recordIdentifierFor$1(recordOrPromiseRecord);
 }
-function isPromiseRecord$1(record) {
-  return !!record.then;
-}
+const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
 var _dec, _class$5;
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
 const Extended = PromiseObject;
 
 /**
@@ -1373,9 +934,26 @@ let PromiseBelongsTo = (_dec = computed(), (_class$5 = class PromiseBelongsTo ex
   }
 }, (_applyDecoratedDescriptor(_class$5.prototype, "id", [cached], Object.getOwnPropertyDescriptor(_class$5.prototype, "id"), _class$5.prototype), _applyDecoratedDescriptor(_class$5.prototype, "meta", [_dec], Object.getOwnPropertyDescriptor(_class$5.prototype, "meta"), _class$5.prototype)), _class$5));
 var _class$4, _descriptor$4, _descriptor2$1, _descriptor3, _descriptor4, _descriptor5;
-let PromiseManyArray = (_class$4 = class PromiseManyArray {
-  // @deprecated (isDestroyed is not deprecated)
+/**
+ @module @ember-data/model
+ */
+/**
+  This class is returned as the result of accessing an async hasMany relationship
+  on an instance of a Model extending from `@ember-data/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;
+  ```
+
+  @class PromiseManyArray
+  @public
+*/
+let PromiseManyArray = (_class$4 = class PromiseManyArray {
   constructor(promise, content) {
     //---- Methods/Properties on ArrayProxy that we will keep as our API
     _initializerDefineProperty(this, "content", _descriptor$4, this);
@@ -1410,26 +988,7 @@ let PromiseManyArray = (_class$4 = class PromiseManyArray {
     _initializerDefineProperty(this, "isSettled", _descriptor5, this);
     this._update(promise, content);
     this.isDestroyed = false;
-    this.isDestroying = false;
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_A_USAGE)) {
-      const meta = Ember.meta(this);
-      meta.hasMixin = mixin => {
-        deprecate(`Do not use A() on an EmberData PromiseManyArray`, false, {
-          id: 'ember-data:no-a-with-array-like',
-          until: '5.0',
-          since: {
-            enabled: '4.7',
-            available: '4.7'
-          },
-          for: 'ember-data'
-        });
-        // @ts-expect-error ArrayMixin is more than a type
-        if (mixin === NativeArray || mixin === ArrayMixin) {
-          return true;
-        }
-        return false;
-      };
-    } else if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       const meta = Ember.meta(this);
       meta.hasMixin = mixin => {
         assert(`Do not use A() on an EmberData PromiseManyArray`);
@@ -1527,7 +1086,6 @@ let PromiseManyArray = (_class$4 = class PromiseManyArray {
   //---- Methods on EmberObject that we should keep
 
   destroy() {
-    this.isDestroying = true;
     this.isDestroyed = true;
     this.content = null;
     this.promise = null;
@@ -1603,55 +1161,12 @@ let PromiseManyArray = (_class$4 = class PromiseManyArray {
     return false;
   }
 }), _applyDecoratedDescriptor(_class$4.prototype, "links", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$4.prototype, "links"), _class$4.prototype), _applyDecoratedDescriptor(_class$4.prototype, "meta", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class$4.prototype, "meta"), _class$4.prototype)), _class$4);
-if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_MANY_ARRAY_BEHAVIORS)) {
-  PromiseManyArray.prototype.createRecord = function createRecord(...args) {
-    deprecate(`The createRecord method on ember-data's PromiseManyArray is deprecated. await the promise and work with the ManyArray directly.`, false, {
-      id: 'ember-data:deprecate-promise-many-array-behaviors',
-      until: '5.0',
-      since: {
-        enabled: '4.7',
-        available: '4.7'
-      },
-      for: 'ember-data'
-    });
-    assert('You are trying to createRecord on an async manyArray before it has been created', this.content);
-    return this.content.createRecord(...args);
-  };
-  Object.defineProperty(PromiseManyArray.prototype, 'firstObject', {
-    get() {
-      deprecate(`The firstObject property on ember-data's PromiseManyArray is deprecated. await the promise and work with the ManyArray directly.`, false, {
-        id: 'ember-data:deprecate-promise-many-array-behaviors',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        },
-        for: 'ember-data'
-      });
-      return this.content ? this.content.firstObject : undefined;
-    }
-  });
-  Object.defineProperty(PromiseManyArray.prototype, 'lastObject', {
-    get() {
-      deprecate(`The lastObject property on ember-data's PromiseManyArray is deprecated. await the promise and work with the ManyArray directly.`, false, {
-        id: 'ember-data:deprecate-promise-many-array-behaviors',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        },
-        for: 'ember-data'
-      });
-      return this.content ? this.content.lastObject : undefined;
-    }
-  });
-}
 function tapPromise(proxy, promise) {
   proxy.isPending = true;
   proxy.isSettled = false;
   proxy.isFulfilled = false;
   proxy.isRejected = false;
-  return resolve(promise).then(content => {
+  return Promise.resolve(promise).then(content => {
     proxy.isPending = false;
     proxy.isFulfilled = true;
     proxy.isSettled = true;
@@ -1665,41 +1180,6 @@ function tapPromise(proxy, promise) {
     throw error;
   });
 }
-if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_MANY_ARRAY_BEHAVIORS)) {
-  const EmberObjectMethods = ['addObserver', 'cacheFor', 'decrementProperty', 'get', 'getProperties', 'incrementProperty', 'notifyPropertyChange', 'removeObserver', 'set', 'setProperties', 'toggleProperty'];
-  EmberObjectMethods.forEach(method => {
-    PromiseManyArray.prototype[method] = function delegatedMethod(...args) {
-      deprecate(`The ${method} method on ember-data's PromiseManyArray is deprecated. await the promise and work with the ManyArray directly.`, false, {
-        id: 'ember-data:deprecate-promise-many-array-behaviors',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        },
-        for: 'ember-data'
-      });
-      return Ember[method](this, ...args);
-    };
-  });
-  const InheritedProxyMethods = ['addArrayObserver', 'addObject', 'addObjects', 'any', 'arrayContentDidChange', 'arrayContentWillChange', 'clear', 'compact', 'every', 'filter', 'filterBy', 'find', 'findBy', 'getEach', 'includes', 'indexOf', 'insertAt', 'invoke', 'isAny', 'isEvery', 'lastIndexOf', 'map', 'mapBy',
-  // TODO update RFC to note objectAt was deprecated (forEach was left for iteration)
-  'objectAt', 'objectsAt', 'popObject', 'pushObject', 'pushObjects', 'reduce', 'reject', 'rejectBy', 'removeArrayObserver', 'removeAt', 'removeObject', 'removeObjects', 'replace', 'reverseObjects', 'setEach', 'setObjects', 'shiftObject', 'slice', 'sortBy', 'toArray', 'uniq', 'uniqBy', 'unshiftObject', 'unshiftObjects', 'without'];
-  InheritedProxyMethods.forEach(method => {
-    PromiseManyArray.prototype[method] = function proxiedMethod(...args) {
-      deprecate(`The ${method} method on ember-data's PromiseManyArray is deprecated. await the promise and work with the ManyArray directly.`, false, {
-        id: 'ember-data:deprecate-promise-many-array-behaviors',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        },
-        for: 'ember-data'
-      });
-      assert(`Cannot call ${method} before content is assigned.`, this.content);
-      return this.content[method](...args);
-    };
-  });
-}
 
 /*
   Assert that `addedRecord` has a valid type so it can be added to the
@@ -1714,40 +1194,14 @@ if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_MANY_ARRAY_BEHA
   `record.relationshipFor(key)`.
 */
 let assertPolymorphicType;
-if (macroCondition(isDevelopingApp())) {
-  let checkPolymorphic = function checkPolymorphic(modelClass, addedModelClass) {
-    if (modelClass.__isMixin) {
-      return modelClass.__mixin.detect(addedModelClass.PrototypeMixin) ||
-      // handle native class extension e.g. `class Post extends Model.extend(Commentable) {}`
-      modelClass.__mixin.detect(Object.getPrototypeOf(addedModelClass).PrototypeMixin);
-    }
-    return addedModelClass.prototype instanceof modelClass || modelClass.detect(addedModelClass);
-  };
+if (macroCondition(getOwnConfig().env.DEBUG)) {
   assertPolymorphicType = function assertPolymorphicType(parentIdentifier, parentDefinition, addedIdentifier, store) {
-    let asserted = false;
     if (parentDefinition.inverseIsImplicit) {
       return;
     }
     if (parentDefinition.isPolymorphic) {
       let meta = store.getSchemaDefinitionService().relationshipsDefinitionFor(addedIdentifier)[parentDefinition.inverseKey];
-      if (meta?.options?.as) {
-        asserted = true;
-        assert(`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);
-      }
-    }
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_EXPLICIT_POLYMORPHISM)) {
-      if (!asserted) {
-        store = store._store ? store._store : store; // allow usage with storeWrapper
-        let addedModelName = addedIdentifier.type;
-        let parentModelName = parentIdentifier.type;
-        let key = parentDefinition.key;
-        let relationshipModelName = parentDefinition.type;
-        let relationshipClass = store.modelFor(relationshipModelName);
-        let addedClass = store.modelFor(addedModelName);
-        let assertionMessage = `The '${addedModelName}' type does not implement '${relationshipModelName}' and thus cannot be assigned to the '${key}' relationship in '${parentModelName}'. Make it a descendant of '${relationshipModelName}' or use a mixin of the same name.`;
-        let isPolymorphic = checkPolymorphic(relationshipClass, addedClass);
-        assert(assertionMessage, isPolymorphic);
-      }
+      assert(`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);
     }
   };
 }
@@ -1966,7 +1420,8 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
   }
   _resource() {
     this._ref; // subscribe
-    return this.store._instanceCache.getRecordData(this.___identifier).getRelationship(this.___identifier, this.key);
+    const cache = this.store.cache;
+    return cache.getRelationship(this.___identifier, this.key);
   }
 
   /**
@@ -2049,29 +1504,13 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
    ```
     @method push
     @public
-   @param {Object|Promise} objectOrPromise a promise that resolves to a JSONAPI document object describing the new value of this relationship.
+   @param {Object} object a JSONAPI document object describing the new value of this relationship.
    @return {Promise<record>} A promise that resolves with the new value in this belongs-to relationship.
    */
-  async push(data) {
+  push(data) {
     let jsonApiDoc = data;
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-      if (data.then) {
-        jsonApiDoc = await resolve(data);
-        if (jsonApiDoc !== data) {
-          deprecate(`You passed in a Promise to a Reference API that now expects a resolved value. await the value before setting it.`, false, {
-            id: 'ember-data:deprecate-promise-proxies',
-            until: '5.0',
-            since: {
-              enabled: '4.7',
-              available: '4.7'
-            },
-            for: 'ember-data'
-          });
-        }
-      }
-    }
     let record = this.store.push(jsonApiDoc);
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-call
       assertPolymorphicType(this.belongsToRelationship.identifier, this.belongsToRelationship.definition, recordIdentifierFor$1(record), this.store);
     }
@@ -2086,7 +1525,7 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
         value: recordIdentifierFor$1(record)
       });
     });
-    return record;
+    return Promise.resolve(record);
   }
 
   /**
@@ -2331,7 +1770,8 @@ let HasManyReference = (_class$2 = class HasManyReference {
     return [];
   }
   _resource() {
-    return this.store._instanceCache.getRecordData(this.___identifier).getRelationship(this.___identifier, this.key);
+    const cache = this.store.cache;
+    return cache.getRelationship(this.___identifier, this.key);
   }
 
   /**
@@ -2546,22 +1986,6 @@ let HasManyReference = (_class$2 = class HasManyReference {
    */
   async push(objectOrPromise) {
     let payload = objectOrPromise;
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-      if (objectOrPromise.then) {
-        payload = await resolve(objectOrPromise);
-        if (payload !== objectOrPromise) {
-          deprecate(`You passed in a Promise to a Reference API that now expects a resolved value. await the value before setting it.`, false, {
-            id: 'ember-data:deprecate-promise-proxies',
-            until: '5.0',
-            since: {
-              enabled: '4.7',
-              available: '4.7'
-            },
-            for: 'ember-data'
-          });
-        }
-      }
-    }
     let array;
     if (!Array.isArray(payload) && typeof payload === 'object' && Array.isArray(payload.data)) {
       array = payload.data;
@@ -2581,7 +2005,7 @@ let HasManyReference = (_class$2 = class HasManyReference {
           data: obj
         });
       }
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         let relationshipMeta = this.hasManyRelationship.definition;
         let identifier = this.hasManyRelationship.identifier;
 
@@ -2774,9 +2198,9 @@ let HasManyReference = (_class$2 = class HasManyReference {
 class LegacySupport {
   constructor(record) {
     this.record = record;
-    this.store = storeFor$1(record);
+    this.store = storeFor(record);
     this.identifier = recordIdentifierFor$1(record);
-    this.recordData = this.store._instanceCache.getRecordData(this.identifier);
+    this.cache = peekCache(record);
     this._manyArrayCache = Object.create(null);
     this._relationshipPromisesCache = Object.create(null);
     this._relationshipProxyCache = Object.create(null);
@@ -2799,8 +2223,8 @@ class LegacySupport {
     currentState.length = 0;
     fastPush(currentState, identifiers);
   }
-  updateCache(operation) {
-    this.recordData.update(operation);
+  mutate(mutation) {
+    this.cache.mutate(mutation);
   }
   _findBelongsTo(key, resource, relationship, options) {
     // TODO @runspired follow up if parent isNew then we should not be attempting load here
@@ -2815,7 +2239,7 @@ class LegacySupport {
     const graphFor = importSync('@ember-data/graph/-private').graphFor;
     const relationship = graphFor(this.store).get(this.identifier, key);
     assert(`Expected ${key} to be a belongs-to relationship`, isBelongsTo(relationship));
-    let resource = this.recordData.getRelationship(this.identifier, key);
+    let resource = this.cache.getRelationship(this.identifier, key);
     relationship.state.hasFailedLoadAttempt = false;
     relationship.state.shouldForceReload = true;
     let promise = this._findBelongsTo(key, resource, relationship, options);
@@ -2829,9 +2253,9 @@ class LegacySupport {
   getBelongsTo(key, options) {
     const {
       identifier,
-      recordData
+      cache
     } = this;
-    let resource = recordData.getRelationship(this.identifier, key);
+    let resource = cache.getRelationship(this.identifier, key);
     let relatedIdentifier = resource && resource.data ? resource.data : null;
     assert(`Expected a stable identifier`, !relatedIdentifier || isStableIdentifier(relatedIdentifier));
     const store = this.store;
@@ -2867,7 +2291,7 @@ class LegacySupport {
     }
   }
   setDirtyBelongsTo(key, value) {
-    return this.recordData.update({
+    return this.cache.mutate({
       op: 'replaceRelatedRecord',
       record: this.identifier,
       field: key,
@@ -2877,7 +2301,7 @@ class LegacySupport {
     true);
   }
   _getCurrentState(identifier, field) {
-    let jsonApi = this.recordData.getRelationship(identifier, field, true);
+    let jsonApi = this.cache.getRelationship(identifier, field);
     const cache = this.store._instanceCache;
     let identifiers = [];
     if (jsonApi.data) {
@@ -2892,7 +2316,7 @@ class LegacySupport {
     return [identifiers, jsonApi];
   }
   getManyArray(key, definition) {
-    if (moduleExists("@ember-data/json-api")) {
+    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
       let manyArray = this._manyArrayCache[key];
       if (!definition) {
         const graphFor = importSync('@ember-data/graph/-private').graphFor;
@@ -2904,7 +2328,7 @@ class LegacySupport {
           store: this.store,
           type: definition.type,
           identifier: this.identifier,
-          recordData: this.recordData,
+          cache: this.cache,
           identifiers,
           key,
           meta: doc.meta || null,
@@ -2923,16 +2347,16 @@ class LegacySupport {
     assert('hasMany only works with the @ember-data/json-api package');
   }
   fetchAsyncHasMany(key, relationship, manyArray, options) {
-    if (moduleExists("@ember-data/json-api")) {
+    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
       let loadingPromise = this._relationshipPromisesCache[key];
       if (loadingPromise) {
         return loadingPromise;
       }
-      const jsonApi = this.recordData.getRelationship(this.identifier, key);
+      const jsonApi = this.cache.getRelationship(this.identifier, key);
       const promise = this._findHasManyByJsonApiResource(jsonApi, this.identifier, relationship, options);
       if (!promise) {
         manyArray.isLoaded = true;
-        return resolve(manyArray);
+        return Promise.resolve(manyArray);
       }
       loadingPromise = promise.then(() => handleCompletedRelationshipRequest(this, key, relationship, manyArray), e => handleCompletedRelationshipRequest(this, key, relationship, manyArray, e));
       this._relationshipPromisesCache[key] = loadingPromise;
@@ -2941,7 +2365,7 @@ class LegacySupport {
     assert('hasMany only works with the @ember-data/json-api package');
   }
   reloadHasMany(key, options) {
-    if (moduleExists("@ember-data/json-api")) {
+    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
       let loadingPromise = this._relationshipPromisesCache[key];
       if (loadingPromise) {
         return loadingPromise;
@@ -2966,7 +2390,7 @@ class LegacySupport {
     assert(`hasMany only works with the @ember-data/json-api package`);
   }
   getHasMany(key, options) {
-    if (moduleExists("@ember-data/json-api")) {
+    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
       const graphFor = importSync('@ember-data/graph/-private').graphFor;
       const relationship = graphFor(this.store).get(this.identifier, key);
       const {
@@ -3024,7 +2448,7 @@ class LegacySupport {
   referenceFor(kind, name) {
     let reference = this.references[name];
     if (!reference) {
-      if (!moduleExists("@ember-data/json-api")) {
+      if (macroCondition(!getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
         // 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.
@@ -3033,7 +2457,7 @@ class LegacySupport {
       const graphFor = importSync('@ember-data/graph/-private').graphFor;
       const graph = graphFor(this.store);
       const relationship = graph.get(this.identifier, name);
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (kind) {
           let modelName = this.identifier.type;
           let actualRelationshipKind = relationship.definition.kind;
@@ -3051,7 +2475,7 @@ class LegacySupport {
     return reference;
   }
   _findHasManyByJsonApiResource(resource, parentIdentifier, relationship, options = {}) {
-    if (moduleExists("@ember-data/json-api")) {
+    if (macroCondition(getOwnConfig().packages.HAS_JSON_API_PACKAGE)) {
       if (!resource) {
         return;
       }
@@ -3068,66 +2492,52 @@ class LegacySupport {
         shouldForceReload
       } = state;
       const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
-      const shouldFindViaLink = resource.links && resource.links.related && (typeof adapter.findHasMany === 'function' || typeof resource.data === 'undefined') && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
+      const identifiers = resource.data;
+      const shouldFindViaLink = resource.links && resource.links.related && (typeof adapter.findHasMany === 'function' || typeof identifiers === 'undefined') && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
+      const relationshipMeta = this.store.getSchemaDefinitionService().relationshipsDefinitionFor({
+        type: definition.inverseType
+      })[definition.key];
+      const request = {
+        useLink: shouldFindViaLink,
+        field: relationshipMeta,
+        links: resource.links,
+        meta: resource.meta,
+        options,
+        record: parentIdentifier
+      };
 
       // fetch via link
       if (shouldFindViaLink) {
-        // findHasMany, although not public, does not need to care about our upgrade relationship definitions
-        // and can stick with the public definition API for now.
-        const relationshipMeta = this.store.getSchemaDefinitionService().relationshipsDefinitionFor({
-          type: definition.inverseType
-        })[definition.key];
-        let adapter = this.store.adapterFor(parentIdentifier.type);
-
-        /*
-          If a relationship was originally populated by the adapter as a link
-          (as opposed to a list of IDs), this method is called when the
-          relationship is fetched.
-           The link (which is usually a URL) is passed through unchanged, so the
-          adapter can make whatever request it wants.
-           The usual use-case is for the server to register a URL as a link, and
-          then use that URL in the future to make a request for the relationship.
-        */
-        assert(`You tried to load a hasMany relationship but you have no adapter (for ${parentIdentifier.type})`, adapter);
-        assert(`You tried to load a hasMany relationship from a specified 'link' in the original payload but your adapter does not implement 'findHasMany'`, typeof adapter.findHasMany === 'function');
-        return _findHasMany(adapter, this.store, parentIdentifier, resource.links.related, relationshipMeta, options);
+        assert(`Expected collection to be an array`, !identifiers || Array.isArray(identifiers));
+        assert(`Expected stable identifiers`, !identifiers || identifiers.every(isStableIdentifier));
+        return this.store.request({
+          op: 'findHasMany',
+          records: identifiers || [],
+          data: request,
+          cacheOptions: {
+            [Symbol.for('ember-data:skip-cache')]: true
+          }
+        });
       }
       const preferLocalCache = hasReceivedData && !isEmpty;
-      const hasLocalPartialData = hasDematerializedInverse || isEmpty && Array.isArray(resource.data) && resource.data.length > 0;
-
-      // fetch using data, pulling from local cache if possible
-      if (!shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData)) {
-        if (allInverseRecordsAreLoaded) {
-          return;
-        }
-        assert(`Expected collection to be an array`, Array.isArray(resource.data));
-        if (allInverseRecordsAreLoaded) {
-          return;
-        }
-        let finds = new Array(resource.data.length);
-        let cache = this.store._instanceCache;
-        for (let i = 0; i < resource.data.length; i++) {
-          const identifier = resource.data[i];
-          assert(`expected a stable identifier`, isStableIdentifier(identifier));
-          finds[i] = cache._fetchDataIfNeededForIdentifier(identifier, options);
-        }
-        return all(finds);
+      const hasLocalPartialData = hasDematerializedInverse || isEmpty && Array.isArray(identifiers) && identifiers.length > 0;
+      const attemptLocalCache = !shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData);
+      if (attemptLocalCache && allInverseRecordsAreLoaded) {
+        return;
       }
-      let hasData = hasReceivedData && !isEmpty;
-
-      // fetch by data
-      if (hasData || hasLocalPartialData) {
-        const identifiers = resource.data;
+      const hasData = hasReceivedData && !isEmpty;
+      if (attemptLocalCache || hasData || hasLocalPartialData) {
         assert(`Expected collection to be an array`, Array.isArray(identifiers));
         assert(`Expected stable identifiers`, identifiers.every(isStableIdentifier));
-        let fetches = new Array(identifiers.length);
-        const manager = this.store._fetchManager;
-        for (let i = 0; i < identifiers.length; i++) {
-          let identifier = identifiers[i];
-          assertIdentifierHasId(identifier);
-          fetches[i] = manager.scheduleFetch(identifier, options);
-        }
-        return all(fetches);
+        options.reload = options.reload || !attemptLocalCache || undefined;
+        return this.store.request({
+          op: 'findHasMany',
+          records: identifiers,
+          data: request,
+          cacheOptions: {
+            [Symbol.for('ember-data:skip-cache')]: true
+          }
+        });
       }
 
       // we were explicitly told we have no data and no links.
@@ -3138,7 +2548,14 @@ class LegacySupport {
   }
   _findBelongsToByJsonApiResource(resource, parentIdentifier, relationship, options = {}) {
     if (!resource) {
-      return resolve(null);
+      return Promise.resolve(null);
+    }
+
+    // interleaved promises mean that we MUST cache this here
+    // in order to prevent infinite re-render if the request
+    // fails.
+    if (this._pending) {
+      return this._pending;
     }
     const identifier = resource.data ? resource.data : null;
     assert(`Expected a stable identifier`, !identifier || isStableIdentifier(identifier));
@@ -3149,53 +2566,71 @@ class LegacySupport {
       isEmpty,
       shouldForceReload
     } = relationship.state;
-
-    // short circuit if we are already loading
-    let pendingRequest = identifier && this.store._fetchManager.getPendingFetch(identifier, options);
-    if (pendingRequest) {
-      return pendingRequest;
-    }
     const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
     const shouldFindViaLink = resource.links?.related && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
+    const relationshipMeta = this.store.getSchemaDefinitionService().relationshipsDefinitionFor(this.identifier)[relationship.definition.key];
+    assert(`Attempted to access a belongsTo relationship but no definition exists for it`, relationshipMeta);
+    const request = {
+      useLink: shouldFindViaLink,
+      field: relationshipMeta,
+      links: resource.links,
+      meta: resource.meta,
+      options,
+      record: parentIdentifier
+    };
 
     // fetch via link
     if (shouldFindViaLink) {
-      const relationshipMeta = this.store.getSchemaDefinitionService().relationshipsDefinitionFor(this.identifier)[relationship.definition.key];
-      assert(`Attempted to access a belongsTo relationship but no definition exists for it`, relationshipMeta);
-      return _findBelongsTo(this.store, parentIdentifier, resource.links.related, relationshipMeta, options);
+      const future = this.store.request({
+        op: 'findBelongsTo',
+        records: identifier ? [identifier] : [],
+        data: request,
+        cacheOptions: {
+          [Symbol.for('ember-data:skip-cache')]: true
+        }
+      });
+      this._pending = future.then(doc => doc.content).finally(() => {
+        this._pending = null;
+      });
+      return this._pending;
     }
-    let preferLocalCache = hasReceivedData && allInverseRecordsAreLoaded && !isEmpty;
-    let hasLocalPartialData = hasDematerializedInverse || isEmpty && resource.data;
+    const preferLocalCache = hasReceivedData && allInverseRecordsAreLoaded && !isEmpty;
+    const hasLocalPartialData = hasDematerializedInverse || isEmpty && resource.data;
     // null is explicit empty, undefined is "we don't know anything"
-    const localDataIsEmpty = resource.data === undefined || resource.data === null;
-
-    // fetch using data, pulling from local cache if possible
-    if (!shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData)) {
-      /*
-        We have canonical data, but our local state is empty
-       */
-      if (localDataIsEmpty) {
-        return resolve(null);
-      }
-      if (!identifier) {
-        assert(`No Information found for ${resource.data.lid}`, identifier);
-      }
-      return this.store._instanceCache._fetchDataIfNeededForIdentifier(identifier, options);
-    }
-    let resourceIsLocal = !localDataIsEmpty && resource.data.id === null;
-    if (identifier && resourceIsLocal) {
-      return resolve(identifier);
-    }
-
-    // fetch by data
-    if (identifier && !localDataIsEmpty) {
-      assertIdentifierHasId(identifier);
-      return this.store._fetchManager.scheduleFetch(identifier, options);
+    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) {
+      assert(`Cannot fetch belongs-to relationship with no information`, identifier);
+      options.reload = options.reload || !attemptLocalCache || undefined;
+      this._pending = this.store.request({
+        op: 'findBelongsTo',
+        records: [identifier],
+        data: request,
+        cacheOptions: {
+          [Symbol.for('ember-data:skip-cache')]: true
+        }
+      }).then(doc => doc.content).finally(() => {
+        this._pending = null;
+      });
+      return this._pending;
     }
 
     // we were explicitly told we have no data and no links.
     //   TODO if the relationshipIsStale, should we hit the adapter anyway?
-    return resolve(null);
+    return Promise.resolve(null);
   }
   destroy() {
     this.isDestroying = true;
@@ -3244,41 +2679,25 @@ function handleCompletedRelationshipRequest(recordExt, key, relationship, value,
       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(recordOrPromiseRecord) {
-  if (!recordOrPromiseRecord) {
+function extractIdentifierFromRecord(record) {
+  if (!record) {
     return null;
   }
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_PROXIES)) {
-    if (isPromiseRecord(recordOrPromiseRecord)) {
-      let content = recordOrPromiseRecord.content;
-      assert('You passed in a promise that did not originate from an EmberData relationship. You can only pass promises that come from a belongsTo or hasMany relationship to the get call.', content !== undefined);
-      deprecate(`You passed in a PromiseProxy to a Relationship API that now expects a resolved value. await the value before setting it.`, false, {
-        id: 'ember-data:deprecate-promise-proxies',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        },
-        for: 'ember-data'
-      });
-      return content ? recordIdentifierFor$1(content) : null;
-    }
-  }
-  return recordIdentifierFor$1(recordOrPromiseRecord);
-}
-function isPromiseRecord(record) {
-  return !!record.then;
+  return recordIdentifierFor$1(record);
 }
 function anyUnloaded(store, relationship) {
   let state = relationship.localState;
@@ -3355,7 +2774,8 @@ function notifyRelationship(identifier, key, record, meta) {
 }
 function notifyAttribute(store, identifier, key, record) {
   let currentValue = cacheFor(record, key);
-  if (currentValue !== store._instanceCache.getRecordData(identifier).getAttr(identifier, key)) {
+  const cache = store.cache;
+  if (currentValue !== cache.getAttr(identifier, key)) {
     record.notifyPropertyChange(key);
   }
 }
@@ -3384,6 +2804,9 @@ let Tag = (_class$1 = class Tag {
     this.rev = 1;
     this.isDirty = true;
     this.value = undefined;
+    /*
+     * whether this was part of a transaction when mutated
+     */
     this.t = false;
   }
   notify() {
@@ -3487,11 +2910,11 @@ root
 let RecordState = (_class3 = class RecordState {
   constructor(record) {
     _initializerDefineProperty(this, "isSaving", _descriptor2, this);
-    const store = storeFor(record);
+    const store = storeFor$1(record);
     const identity = recordIdentifierFor$1(record);
     this.identifier = identity;
     this.record = record;
-    this.cache = store._instanceCache.getRecordData(identity);
+    this.cache = store.cache;
     this.pendingCount = 0;
     this.fulfilledCount = 0;
     this.rejectedCount = 0;
@@ -3551,7 +2974,7 @@ let RecordState = (_class3 = class RecordState {
 
     // we instantiate lazily
     // so we grab anything we don't have yet
-    if (macroCondition(!isDevelopingApp())) {
+    if (macroCondition(!getOwnConfig().env.DEBUG)) {
       const lastRequest = requests.getLastRequestForRecord(identity);
       if (lastRequest) {
         handleRequest(lastRequest);
@@ -3576,7 +2999,7 @@ let RecordState = (_class3 = class RecordState {
     });
   }
   destroy() {
-    storeFor(this.record).notifications.unsubscribe(this.handler);
+    storeFor$1(this.record).notifications.unsubscribe(this.handler);
   }
   notify(key) {
     getTag(this, key).notify();
@@ -3753,79 +3176,6 @@ function notifyErrorsStateChanged(state) {
   state.notify('isError');
   state.notify('adapterError');
 }
-function typeForRelationshipMeta(meta) {
-  let modelName = dasherize(meta.type || meta.key);
-  if (meta.kind === 'hasMany') {
-    modelName = singularize(modelName);
-  }
-  return modelName;
-}
-function shouldFindInverse(relationshipMeta) {
-  let options = relationshipMeta.options;
-  return !(options && options.inverse === null);
-}
-class RelationshipDefinition {
-  constructor(meta) {
-    this._type = '';
-    this.__inverseKey = '';
-    this.__hasCalculatedInverse = false;
-    this.parentModelName = meta.parentModelName;
-    this.meta = meta;
-  }
-
-  /**
-   * @internal
-   * @deprecated
-   */
-  get key() {
-    return this.meta.key;
-  }
-  get kind() {
-    return this.meta.kind;
-  }
-  get type() {
-    if (this._type) {
-      return this._type;
-    }
-    this._type = typeForRelationshipMeta(this.meta);
-    return this._type;
-  }
-  get options() {
-    return this.meta.options;
-  }
-  get name() {
-    return this.meta.name;
-  }
-  _inverseKey(store, modelClass) {
-    if (this.__hasCalculatedInverse === false) {
-      this._calculateInverse(store, modelClass);
-    }
-    return this.__inverseKey;
-  }
-  _calculateInverse(store, modelClass) {
-    this.__hasCalculatedInverse = true;
-    let inverseKey;
-    let inverse = null;
-    if (shouldFindInverse(this.meta)) {
-      inverse = modelClass.inverseFor(this.key, store);
-    }
-    // TODO make this error again for the non-polymorphic case
-    if (macroCondition(isDevelopingApp())) {
-      if (!this.options.polymorphic) {
-        modelClass.typeForRelationship(this.key, store);
-      }
-    }
-    if (inverse) {
-      inverseKey = inverse.name;
-    } else {
-      inverseKey = null;
-    }
-    this.__inverseKey = inverseKey;
-  }
-}
-function relationshipFromMeta(meta) {
-  return new RelationshipDefinition(meta);
-}
 var _class, _descriptor, _class2;
 const {
   changeProperties
@@ -3835,6 +3185,7 @@ function lookupLegacySupport(record) {
   const identifier = recordIdentifierFor(record);
   let support = LEGACY_SUPPORT.get(identifier);
   if (!support) {
+    assert(`Memory Leak Detected`, !record.isDestroyed && !record.isDestroying);
     support = new LegacySupport(record);
     LEGACY_SUPPORT.set(identifier, support);
     LEGACY_SUPPORT.set(record, support);
@@ -3893,7 +3244,7 @@ function computeOnce(target, key, desc) {
 }
 
 /**
-  Base class from which Models can be define.
+  Base class from which Models can be defined.
 
   ```js
   import Model, { attr } from '@ember-data/model';
@@ -3927,7 +3278,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     _initializerDefineProperty(this, "isReloading", _descriptor, this);
   }
   init(options = {}) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       if (!options._secretInit && !options._createProps) {
         throw new Error('You should not call `create` on a model. Instead, call `store.createRecord` with the attributes you would like to set.');
       }
@@ -3939,8 +3290,8 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     let store = this.store = _secretInit.store;
     super.init(options);
     let identity = _secretInit.identifier;
-    _secretInit.cb(this, _secretInit.recordData, identity, _secretInit.store);
-    this.___recordState = macroCondition(isDevelopingApp()) ? new RecordState(this) : null;
+    _secretInit.cb(this, _secretInit.cache, identity, _secretInit.store);
+    this.___recordState = macroCondition(getOwnConfig().env.DEBUG) ? new RecordState(this) : null;
     this.setProperties(createProps);
     let notifications = store.notifications;
     this.___private_notifications = notifications.subscribe(identity, (identifier, type, key) => {
@@ -3950,7 +3301,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
   destroy() {
     const identifier = recordIdentifierFor(this);
     this.___recordState?.destroy();
-    const store = storeFor(this);
+    const store = storeFor$1(this);
     store.notifications.unsubscribe(this.___private_notifications);
     // Legacy behavior is to notify the relationships on destroy
     // such that they "clear". It's uncertain this behavior would
@@ -4185,7 +3536,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     return this.currentState.isError;
   }
   set isError(v) {
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       throw new Error(`isError is not directly settable`);
     }
   }
@@ -4210,7 +3561,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     // this guard exists, because some dev-only deprecation code
     // (addListener via validatePropertyInjections) invokes toString before the
     // object is real.
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       try {
         return recordIdentifierFor(this).id;
       } catch {
@@ -4245,7 +3596,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     // when using legacy/classic ember classes. Basically: lazy in prod and eager in dev.
     // so we do this to try to steer folks to the nicer "dont user currentState"
     // error.
-    if (macroCondition(!isDevelopingApp())) {
+    if (macroCondition(!getOwnConfig().env.DEBUG)) {
       if (!this.___recordState) {
         this.___recordState = new RecordState(this);
       }
@@ -4341,7 +3692,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     @return {Object} an object whose values are primitive JSON values only
   */
   serialize(options) {
-    return storeFor(this)._instanceCache.createSnapshot(recordIdentifierFor(this)).serialize(options);
+    return storeFor$1(this).serializeRecord(this, options);
   }
 
   /*
@@ -4390,7 +3741,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
   deleteRecord() {
     // ensure we've populated currentState prior to deleting a new record
     if (this.currentState) {
-      storeFor(this).deleteRecord(this);
+      storeFor$1(this).deleteRecord(this);
     }
   }
 
@@ -4437,7 +3788,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     } = this.currentState;
     this.deleteRecord();
     if (isNew) {
-      return resolve(this);
+      return Promise.resolve(this);
     }
     return this.save(options).then(_ => {
       run(() => {
@@ -4457,7 +3808,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     if (this.currentState.isNew && (this.isDestroyed || this.isDestroying)) {
       return;
     }
-    storeFor(this).unloadRecord(this);
+    storeFor$1(this).unloadRecord(this);
   }
 
   /**
@@ -4513,7 +3864,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
       and value is an [oldProp, newProp] array.
   */
   changedAttributes() {
-    return recordDataFor(this).changedAttrs(recordIdentifierFor(this));
+    return peekCache(this).changedAttrs(recordIdentifierFor(this));
   }
 
   /**
@@ -4538,8 +3889,8 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     const {
       isNew
     } = currentState;
-    storeFor(this)._join(() => {
-      recordDataFor(this).rollbackAttrs(recordIdentifierFor(this));
+    storeFor$1(this)._join(() => {
+      peekCache(this).rollbackAttrs(recordIdentifierFor(this));
       this.errors.clear();
       currentState.cleanErrorRequests();
       if (isNew) {
@@ -4554,7 +3905,12 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
   */
   // TODO @deprecate in favor of a public API or examples of how to test successfully
   _createSnapshot() {
-    return storeFor(this)._instanceCache.createSnapshot(recordIdentifierFor(this));
+    const store = storeFor$1(this);
+    if (!store._fetchManager) {
+      const FetchManager = importSync('@ember-data/legacy-compat/-private').FetchManager;
+      store._fetchManager = new FetchManager(store);
+    }
+    return store._fetchManager.createSnapshot(recordIdentifierFor(this));
   }
 
   /**
@@ -4594,12 +3950,9 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
   save(options) {
     let promise;
     if (this.currentState.isNew && this.currentState.isDeleted) {
-      promise = resolve(this);
+      promise = Promise.resolve(this);
     } else {
-      promise = storeFor(this).saveRecord(this, options);
-    }
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SAVE_PROMISE_ACCESS)) {
-      return deprecatedPromiseObject(promise);
+      promise = storeFor$1(this).saveRecord(this, options);
     }
     return promise;
   }
@@ -4627,21 +3980,24 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     adapter returns successfully or rejected if the adapter returns
     with an error.
   */
-  reload(_options) {
-    let options = {};
-    if (typeof _options === 'object' && _options !== null && _options.adapterOptions) {
-      options.adapterOptions = _options.adapterOptions;
-    }
+  reload(options = {}) {
     options.isReloading = true;
-    let identifier = recordIdentifierFor(this);
+    options.reload = true;
+    const identifier = recordIdentifierFor(this);
     assert(`You cannot reload a record without an ID`, identifier.id);
     this.isReloading = true;
-    const promise = storeFor(this)._fetchManager.scheduleFetch(identifier, options).then(() => this).finally(() => {
+    const promise = storeFor$1(this).request({
+      op: 'findRecord',
+      data: {
+        options,
+        record: identifier
+      },
+      cacheOptions: {
+        [Symbol.for('ember-data:skip-cache')]: true
+      }
+    }).then(() => this).finally(() => {
       this.isReloading = false;
     });
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SAVE_PROMISE_ACCESS)) {
-      return deprecatedPromiseObject(promise);
-    }
     return promise;
   }
   attr() {
@@ -4804,11 +4160,46 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     return this.constructor.relationshipsByName.get(name);
   }
   inverseFor(key) {
-    return this.constructor.inverseFor(key, storeFor(this));
+    return this.constructor.inverseFor(key, storeFor$1(this));
   }
   eachAttribute(callback, binding) {
     this.constructor.eachAttribute(callback, binding);
   }
+
+  /**
+    Create should only ever be called by the store. To create an instance of a
+    `Model` in a dirty state use `store.createRecord`.
+    To create instances of `Model` in a clean state, use `store.push`
+     @method create
+    @private
+    @static
+  */
+  /**
+   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 Ember Data. 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);
+     }
+   });
+   ```
+   @property modelName
+    @public
+   @type String
+   @readonly
+   @static
+  */
   /*
    These class methods below provide relationship
    introspection abilities about relationships.
@@ -4822,7 +4213,6 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    do it before using your model with the store, which uses these properties
    extensively.
    */
-
   /**
    For a given relationship name, returns the model type of the relationship.
     For example, if you define a model like this:
@@ -4841,36 +4231,12 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    @return {Model} the type of the relationship, or undefined
    */
   static typeForRelationship(name, store) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     let relationship = this.relationshipsByName.get(name);
     return relationship && store.modelFor(relationship.type);
   }
   static get inverseMap() {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     return Object.create(null);
   }
 
@@ -4901,19 +4267,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    @return {Object} the inverse relationship, or null
    */
   static inverseFor(name, store) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     let inverseMap = this.inverseMap;
     if (inverseMap[name]) {
       return inverseMap[name];
@@ -4926,19 +4280,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
 
   //Calculate the inverse, ignoring the cache
   static _findInverseFor(name, store) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     const relationship = this.relationshipsByName.get(name);
     const {
       options
@@ -4976,7 +4318,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
       if (possibleRelationships.length === 0) {
         return null;
       }
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         let filteredRelationships = possibleRelationships.filter(possibleRelationship => {
           let optionsForRelationship = possibleRelationship.options;
           return name === optionsForRelationship.inverse;
@@ -4994,46 +4336,18 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     }
 
     // ensure inverse is properly configured
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       if (isPolymorphic) {
-        if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_EXPLICIT_POLYMORPHISM)) {
-          if (!inverseOptions.as) {
-            deprecate(`Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${fieldOnInverse}' on type '${inverseSchema.modelName}' is misconfigured.`, false, {
-              id: 'ember-data:non-explicit-relationships',
-              since: {
-                enabled: '4.7',
-                available: '4.7'
-              },
-              until: '5.0',
-              for: 'ember-data'
-            });
-          }
-        } else {
-          assert(`Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${fieldOnInverse}' on type '${inverseSchema.modelName}' is misconfigured.`, inverseOptions.as);
-          assert(`options.as should match the expected type of the polymorphic relationship. Expected field '${fieldOnInverse}' on type '${inverseSchema.modelName}' to specify '${relationship.type}' but found '${inverseOptions.as}'`, !!inverseOptions.as && relationship.type === inverseOptions.as);
-        }
+        assert(`Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${fieldOnInverse}' on type '${inverseSchema.modelName}' is misconfigured.`, inverseOptions.as);
+        assert(`options.as should match the expected type of the polymorphic relationship. Expected field '${fieldOnInverse}' on type '${inverseSchema.modelName}' to specify '${relationship.type}' but found '${inverseOptions.as}'`, !!inverseOptions.as && relationship.type === inverseOptions.as);
       }
     }
 
     // ensure we are properly configured
-    if (macroCondition(isDevelopingApp())) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       if (inverseOptions.polymorphic) {
-        if (macroCondition(getOwnConfig().deprecations.DEPRECATE_NON_EXPLICIT_POLYMORPHISM)) {
-          if (!options.as) {
-            deprecate(`Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${name}' on type '${this.modelName}' is misconfigured.`, false, {
-              id: 'ember-data:non-explicit-relationships',
-              since: {
-                enabled: '4.7',
-                available: '4.7'
-              },
-              until: '5.0',
-              for: 'ember-data'
-            });
-          }
-        } else {
-          assert(`Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${name}' on type '${this.modelName}' is misconfigured.`, options.as);
-          assert(`options.as should match the expected type of the polymorphic relationship. Expected field '${name}' on type '${this.modelName}' to specify '${inverseRelationship.type}' but found '${options.as}'`, !!options.as && inverseRelationship.type === options.as);
-        }
+        assert(`Relationships that satisfy polymorphic relationships MUST define which abstract-type they are satisfying using 'as'. The field '${name}' on type '${this.modelName}' is misconfigured.`, options.as);
+        assert(`options.as should match the expected type of the polymorphic relationship. Expected field '${name}' on type '${this.modelName}' to specify '${inverseRelationship.type}' but found '${options.as}'`, !!options.as && inverseRelationship.type === options.as);
       }
     }
     assert(`The ${inverseSchema.modelName}:${fieldOnInverse} relationship declares 'inverse: null', but it was resolved as the inverse for ${this.modelName}:${name}.`, inverseOptions.inverse !== null);
@@ -5081,19 +4395,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    */
 
   static get relationships() {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     let map = new Map();
     let relationshipsByName = this.relationshipsByName;
 
@@ -5139,19 +4441,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    @readOnly
    */
   static get relationshipNames() {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     let names = {
       hasMany: [],
       belongsTo: []
@@ -5182,7 +4472,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    import { get } from '@ember/object';
    import Blog from 'app/models/blog';
     let relatedTypes = Blog.relatedTypes');
-   //=> [ User, Post ]
+   //=> ['user', 'post']
    ```
     @property relatedTypes
     @public
@@ -5191,19 +4481,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    @readOnly
    */
   static get relatedTypes() {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     let types = [];
     let rels = this.relationshipsObject;
     let relationships = Object.keys(rels);
@@ -5251,43 +4529,19 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    @readOnly
    */
   static get relationshipsByName() {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     let map = new Map();
     let rels = this.relationshipsObject;
     let relationships = Object.keys(rels);
     for (let i = 0; i < relationships.length; i++) {
       let key = relationships[i];
       let value = rels[key];
-      map.set(value.key, value);
+      map.set(value.name || value.key, value);
     }
     return map;
   }
   static get relationshipsObject() {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     let relationships = Object.create(null);
     let modelName = this.modelName;
     this.eachComputedProperty((name, meta) => {
@@ -5295,7 +4549,8 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
         meta.key = name;
         meta.name = name;
         meta.parentModelName = modelName;
-        relationships[name] = macroCondition(getOwnConfig().deprecations.DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE) ? relationshipFromMeta(meta) : meta;
+        relationships[name] = meta;
+        assert(`You should not specify both options.as and options.inverse as null on ${modelName}.${meta.name}, as if there is no inverse field there is no abstract type to conform to. You may have intended for this relationship to be polymorphic, or you may have mistakenly set inverse to null.`, !(meta.options.inverse === null && meta.options.as?.length > 0));
       }
     });
     return relationships;
@@ -5335,19 +4590,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    @readOnly
    */
   static get fields() {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     let map = new Map();
     this.eachComputedProperty((name, meta) => {
       // TODO end reliance on these booleans and stop leaking them in the spec
@@ -5371,19 +4614,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    @param {any} binding the value to which the callback's `this` should be bound
    */
   static eachRelationship(callback, binding) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     this.relationshipsByName.forEach((relationship, name) => {
       callback.call(binding, name, relationship);
     });
@@ -5401,19 +4632,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    @param {any} binding the value to which the callback's `this` should be bound
    */
   static eachRelatedType(callback, binding) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     let relationshipTypes = this.relatedTypes;
     for (let i = 0; i < relationshipTypes.length; i++) {
       let type = relationshipTypes[i];
@@ -5421,19 +4640,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     }
   }
   static determineRelationshipType(knownSide, store) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     let knownKey = knownSide.key;
     let knownKind = knownSide.kind;
     let inverse = this.inverseFor(knownKey, store);
@@ -5484,19 +4691,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    @readOnly
    */
   static get attributes() {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     let map = new Map();
     this.eachComputedProperty((name, meta) => {
       if (meta.isAttribute) {
@@ -5540,19 +4735,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    @readOnly
    */
   static get transformedAttributes() {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     let map = new Map();
     this.eachAttribute((key, meta) => {
       if (meta.type) {
@@ -5597,19 +4780,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    @static
    */
   static eachAttribute(callback, binding) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     this.attributes.forEach((meta, name) => {
       callback.call(binding, name, meta);
     });
@@ -5651,19 +4822,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    @static
    */
   static eachTransformedAttribute(callback, binding) {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     this.transformedAttributes.forEach((type, name) => {
       callback.call(binding, name, type);
     });
@@ -5676,19 +4835,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
    @static
    */
   static toString() {
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_EARLY_STATIC)) {
-      deprecate(`Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`, this.modelName, {
-        id: 'ember-data:deprecate-early-static',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-    } else {
-      assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
-    }
+    assert(`Accessing schema information on Models without looking up the model via the store is disallowed.`, this.modelName);
     return `model:${this.modelName}`;
   }
 }, _class2.isModel = true, _class2.modelName = null, _class2), (_applyDecoratedDescriptor(_class.prototype, "isEmpty", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, "isEmpty"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isLoading", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, "isLoading"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isLoaded", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, "isLoaded"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "hasDirtyAttributes", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, "hasDirtyAttributes"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isSaving", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, "isSaving"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isDeleted", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, "isDeleted"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isNew", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, "isNew"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isValid", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, "isValid"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "dirtyType", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, "dirtyType"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "isError", [dependentKeyCompat], Object.getOwnPropertyDescriptor(_class.prototype, "isError"), _class.prototype), _descriptor = _applyDecoratedDescriptor(_class.prototype, "isReloading", [tracked], {
@@ -5702,7 +4849,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
 // the values initialized during create to `setUnknownProperty`
 Model.prototype._createProps = null;
 Model.prototype._secretInit = null;
-if (getOwnConfig().includeDataAdapter) {
+if (macroCondition(getOwnConfig().includeDataAdapter)) {
   /**
    Provides info about the model for debugging purposes
    by grouping the properties into more semantic groups.
@@ -5717,16 +4864,21 @@ if (getOwnConfig().includeDataAdapter) {
    @private
    */
   Model.prototype._debugInfo = function () {
-    let attributes = ['id'];
     let relationships = {};
     let expensiveProperties = [];
-    this.eachAttribute((name, meta) => attributes.push(name));
+    const identifier = recordIdentifierFor(this);
+    const schema = this.store.getSchemaDefinitionService();
+    const attrDefs = schema.attributesDefinitionFor(identifier);
+    const relDefs = schema.relationshipsDefinitionFor(identifier);
+    const attributes = Object.keys(attrDefs);
+    attributes.unshift('id');
     let groups = [{
       name: 'Attributes',
       properties: attributes,
       expand: true
     }];
-    this.eachRelationship((name, relationship) => {
+    Object.keys(relDefs).forEach(name => {
+      const relationship = relDefs[name];
       let properties = relationships[relationship.kind];
       if (properties === undefined) {
         properties = relationships[relationship.kind] = [];
@@ -5754,7 +4906,7 @@ if (getOwnConfig().includeDataAdapter) {
     };
   };
 }
-if (macroCondition(isDevelopingApp())) {
+if (macroCondition(getOwnConfig().env.DEBUG)) {
   let lookupDescriptor = function lookupDescriptor(obj, keyName) {
     let current = obj;
     do {
@@ -5782,41 +4934,14 @@ if (macroCondition(isDevelopingApp())) {
       }
     }
   });
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_MODEL_REOPEN)) {
-    const originalReopen = Model.reopen;
-    const originalReopenClass = Model.reopenClass;
-    Model.reopen = function deprecatedReopen() {
-      deprecate(`Model.reopen is deprecated. Use Foo extends Model to extend your class instead.`, false, {
-        id: 'ember-data:deprecate-model-reopen',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-      return originalReopen.call(this, ...arguments);
-    };
-    Model.reopenClass = function deprecatedReopenClass() {
-      deprecate(`Model.reopenClass is deprecated. Use Foo extends Model to add static methods and properties to your class instead.`, false, {
-        id: 'ember-data:deprecate-model-reopenclass',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          available: '4.7',
-          enabled: '4.7'
-        }
-      });
-      return originalReopenClass.call(this, ...arguments);
-    };
-  }
+  Model.reopen = function deprecatedReopen() {
+    assert(`Model.reopen is deprecated. Use Foo extends Model to extend your class instead.`);
+  };
+  Model.reopenClass = function deprecatedReopenClass() {
+    assert(`Model.reopenClass is deprecated. Use Foo extends Model to add static methods and properties to your class instead.`);
+  };
 }
 function normalizeType$1(type) {
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE)) {
-    if (!type) {
-      return;
-    }
-  }
   return dasherize(type);
 }
 /**
@@ -5857,6 +4982,7 @@ function normalizeType$1(type) {
   ```
 
   #### One-To-Many
+
   To declare a one-to-many relationship between two models, use
   `belongsTo` in combination with `hasMany`, like this:
 
@@ -5864,7 +4990,7 @@ function normalizeType$1(type) {
   import Model, { hasMany } from '@ember-data/model';
 
   export default class PostModel extends Model {
-    @hasMany('comment') comments;
+    @hasMany('comment', { async: false, inverse: 'post' }) comments;
   }
   ```
 
@@ -5872,23 +4998,10 @@ function normalizeType$1(type) {
   import Model, { belongsTo } from '@ember-data/model';
 
   export default class CommentModel extends Model {
-    @belongsTo('post') post;
-  }
-  ```
-
-  You can avoid passing a string as the first parameter. In that case Ember Data
-  will infer the type from the key name.
-
-  ```app/models/comment.js
-  import Model, { belongsTo } from '@ember-data/model';
-
-  export default class CommentModel extends Model {
-    @belongsTo post;
+    @belongsTo('post', { async: false, inverse: 'comments' }) post;
   }
   ```
 
-  will lookup for a Post type.
-
   #### Sync relationships
 
   Ember Data resolves sync relationships with the related resources
@@ -5900,7 +5013,8 @@ function normalizeType$1(type) {
 
   export default class CommentModel extends Model {
     @belongsTo('post', {
-      async: false
+      async: false,
+      inverse: null
     })
     post;
   }
@@ -5927,65 +5041,8 @@ function normalizeType$1(type) {
 function belongsTo(modelName, options) {
   let opts = options;
   let userEnteredModelName = modelName;
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE)) {
-    if (typeof modelName !== 'string' || !modelName.length) {
-      deprecate('belongsTo() must specify the string type of the related resource as the first parameter', false, {
-        id: 'ember-data:deprecate-non-strict-relationships',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-      if (typeof modelName === 'object') {
-        opts = modelName;
-        userEnteredModelName = undefined;
-      } else {
-        opts = options;
-        userEnteredModelName = modelName;
-      }
-      assert('The first argument to belongsTo must be a string representing a model type key, not an instance of ' + typeof userEnteredModelName + ". E.g., to define a relation to the Person model, use belongsTo('person')", typeof userEnteredModelName === 'string' || typeof userEnteredModelName === 'undefined');
-    }
-  }
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC)) {
-    if (!opts || typeof opts.async !== 'boolean') {
-      opts = opts || {};
-      if (!('async' in opts)) {
-        opts.async = true;
-      }
-      deprecate('belongsTo(<type>, <options>) must specify options.async as either `true` or `false`.', false, {
-        id: 'ember-data:deprecate-non-strict-relationships',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-    } else {
-      assert(`Expected belongsTo options.async to be a boolean`, opts && typeof opts.async === 'boolean');
-    }
-  } else {
-    assert(`Expected belongsTo options.async to be a boolean`, opts && typeof opts.async === 'boolean');
-  }
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE)) {
-    if (opts.inverse !== null && (typeof opts.inverse !== 'string' || opts.inverse.length === 0)) {
-      deprecate('belongsTo(<type>, <options>) must specify options.inverse as either `null` or the name of the field on the related resource type.', false, {
-        id: 'ember-data:deprecate-non-strict-relationships',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-    } else {
-      assert(`Expected belongsTo options.inverse to be either null or the string type of the related resource.`, opts.inverse === null || typeof opts.inverse === 'string' && opts.inverse.length > 0);
-    }
-  } else {
-    assert(`Expected belongsTo options.inverse to be either null or the string type of the related resource.`, opts.inverse === null || typeof opts.inverse === 'string' && opts.inverse.length > 0);
-  }
+  assert(`Expected belongsTo options.async to be a boolean`, opts && typeof opts.async === 'boolean');
+  assert(`Expected belongsTo options.inverse to be either null or the string type of the related resource.`, opts.inverse === null || typeof opts.inverse === 'string' && opts.inverse.length > 0);
   let meta = {
     type: normalizeType$1(userEnteredModelName),
     isRelationship: true,
@@ -6003,7 +5060,7 @@ function belongsTo(modelName, options) {
         return null;
       }
       const support = lookupLegacySupport(this);
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (['currentState'].indexOf(key) !== -1) {
           throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your belongsTo on ${this.constructor.toString()}`);
         }
@@ -6022,7 +5079,7 @@ function belongsTo(modelName, options) {
     },
     set(key, value) {
       const support = lookupLegacySupport(this);
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (['currentState'].indexOf(key) !== -1) {
           throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your belongsTo on ${this.constructor.toString()}`);
         }
@@ -6036,11 +5093,6 @@ function belongsTo(modelName, options) {
 }
 var belongsTo$1 = computedMacroWithOptionalParams(belongsTo);
 function normalizeType(type) {
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE)) {
-    if (!type) {
-      return;
-    }
-  }
   return singularize(dasherize(type));
 }
 
@@ -6186,58 +5238,7 @@ function normalizeType(type) {
   @return {Ember.computed} relationship
 */
 function hasMany(type, options) {
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RELATIONSHIPS_WITHOUT_TYPE)) {
-    if (typeof type !== 'string' || !type.length) {
-      deprecate('hasMany(<type>, <options>) must specify the string type of the related resource as the first parameter', false, {
-        id: 'ember-data:deprecate-non-strict-relationships',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-      if (typeof type === 'object') {
-        options = type;
-        type = undefined;
-      }
-      assert(`The first argument to hasMany must be a string representing a model type key, not an instance of ${inspect(type)}. E.g., to define a relation to the Comment model, use hasMany('comment')`, typeof type === 'string' || typeof type === 'undefined');
-    }
-  }
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RELATIONSHIPS_WITHOUT_ASYNC)) {
-    if (!options || typeof options.async !== 'boolean') {
-      options = options || {};
-      if (!('async' in options)) {
-        options.async = true;
-      }
-      deprecate('hasMany(<type>, <options>) must specify options.async as either `true` or `false`.', false, {
-        id: 'ember-data:deprecate-non-strict-relationships',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-    } else {
-      assert(`Expected hasMany options.async to be a boolean`, options && typeof options.async === 'boolean');
-    }
-  } else {
-    assert(`Expected hasMany options.async to be a boolean`, options && typeof options.async === 'boolean');
-  }
-  if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RELATIONSHIPS_WITHOUT_INVERSE)) {
-    if (options.inverse !== null && (typeof options.inverse !== 'string' || options.inverse.length === 0)) {
-      deprecate('hasMany(<type>, <options>) must specify options.inverse as either `null` or the name of the field on the related resource type.', false, {
-        id: 'ember-data:deprecate-non-strict-relationships',
-        for: 'ember-data',
-        until: '5.0',
-        since: {
-          enabled: '4.7',
-          available: '4.7'
-        }
-      });
-    }
-  }
+  assert(`Expected hasMany options.async to be a boolean`, options && typeof options.async === 'boolean');
 
   // Metadata about relationships is stored on the meta of
   // the relationship. This is used for introspection and
@@ -6253,7 +5254,7 @@ function hasMany(type, options) {
   };
   return computed({
     get(key) {
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (['currentState'].indexOf(key) !== -1) {
           throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your hasMany on ${this.constructor.toString()}`);
         }
@@ -6264,7 +5265,7 @@ function hasMany(type, options) {
       return lookupLegacySupport(this).getHasMany(key);
     },
     set(key, records) {
-      if (macroCondition(isDevelopingApp())) {
+      if (macroCondition(getOwnConfig().env.DEBUG)) {
         if (['currentState'].indexOf(key) !== -1) {
           throw new Error(`'${key}' is a reserved property name on instances of classes extending Model. Please choose a different property name for your hasMany on ${this.constructor.toString()}`);
         }