Deprecations Added in Ember 6.x

Previously, __loader could be accessed via the Ember import:

import Ember from 'ember';

Ember.__loader

There is no replacement for this API.

Previously, _action could be accessed via the Ember import:

import Ember from 'ember';

Ember._action

If needed, _action can be imported:

import { action } from '@ember/object';

Previously, _array could be accessed via the Ember import:

import Ember from 'ember';

Ember._array

If needed, _array can be imported:

import { array } from '@ember/helper';

Previously, _assertDestroyablesDestroyed could be accessed via the Ember import:

import Ember from 'ember';

Ember._assertDestroyablesDestroyed

If needed, _assertDestroyablesDestroyed can be imported:

import { assertDestroyablesDestroyed } from '@ember/destroyable';

Previously, _associateDestroyableChild could be accessed via the Ember import:

import Ember from 'ember';

Ember._associateDestroyableChild

If needed, _associateDestroyableChild can be imported:

import { associateDestroyableChild } from '@ember/destroyable';

Previously, _Backburner could be accessed via the Ember import:

import Ember from 'ember';

Ember._Backburner

_Backburner is also private.

There is no replacement for this API.

Previously, _Cache could be accessed via the Ember import:

import Ember from 'ember';

Ember._Cache

There is no replacement for this API.

Previously, _cacheGetValue could be accessed via the Ember import:

import Ember from 'ember';

Ember._cacheGetValue

If needed, _cacheGetValue can be imported:

import { getValue } from '@glimmer/tracking/primitives/cache';

Previously, _cacheIsConst could be accessed via the Ember import:

import Ember from 'ember';

Ember._cacheIsConst

If needed, _cacheIsConst can be imported:

import { isConst } from '@glimmer/tracking/primitives/cache';

Previously, _captureRenderTree could be accessed via the Ember import:

import Ember from 'ember';

Ember._captureRenderTree

_captureRenderTree is also private.

If needed, _captureRenderTree can be imported:

import { captureRenderTree } from '@ember/debug';

However, due to _captureRenderTree being private, it is not recommended, nor supported.

Previously, _componentManagerCapabilities could be accessed via the Ember import:

import Ember from 'ember';

Ember._componentManagerCapabilities

If needed, _componentManagerCapabilities can be imported:

import { capabilities } from '@ember/component';

Previously, _concat could be accessed via the Ember import:

import Ember from 'ember';

Ember._concat

If needed, _concat can be imported:

import { concat } from '@ember/helper';

Previously, _ContainerProxyMixin could be accessed via the Ember import:

import Ember from 'ember';

Ember._ContainerProxyMixin

_ContainerProxyMixin is also private.

There is no replacement for this API.

Previously, _createCache could be accessed via the Ember import:

import Ember from 'ember';

Ember._createCache

If needed, _createCache can be imported:

import { createCache } from '@glimmer/tracking/primitives/cache';

Previously, _dependentKeyCompat could be accessed via the Ember import:

import Ember from 'ember';

Ember._dependentKeyCompat

If needed, _dependentKeyCompat can be imported:

import { dependentKeyCompat } from '@ember/object/compat';

Previously, _descriptor could be accessed via the Ember import:

import Ember from 'ember';

Ember._descriptor

There is no replacement for this API.

Previously, _enableDestroyableTracking could be accessed via the Ember import:

import Ember from 'ember';

Ember._enableDestroyableTracking

If needed, _enableDestroyableTracking can be imported:

import { enableDestroyableTracking } from '@ember/destroyable';

Previously, _fn could be accessed via the Ember import:

import Ember from 'ember';

Ember._fn

If needed, _fn can be imported:

import { fn } from '@ember/helper';

Previously, _getComponentTemplate could be accessed via the Ember import:

import Ember from 'ember';

Ember._getComponentTemplate

If needed, _getComponentTemplate can be imported:

import { getComponentTemplate } from '@ember/component';

Previously, _get could be accessed via the Ember import:

import Ember from 'ember';

Ember._get

If needed, _get can be imported:

import { get } from '@ember/helper';

Previously, _getPath could be accessed via the Ember import:

import Ember from 'ember';

Ember._getPath

There is no replacement for this API.

