@ember-data/model 5.0.0-alpha.1 → 5.0.0-alpha.2

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

@@ -1,19 +1,19 @@
 import { macroCondition, getOwnConfig, importSync } from '@embroider/macros';
-import { assert, deprecate, warn, inspect } from '@ember/debug';
+import { assert, warn } from '@ember/debug';
 import EmberObject, { computed, get } from '@ember/object';
 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 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) {
@@ -212,62 +212,6 @@ function _applyDecoratedDescriptor(target, property, decorators, descriptor, con
   }
   return desc;
 }
-const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
-function promiseObject(promise) {
-  return PromiseObject.create({
-    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(!getOwnConfig().env.DEBUG)) {
-    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;
 
 /**
@@ -639,6 +583,9 @@ let Errors = (_dec$1 = computed(), _dec2 = mapBy('content', 'message'), _dec3 =
   initializer: null
 })), _class$6));
 
+/**
+  @module @ember-data/store
+*/
 /**
   A `ManyArray` is a `MutableArray` that represents the contents of a has-many
   relationship.
@@ -933,29 +880,10 @@ 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
@@ -1006,7 +934,6 @@ 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;
-
 /**
  @module @ember-data/model
  */
@@ -1027,8 +954,6 @@ var _class$4, _descriptor$4, _descriptor2$1, _descriptor3, _descriptor4, _descri
   @public
 */
 let PromiseManyArray = (_class$4 = class PromiseManyArray {
-  // @deprecated (isDestroyed is not deprecated)
-
   constructor(promise, content) {
     //---- Methods/Properties on ArrayProxy that we will keep as our API
     _initializerDefineProperty(this, "content", _descriptor$4, this);
@@ -1063,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(getOwnConfig().env.DEBUG)) {
+    if (macroCondition(getOwnConfig().env.DEBUG)) {
       const meta = Ember.meta(this);
       meta.hasMixin = mixin => {
         assert(`Do not use A() on an EmberData PromiseManyArray`);
@@ -1180,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;
@@ -1256,49 +1161,6 @@ 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;
@@ -1318,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
@@ -1368,39 +1195,13 @@ if (macroCondition(getOwnConfig().deprecations.DEPRECATE_PROMISE_MANY_ARRAY_BEHA
 */
 let assertPolymorphicType;
 if (macroCondition(getOwnConfig().env.DEBUG)) {
-  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);
-  };
   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);
     }
   };
 }
@@ -1619,7 +1420,7 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
   }
   _resource() {
     this._ref; // subscribe
-    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this.store._instanceCache.getResourceCache(this.___identifier) : this.store.cache;
+    const cache = this.store.cache;
     return cache.getRelationship(this.___identifier, this.key);
   }
 
@@ -1703,27 +1504,11 @@ 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 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(getOwnConfig().env.DEBUG)) {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-call
@@ -1740,7 +1525,7 @@ let BelongsToReference = (_class$3 = class BelongsToReference {
         value: recordIdentifierFor$1(record)
       });
     });
-    return record;
+    return Promise.resolve(record);
   }
 
   /**
@@ -1985,7 +1770,7 @@ let HasManyReference = (_class$2 = class HasManyReference {
     return [];
   }
   _resource() {
-    const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? this.store._instanceCache.getResourceCache(this.___identifier) : this.store.cache;
+    const cache = this.store.cache;
     return cache.getRelationship(this.___identifier, this.key);
   }
 
@@ -2201,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 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;
@@ -2532,7 +2301,7 @@ class LegacySupport {
     true);
   }
   _getCurrentState(identifier, field) {
-    let jsonApi = this.cache.getRelationship(identifier, field, true);
+    let jsonApi = this.cache.getRelationship(identifier, field);
     const cache = this.store._instanceCache;
     let identifiers = [];
     if (jsonApi.data) {
@@ -2924,30 +2693,11 @@ function handleCompletedRelationshipRequest(recordExt, key, relationship, value,
   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;
@@ -3024,7 +2774,7 @@ function notifyRelationship(identifier, key, record, meta) {
 }
 function notifyAttribute(store, identifier, key, record) {
   let currentValue = cacheFor(record, key);
-  const cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? peekCache(record) : store.cache;
+  const cache = store.cache;
   if (currentValue !== cache.getAttr(identifier, key)) {
     record.notifyPropertyChange(key);
   }
@@ -3164,7 +2914,7 @@ let RecordState = (_class3 = class RecordState {
     const identity = recordIdentifierFor$1(record);
     this.identifier = identity;
     this.record = record;
-    this.cache = macroCondition(getOwnConfig().deprecations.DEPRECATE_V1_RECORD_DATA) ? peekCache(record) : store.cache;
+    this.cache = store.cache;
     this.pendingCount = 0;
     this.fulfilledCount = 0;
     this.rejectedCount = 0;
@@ -3426,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(getOwnConfig().env.DEBUG)) {
-      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
@@ -4277,9 +3954,6 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     } else {
       promise = storeFor$1(this).saveRecord(this, options);
     }
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SAVE_PROMISE_ACCESS)) {
-      return deprecatedPromiseObject(promise);
-    }
     return promise;
   }
 
@@ -4324,9 +3998,6 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     }).then(() => this).finally(() => {
       this.isReloading = false;
     });
-    if (macroCondition(getOwnConfig().deprecations.DEPRECATE_SAVE_PROMISE_ACCESS)) {
-      return deprecatedPromiseObject(promise);
-    }
     return promise;
   }
   attr() {
@@ -4560,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);
   }
 
@@ -4620,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];
@@ -4645,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
@@ -4715,44 +4338,16 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     // ensure inverse is properly configured
     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(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);
@@ -4800,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;
 
@@ -4858,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: []
@@ -4910,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);
@@ -4970,19 +4529,7 @@ 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);
@@ -4994,19 +4541,7 @@ let Model = (_class = (_class2 = class Model extends EmberObject {
     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) => {
@@ -5014,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;
@@ -5054,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
@@ -5090,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);
     });
@@ -5120,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];
@@ -5140,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);
@@ -5203,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) {
@@ -5259,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) {
@@ -5316,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);
     });
@@ -5370,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);
     });
@@ -5395,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], {
@@ -5506,41 +4934,14 @@ if (macroCondition(getOwnConfig().env.DEBUG)) {
       }
     }
   });
-  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);
 }
 /**
@@ -5640,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,
@@ -5749,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));
 }
 
@@ -5899,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