diff --git a/type-tests/@ember/object-test/proxy.ts b/type-tests/@ember/object-test/proxy.ts
index ebebf9a6ffe..8606ff6f6b3 100644
--- a/type-tests/@ember/object-test/proxy.ts
+++ b/type-tests/@ember/object-test/proxy.ts
@@ -1,8 +1,8 @@
-import Ember from 'ember';
+import EmberObject, { set, computed } from '@ember/object';
 import ObjectProxy from '@ember/object/proxy';
 import { expectTypeOf } from 'expect-type';
 
-declare class X extends Ember.Object {
+declare class X extends EmberObject {
   foo: string;
   bar: number;
 }
@@ -74,12 +74,12 @@ book.setProperties({ title: 1 });
 book.setProperties({ altTitle: 1 });
 book.setProperties({ invalid: true });
 
-class Person extends Ember.Object {
+class Person extends EmberObject {
   firstName = 'Peter';
 
   lastName = 'Wagenet';
 
-  @Ember.computed('firstName', 'lastName')
+  @computed('firstName', 'lastName')
   get fullName() {
     return `${this.firstName} ${this.lastName}`;
   }
@@ -87,8 +87,8 @@ class Person extends Ember.Object {
   set fullName(value: string) {
     const [firstName, lastName] = value.split(' ');
 
-    Ember.set(this, 'firstName', firstName ?? '');
-    Ember.set(this, 'lastName', lastName ?? '');
+    set(this, 'firstName', firstName ?? '');
+    set(this, 'lastName', lastName ?? '');
   }
 }
 
diff --git a/type-tests/ember/application.ts b/type-tests/ember/application.ts
index 3f4aa047652..b4f408e5254 100755
--- a/type-tests/ember/application.ts
+++ b/type-tests/ember/application.ts
@@ -1,7 +1,7 @@
+import Application from '@ember/application';
 import EmberObject from '@ember/object';
-import Ember from 'ember';
 
-const BaseApp = Ember.Application.extend({
+const BaseApp = Application.extend({
   modulePrefix: 'my-app',
 });
 
diff --git a/type-tests/ember/array-proxy.ts b/type-tests/ember/array-proxy.ts
index d88fe73fff8..3b0a96afdd1 100644
--- a/type-tests/ember/array-proxy.ts
+++ b/type-tests/ember/array-proxy.ts
@@ -1,27 +1,28 @@
 import type Array from '@ember/array';
-import Ember from 'ember';
+import { A } from '@ember/array';
+import ArrayProxy from '@ember/array/proxy';
 import { expectTypeOf } from 'expect-type';
 
 const pets = ['dog', 'cat', 'fish'];
-const proxy = Ember.ArrayProxy.create({ content: Ember.A(pets) });
+const proxy = ArrayProxy.create({ content: A(pets) });
 
 proxy.get('firstObject'); // 'dog'
-proxy.set('content', Ember.A(['amoeba', 'paramecium']));
+proxy.set('content', A(['amoeba', 'paramecium']));
 proxy.get('firstObject'); // 'amoeba'
 
-const overridden = Ember.ArrayProxy.create({
-  content: Ember.A(pets),
-  objectAtContent(this: Ember.ArrayProxy<string>, idx: number): string | undefined {
+const overridden = ArrayProxy.create({
+  content: A(pets),
+  objectAtContent(this: ArrayProxy<string>, idx: number): string | undefined {
     return (this.get('content') as Array<string>).objectAt(idx)?.toUpperCase();
   },
 });
 
 overridden.get('firstObject'); // 'DOG'
 
-class MyNewProxy<T> extends Ember.ArrayProxy<T> {
+class MyNewProxy<T> extends ArrayProxy<T> {
   isNew = true;
 }
 
-const x = MyNewProxy.create({ content: Ember.A([1, 2, 3]) }) as MyNewProxy<number>;
+const x = MyNewProxy.create({ content: A([1, 2, 3]) }) as MyNewProxy<number>;
 expectTypeOf(x.get('firstObject')).toEqualTypeOf<number | undefined>();
 expectTypeOf(x.isNew).toBeBoolean();
diff --git a/type-tests/ember/array.ts b/type-tests/ember/array.ts
index 0daa72308e6..fad6dcf073b 100755
--- a/type-tests/ember/array.ts
+++ b/type-tests/ember/array.ts
@@ -1,12 +1,13 @@
-import Ember from 'ember';
+import { A, NativeArray } from '@ember/array';
+import EmberObject from '@ember/object';
 import { expectTypeOf } from 'expect-type';
 
-class Person extends Ember.Object {
+class Person extends EmberObject {
   name = '';
   isHappy = false;
 }
 
-const people = Ember.A([
+const people = A([
   Person.create({ name: 'Yehuda', isHappy: true }),
   Person.create({ name: 'Majd', isHappy: false }),
 ]);
@@ -23,17 +24,17 @@ expectTypeOf(people.objectAt(0)).toEqualTypeOf<Person | undefined>();
 expectTypeOf(people.objectsAt([1, 2, 3])).toEqualTypeOf<Array<Person | undefined>>();
 
 expectTypeOf(people.filterBy('isHappy')).toMatchTypeOf<Person[]>();
-expectTypeOf(people.filterBy('isHappy')).toMatchTypeOf<Ember.NativeArray<Person>>();
+expectTypeOf(people.filterBy('isHappy')).toMatchTypeOf<NativeArray<Person>>();
 expectTypeOf(people.rejectBy('isHappy')).toMatchTypeOf<Person[]>();
-expectTypeOf(people.rejectBy('isHappy')).toMatchTypeOf<Ember.NativeArray<Person>>();
+expectTypeOf(people.rejectBy('isHappy')).toMatchTypeOf<NativeArray<Person>>();
 expectTypeOf(people.filter((person) => person.get('name') === 'Yehuda')).toMatchTypeOf<Person[]>();
 expectTypeOf(people.filter((person) => person.get('name') === 'Yehuda')).toMatchTypeOf<Person[]>();
 
 expectTypeOf(people.get('[]')).toEqualTypeOf<typeof people>();
 expectTypeOf(people.get('[]').get('firstObject')).toEqualTypeOf<Person | undefined>();
 
-expectTypeOf(people.mapBy('isHappy')).toEqualTypeOf<Ember.NativeArray<boolean>>();
-expectTypeOf(people.mapBy('name.length')).toEqualTypeOf<Ember.NativeArray<unknown>>();
+expectTypeOf(people.mapBy('isHappy')).toEqualTypeOf<NativeArray<boolean>>();
+expectTypeOf(people.mapBy('name.length')).toEqualTypeOf<NativeArray<unknown>>();
 
 const last = people.get('lastObject');
 expectTypeOf(last).toEqualTypeOf<Person | undefined>();
@@ -46,7 +47,7 @@ if (first) {
   expectTypeOf(first.get('isHappy')).toBeBoolean();
 }
 
-const letters: Ember.NativeArray<string> = Ember.A(['a', 'b', 'c']);
+const letters: NativeArray<string> = A(['a', 'b', 'c']);
 const codes = letters.map((item, index, array) => {
   expectTypeOf(item).toBeString();
   expectTypeOf(index).toBeNumber();
@@ -56,11 +57,11 @@ const codes = letters.map((item, index, array) => {
 expectTypeOf(codes).toEqualTypeOf<number[]>();
 
 const value = '1,2,3';
-const filters = Ember.A(value.split(','));
+const filters = A(value.split(','));
 filters.push('4');
 filters.sort();
 
-const multiSortArr = Ember.A([
+const multiSortArr = A([
   { k: 'a', v: 'z' },
   { k: 'a', v: 'y' },
   { k: 'b', v: 'c' },
diff --git a/type-tests/ember/component.ts b/type-tests/ember/component.ts
index 493645d31e2..d5434a5a949 100755
--- a/type-tests/ember/component.ts
+++ b/type-tests/ember/component.ts
@@ -1,14 +1,15 @@
-import Ember from 'ember';
+import Component from '@ember/component';
+import EmberObject, { computed, get } from '@ember/object';
 import { expectTypeOf } from 'expect-type';
 
-Ember.Component.extend({
+Component.extend({
   layout: 'my-layout',
 });
 
-const MyComponent = Ember.Component.extend();
-expectTypeOf(Ember.get(MyComponent, 'positionalParams')).toEqualTypeOf<string | string[]>();
+const MyComponent = Component.extend();
+expectTypeOf(get(MyComponent, 'positionalParams')).toEqualTypeOf<string | string[]>();
 
-const component1 = Ember.Component.extend({
+const component1 = Component.extend({
   actions: {
     hello(name: string) {
       console.log('Hello', name);
@@ -16,7 +17,7 @@ const component1 = Ember.Component.extend({
   },
 });
 
-class AnotherComponent extends Ember.Component {
+class AnotherComponent extends Component {
   name = '';
 
   hello(name: string) {
@@ -25,19 +26,19 @@ class AnotherComponent extends Ember.Component {
   }
 }
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'em',
 });
 
-Ember.Component.extend({
+Component.extend({
   classNames: ['my-class', 'my-other-class'],
 });
 
-class Bindings extends Ember.Component {
+class Bindings extends Component {
   classNameBindings = ['propertyA', 'propertyB'];
   propertyA = 'from-a';
 
-  @Ember.computed()
+  @computed()
   get propertyB() {
     if (!this.get('propertyA')) {
       return 'from-b';
@@ -45,73 +46,73 @@ class Bindings extends Ember.Component {
   }
 }
 
-Ember.Component.extend({
+Component.extend({
   classNameBindings: ['hovered'],
   hovered: true,
 });
 
-class Message extends Ember.Object {
+class Message extends EmberObject {
   empty = false;
 }
 
-Ember.Component.extend({
+Component.extend({
   classNameBindings: ['messages.empty'],
   messages: Message.create({
     empty: true,
   }),
 });
 
-Ember.Component.extend({
+Component.extend({
   classNameBindings: ['isEnabled:enabled:disabled'],
   isEnabled: true,
 });
 
-Ember.Component.extend({
+Component.extend({
   classNameBindings: ['isEnabled::disabled'],
   isEnabled: true,
 });
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'a',
   attributeBindings: ['href'],
   href: 'http://google.com',
 });
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'a',
   attributeBindings: ['url:href'],
   url: 'http://google.com',
 });
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'use',
   attributeBindings: ['xlinkHref:xlink:href'],
   xlinkHref: '#triangle',
 });
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'input',
   attributeBindings: ['disabled'],
   disabled: false,
 });
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'input',
   attributeBindings: ['disabled'],
-  disabled: Ember.computed(() => {
+  disabled: computed(() => {
     return someLogic();
   }),
 });
 
 declare function someLogic(): boolean;
 
-Ember.Component.extend({
+Component.extend({
   tagName: 'form',
   attributeBindings: ['novalidate'],
   novalidate: null,
 });
 
-Ember.Component.extend({
+Component.extend({
   click(event: object) {
     // will be called when an instance's
     // rendered element is clicked
diff --git a/type-tests/ember/computed.ts b/type-tests/ember/computed.ts
index a2207e734a5..4cf270b49bf 100755
--- a/type-tests/ember/computed.ts
+++ b/type-tests/ember/computed.ts
@@ -1,34 +1,34 @@
-import Ember from 'ember';
+import EmberObject, { computed } from '@ember/object';
 import { expectTypeOf } from 'expect-type';
 
 function customMacro(message: string) {
-  return Ember.computed(() => {
+  return computed(() => {
     return [message, message];
   });
 }
 
-class Person extends Ember.Object {
+class Person extends EmberObject {
   firstName = '';
   lastName = '';
   age = 0;
 
   // Equivalent to a per-instance `defineProperty` call.
-  @Ember.computed()
+  @computed()
   get noArgs() {
     return 'test';
   }
 
-  @Ember.computed('firstName', 'lastName')
+  @computed('firstName', 'lastName')
   get fullName(): string {
     return `${this.get('firstName')} ${this.get('lastName')}`;
   }
 
-  @(Ember.computed('fullName').readOnly())
+  @(computed('fullName').readOnly())
   get fullNameReadonly() {
     return this.get('fullName');
   }
 
-  @Ember.computed('firstName', 'lastName')
+  @computed('firstName', 'lastName')
   get fullNameWritable(): string {
     return this.get('fullName');
   }
@@ -39,7 +39,7 @@ class Person extends Ember.Object {
     this.set('lastName', last);
   }
 
-  @(Ember.computed().meta({ foo: 'bar' }).readOnly())
+  @(computed().meta({ foo: 'bar' }).readOnly())
   get combinators() {
     return this.get('firstName');
   }
@@ -92,8 +92,8 @@ expectTypeOf(person3.get('firstName')).toEqualTypeOf<string>();
 expectTypeOf(person3.get('fullName')).toEqualTypeOf<string>();
 
 const person4 = Person.extend({
-  firstName: Ember.computed(() => 'Fred'),
-  fullName: Ember.computed(() => 'Fred Smith'),
+  firstName: computed(() => 'Fred'),
+  fullName: computed(() => 'Fred Smith'),
 }).create();
 
 expectTypeOf(person4.get('firstName')).toEqualTypeOf<string>();
diff --git a/type-tests/ember/controller.ts b/type-tests/ember/controller.ts
index 7e89a8d8334..34148a56e88 100755
--- a/type-tests/ember/controller.ts
+++ b/type-tests/ember/controller.ts
@@ -1,6 +1,6 @@
-import Ember from 'ember';
+import Controller from "@ember/controller";
 
-class MyController extends Ember.Controller {
+class MyController extends Controller {
   queryParams = ['category'];
   category = null;
   isExpanded = false;
diff --git a/type-tests/ember/core-object.ts b/type-tests/ember/core-object.ts
index 57fdb990321..61dd3a357f9 100644
--- a/type-tests/ember/core-object.ts
+++ b/type-tests/ember/core-object.ts
@@ -1,21 +1,19 @@
-import Ember from 'ember';
+import CoreObject from '@ember/object/core';
 import { expectTypeOf } from 'expect-type';
 
-const { CoreObject } = Ember;
-
 /** Newable tests */
 const co1 = new CoreObject();
 
 expectTypeOf(co1.isDestroyed).toBeBoolean();
 expectTypeOf(co1.isDestroying).toBeBoolean();
-expectTypeOf(co1.destroy()).toEqualTypeOf<Ember.CoreObject>();
+expectTypeOf(co1.destroy()).toEqualTypeOf<CoreObject>();
 expectTypeOf(co1.toString()).toBeString();
 
 /** .create tests */
 const co2 = CoreObject.create();
 expectTypeOf(co2.isDestroyed).toBeBoolean();
 expectTypeOf(co2.isDestroying).toBeBoolean();
-expectTypeOf(co2.destroy()).toEqualTypeOf<Ember.CoreObject>();
+expectTypeOf(co2.destroy()).toEqualTypeOf<CoreObject>();
 expectTypeOf(co2.toString()).toBeString();
 
 /** .create tests w/ initial instance data passed in */
diff --git a/type-tests/ember/create.ts b/type-tests/ember/create.ts
index 5846fd2b037..e615991b6b4 100755
--- a/type-tests/ember/create.ts
+++ b/type-tests/ember/create.ts
@@ -1,21 +1,21 @@
-import Ember from 'ember';
+import EmberObject, { computed } from '@ember/object';
 import { expectTypeOf } from 'expect-type';
 
 /**
  * Zero-argument case
  */
-const o = Ember.Object.create();
+const o = EmberObject.create();
 // create returns an object
 expectTypeOf(o).toBeObject();
-// object returned by create type-checks as an instance of Ember.Object
+// object returned by create type-checks as an instance of EmberObject
 expectTypeOf(o.isDestroyed).toBeBoolean();
 expectTypeOf(o.isDestroying).toBeBoolean();
-expectTypeOf(o.get).toMatchTypeOf<<K extends keyof Ember.Object>(key: K) => Ember.Object[K]>();
+expectTypeOf(o.get).toMatchTypeOf<<K extends keyof EmberObject>(key: K) => EmberObject[K]>();
 
 /**
  * One-argument case
  */
-class O1 extends Ember.Object {
+class O1 extends EmberObject {
   declare x: number;
   declare y: string;
   declare z: boolean;
@@ -26,7 +26,7 @@ expectTypeOf(o1.x).toBeNumber();
 expectTypeOf(o1.y).toBeString();
 expectTypeOf(o1.z).toBeBoolean();
 
-class O2 extends Ember.Object {
+class O2 extends EmberObject {
   declare a: number;
   declare b: number;
   declare c: number;
@@ -36,12 +36,12 @@ expectTypeOf(obj.b).toBeNumber();
 expectTypeOf(obj.a).toBeNumber();
 expectTypeOf(obj.c).toBeNumber();
 
-export class Person extends Ember.Object {
+export class Person extends EmberObject {
   declare firstName: string;
   declare lastName: string;
   declare age: number;
 
-  @Ember.computed('firstName', 'lastName')
+  @computed('firstName', 'lastName')
   get fullName() {
     return [this.firstName + this.lastName].join(' ');
   }
diff --git a/type-tests/ember/data-adapter.ts b/type-tests/ember/data-adapter.ts
index a7e0096691c..dfcbf251330 100644
--- a/type-tests/ember/data-adapter.ts
+++ b/type-tests/ember/data-adapter.ts
@@ -1,7 +1,8 @@
-import Ember from 'ember';
+import type ContainerDebugAdapter from '@ember/debug/container-debug-adapter';
+import DataAdapter from '@ember/debug/data-adapter';
 import { expectTypeOf } from 'expect-type';
 
-const da = Ember.DataAdapter.create();
+const da = DataAdapter.create();
 
 const filters = da.getFilters();
 expectTypeOf(filters.includes({ name: 'foo', desc: 'bar' })).toBeBoolean();
@@ -52,8 +53,8 @@ expectTypeOf(
 da.watchRecords(() => {});
 
 expectTypeOf(da.acceptsModelName).toEqualTypeOf<boolean>();
-expectTypeOf(da.containerDebugAdapter).toEqualTypeOf<Ember.ContainerDebugAdapter>();
+expectTypeOf(da.containerDebugAdapter).toEqualTypeOf<ContainerDebugAdapter>();
 
-const ca: Ember.ContainerDebugAdapter = da.containerDebugAdapter;
+const ca: ContainerDebugAdapter = da.containerDebugAdapter;
 expectTypeOf(ca.canCatalogEntriesByType('controller')).toEqualTypeOf<boolean>();
 expectTypeOf(ca.catalogEntriesByType('controller')).toEqualTypeOf<string[]>();
diff --git a/type-tests/ember/debug.ts b/type-tests/ember/debug.ts
index 75ff474845c..7d99bfce88c 100644
--- a/type-tests/ember/debug.ts
+++ b/type-tests/ember/debug.ts
@@ -1,15 +1,8 @@
-import Ember from 'ember';
 import { expectTypeOf } from 'expect-type';
-
-const {
-  runInDebug,
-  warn,
-  debug,
-  Debug: { registerDeprecationHandler, registerWarnHandler },
-} = Ember;
+import { debug, assert as EmberAssert, registerDeprecationHandler, registerWarnHandler, runInDebug, warn } from '@ember/debug';
 
 // Workaround for https://github.com/microsoft/TypeScript/issues/36931.
-const assert: typeof Ember.assert = Ember.assert;
+const assert: typeof EmberAssert = EmberAssert;
 
 /**
  * @ember/debug tests
diff --git a/type-tests/ember/ember-module-tests.ts b/type-tests/ember/ember-module-tests.ts
index d96579fefc2..036945d8edf 100644
--- a/type-tests/ember/ember-module-tests.ts
+++ b/type-tests/ember/ember-module-tests.ts
@@ -295,3 +295,7 @@ Ember.create;
 Ember.reset;
 // @ts-expect-error
 Ember.unsubscribe;
+
+// Ensure that Ember.Transition is private
+// @ts-expect-error
+Ember.Transition;
diff --git a/type-tests/ember/ember-tests.ts b/type-tests/ember/ember-tests.ts
index 6419033ea88..0bc0f08b4f5 100755
--- a/type-tests/ember/ember-tests.ts
+++ b/type-tests/ember/ember-tests.ts
@@ -1,26 +1,31 @@
 import type { AnyFn } from '@ember/-internals/utility-types';
-import { A } from '@ember/array';
-import Ember from 'ember';
+import Application from '@ember/application';
+import { A, NativeArray } from '@ember/array';
+import Component from '@ember/component';
+import EmberObject, { computed } from '@ember/object';
+import Mixin from '@ember/object/mixin';
+import { service } from '@ember/service';
 import { expectTypeOf } from 'expect-type';
+import RSVP from 'rsvp';
 
-class President extends Ember.Object {
+class President extends EmberObject {
   name = 'Barack Obama';
 }
 
 class DetailedPresident extends President {
   firstName = 'Barack';
   lastName = 'Obama';
-  @Ember.computed()
+  @computed()
   get fullName() {
     return `${this.get('firstName')} ${this.get('lastName')}`;
   }
 }
 
-class Country extends Ember.Object {
+class Country extends EmberObject {
   presidentNameBinding = 'MyApp.president.name';
 }
 
-class MyApp extends Ember.Application {
+class MyApp extends Application {
   president = President.create();
   country = Country.create();
 
@@ -32,19 +37,19 @@ App.country.get('presidentName');
 App.president = DetailedPresident.create();
 App.president.get('fullName');
 
-declare class MyPerson extends Ember.Object {
+declare class MyPerson extends EmberObject {
   static createMan(): MyPerson;
 }
 MyPerson.createMan();
 
-class Person1 extends Ember.Object {
+class Person1 extends EmberObject {
   name?: string;
   say = (thing: string) => {
     alert(thing);
   };
 }
 
-declare class MyPerson2 extends Ember.Object {
+declare class MyPerson2 extends EmberObject {
   helloWorld(): void;
 }
 MyPerson2.create().helloWorld();
@@ -61,14 +66,14 @@ tom.helloWorld();
 const PersonReopened = Person1.reopen({ isPerson: true });
 PersonReopened.create().get('isPerson');
 
-class Todo extends Ember.Object {
+class Todo extends EmberObject {
   isDone = false;
 }
 
-class TodosController extends Ember.Object {
+class TodosController extends EmberObject {
   todos = A([Todo.create()]);
 
-  @Ember.computed('todos.@each.isDone')
+  @computed('todos.@each.isDone')
   get remaining() {
     const todos = this.get('todos');
     return todos.filterBy('isDone', false).get('length');
@@ -85,18 +90,18 @@ todo = Todo.create({ isDone: true });
 todos.pushObject(todo);
 App.todosController.get('remaining');
 
-const NormalApp = Ember.Application.create({
+const NormalApp = Application.create({
   rootElement: '#sidebar',
 });
 
-class Person2 extends Ember.Object {
+class Person2 extends EmberObject {
   name = '';
 
   sayHello() {
     console.log('Hello from ' + this.get('name'));
   }
 }
-const people = Ember.A([
+const people = A([
   Person2.create({ name: 'Juan' }),
   Person2.create({ name: 'Charles' }),
   Person2.create({ name: 'Majd' }),
@@ -105,24 +110,24 @@ people.invoke('sayHello');
 // @ts-expect-error
 people.invoke('name');
 
-class Obj extends Ember.Object {
+class Obj extends EmberObject {
   name?: string;
 }
 
-const arr: Ember.NativeArray<Obj> = Ember.A([Ember.Object.create(), Ember.Object.create()]);
+const arr: NativeArray<Obj> = A([EmberObject.create(), EmberObject.create()]);
 expectTypeOf(arr.setEach('name', 'unknown')).toEqualTypeOf(arr);
 expectTypeOf(arr.setEach('name', undefined)).toEqualTypeOf(arr);
-expectTypeOf(arr.getEach('name')).toEqualTypeOf<Ember.NativeArray<string | undefined>>();
+expectTypeOf(arr.getEach('name')).toEqualTypeOf<NativeArray<string | undefined>>();
 // @ts-expect-error
 arr.setEach('age', 123);
 // @ts-expect-error
 arr.getEach('age');
 
-class Person3 extends Ember.Object {
+class Person3 extends EmberObject {
   name?: string;
   isHappy = false;
 }
-const people2 = Ember.A([
+const people2 = A([
   Person3.create({ name: 'Yehuda', isHappy: true }),
   Person3.create({ name: 'Majd', isHappy: false }),
 ]);
@@ -139,7 +144,7 @@ people2.isAny('isHappy', true);
 people2.isAny('isHappy');
 
 // Examples taken from http://emberjs.com/api/classes/Em.RSVP.Promise.html
-const promise = new Ember.RSVP.Promise<string>((resolve: AnyFn, reject: AnyFn) => {
+const promise = new RSVP.Promise<string>((resolve: AnyFn, reject: AnyFn) => {
   // on success
   resolve('ok!');
 
@@ -158,17 +163,17 @@ promise.then(
 );
 
 // make sure Ember.RSVP.Promise can be reference as a type
-declare function promiseReturningFunction(urn: string): Ember.RSVP.Promise<string>;
+declare function promiseReturningFunction(urn: string): RSVP.Promise<string>;
 
-const mix1 = Ember.Mixin.create({
+const mix1 = Mixin.create({
   foo: 1,
 });
 
-const mix2 = Ember.Mixin.create({
+const mix2 = Mixin.create({
   bar: 2,
 });
 
-const component1 = Ember.Component.extend(mix1, mix2, {
-  lyft: Ember.inject.service(),
-  cars: Ember.computed('lyft.cars').readOnly(),
+const component1 = Component.extend(mix1, mix2, {
+  lyft: service(),
+  cars: computed('lyft.cars').readOnly(),
 });
diff --git a/type-tests/ember/engine-instance.ts b/type-tests/ember/engine-instance.ts
index 0da036e13af..31673364402 100644
--- a/type-tests/ember/engine-instance.ts
+++ b/type-tests/ember/engine-instance.ts
@@ -1,5 +1,4 @@
-import Ember from 'ember';
-const { EngineInstance } = Ember;
+import EngineInstance from "@ember/engine/instance";
 
 const engineInstance = EngineInstance.create();
 engineInstance.register('some:injection', class Foo {});
diff --git a/type-tests/ember/engine.ts b/type-tests/ember/engine.ts
index f409fb708c4..bbaba4995fa 100755
--- a/type-tests/ember/engine.ts
+++ b/type-tests/ember/engine.ts
@@ -1,10 +1,11 @@
-import Ember from 'ember';
+import Engine from "@ember/engine";
+import EmberObject from "@ember/object";
 
-class BaseEngine extends Ember.Engine {
+class BaseEngine extends Engine {
   modulePrefix = 'my-engine';
 }
 
-class Obj extends Ember.Object {
+class Obj extends EmberObject {
   foo = 'bar';
 }
 
diff --git a/type-tests/ember/event.ts b/type-tests/ember/event.ts
index 90580d8ba9a..81179546af3 100755
--- a/type-tests/ember/event.ts
+++ b/type-tests/ember/event.ts
@@ -1,20 +1,23 @@
-import Ember from 'ember';
+import Component from "@ember/component";
+import EmberObject, { observer } from "@ember/object";
+import Evented, { on } from "@ember/object/evented";
+import { addListener, removeListener, sendEvent } from "@ember/object/events";
 
 function testOn() {
-  const Job = Ember.Object.extend({
-    logCompleted: Ember.on('completed', () => {
+  const Job = EmberObject.extend({
+    logCompleted: on('completed', () => {
       console.log('Job completed!');
     }),
   });
 
   const job = Job.create();
 
-  Ember.sendEvent(job, 'completed'); // Logs 'Job completed!'
+  sendEvent(job, 'completed'); // Logs 'Job completed!'
 }
 
 function testEvented() {
-  interface Person extends Ember.Evented {}
-  class Person extends Ember.Object {
+  interface Person extends Evented {}
+  class Person extends EmberObject {
     greet() {
       this.trigger('greet');
     }
@@ -39,22 +42,22 @@ function testEvented() {
 }
 
 function testObserver() {
-  Ember.Object.extend({
-    valueObserver: Ember.observer('value', () => {
+  EmberObject.extend({
+    valueObserver: observer('value', () => {
       // Executes whenever the "value" property changes
     }),
   });
 }
 
 function testListener() {
-  class TestListener extends Ember.Component {
+  class TestListener extends Component {
     init() {
-      Ember.addListener(this, 'willDestroyElement', this, 'willDestroyListener');
-      Ember.addListener(this, 'willDestroyElement', this, 'willDestroyListener', true);
-      Ember.addListener(this, 'willDestroyElement', this, this.willDestroyListener);
-      Ember.addListener(this, 'willDestroyElement', this, this.willDestroyListener, true);
-      Ember.removeListener(this, 'willDestroyElement', this, 'willDestroyListener');
-      Ember.removeListener(this, 'willDestroyElement', this, this.willDestroyListener);
+      addListener(this, 'willDestroyElement', this, 'willDestroyListener');
+      addListener(this, 'willDestroyElement', this, 'willDestroyListener', true);
+      addListener(this, 'willDestroyElement', this, this.willDestroyListener);
+      addListener(this, 'willDestroyElement', this, this.willDestroyListener, true);
+      removeListener(this, 'willDestroyElement', this, 'willDestroyListener');
+      removeListener(this, 'willDestroyElement', this, this.willDestroyListener);
     }
     willDestroyListener() {}
   }
diff --git a/type-tests/ember/extend.ts b/type-tests/ember/extend.ts
index a994fa39867..05f58600701 100755
--- a/type-tests/ember/extend.ts
+++ b/type-tests/ember/extend.ts
@@ -1,7 +1,7 @@
-import Ember from 'ember';
+import EmberObject from '@ember/object';
 import { expectTypeOf } from 'expect-type';
 
-class Person extends Ember.Object {
+class Person extends EmberObject {
   declare firstName: string;
   declare lastName: string;
 
@@ -25,7 +25,7 @@ const person = Person.create({
 expectTypeOf(person.fullName).toBeString();
 expectTypeOf(person.extra).toBeNumber();
 
-class PersonWithStatics extends Ember.Object {
+class PersonWithStatics extends EmberObject {
   static isPerson = true;
 }
 const PersonWithStatics2 = PersonWithStatics.extend({});
diff --git a/type-tests/ember/helper.ts b/type-tests/ember/helper.ts
index 2cfc4141a60..2eb4bca4149 100755
--- a/type-tests/ember/helper.ts
+++ b/type-tests/ember/helper.ts
@@ -1,16 +1,18 @@
-import Ember from 'ember';
+import Helper, { helper } from '@ember/component/helper';
+import EmberObject from '@ember/object';
+import Service, { service } from '@ember/service';
 
-const FormatCurrencyHelper = Ember.Helper.helper((params: [number], hash: { currency: string }) => {
+const FormatCurrencyHelper = helper((params: [number], hash: { currency: string }) => {
   const cents = params[0];
   const currency = hash.currency;
   return `${currency}${cents * 0.01}`;
 });
 
-class User extends Ember.Object {
+class User extends EmberObject {
   declare email: string;
 }
 
-class SessionService extends Ember.Service {
+class SessionService extends Service {
   declare currentUser: User;
 }
 
@@ -20,8 +22,8 @@ declare module '@ember/service' {
   }
 }
 
-class CurrentUserEmailHelper extends Ember.Helper {
-  @Ember.inject.service('session')
+class CurrentUserEmailHelper extends Helper {
+  @service('session')
   declare session: SessionService;
 
   compute(): string {
@@ -29,8 +31,6 @@ class CurrentUserEmailHelper extends Ember.Helper {
   }
 }
 
-import { helper } from '@ember/component/helper';
-
 function typedHelp(/*params, hash*/) {
   return 'my type of help';
 }
diff --git a/type-tests/ember/inject.ts b/type-tests/ember/inject.ts
index 42df94317e7..938f79973d4 100755
--- a/type-tests/ember/inject.ts
+++ b/type-tests/ember/inject.ts
@@ -1,11 +1,10 @@
-import Ember from 'ember';
 import { expectTypeOf } from 'expect-type';
 
-class AuthService extends Ember.Service {
+class AuthService extends Service {
   declare isAuthenticated: boolean;
 }
 
-class ApplicationController extends Ember.Controller {
+class ApplicationController extends Controller {
   model = {};
   declare string: string;
   transitionToLogin() {}
@@ -23,11 +22,11 @@ declare module '@ember/controller' {
   }
 }
 
-class LoginRoute extends Ember.Route {
-  @Ember.inject.service('auth')
+class LoginRoute extends Route {
+  @service('auth')
   declare auth: AuthService;
 
-  @Ember.inject.controller('emberApplication')
+  @controller('emberApplication')
   declare application: ApplicationController;
 
   didTransition() {
@@ -44,23 +43,27 @@ class LoginRoute extends Ember.Route {
 
 // New module injection style.
 import RouterService from '@ember/routing/router-service';
-import Controller from '@ember/controller';
+import Controller, { inject as controller } from '@ember/controller';
+import Service from '@ember/service';
+import Route from '@ember/routing/route';
+import { service } from '@ember/service';
+import Component from '@ember/component';
 
-class ComponentInjection extends Ember.Component {
-  @Ember.inject.controller('emberApplication')
+class ComponentInjection extends Component {
+  @controller('emberApplication')
   declare applicationController: ApplicationController;
 
-  @Ember.inject.service('auth')
+  @service('auth')
   declare auth: AuthService;
 
-  @Ember.inject.service('router')
+  @service('router')
   declare router: RouterService;
 
-  @Ember.inject.service
-  declare misc: Ember.Service;
+  @service
+  declare misc: Service;
 
   testem() {
-    expectTypeOf(this.misc).toEqualTypeOf<Ember.Service>();
+    expectTypeOf(this.misc).toEqualTypeOf<Service>();
 
     const url = this.router.urlFor('some-route', 1, 2, 3, {
       queryParams: { seriously: 'yes' },
diff --git a/type-tests/ember/mixin.ts b/type-tests/ember/mixin.ts
index 55176a725ce..9c2ac42f5f8 100755
--- a/type-tests/ember/mixin.ts
+++ b/type-tests/ember/mixin.ts
@@ -1,13 +1,15 @@
-import Ember from 'ember';
+import EmberObject from '@ember/object';
+import Mixin from '@ember/object/mixin';
+import Route from '@ember/routing/route';
 import { expectTypeOf } from 'expect-type';
 
-interface EditableMixin extends Ember.Mixin {
+interface EditableMixin extends Mixin {
   edit(): void;
   isEditing: boolean;
 }
 
-const EditableMixin = Ember.Mixin.create({
-  edit(this: EditableMixin & Ember.Object) {
+const EditableMixin = Mixin.create({
+  edit(this: EditableMixin & EmberObject) {
     this.get('controller');
     console.log('starting to edit');
     this.set('isEditing', true);
@@ -16,7 +18,7 @@ const EditableMixin = Ember.Mixin.create({
 });
 
 interface EditableComment extends EditableMixin {}
-class EditableComment extends Ember.Route.extend(EditableMixin) {
+class EditableComment extends Route.extend(EditableMixin) {
   postId = 0;
 
   canEdit() {
@@ -41,7 +43,7 @@ expectTypeOf(comment.isEditing).toBeBoolean();
 expectTypeOf(comment.postId).toBeNumber();
 
 // We do not expect this to update the type; we do expect it to minimally check
-const LiteralMixins = Ember.Object.extend({ a: 1 }, { b: 2 }, { c: 3 });
+const LiteralMixins = EmberObject.extend({ a: 1 }, { b: 2 }, { c: 3 });
 const obj = LiteralMixins.create();
 // @ts-expect-error
 obj.a;
@@ -54,12 +56,12 @@ obj.c;
 interface EditableAndCancelableMixin extends EditableMixin {
   cancelled: boolean;
 }
-const EditableAndCancelableMixin = Ember.Mixin.create(EditableMixin, {
+const EditableAndCancelableMixin = Mixin.create(EditableMixin, {
   cancelled: false,
 });
 
 interface EditableAndCancelableComment extends EditableAndCancelableMixin {}
-class EditableAndCancelableComment extends Ember.Route.extend(EditableAndCancelableMixin) {}
+class EditableAndCancelableComment extends Route.extend(EditableAndCancelableMixin) {}
 
 const editableAndCancelable = EditableAndCancelableComment.create();
 expectTypeOf(editableAndCancelable.isEditing).toBeBoolean();
diff --git a/type-tests/ember/object.ts b/type-tests/ember/object.ts
index 9ae285df6a1..4ce66ebeb77 100755
--- a/type-tests/ember/object.ts
+++ b/type-tests/ember/object.ts
@@ -1,7 +1,8 @@
-import Ember from 'ember';
+import type EngineInstance from '@ember/engine/instance';
+import EmberObject, { computed, get, notifyPropertyChange, set, setProperties } from '@ember/object';
 import { expectTypeOf } from 'expect-type';
 
-class LifetimeHooks extends Ember.Object {
+class LifetimeHooks extends EmberObject {
   resource: {} | undefined;
 
   init() {
@@ -15,20 +16,20 @@ class LifetimeHooks extends Ember.Object {
   }
 }
 
-class MyObject30 extends Ember.Object {
+class MyObject30 extends EmberObject {
   constructor() {
     super();
   }
 }
 
-class MyObject31 extends Ember.Object {
-  constructor(owner: Ember.EngineInstance) {
+class MyObject31 extends EmberObject {
+  constructor(owner: EngineInstance) {
     super(owner);
   }
 }
 
-class Foo extends Ember.Object {
-  @Ember.computed()
+class Foo extends EmberObject {
+  @computed()
   get a() {
     return '';
   }
@@ -54,11 +55,11 @@ class Foo extends Ember.Object {
   }
 }
 
-export class Foo2 extends Ember.Object {
+export class Foo2 extends EmberObject {
   name = '';
 
   changeName(name: string) {
-    expectTypeOf(Ember.set(this, 'name', name)).toBeString();
+    expectTypeOf(set(this, 'name', name)).toBeString();
 
     // For some reason, `this` type lookup does not resolve correctly here. Used
     // outside a class, like `get(someFoo, 'name')`, this works correctly. Since
@@ -67,20 +68,20 @@ export class Foo2 extends Ember.Object {
     // castable.
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const s: string = this.get('name');
-    expectTypeOf(Ember.get(this as Foo2, 'name')).toBeString();
+    expectTypeOf(get(this as Foo2, 'name')).toBeString();
     expectTypeOf((this as Foo2).get('name')).toBeString();
 
     expectTypeOf(this.setProperties({ name })).toEqualTypeOf<{ name: string }>();
-    expectTypeOf(Ember.setProperties(this, { name })).toEqualTypeOf<{ name: string }>();
+    expectTypeOf(setProperties(this, { name })).toEqualTypeOf<{ name: string }>();
   }
 
   bar() {
-    Ember.notifyPropertyChange(this, 'name');
+    notifyPropertyChange(this, 'name');
     // @ts-expect-error
-    Ember.notifyPropertyChange(this);
+    notifyPropertyChange(this);
     // @ts-expect-error
-    Ember.notifyPropertyChange('name');
+    notifyPropertyChange('name');
     // @ts-expect-error
-    Ember.notifyPropertyChange(this, 'name', 'bar');
+    notifyPropertyChange(this, 'name', 'bar');
   }
 }
diff --git a/type-tests/ember/observable.ts b/type-tests/ember/observable.ts
index 88fc7634aff..fd43100f42f 100755
--- a/type-tests/ember/observable.ts
+++ b/type-tests/ember/observable.ts
@@ -1,29 +1,31 @@
-import Ember from 'ember';
+import Component from '@ember/component';
+import EmberObject, { computed, get, getProperties, set, setProperties } from '@ember/object';
+import { addObserver, removeObserver } from '@ember/object/observers';
 import { expectTypeOf } from 'expect-type';
 
-class MyComponent extends Ember.Component {
+class MyComponent extends Component {
   foo = 'bar';
 
   init() {
     this._super();
     this.addObserver('foo', this, 'fooDidChange');
     this.addObserver('foo', this, this.fooDidChange);
-    Ember.addObserver(this, 'foo', this, 'fooDidChange');
-    Ember.addObserver(this, 'foo', this, this.fooDidChange);
+    addObserver(this, 'foo', this, 'fooDidChange');
+    addObserver(this, 'foo', this, this.fooDidChange);
     this.removeObserver('foo', this, 'fooDidChange');
     this.removeObserver('foo', this, this.fooDidChange);
-    Ember.removeObserver(this, 'foo', this, 'fooDidChange');
-    Ember.removeObserver(this, 'foo', this, this.fooDidChange);
+    removeObserver(this, 'foo', this, 'fooDidChange');
+    removeObserver(this, 'foo', this, this.fooDidChange);
     const lambda = () => {
       this.fooDidChange(this, 'foo');
     };
     this.addObserver('foo', lambda);
     this.removeObserver('foo', lambda);
-    Ember.addObserver(this, 'foo', lambda);
-    Ember.removeObserver(this, 'foo', lambda);
+    addObserver(this, 'foo', lambda);
+    removeObserver(this, 'foo', lambda);
   }
 
-  @Ember.computed('foo')
+  @computed('foo')
   get bar(): string {
     return this.foo;
   }
@@ -38,11 +40,11 @@ myComponent.addObserver('foo', null, () => {});
 myComponent.set('foo', 'baz');
 expectTypeOf(myComponent.get('foo')).toEqualTypeOf<string>();
 
-class Person extends Ember.Object {
+class Person extends EmberObject {
   name = '';
   age = 0;
 
-  @Ember.computed()
+  @computed()
   get capitalized() {
     return this.get('name').toUpperCase();
   }
@@ -55,26 +57,26 @@ const person = Person.create({
 const pojo = { name: 'Fred', age: 29 };
 
 function testGet() {
-  expectTypeOf(Ember.get(person, 'name')).toEqualTypeOf<string>();
-  expectTypeOf(Ember.get(person, 'age')).toEqualTypeOf<number>();
-  expectTypeOf(Ember.get(person, 'capitalized')).toEqualTypeOf<string>();
+  expectTypeOf(get(person, 'name')).toEqualTypeOf<string>();
+  expectTypeOf(get(person, 'age')).toEqualTypeOf<number>();
+  expectTypeOf(get(person, 'capitalized')).toEqualTypeOf<string>();
   expectTypeOf(person.get('name')).toEqualTypeOf<string>();
   expectTypeOf(person.get('age')).toEqualTypeOf<number>();
   expectTypeOf(person.get('capitalized')).toEqualTypeOf<string>();
-  expectTypeOf(Ember.get(pojo, 'name')).toEqualTypeOf<string>();
+  expectTypeOf(get(pojo, 'name')).toEqualTypeOf<string>();
 }
 
 function testGetProperties() {
-  expectTypeOf(Ember.getProperties(person, 'name')).toEqualTypeOf<{ name: string }>();
-  expectTypeOf(Ember.getProperties(person, 'name', 'age')).toEqualTypeOf<{
+  expectTypeOf(getProperties(person, 'name')).toEqualTypeOf<{ name: string }>();
+  expectTypeOf(getProperties(person, 'name', 'age')).toEqualTypeOf<{
     name: string;
     age: number;
   }>();
-  expectTypeOf(Ember.getProperties(person, ['name', 'age'])).toEqualTypeOf<{
+  expectTypeOf(getProperties(person, ['name', 'age'])).toEqualTypeOf<{
     name: string;
     age: number;
   }>();
-  expectTypeOf(Ember.getProperties(person, 'name', 'age', 'capitalized')).toEqualTypeOf<
+  expectTypeOf(getProperties(person, 'name', 'age', 'capitalized')).toEqualTypeOf<
     Pick<Person, 'name' | 'age' | 'capitalized'>
   >();
   expectTypeOf(person.getProperties('name')).toEqualTypeOf<{ name: string }>();
@@ -88,28 +90,28 @@ function testGetProperties() {
     age: number;
     capitalized: string;
   }>();
-  expectTypeOf(Ember.getProperties(pojo, 'name', 'age')).toEqualTypeOf<
+  expectTypeOf(getProperties(pojo, 'name', 'age')).toEqualTypeOf<
     Pick<typeof pojo, 'name' | 'age'>
   >();
 }
 
 function testSet() {
-  expectTypeOf(Ember.set(person, 'name', 'Joe')).toBeString();
-  expectTypeOf(Ember.set(person, 'age', 35)).toBeNumber();
-  expectTypeOf(Ember.set(person, 'capitalized', 'JOE')).toBeString();
+  expectTypeOf(set(person, 'name', 'Joe')).toBeString();
+  expectTypeOf(set(person, 'age', 35)).toBeNumber();
+  expectTypeOf(set(person, 'capitalized', 'JOE')).toBeString();
   expectTypeOf(person.set('name', 'Joe')).toBeString();
   expectTypeOf(person.set('age', 35)).toBeNumber();
   expectTypeOf(person.set('capitalized', 'JOE')).toBeString();
-  expectTypeOf(Ember.set(pojo, 'name', 'Joe')).toBeString();
+  expectTypeOf(set(pojo, 'name', 'Joe')).toBeString();
 }
 
 function testSetProperties() {
-  expectTypeOf(Ember.setProperties(person, { name: 'Joe' })).toEqualTypeOf<{ name: string }>();
-  expectTypeOf(Ember.setProperties(person, { name: 'Joe', age: 35 })).toEqualTypeOf<{
+  expectTypeOf(setProperties(person, { name: 'Joe' })).toEqualTypeOf<{ name: string }>();
+  expectTypeOf(setProperties(person, { name: 'Joe', age: 35 })).toEqualTypeOf<{
     name: string;
     age: number;
   }>();
-  expectTypeOf(Ember.setProperties(person, { name: 'Joe', capitalized: 'JOE' })).toEqualTypeOf<
+  expectTypeOf(setProperties(person, { name: 'Joe', capitalized: 'JOE' })).toEqualTypeOf<
     Pick<Person, 'name' | 'capitalized'>
   >();
   expectTypeOf(person.setProperties({ name: 'Joe' })).toEqualTypeOf<Pick<Person, 'name'>>();
@@ -120,7 +122,7 @@ function testSetProperties() {
     name: string;
     capitalized: string;
   }>();
-  expectTypeOf(Ember.setProperties(pojo, { name: 'Joe', age: 35 })).toEqualTypeOf<
+  expectTypeOf(setProperties(pojo, { name: 'Joe', age: 35 })).toEqualTypeOf<
     Pick<typeof pojo, 'name' | 'age'>
   >();
 }
@@ -133,18 +135,18 @@ function testDynamic() {
   // never properly supported that flag, and there is no path to doing so. If
   // someone wants that support, they should switch to using direct property
   // access instead of using `get` (which has many other advantages).
-  expectTypeOf(Ember.get(obj, 'dummy')).toEqualTypeOf<string>();
-  expectTypeOf(Ember.get(obj, dynamicKey)).toEqualTypeOf<string>();
-  expectTypeOf(Ember.getProperties(obj, 'dummy')).toEqualTypeOf<{ dummy: string }>();
-  expectTypeOf(Ember.getProperties(obj, ['dummy'])).toEqualTypeOf<{ dummy: string }>();
-  expectTypeOf(Ember.getProperties(obj, dynamicKey)).toEqualTypeOf<Record<string, string>>();
-  expectTypeOf(Ember.getProperties(obj, [dynamicKey])).toEqualTypeOf<Record<string, string>>();
-  expectTypeOf(Ember.set(obj, 'dummy', 'value')).toBeString();
-  expectTypeOf(Ember.set(obj, dynamicKey, 'value')).toBeString();
-  expectTypeOf(Ember.setProperties(obj, { dummy: 'value ' })).toEqualTypeOf<
+  expectTypeOf(get(obj, 'dummy')).toEqualTypeOf<string>();
+  expectTypeOf(get(obj, dynamicKey)).toEqualTypeOf<string>();
+  expectTypeOf(getProperties(obj, 'dummy')).toEqualTypeOf<{ dummy: string }>();
+  expectTypeOf(getProperties(obj, ['dummy'])).toEqualTypeOf<{ dummy: string }>();
+  expectTypeOf(getProperties(obj, dynamicKey)).toEqualTypeOf<Record<string, string>>();
+  expectTypeOf(getProperties(obj, [dynamicKey])).toEqualTypeOf<Record<string, string>>();
+  expectTypeOf(set(obj, 'dummy', 'value')).toBeString();
+  expectTypeOf(set(obj, dynamicKey, 'value')).toBeString();
+  expectTypeOf(setProperties(obj, { dummy: 'value ' })).toEqualTypeOf<
     Record<'dummy', string>
   >();
-  expectTypeOf(Ember.setProperties(obj, { [dynamicKey]: 'value' })).toEqualTypeOf<
+  expectTypeOf(setProperties(obj, { [dynamicKey]: 'value' })).toEqualTypeOf<
     Record<string, string>
   >();
 }
diff --git a/type-tests/ember/private/computed-tests.ts b/type-tests/ember/private/computed-tests.ts
index 7a5448faa93..da74dfb713e 100644
--- a/type-tests/ember/private/computed-tests.ts
+++ b/type-tests/ember/private/computed-tests.ts
@@ -1,16 +1,16 @@
-import Ember from 'ember';
+import EmberObject, { computed } from '@ember/object';
 import { expectTypeOf } from 'expect-type';
 
-class Example1 extends Ember.Object {
+class Example1 extends EmberObject {
   firstName = '';
   lastName = '';
 
-  @Ember.computed('fullName')
+  @computed('fullName')
   get allNames() {
     return [this.fullName];
   }
 
-  @Ember.computed('firstName', 'lastName')
+  @computed('firstName', 'lastName')
   get fullName() {
     return `${this.firstName} ${this.lastName}`;
   }
diff --git a/type-tests/ember/reopen.ts b/type-tests/ember/reopen.ts
index a4cf4673dcf..cd361c11d5f 100755
--- a/type-tests/ember/reopen.ts
+++ b/type-tests/ember/reopen.ts
@@ -1,7 +1,8 @@
-import Ember from 'ember';
+import EmberObject from '@ember/object';
+import Mixin from '@ember/object/mixin';
 import { expectTypeOf } from 'expect-type';
 
-class Person extends Ember.Object {
+class Person extends EmberObject {
   name = '';
 
   sayHello() {
@@ -66,10 +67,10 @@ person3.sayGoodbye();
 interface AutoResizeMixin {
   resizable: true;
 }
-const AutoResizeMixin = Ember.Mixin.create({ resizable: true });
+const AutoResizeMixin = Mixin.create({ resizable: true });
 
 // And the same here.
-const Reopened = Ember.Object.reopenClass({ a: 1 }, { b: 2 }, { c: 3 });
+const Reopened = EmberObject.reopenClass({ a: 1 }, { b: 2 }, { c: 3 });
 // @ts-expect-error
 Reopened.a;
 // @ts-expect-error
diff --git a/type-tests/ember/route.ts b/type-tests/ember/route.ts
index 67b5fa54ef8..e3a6cab5bd6 100755
--- a/type-tests/ember/route.ts
+++ b/type-tests/ember/route.ts
@@ -1,16 +1,14 @@
 import Route from '@ember/routing/route';
 import Array from '@ember/array';
-import Ember from 'ember'; // currently needed for Transition
+
 import type Transition from '@ember/routing/transition';
 import { expectTypeOf } from 'expect-type';
 import { service } from '@ember/service';
 import RouterService from '@ember/routing/router-service';
+import type EmberObject from '@ember/object';
+import type Controller from '@ember/controller';
 
-// Ensure that Ember.Transition is private
-// @ts-expect-error
-Ember.Transition;
-
-interface Post extends Ember.Object {
+interface Post extends EmberObject {
   title: string;
 }
 
@@ -36,12 +34,12 @@ class Test extends Route {
     }
   }
 
-  setupController(controller: Ember.Controller, model: {}) {
+  setupController(controller: Controller, model: {}) {
     this._super(controller, model);
     this.controllerFor('application').set('model', model);
   }
 
-  resetController(controller: Ember.Controller, isExiting: boolean, transition: Transition) {
+  resetController(controller: Controller, isExiting: boolean, transition: Transition) {
     if (isExiting) {
       //   controller.set('page', 1);
     }
diff --git a/type-tests/ember/router.ts b/type-tests/ember/router.ts
index 849677e4716..4aa611c3880 100755
--- a/type-tests/ember/router.ts
+++ b/type-tests/ember/router.ts
@@ -1,8 +1,10 @@
 import RouterService from '@ember/routing/router-service';
-import Ember from 'ember';
 import { expectTypeOf } from 'expect-type';
+import Router from '@ember/routing/router';
+import Service, { service } from '@ember/service';
+import EmberObject, { get } from '@ember/object';
 
-const AppRouter = Ember.Router.extend({});
+const AppRouter = Router.extend({});
 
 AppRouter.map(function () {
   this.route('index', { path: '/' });
@@ -24,8 +26,8 @@ AppRouter.map(function () {
   this.mount('my-engine', { as: 'some-other-engine', path: '/some-other-engine' });
 });
 
-class RouterServiceConsumer extends Ember.Service {
-  @Ember.inject.service('router')
+class RouterServiceConsumer extends Service {
+  @service('router')
   declare router: RouterService;
 
   currentRouteName() {
@@ -35,18 +37,18 @@ class RouterServiceConsumer extends Ember.Service {
     expectTypeOf(this.router.currentURL).toEqualTypeOf<string | null>();
   }
   transitionWithoutModel() {
-    Ember.get(this, 'router').transitionTo('some-route');
+    get(this, 'router').transitionTo('some-route');
   }
   transitionWithModel() {
-    const model = Ember.Object.create();
-    Ember.get(this, 'router').transitionTo('some.other.route', model);
+    const model = EmberObject.create();
+    get(this, 'router').transitionTo('some.other.route', model);
   }
   transitionWithMultiModel() {
-    const model = Ember.Object.create();
-    Ember.get(this, 'router').transitionTo('some.other.route', model, model);
+    const model = EmberObject.create();
+    get(this, 'router').transitionTo('some.other.route', model, model);
   }
   transitionWithModelAndOptions() {
-    const model = Ember.Object.create();
-    Ember.get(this, 'router').transitionTo('index', model, { queryParams: { search: 'ember' } });
+    const model = EmberObject.create();
+    get(this, 'router').transitionTo('index', model, { queryParams: { search: 'ember' } });
   }
 }
diff --git a/type-tests/ember/run.ts b/type-tests/ember/run.ts
index ad9bf421c2b..b4b55178fba 100755
--- a/type-tests/ember/run.ts
+++ b/type-tests/ember/run.ts
@@ -1,16 +1,17 @@
-import Ember from 'ember';
+import type Application from '@ember/application';
+import { run } from '@ember/runloop';
 import { expectTypeOf } from 'expect-type';
 
 function testRun() {
-  const r = Ember.run(() => {
+  const r = run(() => {
     // code to be executed within a RunLoop
     return 123;
   });
   expectTypeOf(r).toEqualTypeOf<number>();
 
-  function destroyApp(application: Ember.Application) {
-    Ember.run(application, 'destroy');
-    Ember.run(application, function () {
+  function destroyApp(application: Application) {
+    run(application, 'destroy');
+    run(application, function () {
       this.destroy();
     });
   }
diff --git a/type-tests/ember/test.ts b/type-tests/ember/test.ts
index 09cbeaa21db..60ba2c04ae7 100755
--- a/type-tests/ember/test.ts
+++ b/type-tests/ember/test.ts
@@ -1,4 +1,7 @@
-import Ember from 'ember';
+import { run } from "@ember/runloop";
+import { registerAsyncHelper, registerHelper, registerWaiter } from "@ember/test";
+import { asyncEnd, asyncStart } from "ember-testing/lib/test/adapter";
+import TestPromise, { promise} from "ember-testing/lib/test/promise";
 
 const pending = 0;
 
@@ -6,41 +9,30 @@ declare const MyDb: {
   hasPendingTransactions(): boolean;
 };
 
-if (Ember.Test) {
-  Ember.Test.registerWaiter(() => pending !== 0);
 
-  Ember.Test.registerWaiter(MyDb, MyDb.hasPendingTransactions);
+registerWaiter(() => pending !== 0);
 
-  Ember.Test.promise((resolve) => {
+  registerWaiter(MyDb, MyDb.hasPendingTransactions);
+
+  promise((resolve) => {
     window.setTimeout(resolve, 500);
   });
 
-  Ember.Test.registerHelper('boot', (app) => {
-    Ember.run(app, app.advanceReadiness);
+  registerHelper('boot', (app) => {
+    run(app, app.advanceReadiness);
   });
 
-  Ember.Test.registerAsyncHelper('boot', (app) => {
-    Ember.run(app, app.advanceReadiness);
+  registerAsyncHelper('boot', (app) => {
+    run(app, app.advanceReadiness);
   });
 
-  Ember.Test.registerAsyncHelper('waitForPromise', (app, promise) => {
-    if (!Ember.Test) {
-      return;
-    }
-
-    return new Ember.Test.Promise((resolve) => {
-      if (!Ember.Test) {
-        return;
-      }
-      Ember.Test.Adapter.asyncStart();
+  registerAsyncHelper('waitForPromise', (app, promise) => {
+    return new TestPromise((resolve) => {
+      asyncStart();
 
       promise.then(() => {
-        if (!Ember.Test) {
-          return;
-        }
-
-        Ember.Test.Adapter.asyncEnd();
+        asyncEnd();
       });
     });
   });
-}
+
diff --git a/type-tests/ember/transition.ts b/type-tests/ember/transition.ts
index 74aad7a0863..0fa1eef7000 100755
--- a/type-tests/ember/transition.ts
+++ b/type-tests/ember/transition.ts
@@ -1,5 +1,5 @@
-import Ember from 'ember';
+import type Route from '@ember/routing/route';
 import type Transition from '@ember/routing/transition';
 import { expectTypeOf } from 'expect-type';
 
-expectTypeOf<Parameters<Ember.Route['beforeModel']>[0]>().toEqualTypeOf<Transition>();
+expectTypeOf<Parameters<Route['beforeModel']>[0]>().toEqualTypeOf<Transition>();
diff --git a/type-tests/ember/utils.ts b/type-tests/ember/utils.ts
index fa5d9a36ff3..8eb7ebc98c5 100755
--- a/type-tests/ember/utils.ts
+++ b/type-tests/ember/utils.ts
@@ -1,52 +1,55 @@
-import Ember from 'ember';
+import { setOnerror } from '@ember/-internals/error-handling';
+import EmberObject, { computed, defineProperty } from '@ember/object';
+import { isBlank, isEmpty, isNone, isPresent, typeOf } from '@ember/utils';
 import { expectTypeOf } from 'expect-type';
 
 function testTypeOf() {
   // @ts-expect-error
-  Ember.typeOf();
-  const str: string = Ember.typeOf({});
+  typeOf();
+  const str: string = typeOf({});
 }
 
 function testIsNoneType() {
   const maybeUndefined: string | undefined = 'not actually undefined';
-  if (Ember.isNone(maybeUndefined)) {
+  if (isNone(maybeUndefined)) {
     return;
   }
 
   const anotherString = maybeUndefined + 'another string';
-  expectTypeOf(Ember.isNone(anotherString)).toBeBoolean();
+  expectTypeOf(isNone(anotherString)).toBeBoolean();
 }
 
 function testIsBlank() {
-  expectTypeOf(Ember.isBlank(undefined)).toBeBoolean();
-  expectTypeOf(Ember.isBlank('')).toBeBoolean();
+  expectTypeOf(isBlank(undefined)).toBeBoolean();
+  expectTypeOf(isBlank('')).toBeBoolean();
   // @ts-expect-error
   Ember.isBlank('', '');
 }
 
 function testIsEmpty() {
-  expectTypeOf(Ember.isEmpty(undefined)).toBeBoolean();
-  expectTypeOf(Ember.isEmpty('')).toBeBoolean();
+  expectTypeOf(isEmpty(undefined)).toBeBoolean();
+  expectTypeOf(isEmpty('')).toBeBoolean();
   // @ts-expect-error
   Ember.isEmpty('', '');
 }
 
 function testIsPresent() {
-  expectTypeOf(Ember.isPresent(undefined)).toBeBoolean();
-  expectTypeOf(Ember.isPresent('')).toBeBoolean();
+  expectTypeOf(isPresent(undefined)).toBeBoolean();
+  expectTypeOf(isPresent('')).toBeBoolean();
   // @ts-expect-error
   Ember.isPresent('', '');
 }
 
 function testIsNone() {
-  expectTypeOf(Ember.isNone(undefined)).toBeBoolean();
-  expectTypeOf(Ember.isNone('')).toBeBoolean();
+  expectTypeOf(isNone(undefined)).toBeBoolean();
+  expectTypeOf(isNone('')).toBeBoolean();
   // @ts-expect-error
   Ember.isNone('', '');
 }
 
 function testOnError() {
-  Ember.onerror = (error) => {
+  setOnerror(
+   (error: any) => {
     fetch('/report-error', {
       method: 'POST',
       body: JSON.stringify({
@@ -54,7 +57,8 @@ function testOnError() {
         otherInformation: 'whatever app state you want to provide',
       }),
     });
-  };
+  }
+  );
 }
 
 function testDefineProperty() {
@@ -62,7 +66,7 @@ function testDefineProperty() {
   const contact: Contact = {};
 
   // ES5 compatible mode
-  Ember.defineProperty(contact, 'firstName', {
+  defineProperty(contact, 'firstName', {
     writable: true,
     configurable: false,
     enumerable: true,
@@ -70,13 +74,13 @@ function testDefineProperty() {
   });
 
   // define a simple property
-  Ember.defineProperty(contact, 'lastName', undefined, 'Jolley');
+  defineProperty(contact, 'lastName', undefined, 'Jolley');
 
   // define a computed property
-  Ember.defineProperty(
+  defineProperty(
     contact,
     'fullName',
-    Ember.computed('firstName', 'lastName', function (this: Contact) {
+    computed('firstName', 'lastName', function (this: Contact) {
       return `${this.firstName} ${this.lastName}`;
     })
   );
@@ -87,23 +91,23 @@ declare const fileList: FileList;
 
 (() => {
   /** typeOf */
-  expectTypeOf(Ember.typeOf(null)).toBeString();
-  expectTypeOf(Ember.typeOf(undefined)).toBeString();
-  expectTypeOf(Ember.typeOf('michael')).toBeString();
-  expectTypeOf(Ember.typeOf(new String('michael'))).toBeString();
-  expectTypeOf(Ember.typeOf(101)).toBeString();
-  expectTypeOf(Ember.typeOf(new Number(101))).toBeString();
-  expectTypeOf(Ember.typeOf(true)).toBeString();
-  expectTypeOf(Ember.typeOf(new Boolean(true))).toBeString();
-  expectTypeOf(Ember.typeOf(() => 4)).toBeString();
+  expectTypeOf(typeOf(null)).toBeString();
+  expectTypeOf(typeOf(undefined)).toBeString();
+  expectTypeOf(typeOf('michael')).toBeString();
+  expectTypeOf(typeOf(new String('michael'))).toBeString();
+  expectTypeOf(typeOf(101)).toBeString();
+  expectTypeOf(typeOf(new Number(101))).toBeString();
+  expectTypeOf(typeOf(true)).toBeString();
+  expectTypeOf(typeOf(new Boolean(true))).toBeString();
+  expectTypeOf(typeOf(() => 4)).toBeString();
 
-  expectTypeOf(Ember.typeOf([1, 2, 90])).toBeString();
-  expectTypeOf(Ember.typeOf(/abc/)).toBeString();
-  expectTypeOf(Ember.typeOf(new Date())).toBeString();
-  expectTypeOf(Ember.typeOf(fileList)).toBeString();
-  expectTypeOf(Ember.typeOf(Ember.Object.extend())).toBeString();
-  expectTypeOf(Ember.typeOf(Ember.Object.create())).toBeString();
-  expectTypeOf(Ember.typeOf(new Error('teamocil'))).toBeString();
-  expectTypeOf(Ember.typeOf(new Date() as RegExp | Date)).toBeString();
-  expectTypeOf(Ember.typeOf({ randomObject: true })).toBeString();
+  expectTypeOf(typeOf([1, 2, 90])).toBeString();
+  expectTypeOf(typeOf(/abc/)).toBeString();
+  expectTypeOf(typeOf(new Date())).toBeString();
+  expectTypeOf(typeOf(fileList)).toBeString();
+  expectTypeOf(typeOf(EmberObject.extend())).toBeString();
+  expectTypeOf(typeOf(EmberObject.create())).toBeString();
+  expectTypeOf(typeOf(new Error('teamocil'))).toBeString();
+  expectTypeOf(typeOf(new Date() as RegExp | Date)).toBeString();
+  expectTypeOf(typeOf({ randomObject: true })).toBeString();
 })();
diff --git a/type-tests/ember/view-utils.ts b/type-tests/ember/view-utils.ts
index d032ede90dc..2a87b7355c2 100644
--- a/type-tests/ember/view-utils.ts
+++ b/type-tests/ember/view-utils.ts
@@ -1,7 +1,4 @@
-import Ember from 'ember';
+import { isSimpleClick } from '@ember/-internals/views';
 import { expectTypeOf } from 'expect-type';
 
-const {
-  ViewUtils: { isSimpleClick },
-} = Ember;
 expectTypeOf(isSimpleClick(new Event('wat'))).toBeBoolean();