Previously, _hash could be accessed via the Ember import:

import Ember from 'ember';

Ember._hash

If needed, _hash can be imported:

import { hash } from '@ember/helper';

Previously, _helperManagerCapabilities could be accessed via the Ember import:

import Ember from 'ember';

Ember._helperManagerCapabilities

If needed, _helperManagerCapabilities can be imported:

import { capabilities } from '@ember/helper';

Previously, _Input could be accessed via the Ember import:

import Ember from 'ember';

Ember._Input

If needed, _Input can be imported:

import { Input }  from '@ember/component';

Previously, _invokeHelper could be accessed via the Ember import:

import Ember from 'ember';

Ember._invokeHelper

If needed, _invokeHelper can be imported:

import { invokeHelper } from '@ember/helper';

Previously, _isDestroyed could be accessed via the Ember import:

import Ember from 'ember';

Ember._isDestroyed

If needed, _isDestroyed can be imported:

import { isDestroyed } from '@ember/destroyable';

Previously, _isDestroying could be accessed via the Ember import:

import Ember from 'ember';

Ember._isDestroying

If needed, _isDestroying can be imported:

import { isDestroying } from '@ember/destroyable';

Previously, _modifierManagerCapabilities could be accessed via the Ember import:

import Ember from 'ember';

Ember._modifierManagerCapabilities

If needed, _modifierManagerCapabilities can be imported:

import { capabilities } from '@ember/modifier';

Previously, _on could be accessed via the Ember import:

import Ember from 'ember';

Ember._on

If needed, _on can be imported:

import { on } from '@ember/modifier';

Previously, _ProxyMixin could be accessed via the Ember import:

import Ember from 'ember';

Ember._ProxyMixin

_ProxyMixin is also private.

There is no replacement for this API.

Previously, _registerDestructor could be accessed via the Ember import:

import Ember from 'ember';

Ember._registerDestructor

If needed, _registerDestructor can be imported:

import { registerDestructor } from '@ember/destroyable';

Previously, _RegistryProxyMixin could be accessed via the Ember import:

import Ember from 'ember';

Ember._RegistryProxyMixin

_RegistryProxyMixin is also private.

There is no replacement for this API.

Previously, _setClassicDecorator could be accessed via the Ember import:

import Ember from 'ember';

Ember._setClassicDecorator

_setClassicDecorator is also private.

There is no replacement for this API.

Previously, _setComponentManager could be accessed via the Ember import:

import Ember from 'ember';

Ember._setComponentManager

If needed, _setComponentManager can be imported:

import { setComponentManager } from '@ember/component';

Previously, _setComponentTemplate could be accessed via the Ember import:

import Ember from 'ember';

Ember._setComponentTemplate

If needed, _setComponentTemplate can be imported:

import { setComponentTemplate } from '@ember/component';

Previously, _setHelperManager could be accessed via the Ember import:

import Ember from 'ember';

Ember._setHelperManager

If needed, _setHelperManager can be imported:

import { setHelperManager } from '@ember/helper';

Previously, _setModifierManager could be accessed via the Ember import:

import Ember from 'ember';

Ember._setModifierManager

If needed, _setModifierManager can be imported:

import { setModifierManager } from '@ember/modifier';

Previously, _templateOnlyComponent could be accessed via the Ember import:

import Ember from 'ember';

Ember._templateOnlyComponent

If needed, _templateOnlyComponent can be imported:

import templateOnly from '@ember/component/template-only';

Previously, _tracked could be accessed via the Ember import:

import Ember from 'ember';

Ember._tracked

If needed, _tracked can be imported:

import { tracked } from '@glimmer/tracking';

Previously, _unregisterDestructor could be accessed via the Ember import:

import Ember from 'ember';

Ember._unregisterDestructor

If needed, _unregisterDestructor can be imported:

import { unregisterDestructor } from '@ember/destroyable';

Previously, A could be accessed via the Ember import:

import Ember from 'ember';

Ember.A

If needed, A can be imported:

import { A }  from '@ember/array';

Previously, ActionHandler could be accessed via the Ember import:

import Ember from 'ember';

Ember.ActionHandler

ActionHandler is also private.

There is no replacement for this API.

Previously, addListener could be accessed via the Ember import:

import Ember from 'ember';

Ember.addListener

If needed, addListener can be imported:

import { addListener } from '@ember/object/events';

Previously, addObserver could be accessed via the Ember import:

import Ember from 'ember';

Ember.addObserver

If needed, addObserver can be imported:

import { addObserver } from '@ember/object/observers';

Previously, Application could be accessed via the Ember import:

import Ember from 'ember';

Ember.Application

If needed, Application can be imported:

import Application from '@ember/application';

Previously, ApplicationInstance could be accessed via the Ember import:

import Ember from 'ember';

Ember.ApplicationInstance

If needed, ApplicationInstance can be imported:

import ApplicationInstance from '@ember/application/instance';

Previously, Array could be accessed via the Ember import:

import Ember from 'ember';

Ember.Array

If needed, Array can be imported:

import Array  from '@ember/array';

Previously, ArrayProxy could be accessed via the Ember import:

import Ember from 'ember';

Ember.ArrayProxy

If needed, ArrayProxy can be imported:

import ArrayProxy  from '@ember/array/proxy';

Previously, assert could be accessed via the Ember import:

import Ember from 'ember';

Ember.assert

If needed, assert can be imported:

import { assert } from '@ember/debug';

Previously, beginPropertyChanges could be accessed via the Ember import:

import Ember from 'ember';

Ember.beginPropertyChanges

beginPropertyChanges is also private.

There is no replacement for this API.

Previously, BOOTED could be accessed via the Ember import:

import Ember from 'ember';

Ember.BOOTED

BOOTED is also private.

There is no replacement for this API.

Previously, cacheFor could be accessed via the Ember import:

import Ember from 'ember';

Ember.cacheFor

There is no replacement for this API.

Previously, canInvoke could be accessed via the Ember import:

import Ember from 'ember';

Ember.canInvoke

canInvoke is also private.

There is no replacement for this API.

Previously, changeProperties could be accessed via the Ember import:

import Ember from 'ember';

Ember.changeProperties

changeProperties is also private.

There is no replacement for this API.

Previously, Comparable could be accessed via the Ember import:

import Ember from 'ember';

Ember.Comparable

Comparable is also private.

There is no replacement for this API.

Previously, compare could be accessed via the Ember import:

import Ember from 'ember';

Ember.compare

If needed, compare can be imported:

import { compare } from '@ember/utils';

Previously, Component could be accessed via the Ember import:

import Ember from 'ember';

Ember.Component

If needed, Component can be imported:

import Component  from '@ember/component';

Previously, computed could be accessed via the Ember import:

import Ember from 'ember';

Ember.computed

If needed, computed can be imported:

import { computed } from '@ember/object';

Previously, ComputedProperty could be accessed via the Ember import:

import Ember from 'ember';

Ember.ComputedProperty

There is no replacement for this API.

Previously, ContainerDebugAdapter could be accessed via the Ember import:

import Ember from 'ember';

Ember.ContainerDebugAdapter

If needed, ContainerDebugAdapter can be imported:

import ContainerDebugAdapter from '@ember/debug/container-debug-adapter';

Previously, Container could be accessed via the Ember import:

import Ember from 'ember';

Ember.Container

Container is also private.

There is no replacement for this API.

Previously, controllerFor could be accessed via the Ember import:

import Ember from 'ember';

Ember.controllerFor

controllerFor is also private.

There is no replacement for this API.

Previously, Controller could be accessed via the Ember import:

import Ember from 'ember';

Ember.Controller

If needed, Controller can be imported:

import Controller  from '@ember/controller';

Previously, ControllerMixin could be accessed via the Ember import:

import Ember from 'ember';

Ember.ControllerMixin

ControllerMixin is also private.

If needed, ControllerMixin can be imported:

import { ControllerMixin } from '@ember/controller';

However, due to ControllerMixin being private, it is not recommended, nor supported.

Previously, CoreObject could be accessed via the Ember import:

import Ember from 'ember';

Ember.CoreObject

If needed, CoreObject can be imported:

import EmberObject from '@ember/object';

Previously, DataAdapter could be accessed via the Ember import:

import Ember from 'ember';

Ember.DataAdapter

If needed, DataAdapter can be imported:

import DataAdapter from '@ember/debug/data-adapter';

Previously, debug could be accessed via the Ember import:

import Ember from 'ember';

Ember.debug

If needed, debug can be imported:

import { debug } from '@ember/debug';

Previously, defineProperty could be accessed via the Ember import:

import Ember from 'ember';

Ember.defineProperty

If needed, defineProperty can be imported:

import { defineProperty } from '@ember/object';

Previously, deprecate could be accessed via the Ember import:

import Ember from 'ember';

Ember.deprecate

If needed, deprecate can be imported:

import { deprecate } from '@ember/debug';

Previously, deprecateFunc could be accessed via the Ember import:

import Ember from 'ember';

Ember.deprecateFunc

If needed, deprecateFunc can be imported:

import { deprecateFunc } from '@ember/debug';

Previously, destroy could be accessed via the Ember import:

import Ember from 'ember';

Ember.destroy

If needed, destroy can be imported:

import { destroy } from '@ember/destroyable';

Previously, endPropertyChanges could be accessed via the Ember import:

import Ember from 'ember';

Ember.endPropertyChanges

endPropertyChanges is also private.

There is no replacement for this API.

Previously, Engine could be accessed via the Ember import:

import Ember from 'ember';

Ember.Engine

If needed, Engine can be imported:

import Engine from '@ember/engine';

Previously, EngineInstance could be accessed via the Ember import:

import Ember from 'ember';

Ember.EngineInstance

If needed, EngineInstance can be imported:

import Engine from '@ember/engine/instance';

Previously, Enumerable could be accessed via the Ember import:

import Ember from 'ember';

Ember.Enumerable

Enumerable is also private.

If needed, Enumerable can be imported:

import Enumerable from '@ember/enumerable';

However, due to Enumerable being private, it is not recommended, nor supported.

Previously, ENV could be accessed via the Ember import:

import Ember from 'ember';

Ember.ENV

If needed, ENV can be imported:

import MyEnv from '<my-app>/config/environment';

For addons, getting access to the environment requires having access to the owner:

import { getOwner } from '@ember/owner';

// ...

let env = getOwner(this).resolveRegistration('config:environment');

Previously, Evented could be accessed via the Ember import:

import Ember from 'ember';

Ember.Evented

If needed, Evented can be imported:

import Evented from '@ember/object/evented';

Previously, expandProperties could be accessed via the Ember import:

import Ember from 'ember';

Ember.expandProperties

If needed, expandProperties can be imported:

import { expandProperties } from '@ember/object/computed';

Previously, FEATURES could be accessed via the Ember import:

import Ember from 'ember';

Ember.FEATURES

If needed, FEATURES can be imported:

import { isEnabled, FEATURES } from '@ember/canary-features';

Previously, generateControllerFactory could be accessed via the Ember import:

import Ember from 'ember';

Ember.generateControllerFactory

generateControllerFactory is also private.

There is no replacement for this API.

Previously, generateController could be accessed via the Ember import:

import Ember from 'ember';

Ember.generateController

generateController is also private.

There is no replacement for this API.

Previously, generateGuid could be accessed via the Ember import:

import Ember from 'ember';

Ember.generateGuid

generateGuid is also private.

There is no replacement for this API.

Previously, get could be accessed via the Ember import:

import Ember from 'ember';

Ember.get

If needed, get can be imported:

import { get } from '@ember/object';

Previously, getOwner could be accessed via the Ember import:

import Ember from 'ember';

Ember.getOwner

If needed, getOwner can be imported:

import { getOwner } from '@ember/owner';

If you're working in a library and need to support earlier than ember-source@4.11, you may use @embroider/macros to selectively import from the old location

import {
  macroCondition,
  dependencySatisfies,
  importSync,
} from '@embroider/macros';

let getOwner;

if (macroCondition(dependencySatisfies('ember-source', '>= 4.11'))) {
  getOwner = importSync('@ember/owner').getOwner;
} else {
  getOwner = importSync('@ember/application').getOwner;
}

Previously, getProperties could be accessed via the Ember import:

import Ember from 'ember';

Ember.getProperties

If needed, getProperties can be imported:

import { getProperties } from '@ember/object';

Previously, guidFor could be accessed via the Ember import:

import Ember from 'ember';

Ember.guidFor

If needed, guidFor can be imported:

import { guidFor } from '@ember/object/internals';

Previously, GUID_KEY could be accessed via the Ember import:

import Ember from 'ember';

Ember.GUID_KEY

GUID_KEY is also private.

There is no replacement for this API.

Previously, Handlebars could be accessed via the Ember import:

import Ember from 'ember';

Ember.Handlebars

There is no replacement for this API.

Previously, hasListeners could be accessed via the Ember import:

import Ember from 'ember';

Ember.hasListeners

There is no replacement for this API.

Previously, HashLocation could be accessed via the Ember import:

import Ember from 'ember';

Ember.HashLocation

If needed, HashLocation can be imported:

import HashLocation from '@ember/routing/hash-location';

Previously, Helper could be accessed via the Ember import:

import Ember from 'ember';

Ember.Helper

If needed, Helper can be imported:

import Helper  from '@ember/component/helper';

Previously, HistoryLocation could be accessed via the Ember import:

import Ember from 'ember';

Ember.HistoryLocation

If needed, HistoryLocation can be imported:

import HistoryLocation from '@ember/routing/history-location';

Previously, HTMLBars could be accessed via the Ember import:

import Ember from 'ember';

Ember.HTMLBars

There is no replacement for this API.

Previously, inject could be accessed via the Ember import:

import Ember from 'ember';

Ember.inject

There is no replacement for this API.

Previously, inspect could be accessed via the Ember import:

import Ember from 'ember';

Ember.inspect

inspect is also private.

There is no replacement for this API.

Previously, instrument could be accessed via the Ember import:

import Ember from 'ember';

Ember.instrument

instrument is also private.

If needed, instrument can be imported:

import { instrument } from '@ember/instrumentation';

However, due to instrument being private, it is not recommended, nor supported.

Previously, Instrumentation could be accessed via the Ember import:

import Ember from 'ember';

Ember.Instrumentation

Instrumentation is also private.

If needed, Instrumentation can be imported:

import { * } from '@ember/instrumentation';

However, due to Instrumentation being private, it is not recommended, nor supported.

Previously, isArray could be accessed via the Ember import:

import Ember from 'ember';

Ember.isArray

If needed, isArray can be imported:

import { isArray }  from '@ember/array';

Previously, isBlank could be accessed via the Ember import:

import Ember from 'ember';

Ember.isBlank

If needed, isBlank can be imported:

import { isBlank } from '@ember/utils';

Previously, isEmpty could be accessed via the Ember import:

import Ember from 'ember';

Ember.isEmpty

If needed, isEmpty can be imported:

import { isEmpty } from '@ember/utils';

Previously, isEqual could be accessed via the Ember import:

import Ember from 'ember';

Ember.isEqual

If needed, isEqual can be imported:

import { isEqual } from '@ember/utils';

Previously, isNamespace could be accessed via the Ember import:

import Ember from 'ember';

Ember.isNamespace

There is no replacement for this API.

Previously, isPresent could be accessed via the Ember import:

import Ember from 'ember';

Ember.isPresent

If needed, isPresent can be imported:

import { isPresent } from '@ember/utils';

Previously, libraries could be accessed via the Ember import:

import Ember from 'ember';

Ember.libraries

There is no replacement for this API.

If needed, libraries can be imported from a private module:

import { libraries } from '@ember/-internals/metal';

Instead of using this import, consider using a build plugin for your packager. Some options:

• https://github.com/ubilabs/webpack-node-modules-list
• https://github.com/yjl9903/unplugin-info

These are both more automatic than Ember's libraries utility.

Previously, lookup could be accessed via the Ember import:

import Ember from 'ember';

Ember.lookup

There is no replacement for this API.

Previously, makeArray could be accessed via the Ember import:

import Ember from 'ember';

Ember.makeArray

makeArray is also private.

If needed, makeArray can be imported:

import { makeArray }  from '@ember/array';

However, due to makeArray being private, it is not recommended, nor supported.

Previously, meta could be accessed via the Ember import:

import Ember from 'ember';

Ember.meta

meta is also private.

If needed, meta can be imported:

import { meta } from '@ember/-internals/meta';

However, due to meta being private, it is not recommended, nor supported.

Previously, mixin could be accessed via the Ember import:

import Ember from 'ember';

Ember.mixin

mixin is also private.

If needed, mixin can be imported:

import { mixin } from '@ember/object/mixin';

However, due to mixin being private, it is not recommended, nor supported.

Previously, MutableArray could be accessed via the Ember import:

import Ember from 'ember';

Ember.MutableArray

If needed, MutableArray can be imported:

import MutableArray  from '@ember/array/mutable';

Previously, MutableEnumerable could be accessed via the Ember import:

import Ember from 'ember';

Ember.MutableEnumerable

MutableEnumerable is also private.

If needed, MutableEnumerable can be imported:

import MutableEnumerable from '@ember/enumerable/mutable';

However, due to MutableEnumerable being private, it is not recommended, nor supported.

Previously, Namespace could be accessed via the Ember import:

import Ember from 'ember';

Ember.Namespace

If needed, Namespace can be imported:

import Namespace from '@ember/application/namespace';

Previously, NativeArray could be accessed via the Ember import:

import Ember from 'ember';

Ember.NativeArray

If needed, NativeArray can be imported:

import { NativeArray }  from '@ember/array';

Previously, NoneLocation could be accessed via the Ember import:

import Ember from 'ember';

Ember.NoneLocation

If needed, NoneLocation can be imported:

import NoneLocation from '@ember/routing/none-location';

Previously, notifyPropertyChange could be accessed via the Ember import:

import Ember from 'ember';

Ember.notifyPropertyChange

If needed, notifyPropertyChange can be imported:

import { notifyPropertyChange } from '@ember/object';

Previously, Object could be accessed via the Ember import:

import Ember from 'ember';

Ember.Object

If needed, Object can be imported:

import Object from '@ember/object';

Previously, ObjectProxy could be accessed via the Ember import:

import Ember from 'ember';

Ember.ObjectProxy

If needed, ObjectProxy can be imported:

import ObjectProxy from '@ember/object/proxy';

Previously, Observable could be accessed via the Ember import:

import Ember from 'ember';

Ember.Observable

If needed, Observable can be imported:

import Observable from '@ember/object/observable';

Previously, observer could be accessed via the Ember import:

import Ember from 'ember';

Ember.observer

If needed, observer can be imported:

import { observer } from '@ember/object';

Previously, on could be accessed via the Ember import:

import Ember from 'ember';

Ember.on

If needed, on can be imported:

import { on } from '@ember/object/evented';

Previously, onLoad could be accessed via the Ember import:

import Ember from 'ember';

Ember.onLoad

If needed, onLoad can be imported:

import { onLoad } from '@ember/application';

Previously, onerror could be accessed via the Ember import:

import Ember from 'ember';

Ember.onerror

There is no replacement for this API.

Previously, PromiseProxyMixin could be accessed via the Ember import:

import Ember from 'ember';

Ember.PromiseProxyMixin

If needed, PromiseProxyMixin can be imported:

import EmberPromiseProxyMixin from '@ember/object/promise-proxy-mixin';

Previously, Registry could be accessed via the Ember import:

import Ember from 'ember';

Ember.Registry

Registry is also private.

There is no replacement for this API.

Previously, removeListener could be accessed via the Ember import:

import Ember from 'ember';

Ember.removeListener

If needed, removeListener can be imported:

import { removeListener } from '@ember/object/events';

Previously, removeObserver could be accessed via the Ember import:

import Ember from 'ember';

Ember.removeObserver

If needed, removeObserver can be imported:

import { removeObserver } from '@ember/object/observers';

Previously, Route could be accessed via the Ember import:

import Ember from 'ember';

Ember.Route

If needed, Route can be imported:

import Route from '@ember/routing/route';

Previously, RouterDSL could be accessed via the Ember import:

import Ember from 'ember';

Ember.RouterDSL

There is no replacement for this API.

Previously, RSVP could be accessed via the Ember import:

import Ember from 'ember';

Ember.RSVP

If needed, RSVP can be imported:

import RSVP from 'rsvp';

Previously, run could be accessed via the Ember import:

import Ember from 'ember';

Ember.run

If needed, run can be imported:

import { run } from '@ember/runloop';

Previously, runInDebug could be accessed via the Ember import:

import Ember from 'ember';

Ember.runInDebug

If needed, runInDebug can be imported:

import { runInDebug } from '@ember/debug';

Previously, runLoadHooks could be accessed via the Ember import:

import Ember from 'ember';

Ember.runLoadHooks

If needed, runLoadHooks can be imported:

import { runLoadHooks } from '@ember/application';

Previously, sendEvent could be accessed via the Ember import:

import Ember from 'ember';

Ember.sendEvent

If needed, sendEvent can be imported:

import { sendEvent } from '@ember/object/events';

Previously, Service could be accessed via the Ember import:

import Ember from 'ember';

Ember.Service

If needed, Service can be imported:

import Service from '@ember/service';

Previously, set could be accessed via the Ember import:

import Ember from 'ember';

Ember.set

If needed, set can be imported:

import { set } from '@ember/object';

Previously, setOwner could be accessed via the Ember import:

import Ember from 'ember';

Ember.setOwner

If needed, setOwner can be imported:

import { setOwner } from '@ember/owner';

If you're working in a library and need to support earlier than ember-source@4.11, you may use @embroider/macros to selectively import from the old location

import {
  macroCondition,
  dependencySatisfies,
  importSync,
} from '@embroider/macros';

let setOwner;

if (macroCondition(dependencySatisfies('ember-source', '>= 4.11'))) {
  setOwner = importSync('@ember/owner').setOwner;
} else {
  setOwner = importSync('@ember/application').setOwner;
}

Previously, setProperties could be accessed via the Ember import:

import Ember from 'ember';

Ember.setProperties

If needed, setProperties can be imported:

import { setProperties } from '@ember/object';

Previously, setupForTesting could be accessed via the Ember import:

import Ember from 'ember';

Ember.setupForTesting

There is no replacement for this API.

Previously, subscribe could be accessed via the Ember import:

import Ember from 'ember';

Ember.subscribe

subscribe is also private.

If needed, subscribe can be imported:

import { subscribe } from '@ember/instrumentation';

However, due to subscribe being private, it is not recommended, nor supported.

Previously, TEMPLATES could be accessed via the Ember import:

import Ember from 'ember';

Ember.TEMPLATES

TEMPLATES is also private.

There is no replacement for this API.

Previously, Test could be accessed via the Ember import:

import Ember from 'ember';

Ember.Test

There is no replacement for this API.

Previously, testing could be accessed via the Ember import:

import Ember from 'ember';

Ember.testing

There is no replacement for this API.

Previously, toString could be accessed via the Ember import:

import Ember from 'ember';

Ember.toString

There is no replacement for this API.

Previously, trySet could be accessed via the Ember import:

import Ember from 'ember';

Ember.trySet

If needed, trySet can be imported:

import { trySet } from '@ember/object';

Previously, typeOf could be accessed via the Ember import:

import Ember from 'ember';

Ember.typeOf

If needed, typeOf can be imported:

import { typeOf } from '@ember/utils';

Previously, uuid could be accessed via the Ember import:

import Ember from 'ember';

Ember.uuid

There is no replacement for this API.

Previously, VERSION could be accessed via the Ember import:

import Ember from 'ember';

Ember.VERSION

If needed, VERSION can be imported:

import { VERSION } from '@ember/version';

Previously, ViewUtils could be accessed via the Ember import:

import Ember from 'ember';

Ember.ViewUtils

ViewUtils is also private.

If needed, ViewUtils can be imported:

import { isSerializationFirstNode } from '@ember/-internals/glimmer';

However, due to ViewUtils being private, it is not recommended, nor supported.

Previously, warn could be accessed via the Ember import:

import Ember from 'ember';

Ember.warn

If needed, warn can be imported:

import { warn } from '@ember/debug';

Previously, wrap could be accessed via the Ember import:

import Ember from 'ember';

Ember.wrap

wrap is also private.

There is no replacement for this API.