diff --git a/.eslintignore b/.eslintignore
index 96eab461a6a..7ce02292986 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -6,3 +6,5 @@ node-tests/fixtures/**/*.js
 dist/
 tmp/
 smoke-tests/
+types/
+type-tests/preview
diff --git a/package.json b/package.json
index af8309ccb97..1139694c356 100644
--- a/package.json
+++ b/package.json
@@ -25,7 +25,8 @@
     "dist/ember-testing.js",
     "dist/ember-testing.map",
     "docs/data.json",
-    "lib"
+    "lib",
+    "types"
   ],
   "repository": {
     "type": "git",
@@ -40,7 +41,9 @@
     "lint:docs": "qunit tests/docs/coverage-test.js",
     "lint:eslint": "eslint --report-unused-disable-directives --cache .",
     "lint:eslint:fix": "npm-run-all \"lint:eslint --fix\"",
-    "lint:tsc": "tsc --noEmit",
+    "lint:tsc:stable": "tsc --noEmit",
+    "lint:tsc:preview": "tsc --noEmit --project type-tests/preview",
+    "lint:tsc": "npm-run-all lint:tsc:*",
     "lint:fix": "npm-run-all lint:*:fix",
     "test": "node bin/run-tests.js",
     "test:blueprints:js": "mocha node-tests/blueprints/**/*-test.js",
@@ -80,6 +83,7 @@
   "devDependencies": {
     "@babel/preset-env": "^7.16.11",
     "@glimmer/compiler": "0.84.2",
+    "@glimmer/component": "^1.1.2",
     "@glimmer/destroyable": "0.84.2",
     "@glimmer/env": "^0.1.7",
     "@glimmer/global-context": "0.84.2",
@@ -93,6 +97,7 @@
     "@glimmer/runtime": "0.84.2",
     "@glimmer/validator": "0.84.2",
     "@simple-dom/document": "^1.4.0",
+    "@tsconfig/ember": "^1.0.1",
     "@types/qunit": "^2.19.2",
     "@types/rsvp": "^4.0.4",
     "@typescript-eslint/eslint-plugin": "^5.22.0",
@@ -154,10 +159,20 @@
     "testem-failure-only-reporter": "^1.0.0",
     "typescript": "~4.6.4"
   },
+  "peerDependencies": {
+    "@glimmer/component": "^1.1.2"
+  },
   "engines": {
     "node": ">= 12.*"
   },
   "ember-addon": {
     "after": "ember-cli-legacy-blueprints"
+  },
+  "typesVersions": {
+    "*": {
+      "preview": [
+        "./types/preview"
+      ]
+    }
   }
 }
diff --git a/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.ts b/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.ts
index d5555d8f0a2..2c7ccfdea70 100644
--- a/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.ts
+++ b/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.ts
@@ -12,6 +12,14 @@ import { assert } from '@ember/debug';
 // This is defined as a separate interface so that it can be used in the definition of
 // `Owner` without also including the `__registry__` property.
 export interface IRegistry {
+  /**
+   Given a fullName return the corresponding factory.
+
+   @public
+   @method resolveRegistration
+   @param {String} fullName
+   @return {Function} fullName's factory
+   */
   resolveRegistration(fullName: string): Factory<object> | object | undefined;
 
   register(fullName: string, factory: Factory<object> | object, options?: TypeOptions): void;
@@ -48,14 +56,6 @@ interface RegistryProxyMixin extends IRegistry {
 const RegistryProxyMixin = Mixin.create({
   __registry__: null,
 
-  /**
-   Given a fullName return the corresponding factory.
-
-   @public
-   @method resolveRegistration
-   @param {String} fullName
-   @return {Function} fullName's factory
-   */
   resolveRegistration(fullName: string) {
     assert('fullName must be a proper full name', this.__registry__.isValidFullName(fullName));
     return this.__registry__.resolve(fullName);
diff --git a/packages/@ember/array/index.ts b/packages/@ember/array/index.ts
index f3c1d72de66..3de3d1605e8 100644
--- a/packages/@ember/array/index.ts
+++ b/packages/@ember/array/index.ts
@@ -279,6 +279,10 @@ interface EmberArray<T> extends Enumerable {
   ): NativeArray<T>;
   filterBy(key: string, value?: unknown): NativeArray<T>;
   rejectBy(key: string, value?: unknown): NativeArray<T>;
+  find<S extends T, Target = void>(
+    predicate: (this: void, value: T, index: number, obj: T[]) => value is S,
+    thisArg?: Target
+  ): S | undefined;
   find<Target = void>(
     callback: (this: Target, item: T, index: number, arr: this) => unknown,
     target?: Target
@@ -1907,7 +1911,8 @@ const MutableArray = Mixin.create(EmberArray, MutableEnumerable, {
 */
 interface NativeArray<T>
   extends Omit<Array<T>, 'every' | 'filter' | 'find' | 'forEach' | 'map' | 'reduce' | 'slice'>,
-    MutableArray<T> {}
+    MutableArray<T>,
+    Observable {}
 
 let NativeArray = Mixin.create(MutableArray, Observable, {
   objectAt(idx: number) {
diff --git a/tsconfig.json b/tsconfig.json
index 240bde985ab..7b0a17746e1 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -35,5 +35,5 @@
 
   "include": ["packages/**/*.ts"],
 
-  "exclude": ["dist", "node_modules", "tmp"]
+  "exclude": ["dist", "node_modules", "tmp", "types"]
 }
diff --git a/type-tests/preview/@ember/application-test/application-instance.ts b/type-tests/preview/@ember/application-test/application-instance.ts
new file mode 100644
index 00000000000..07bbf776dee
--- /dev/null
+++ b/type-tests/preview/@ember/application-test/application-instance.ts
@@ -0,0 +1,45 @@
+import ApplicationInstance from '@ember/application/instance';
+
+declare function hbs(strings: TemplateStringsArray): object;
+
+const appInstance = ApplicationInstance.create();
+appInstance.register('some:injection', class Foo {});
+
+appInstance.register('some:injection', class Foo {}, {
+  singleton: true,
+});
+
+appInstance.register('some:injection', class Foo {}, {
+  instantiate: false,
+});
+
+appInstance.register('templates:foo/bar', hbs`<h1>Hello World</h1>`);
+appInstance.register('templates:foo/bar', hbs`<h1>Hello World</h1>`, {
+  singleton: true,
+});
+appInstance.register('templates:foo/bar', hbs`<h1>Hello World</h1>`, {
+  instantiate: true,
+});
+appInstance.register('templates:foo/bar', hbs`<h1>Hello World</h1>`, {
+  singleton: true,
+  instantiate: true,
+});
+appInstance.register('templates:foo/bar', hbs`<h1>Hello World</h1>`, {
+  // @ts-expect-error
+  singleton: 'true',
+  instantiate: true,
+});
+
+appInstance.register('some:injection', class Foo {}, {
+  singleton: false,
+  instantiate: true,
+});
+
+appInstance.factoryFor('router:main');
+appInstance.lookup('route:basic');
+
+appInstance.boot();
+
+(async () => {
+  await appInstance.boot();
+})();
diff --git a/type-tests/preview/@ember/application-test/application.ts b/type-tests/preview/@ember/application-test/application.ts
new file mode 100755
index 00000000000..fa90f68b203
--- /dev/null
+++ b/type-tests/preview/@ember/application-test/application.ts
@@ -0,0 +1,44 @@
+import Application from '@ember/application';
+import ApplicationInstance from '@ember/application/instance';
+import EmberObject from '@ember/object';
+import { expectTypeOf } from 'expect-type';
+
+const BaseApp = Application.extend({
+  modulePrefix: 'my-app',
+});
+
+class Obj extends EmberObject.extend({ foo: 'bar' }) {}
+
+BaseApp.initializer({
+  name: 'my-initializer',
+  initialize(app) {
+    app.register('foo:bar', Obj);
+  },
+});
+
+BaseApp.instanceInitializer({
+  name: 'my-instance-initializer',
+  initialize(app) {
+    (app.lookup('foo:bar') as Obj).get('foo');
+  },
+});
+
+const App1 = BaseApp.create({
+  rootElement: '#app-one',
+  customEvents: {
+    paste: 'paste',
+  },
+});
+
+const App2 = BaseApp.create({
+  rootElement: '#app-two',
+  customEvents: {
+    mouseenter: null,
+    mouseleave: null,
+  },
+});
+
+const App3 = BaseApp.create();
+
+expectTypeOf(App3.buildInstance()).toEqualTypeOf<ApplicationInstance>();
+expectTypeOf(App3.buildInstance({ foo: 'bar' })).toEqualTypeOf<ApplicationInstance>();
diff --git a/type-tests/preview/@ember/application-test/deprecations.ts b/type-tests/preview/@ember/application-test/deprecations.ts
new file mode 100644
index 00000000000..414e38af111
--- /dev/null
+++ b/type-tests/preview/@ember/application-test/deprecations.ts
@@ -0,0 +1,17 @@
+import { deprecate, deprecateFunc } from '@ember/application/deprecations';
+
+deprecate('this is no longer advised', false, {
+  id: 'no-longer-advised',
+  until: 'v4.0',
+});
+deprecate('this is no longer advised', false, {
+  id: 'no-longer-advised',
+  until: 'v4.0',
+  url: 'https://emberjs.com',
+});
+// @ts-expect-error
+deprecate('this is no longer advised', false);
+
+// @ts-expect-error
+deprecateFunc('this is no longer advised', () => {});
+deprecateFunc('this is no longer advised', { id: 'no-longer-do-this', until: 'v4.0' }, () => {});
diff --git a/type-tests/preview/@ember/application-test/index.ts b/type-tests/preview/@ember/application-test/index.ts
new file mode 100644
index 00000000000..aa0d14e762d
--- /dev/null
+++ b/type-tests/preview/@ember/application-test/index.ts
@@ -0,0 +1,27 @@
+import { getOwner, setOwner } from '@ember/application';
+import EngineInstance from '@ember/engine/instance';
+import Owner from '@ember/owner';
+import ApplicationInstance from '@ember/application/instance';
+import Service from '@ember/service';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf(getOwner({})).toEqualTypeOf<Owner | undefined>();
+
+// Confirm that random subclasses work as expected.
+declare class MyService extends Service {
+  withStuff: true;
+}
+declare let myService: MyService;
+expectTypeOf(getOwner(myService)).toEqualTypeOf<Owner>();
+
+// @ts-expect-error
+getOwner();
+
+declare let baseOwner: Owner;
+expectTypeOf(setOwner({}, baseOwner)).toBeVoid();
+
+declare let engine: EngineInstance;
+expectTypeOf(setOwner({}, engine)).toBeVoid();
+
+declare let application: ApplicationInstance;
+expectTypeOf(setOwner({}, application)).toBeVoid();
diff --git a/type-tests/preview/@ember/array-test/array-proxy.ts b/type-tests/preview/@ember/array-test/array-proxy.ts
new file mode 100644
index 00000000000..9b2c81782ff
--- /dev/null
+++ b/type-tests/preview/@ember/array-test/array-proxy.ts
@@ -0,0 +1,60 @@
+import ArrayProxy from '@ember/array/proxy';
+import EmberArray, { A } from '@ember/array';
+import EmberObject from '@ember/object';
+import { expectTypeOf } from 'expect-type';
+
+const pets = ['dog', 'cat', 'fish'];
+const proxy = ArrayProxy.create({ content: A(pets) });
+
+proxy.get('firstObject'); // 'dog'
+proxy.set('content', A(['amoeba', 'paramecium']));
+proxy.get('firstObject'); // 'amoeba'
+
+const overridden = ArrayProxy.create({
+  content: A(pets),
+  objectAtContent(this: ArrayProxy<string>, idx: number): string | undefined {
+    // NOTE: cast is necessary because `this` is not managed correctly in the
+    // `.create()` body anymore.
+    return (this.get('content') as EmberArray<string>).objectAt(idx)?.toUpperCase();
+  },
+});
+
+overridden.get('firstObject'); // 'DOG'
+
+class MyNewProxy<T> extends ArrayProxy<T> {
+  isNew = true;
+}
+
+const x = MyNewProxy.create({ content: A([1, 2, 3]) }) as MyNewProxy<number>;
+expectTypeOf(x.get('firstObject')).toEqualTypeOf<number | undefined>();
+expectTypeOf(x.isNew).toBeBoolean();
+
+// Custom EmberArray
+interface MyArray<T> extends EmberObject, EmberArray<T> {}
+class MyArray<T> extends EmberObject.extend(EmberArray) {
+  constructor(content: ArrayLike<T>) {
+    super();
+    this._content = content;
+  }
+
+  _content: ArrayLike<T>;
+
+  get length() {
+    return this._content.length;
+  }
+
+  objectAt(idx: number) {
+    return this._content[idx];
+  }
+}
+
+const customArrayProxy = ArrayProxy.create({ content: new MyArray(pets) });
+customArrayProxy.get('firstObject'); // 'dog'
+
+// Vanilla array
+const vanillaArrayProxy = ArrayProxy.create({ content: pets });
+vanillaArrayProxy.get('firstObject'); // 'dog'
+
+// Nested ArrayProxy
+const nestedArrayProxy = ArrayProxy.create({ content: proxy });
+nestedArrayProxy.get('firstObject'); // 'amoeba'
diff --git a/type-tests/preview/@ember/array-test/array.ts b/type-tests/preview/@ember/array-test/array.ts
new file mode 100755
index 00000000000..8f7df294f56
--- /dev/null
+++ b/type-tests/preview/@ember/array-test/array.ts
@@ -0,0 +1,73 @@
+import EmberObject from '@ember/object';
+import type Array from '@ember/array';
+import { A } from '@ember/array';
+import type MutableArray from '@ember/array/mutable';
+import { expectTypeOf } from 'expect-type';
+
+class Person extends EmberObject {
+  name = '';
+  isHappy = false;
+}
+
+const people = A([
+  Person.create({ name: 'Yehuda', isHappy: true }),
+  Person.create({ name: 'Majd', isHappy: false }),
+]);
+
+expectTypeOf(people.get('length')).toBeNumber();
+expectTypeOf(people.get('lastObject')).toEqualTypeOf<Person | undefined>();
+expectTypeOf(people.get('firstObject')).toEqualTypeOf<Person | undefined>();
+expectTypeOf(people.isAny('isHappy')).toBeBoolean();
+expectTypeOf(people.isAny('isHappy', false)).toBeBoolean();
+// @ts-expect-error -- string != boolean
+people.isAny('isHappy', 'false');
+
+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<MutableArray<Person>>();
+expectTypeOf(people.rejectBy('isHappy')).toMatchTypeOf<Person[]>();
+expectTypeOf(people.rejectBy('isHappy')).toMatchTypeOf<MutableArray<Person>>();
+expectTypeOf(people.filter((person) => person.get('name') === 'Yehuda')).toMatchTypeOf<Person[]>();
+expectTypeOf(people.filter((person) => person.get('name') === 'Yehuda')).toMatchTypeOf<
+  MutableArray<Person>
+>();
+
+expectTypeOf(people.get('[]')).toEqualTypeOf<typeof people>();
+expectTypeOf(people.get('[]').get('firstObject')).toEqualTypeOf<Person | undefined>();
+
+expectTypeOf(people.mapBy('isHappy')).toMatchTypeOf<boolean[]>();
+expectTypeOf(people.mapBy('name.length')).toMatchTypeOf<unknown[]>();
+
+const last = people.get('lastObject');
+expectTypeOf(last).toEqualTypeOf<Person | undefined>();
+if (last) {
+  expectTypeOf(last.get('name')).toBeString();
+}
+
+const first = people.get('lastObject');
+if (first) {
+  expectTypeOf(first.get('isHappy')).toBeBoolean();
+}
+
+const letters = A(['a', 'b', 'c']);
+const codes = letters.map((item, index, array) => {
+  expectTypeOf(item).toBeString();
+  expectTypeOf(index).toBeNumber();
+  expectTypeOf(array).toMatchTypeOf<string[]>();
+  return item.charCodeAt(0);
+});
+expectTypeOf(codes).toMatchTypeOf<number[]>();
+
+const value = '1,2,3';
+const filters = A(value.split(','));
+filters.push('4');
+filters.sort();
+
+const multiSortArr = A([
+  { k: 'a', v: 'z' },
+  { k: 'a', v: 'y' },
+  { k: 'b', v: 'c' },
+]);
+multiSortArr.sortBy('k', 'v');
diff --git a/type-tests/preview/@ember/component-test/built-ins.ts b/type-tests/preview/@ember/component-test/built-ins.ts
new file mode 100644
index 00000000000..e920b295baa
--- /dev/null
+++ b/type-tests/preview/@ember/component-test/built-ins.ts
@@ -0,0 +1,6 @@
+import { Input, Textarea } from '@ember/component';
+import { expectTypeOf } from 'expect-type';
+
+// Minimal check that we are exporting both type and value
+expectTypeOf(Input).toEqualTypeOf<Input>();
+expectTypeOf(Textarea).toEqualTypeOf<Textarea>();
diff --git a/type-tests/preview/@ember/component-test/component.ts b/type-tests/preview/@ember/component-test/component.ts
new file mode 100644
index 00000000000..3df213d853c
--- /dev/null
+++ b/type-tests/preview/@ember/component-test/component.ts
@@ -0,0 +1,154 @@
+import Component from '@ember/component';
+import Object, { computed, get } from '@ember/object';
+import { expectTypeOf } from 'expect-type';
+
+Component.extend({
+  layout: 'my-layout',
+});
+
+const MyComponent = Component.extend();
+expectTypeOf(get(MyComponent, 'positionalParams')).toEqualTypeOf<string | string[]>();
+
+const component1 = Component.extend({
+  actions: {
+    hello(name: string) {
+      console.log('Hello', name);
+    },
+  },
+});
+
+class AnotherComponent extends Component {
+  name = '';
+
+  hello(name: string) {
+    this.set('name', name);
+    this.name = name;
+  }
+}
+
+Component.extend({
+  tagName: 'em',
+});
+
+Component.extend({
+  classNames: ['my-class', 'my-other-class'],
+});
+
+class Bindings extends Component {
+  classNameBindings = ['propertyA', 'propertyB'];
+  propertyA = 'from-a';
+
+  @computed()
+  get propertyB() {
+    if (!this.get('propertyA')) {
+      return 'from-b';
+    }
+  }
+}
+
+Component.extend({
+  classNameBindings: ['hovered'],
+  hovered: true,
+});
+
+class Message extends Object {
+  empty = false;
+}
+
+Component.extend({
+  classNameBindings: ['messages.empty'],
+  messages: Message.create({
+    empty: true,
+  }),
+});
+
+Component.extend({
+  classNameBindings: ['isEnabled:enabled:disabled'],
+  isEnabled: true,
+});
+
+Component.extend({
+  classNameBindings: ['isEnabled::disabled'],
+  isEnabled: true,
+});
+
+Component.extend({
+  tagName: 'a',
+  attributeBindings: ['href'],
+  href: 'http://google.com',
+});
+
+Component.extend({
+  tagName: 'a',
+  attributeBindings: ['url:href'],
+  url: 'http://google.com',
+});
+
+Component.extend({
+  tagName: 'use',
+  attributeBindings: ['xlinkHref:xlink:href'],
+  xlinkHref: '#triangle',
+});
+
+Component.extend({
+  tagName: 'input',
+  attributeBindings: ['disabled'],
+  disabled: false,
+});
+
+Component.extend({
+  tagName: 'input',
+  attributeBindings: ['disabled'],
+  disabled: computed(() => {
+    return someLogic();
+  }),
+});
+
+declare function someLogic(): boolean;
+
+Component.extend({
+  tagName: 'form',
+  attributeBindings: ['novalidate'],
+  novalidate: null,
+});
+
+Component.extend({
+  click(event: object) {
+    // will be called when an instance's
+    // rendered element is clicked
+  },
+});
+
+// @ts-expect-error
+Component.reopen({
+  attributeBindings: ['metadata:data-my-metadata'],
+  metadata: '',
+});
+
+interface MySig {
+  Args: {
+    Named: {
+      name: string;
+      age: number;
+    };
+    Positional: [action: () => void];
+  };
+}
+
+// These type helpers are stolen (and tweaked) from Glimmer and Glint internals
+// just to demo that this actually has the expected behavior with a signature
+// and an Ember component
+type GetWithFallback<T, K, Fallback> = K extends keyof T ? T[K] : Fallback;
+type NamedArgsFor<T> = GetWithFallback<GetWithFallback<T, 'Args', {}>, 'Named', object>;
+
+interface SigExample extends NamedArgsFor<MySig> {}
+class SigExample extends Component<MySig> {
+  get accessArgs() {
+    const { name, age } = this;
+
+    expectTypeOf(name).toBeString();
+    expectTypeOf(age).toBeNumber();
+
+    return `${name} is ${age} years old`;
+  }
+}
diff --git a/type-tests/preview/@ember/component-test/helper.ts b/type-tests/preview/@ember/component-test/helper.ts
new file mode 100644
index 00000000000..f63a4c6077f
--- /dev/null
+++ b/type-tests/preview/@ember/component-test/helper.ts
@@ -0,0 +1,169 @@
+import { BadType, DefaultPositional, EmptyObject } from '@ember/component/-private/signature-utils';
+import Helper, {
+  ExpandSignature,
+  FunctionBasedHelper,
+  FunctionBasedHelperInstance,
+  helper,
+} from '@ember/component/helper';
+import { expectTypeOf } from 'expect-type';
+
+class DeprecatedSignatureForm extends Helper<{
+  PositionalArgs: [offset: Date];
+  Return: Date;
+}> {
+  timer?: ReturnType<typeof setInterval> | undefined;
+  now = new Date();
+  init() {
+    super.init();
+    this.timer = setInterval(() => {
+      this.set('now', new Date());
+      this.recompute();
+    }, 100);
+  }
+  compute([offset]: [Date]): Date {
+    return new Date(this.now.getTime() + offset.getTime());
+  }
+  willDestroy() {
+    if (this.timer) {
+      clearInterval(this.timer);
+    }
+  }
+}
+
+interface DemoSig {
+  Args: {
+    Named: {
+      name: string;
+      age: number;
+    };
+    Positional: [i18nizer: (s: string) => string];
+  };
+  Return: string;
+}
+
+function testMissingSignature({ Args, Return }: ExpandSignature<unknown>) {
+  expectTypeOf(Args.Named).toEqualTypeOf<BadType<'This helper is missing a signature'>>();
+
+  expectTypeOf(Args.Positional).toEqualTypeOf<unknown[]>();
+  expectTypeOf(Return).toBeUnknown();
+}
+
+class SignatureForm extends Helper<DemoSig> {
+  compute(
+    [i18nizer]: [i18nizer: (s: string) => string],
+    { name, age }: { name: string; age: number }
+  ): string {
+    return i18nizer(`${name} is ${age} years old`);
+  }
+}
+
+class NoSignatureForm extends Helper {
+  compute(
+    [i18nizer]: [i18nizer: (s: string) => string],
+    { name, age }: { name: string; age: number }
+  ): string {
+    return i18nizer(`${name} is ${age} years old`);
+  }
+}
+
+class BadPosSigForm extends Helper<DemoSig> {
+  compute(
+    // @ts-expect-error
+    [i18nizer, extra]: [i18nizer: (s: string) => string],
+    { name, age }: { name: string; age: number }
+  ): string {
+    return i18nizer(`${name} is ${age} years old`);
+  }
+}
+
+class BadNamedSigForm extends Helper<DemoSig> {
+  compute(
+    [i18nizer]: [i18nizer: (s: string) => string],
+    // @ts-expect-error
+    { name, age, potato }: { name: string; age: number }
+  ): string {
+    return i18nizer(`${name} is ${age} years old`);
+  }
+}
+
+class BadReturnForm extends Helper<DemoSig> {
+  compute(
+    [i18nizer]: [i18nizer: (s: string) => string],
+    { name, age }: { name: string; age: number }
+  ): string {
+    // @ts-expect-error
+    return Boolean(i18nizer(`${name} is ${age} years old`));
+  }
+}
+
+const inferenceOnPositional = helper(function add([a, b]: [number, number]) {
+  return a + b;
+});
+
+expectTypeOf(inferenceOnPositional).toEqualTypeOf<
+  FunctionBasedHelper<{
+    Args: { Positional: [number, number]; Named: EmptyObject };
+    Return: number;
+  }>
+>();
+
+const coolHelper = helper((_, named) => {
+  expectTypeOf(named).toEqualTypeOf<EmptyObject>();
+});
+
+const typeInferenceOnNamed = helper((_, { cool }: { cool: boolean }) => {
+  expectTypeOf(cool).toBeBoolean();
+
+  return cool ? 123 : 'neat';
+});
+expectTypeOf(typeInferenceOnNamed).toEqualTypeOf<
+  FunctionBasedHelper<{
+    Args: { Positional: DefaultPositional; Named: { cool: boolean } };
+    Return: 123 | 'neat';
+  }>
+>();
+
+const dasherizeHelper = helper(function dasherize(
+  [str]: [string],
+  { delim = '-' }: { delim?: string }
+) {
+  return str.split(/[\s\n_.]+/g).join(delim);
+});
+expectTypeOf(dasherizeHelper).toEqualTypeOf<
+  FunctionBasedHelper<{ Args: { Positional: [string]; Named: { delim?: string } }; Return: string }>
+>();
+
+const signatureForm = helper<DemoSig>(([i18nizer], { name, age }) =>
+  i18nizer(`${name} is ${age} years old`)
+);
+
+// @ts-expect-error
+const badPosArgsSig = helper<DemoSig>(([i18nizer, extra], { name, age }) =>
+  i18nizer(`${name} is ${age} years old`)
+);
+
+// @ts-expect-error
+const badNamedArgsSig = helper<DemoSig>(([i18nizer], { name, age, potato }) =>
+  i18nizer(`${name} is ${age} years old`)
+);
+
+const badReturnSig = helper<DemoSig>(([i18nizer], { name, age }) =>
+  // @ts-expect-error
+  Boolean(i18nizer(`${name} is ${age} years old`))
+);
+
+const greet = helper(([name]: [string]) => `Hello, ${name}`);
+
+// @ts-expect-error
+new greet();
+
+// @ts-expect-error
+class Subgreet extends greet {}
+
+const pair = helper(<T>([item]: [T]): [T, T] => [item, item]);
+expectTypeOf(pair).toEqualTypeOf<
+  abstract new <T>() => FunctionBasedHelperInstance<{
+    Args: { Positional: [T]; Named: EmptyObject };
+    Return: [T, T];
+  }>
+>();
diff --git a/type-tests/preview/@ember/component-test/template-only.ts b/type-tests/preview/@ember/component-test/template-only.ts
new file mode 100644
index 00000000000..1e06e9bf369
--- /dev/null
+++ b/type-tests/preview/@ember/component-test/template-only.ts
@@ -0,0 +1,30 @@
+import templateOnly, { TemplateOnlyComponent, TOC } from '@ember/component/template-only';
+import { expectTypeOf } from 'expect-type';
+
+const to = templateOnly();
+expectTypeOf(to).toEqualTypeOf<TemplateOnlyComponent<unknown>>();
+
+expectTypeOf(to.toString()).toBeString();
+
+// @ts-expect-error
+new TemplateOnlyComponent();
+
+interface MySig {
+  Element: HTMLAnchorElement;
+  Args: {
+    name: string;
+    age: number;
+  };
+  Blocks: {
+    default: [(newName: string) => void];
+  };
+}
+
+const toc: TOC<MySig> = templateOnly();
+expectTypeOf(toc).toEqualTypeOf<TemplateOnlyComponent<MySig>>();
+
+const tocInferred = templateOnly<MySig>();
+expectTypeOf(tocInferred).toEqualTypeOf<TemplateOnlyComponent<MySig>>();
+
+const longToc: TemplateOnlyComponent<MySig> = templateOnly();
+expectTypeOf(longToc).toEqualTypeOf<TemplateOnlyComponent<MySig>>();
diff --git a/type-tests/preview/@ember/controller-test/main.ts b/type-tests/preview/@ember/controller-test/main.ts
new file mode 100644
index 00000000000..4fc8c2f0347
--- /dev/null
+++ b/type-tests/preview/@ember/controller-test/main.ts
@@ -0,0 +1,14 @@
+import Controller, { inject } from '@ember/controller';
+
+class MyController extends Controller {
+  queryParams = ['category'];
+  category = null;
+  isExpanded = false;
+
+  @inject declare first: Controller;
+  @inject('second') declare second: Controller;
+
+  toggleBody() {
+    this.toggleProperty('isExpanded');
+  }
+}
diff --git a/type-tests/preview/@ember/controller-test/octane.ts b/type-tests/preview/@ember/controller-test/octane.ts
new file mode 100644
index 00000000000..9d22f33f37b
--- /dev/null
+++ b/type-tests/preview/@ember/controller-test/octane.ts
@@ -0,0 +1,36 @@
+import Controller, { inject } from '@ember/controller';
+
+class FirstController extends Controller {
+  foo = 'bar';
+  @inject declare second: InstanceType<typeof SecondController>;
+  @inject declare otherSecond: InstanceType<typeof SecondController>;
+  @inject('second') declare moreSecond: InstanceType<typeof SecondController>;
+
+  queryParams = [
+    'category',
+    {
+      searchTerm: {
+        as: 'search',
+      },
+      subCategory: 'sub-category',
+    },
+  ];
+
+  first() {
+    return '';
+  }
+}
+const SecondController = Controller.extend({
+  foo: 'bar',
+
+  second() {
+    return '';
+  },
+});
+
+declare module '@ember/controller' {
+  interface Registry {
+    first: FirstController;
+    second: InstanceType<typeof SecondController>;
+  }
+}
diff --git a/type-tests/preview/@ember/debug-tests.ts b/type-tests/preview/@ember/debug-tests.ts
new file mode 100644
index 00000000000..bf5c8f39fbe
--- /dev/null
+++ b/type-tests/preview/@ember/debug-tests.ts
@@ -0,0 +1,273 @@
+import {
+  runInDebug,
+  warn,
+  debug,
+  assert,
+  registerWarnHandler,
+  registerDeprecationHandler,
+  deprecate,
+} from '@ember/debug';
+import { expectTypeOf } from 'expect-type';
+
+/**
+ * @ember/debug tests
+ */
+// @ts-expect-error
+runInDebug();
+expectTypeOf(runInDebug(() => console.log('Should not show up in prod'))).toBeVoid();
+
+// Log a warning if we have more than 3 tomsters
+const tomsterCount = 2;
+// @ts-expect-error
+warn('Too many tomsters!');
+expectTypeOf(warn('Too many tomsters!', { id: 'some-warning' })).toBeVoid();
+// @ts-expect-error
+warn('Too many tomsters!', tomsterCount <= 3);
+expectTypeOf(warn('Too many tomsters!', tomsterCount <= 3, { id: 'some-warning' })).toBeVoid();
+expectTypeOf(
+  warn('Too many tomsters!', tomsterCount <= 3, {
+    id: 'ember-debug.too-many-tomsters',
+  })
+).toBeVoid();
+
+// @ts-expect-error
+debug();
+expectTypeOf(debug('Too many tomsters!')).toBeVoid();
+// @ts-expect-error
+debug('Too many tomsters!', 'foo');
+
+// Test for truthiness
+const str: unknown = 'hello';
+expectTypeOf(assert('Must pass a string', typeof str === 'string')).toBeVoid();
+assert('Must pass a string', typeof str === 'string');
+expectTypeOf(str).toBeString();
+
+const anObject = {};
+expectTypeOf(assert('Must pass an object', anObject)).toBeVoid();
+
+// Test with null and undefined
+expectTypeOf(assert('Can handle falsiness', null)).toBeVoid();
+expectTypeOf(assert('Can handle falsiness', undefined)).toBeVoid();
+
+// next is not called, so no warnings get the default behavior
+// @ts-expect-error
+registerWarnHandler();
+expectTypeOf(registerWarnHandler(() => {})).toBeVoid();
+expectTypeOf(
+  registerWarnHandler((message, options, next) => {
+    expectTypeOf(message).toBeString();
+    expectTypeOf(options).toEqualTypeOf<{ id: string } | undefined>();
+    expectTypeOf(next).toEqualTypeOf<
+      (message: string, options?: { id: string } | undefined) => void
+    >();
+  })
+).toBeVoid();
+expectTypeOf(
+  registerWarnHandler((message, options, next) => {
+    expectTypeOf(message).toBeString();
+    expectTypeOf(options).toEqualTypeOf<{ id: string } | undefined>();
+    // @ts-expect-error
+    next();
+  })
+).toBeVoid();
+expectTypeOf(
+  registerWarnHandler((message, options, next) => {
+    expectTypeOf(message).toBeString();
+    expectTypeOf(options).toEqualTypeOf<{ id: string } | undefined>();
+    expectTypeOf(next(message)).toBeVoid();
+  })
+).toBeVoid();
+expectTypeOf(
+  registerWarnHandler((message, options, next) => {
+    expectTypeOf(message).toBeString();
+    expectTypeOf(options).toEqualTypeOf<{ id: string } | undefined>();
+    expectTypeOf(next(message, options)).toBeVoid();
+  })
+).toBeVoid();
+
+// next is not called, so no warnings get the default behavior
+// @ts-expect-error
+registerDeprecationHandler();
+expectTypeOf(registerDeprecationHandler(() => {})).toBeVoid();
+expectTypeOf(
+  registerDeprecationHandler((message, options, next) => {
+    expectTypeOf(message).toBeString();
+    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(next).toEqualTypeOf<
+      (message: string, options?: { id: string; until: string } | undefined) => void
+    >();
+  })
+).toBeVoid();
+expectTypeOf(
+  registerDeprecationHandler((message, options, next) => {
+    expectTypeOf(message).toBeString();
+    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    // @ts-expect-error
+    next();
+  })
+).toBeVoid();
+expectTypeOf(
+  registerDeprecationHandler((message, options, next) => {
+    expectTypeOf(message).toBeString();
+    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(next(message)).toBeVoid();
+  })
+).toBeVoid();
+expectTypeOf(
+  registerDeprecationHandler((message, options, next) => {
+    expectTypeOf(message).toBeString();
+    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(next(message, options)).toBeVoid();
+  })
+).toBeVoid();
+
+// @ts-expect-error
+deprecate();
+// @ts-expect-error
+deprecate('missing test and options');
+// @ts-expect-error
+deprecate('missing options', true);
+// @ts-expect-error
+deprecate('missing options', false);
+// @ts-expect-error
+deprecate('missing options body', true, {});
+// @ts-expect-error
+deprecate('missing options id', true, { until: 'v4.0.0' });
+// @ts-expect-error
+deprecate('missing options until', true, { id: 'some.deprecation' });
+expectTypeOf(
+  deprecate('a valid deprecation without `url`', true, {
+    id: 'some.deprecation',
+    until: 'v4.0.0',
+    for: 'some.namespace',
+    since: {
+      available: 'some.early.version',
+      enabled: 'some.version',
+    },
+  })
+).toBeVoid();
+deprecate('incorrect options `url`', true, {
+  id: 'some.deprecation',
+  until: 'v4.0.0',
+  // @ts-expect-error
+  url: 123,
+  for: 'some.namespace',
+  since: {
+    available: 'some.earlier.version',
+    enabled: 'some.version',
+  },
+});
+expectTypeOf(
+  deprecate('a valid deprecation with `url`', true, {
+    id: 'some.deprecation',
+    until: 'v4.0.0',
+    url: 'https://example.com/ember-deprecations-yo',
+    for: 'some.namespace',
+    since: {
+      available: 'some.earlier.version',
+      enabled: 'some.version',
+    },
+  })
+).toBeVoid();
+expectTypeOf(
+  deprecate('a valid deprecation with `for`', true, {
+    id: 'some.deprecation',
+    until: 'v4.0.0',
+    for: 'some.namespace',
+    since: {
+      available: 'some.earlier.version',
+      enabled: 'some.version',
+    },
+  })
+).toBeVoid();
+deprecate('incorrect options `for`', true, {
+  id: 'some.deprecation',
+  until: 'v4.0.0',
+  // @ts-expect-error
+  for: 123,
+  since: {
+    available: 'some.earlier.version',
+    enabled: 'some.version',
+  },
+});
+expectTypeOf(
+  deprecate('a valid deprecation with `since`', true, {
+    id: 'some.deprecation',
+    until: 'v4.0.0',
+    for: 'some.namespace',
+    since: {
+      available: 'some.version',
+    },
+  })
+).toBeVoid();
+expectTypeOf(
+  deprecate('a valid deprecation with `since`', true, {
+    id: 'some.deprecation',
+    until: 'v4.0.0',
+    for: 'some.namespace',
+    since: {
+      available: 'some.version',
+      enabled: 'some.version',
+    },
+  })
+).toBeVoid();
+deprecate('incorrect options `since`', true, {
+  id: 'some.deprecation',
+  until: 'v4.0.0',
+  for: 'some.namespace',
+  // @ts-expect-error
+  since: 123,
+});
+deprecate('incorrect options `since`', true, {
+  id: 'some.deprecation',
+  until: 'v4.0.0',
+  for: 'some.namespace',
+  since: {
+    // @ts-expect-error
+    wrongKey: 'some.version',
+  },
+});
+deprecate('incorrect options `since` available', true, {
+  id: 'some.deprecation',
+  until: 'v4.0.0',
+  for: 'some.namespace',
+  since: {
+    // @ts-expect-error
+    available: 123,
+  },
+});
+deprecate('incorrect options `since` enabled', true, {
+  id: 'some.deprecation',
+  until: 'v4.0.0',
+  for: 'some.namespace',
+  since: {
+    available: 'some.earlier.version',
+    // @ts-expect-error
+    enabled: 123,
+  },
+});
+deprecate('incorrect options `since` empty', true, {
+  id: 'some.deprecation',
+  until: 'v4.0.0',
+  for: 'some.namespace',
+  // @ts-expect-error
+  since: {},
+});
+deprecate('incorrect options `since` enabled w/o available', true, {
+  id: 'some.deprecation',
+  until: 'v4.0.0',
+  for: 'some.namespace',
+  // @ts-expect-error
+  since: {
+    enabled: 'some.version',
+  },
+});
+
+// NOTE: these are at the bottom so they don't have the super annoying effect
+// of throwing up TS warnings about all the *other* tests above
+// Fail unconditionally
+expectTypeOf(assert('This code path should never be run')).toBeNever();
+
+// Require first argument
+// @ts-expect-error
+assert();
diff --git a/type-tests/preview/@ember/destroyable-test.ts b/type-tests/preview/@ember/destroyable-test.ts
new file mode 100644
index 00000000000..918f34296ce
--- /dev/null
+++ b/type-tests/preview/@ember/destroyable-test.ts
@@ -0,0 +1,90 @@
+import {
+  assertDestroyablesDestroyed,
+  associateDestroyableChild,
+  destroy,
+  enableDestroyableTracking,
+  isDestroyed,
+  isDestroying,
+  registerDestructor,
+  unregisterDestructor,
+} from '@ember/destroyable';
+import { expectTypeOf } from 'expect-type';
+
+// @ts-expect-error
+enableDestroyableTracking(true);
+// @ts-expect-error
+enableDestroyableTracking({});
+// @ts-expect-error
+enableDestroyableTracking('foo');
+// @ts-expect-error
+enableDestroyableTracking(1);
+enableDestroyableTracking();
+
+class Child {
+  state: boolean;
+  constructor() {
+    this.state = true;
+    // @ts-expect-error
+    registerDestructor();
+    // @ts-expect-error
+    registerDestructor(this);
+    // @ts-expect-error
+    registerDestructor(this.stateDestructor);
+    registerDestructor(this, this.stateDestructor);
+  }
+
+  stateDestructor() {
+    this.state = !this.state;
+  }
+
+  keepForever() {
+    // @ts-expect-error
+    unregisterDestructor();
+    // @ts-expect-error
+    unregisterDestructor(this);
+    // @ts-expect-error
+    unregisterDestructor(this.stateDestructor);
+    unregisterDestructor(this, this.stateDestructor);
+  }
+}
+
+class Parent {
+  child: object;
+
+  constructor(child: object) {
+    // @ts-expect-error
+    this.child = associateDestroyableChild();
+    // @ts-expect-error
+    this.child = associateDestroyableChild(this);
+    // @ts-expect-error
+    this.child = associateDestroyableChild(child);
+    this.child = associateDestroyableChild(this, child);
+  }
+}
+
+const c = new Child();
+const p = new Parent(c);
+
+// @ts-expect-error
+destroy();
+
+expectTypeOf(isDestroyed(c)).toBeBoolean();
+expectTypeOf(isDestroyed(p)).toBeBoolean();
+
+destroy(p);
+
+expectTypeOf(isDestroying(c)).toBeBoolean();
+expectTypeOf(isDestroying(p)).toBeBoolean();
+
+expectTypeOf(isDestroyed(c)).toBeBoolean();
+expectTypeOf(isDestroyed(p)).toBeBoolean();
+
+// @ts-expect-error
+assertDestroyablesDestroyed(true);
+// @ts-expect-error
+assertDestroyablesDestroyed({});
+// @ts-expect-error
+assertDestroyablesDestroyed('foo');
+// @ts-expect-error
+assertDestroyablesDestroyed(1);
+assertDestroyablesDestroyed();
diff --git a/type-tests/preview/@ember/engine-test/engine-instance.ts b/type-tests/preview/@ember/engine-test/engine-instance.ts
new file mode 100644
index 00000000000..eaec71e5722
--- /dev/null
+++ b/type-tests/preview/@ember/engine-test/engine-instance.ts
@@ -0,0 +1,26 @@
+import EngineInstance from '@ember/engine/instance';
+
+const engineInstance = EngineInstance.create();
+engineInstance.register('some:injection', class Foo {});
+
+engineInstance.register('some:injection', class Foo {}, {
+  singleton: true,
+});
+
+engineInstance.register('some:injection', class Foo {}, {
+  instantiate: false,
+});
+
+engineInstance.register('some:injection', class Foo {}, {
+  singleton: false,
+  instantiate: true,
+});
+
+engineInstance.factoryFor('router:main');
+engineInstance.lookup('route:basic');
+
+engineInstance.boot();
+
+(async () => {
+  await engineInstance.boot();
+})();
diff --git a/type-tests/preview/@ember/engine-test/engine.ts b/type-tests/preview/@ember/engine-test/engine.ts
new file mode 100755
index 00000000000..994ff9da610
--- /dev/null
+++ b/type-tests/preview/@ember/engine-test/engine.ts
@@ -0,0 +1,45 @@
+import Engine from '@ember/engine';
+import EmberObject from '@ember/object';
+
+class BaseEngine extends Engine {
+  modulePrefix = 'my-engine';
+}
+
+class Obj extends EmberObject {
+  foo = 'bar';
+}
+
+BaseEngine.initializer({
+  name: 'my-initializer',
+  initialize(engine) {
+    engine.register('foo:bar', Obj);
+  },
+});
+
+BaseEngine.instanceInitializer({
+  name: 'my-instance-initializer',
+  initialize(engine) {
+    (engine.lookup('foo:bar') as Obj).get('foo');
+  },
+});
+
+class Engine1 extends BaseEngine {
+  rootElement = '#engine-one';
+  customEvents = {
+    paste: 'paste',
+  };
+}
+
+class Engine2 extends BaseEngine {
+  rootElement = '#engine-two';
+  customEvents = {
+    mouseenter: null,
+    mouseleave: null,
+  };
+}
+
+const Engine3 = BaseEngine.create();
+
+const Engine3Instance1 = Engine3.buildInstance();
+
+const Engine3Instance2 = Engine3.buildInstance({ foo: 'bar' });
diff --git a/type-tests/preview/@ember/error-tests.ts b/type-tests/preview/@ember/error-tests.ts
new file mode 100644
index 00000000000..3ffd32c5af9
--- /dev/null
+++ b/type-tests/preview/@ember/error-tests.ts
@@ -0,0 +1,7 @@
+import Error from '@ember/error';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf(new Error('Fuuuuuuuu')).toEqualTypeOf<Error>();
+
+// allows to extend from EmberError
+class AjaxError extends Error {}
diff --git a/type-tests/preview/@ember/helper-tests.ts b/type-tests/preview/@ember/helper-tests.ts
new file mode 100644
index 00000000000..d68bce04dcf
--- /dev/null
+++ b/type-tests/preview/@ember/helper-tests.ts
@@ -0,0 +1,19 @@
+import {
+  array,
+  ArrayHelper,
+  concat,
+  ConcatHelper,
+  fn,
+  FnHelper,
+  get,
+  GetHelper,
+  hash,
+  HashHelper,
+} from '@ember/helper';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf(array).toEqualTypeOf<ArrayHelper>();
+expectTypeOf(concat).toEqualTypeOf<ConcatHelper>();
+expectTypeOf(fn).toEqualTypeOf<FnHelper>();
+expectTypeOf(get).toEqualTypeOf<GetHelper>();
+expectTypeOf(hash).toEqualTypeOf<HashHelper>();
diff --git a/type-tests/preview/@ember/modifier-tests.ts b/type-tests/preview/@ember/modifier-tests.ts
new file mode 100644
index 00000000000..b90b0356d27
--- /dev/null
+++ b/type-tests/preview/@ember/modifier-tests.ts
@@ -0,0 +1,6 @@
+import { setModifierManager, capabilities, on, OnModifier } from '@ember/modifier';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf(on).toEqualTypeOf<OnModifier>();
+expectTypeOf(setModifierManager((_owner) => {}, {})).toEqualTypeOf<{}>();
+expectTypeOf(capabilities('3.24')).toBeUnknown();
diff --git a/type-tests/preview/@ember/object-test/compat.ts b/type-tests/preview/@ember/object-test/compat.ts
new file mode 100644
index 00000000000..e6b08c0d7b4
--- /dev/null
+++ b/type-tests/preview/@ember/object-test/compat.ts
@@ -0,0 +1,12 @@
+import { dependentKeyCompat } from '@ember/object/compat';
+
+// Example (without irrelevant details) from https://api.emberjs.com/ember/3.18/functions/@ember%2Fobject%2Fcompat/dependentKeyCompat
+class Person {
+  declare firstName: string;
+  declare lastName: string;
+
+  @dependentKeyCompat
+  get fullName() {
+    return `${this.firstName} ${this.lastName}`;
+  }
+}
diff --git a/type-tests/preview/@ember/object-test/computed.ts b/type-tests/preview/@ember/object-test/computed.ts
new file mode 100644
index 00000000000..cbb90910b6d
--- /dev/null
+++ b/type-tests/preview/@ember/object-test/computed.ts
@@ -0,0 +1,396 @@
+import EmberObject, { computed } from '@ember/object';
+import {
+  alias,
+  or,
+  and,
+  filter,
+  equal,
+  empty,
+  filterBy,
+  notEmpty,
+  none,
+  not,
+  min,
+  max,
+  gt,
+  gte,
+  lt,
+  lte,
+  readOnly,
+  reads,
+  setDiff,
+  sort,
+  intersect,
+  mapBy,
+  match,
+  map,
+  oneWay,
+  sum,
+  union,
+  uniqBy,
+  uniq,
+  deprecatingAlias,
+  bool,
+  collect,
+} from '@ember/object/computed';
+import { expectTypeOf } from 'expect-type';
+
+function customMacro(message: string) {
+  return computed(() => {
+    return [message, message];
+  });
+}
+
+class Person extends EmberObject {
+  firstName = '';
+  lastName = '';
+  age = 0;
+
+  // Equivalent to a per-instance `defineProperty` call.
+  @computed()
+  get noArgs() {
+    return 'test';
+  }
+
+  @computed('firstName', 'lastName')
+  get fullName(): string {
+    return `${this.get('firstName')} ${this.get('lastName')}`;
+  }
+
+  @computed('fullName').readOnly()
+  get fullNameReadonly() {
+    return this.get('fullName');
+  }
+
+  @computed('firstName', 'lastName')
+  get fullNameWritable(): string {
+    return this.get('fullName');
+  }
+
+  set fullNameWritable(value: string) {
+    const [first, last] = value.split(' ');
+    this.set('firstName', first);
+    this.set('lastName', last);
+  }
+
+  @computed().meta({ foo: 'bar' }).readOnly()
+  get combinators() {
+    return this.get('firstName');
+  }
+
+  @alias('fullName')
+  declare explicitlyDeclared: string;
+
+  @customMacro('hi')
+  declare hiTwice: string[];
+}
+
+const person = Person.create({
+  firstName: 'Fred',
+  lastName: 'Smith',
+  age: 29,
+});
+
+expectTypeOf(person.firstName).toEqualTypeOf<string>();
+expectTypeOf(person.age).toEqualTypeOf<number>();
+expectTypeOf(person.noArgs).toEqualTypeOf<string>();
+expectTypeOf(person.fullName).toEqualTypeOf<string>();
+expectTypeOf(person.fullNameReadonly).toEqualTypeOf<string>();
+expectTypeOf(person.fullNameWritable).toEqualTypeOf<string>();
+expectTypeOf(person.combinators).toEqualTypeOf<string>();
+expectTypeOf(person.explicitlyDeclared).toEqualTypeOf<string>();
+
+expectTypeOf(person.get('firstName')).toEqualTypeOf<string>();
+expectTypeOf(person.get('age')).toEqualTypeOf<number>();
+expectTypeOf(person.get('noArgs')).toEqualTypeOf<string>();
+expectTypeOf(person.get('fullName')).toEqualTypeOf<string>();
+expectTypeOf(person.get('fullNameReadonly')).toEqualTypeOf<string>();
+expectTypeOf(person.get('fullNameWritable')).toEqualTypeOf<string>();
+expectTypeOf(person.get('combinators')).toEqualTypeOf<string>();
+expectTypeOf(person.get('explicitlyDeclared')).toEqualTypeOf<string>();
+
+expectTypeOf(person.getProperties('firstName', 'fullName', 'age')).toMatchTypeOf<{
+  firstName: string;
+  fullName: string;
+  age: number;
+}>();
+
+const person2 = Person.create({
+  fullName: 'Fred Smith',
+});
+
+expectTypeOf(person2.get('firstName')).toEqualTypeOf<string>();
+expectTypeOf(person2.get('fullName')).toEqualTypeOf<string>();
+
+const person3 = Person.extend({
+  firstName: 'Fred',
+  fullName: 'Fred Smith',
+}).create();
+
+expectTypeOf(person3.get('firstName')).toEqualTypeOf<string>();
+expectTypeOf(person3.get('fullName')).toEqualTypeOf<string>();
+
+const person4 = Person.extend({
+  firstName: computed(() => 'Fred'),
+  fullName: computed(() => 'Fred Smith'),
+}).create();
+
+expectTypeOf(person4.get('firstName')).toEqualTypeOf<string>();
+expectTypeOf(person4.get('fullName')).toEqualTypeOf<string>();
+
+// computed property macros
+class Bar extends EmberObject {
+  declare firstName: string;
+  declare last: string;
+
+  declare values: number[];
+
+  // @ts-expect-error
+  @alias declare aliasTest0: string;
+  // @ts-expect-error
+  @alias() declare aliasTest1: string;
+  @alias('firstName') declare aliasTest2: string;
+
+  // @ts-expect-error
+  @and declare andTest0: boolean;
+  @and() declare andTest1: boolean;
+  @and('firstName') declare andTest2: boolean;
+  @and('firstName', 'lastName') declare andTest3: boolean;
+
+  // @ts-expect-error
+  @bool declare boolTest0: boolean;
+  // @ts-expect-error
+  @bool() declare boolTest1: boolean;
+  @bool('firstName') declare boolTest2: boolean;
+
+  // @ts-expect-error
+  @collect declare collectTest0: unknown[];
+  @collect() declare collectTest1: unknown[];
+  @collect('firstName') declare collectTest2: string[];
+
+  // @ts-expect-error
+  @deprecatingAlias declare deprecatingAliasTest0: string;
+  // @ts-expect-error
+  @deprecatingAlias() declare deprecatingAliasTest1: string;
+  // @ts-expect-error
+  @deprecatingAlias('firstName') declare deprecatingAliasTest2: string;
+  @deprecatingAlias('firstName', { id: 'deprecate-everything', until: 'v5.0.0' })
+  declare deprecatingAliasTest3: string;
+
+  // @ts-expect-error
+  @empty declare emptyTest0: boolean;
+  // @ts-expect-error
+  @empty() declare emptyTest1: boolean;
+  @empty('firstName') declare emptyTest2: boolean;
+
+  // @ts-expect-error
+  @equal declare equalTest0: boolean;
+  // @ts-expect-error
+  @equal() declare equalTest1: boolean;
+  // @ts-expect-error
+  @equal('firstName') declare equalTest2: boolean;
+  @equal('firstName', 'lastName') declare equalTest3: boolean;
+
+  // @ts-expect-error
+  @filter declare filterTest1: string[];
+  // @ts-expect-error
+  @filter() declare filterTest2: string[];
+  // @ts-expect-error
+  @filter('firstName') declare filterTest3: string[];
+  @filter('firstName', Boolean) declare filterTest4: string[];
+  // @ts-expect-error
+  @filter('firstName', 'secondName', (x) => x) declare filterTest5: string[];
+  @filter('firstName', ['secondName'], Boolean) declare filterTest6: string[];
+
+  // @ts-expect-error
+  @filterBy declare filterByTest1: unknown[];
+  // @ts-expect-error
+  @filterBy() declare filterByTest2: unknown[];
+  // @ts-expect-error
+  @filterBy('firstName') declare filterByTest3: string[];
+  @filterBy('firstName', 'id') declare filterByTest4: string[];
+
+  // @ts-expect-error
+  @gt declare gtTest1: boolean;
+  // @ts-expect-error
+  @gt() declare gtTest2: boolean;
+  // @ts-expect-error
+  @gt('firstName') declare gtTest3: boolean;
+  @gt('firstName', 3) declare gtTest4: boolean;
+
+  // @ts-expect-error
+  @gte declare gteTest1: boolean;
+  // @ts-expect-error
+  @gte() declare gteTest2: boolean;
+  // @ts-expect-error
+  @gte('firstName') declare gteTest3: boolean;
+  @gte('firstName', 3) declare gteTest4: boolean;
+
+  // @ts-expect-error
+  @intersect declare intersectTest1: any;
+  @intersect() declare intersectTest2: any;
+  @intersect('firstName') declare intersectTest3: any;
+  @intersect('firstName', 'lastName') declare intersectTest4: any;
+
+  // @ts-expect-error
+  @lt declare ltTest1: boolean;
+  // @ts-expect-error
+  @lt() declare ltTest2: boolean;
+  // @ts-expect-error
+  @lt('firstName') declare ltTest3: boolean;
+  @lt('firstName', 3) declare ltTest4: boolean;
+
+  // @ts-expect-error
+  @lte declare lteTest1: boolean;
+  // @ts-expect-error
+  @lte() declare lteTest2: boolean;
+  // @ts-expect-error
+  @lte('firstName') declare lteTest3: boolean;
+  @lte('firstName', 3) declare lteTest4: boolean;
+
+  // @ts-expect-error
+  @map declare mapTest1: string[];
+  // @ts-expect-error
+  @map() declare mapTest2: string[];
+  // @ts-expect-error
+  @map('firstName') declare mapTest3: string[];
+  @map('firstName', (x) => x) declare mapTest4: string[];
+
+  // @ts-expect-error
+  @mapBy declare mapByTest1: any[];
+  // @ts-expect-error
+  @mapBy() declare mapByTest2: any[];
+  // @ts-expect-error
+  @mapBy('firstName') declare mapByTest3: any[];
+  @mapBy('firstName', 'id') declare mapByTest4: any[];
+
+  // @ts-expect-error
+  @match declare matchTest1: boolean;
+  // @ts-expect-error
+  @match() declare matchTest2: boolean;
+  // @ts-expect-error
+  @match('firstName') declare matchTest3: boolean;
+  // @ts-expect-error
+  @match('firstName', 'abc') declare matchTest4: boolean;
+  @match('firstName', /\s+/) declare matchTest5: boolean;
+
+  // @ts-expect-error
+  @max declare maxTest1: number;
+  // @ts-expect-error
+  @max() declare maxTest2: number;
+  @max('values') declare maxTest3: number;
+  // @ts-expect-error
+  @max('values', 'a') declare maxTest4: number;
+
+  // @ts-expect-error
+  @min declare minTest1: number;
+  // @ts-expect-error
+  @min() declare minTest2: number;
+  @min('values') declare minTest3: number;
+  // @ts-expect-error
+  @min('values', 'a') declare minTest4: number;
+
+  // @ts-expect-error
+  @none declare noneTest1: number;
+  // @ts-expect-error
+  @none() declare noneTest2: number;
+  @none('values') declare noneTest3: number;
+  // @ts-expect-error
+  @none('values', 'a') declare noneTest4: number;
+
+  // @ts-expect-error
+  @not declare notTest1: number;
+  // @ts-expect-error
+  @not() declare notTest2: number;
+  @not('values') declare notTest3: number;
+  // @ts-expect-error
+  @not('values', 'a') declare notTest4: number;
+
+  // @ts-expect-error
+  @notEmpty declare notEmptyTest1: boolean;
+  // @ts-expect-error
+  @notEmpty() declare notEmptyTest2: boolean;
+  @notEmpty('firstName') declare notEmptyTest3: boolean;
+  // @ts-expect-error
+  @notEmpty('firstName', 'a') declare notEmptyTest4: boolean;
+
+  // @ts-expect-error
+  @oneWay declare oneWayTest1: boolean;
+  // @ts-expect-error
+  @oneWay() declare oneWayTest2: boolean;
+  @oneWay('firstName') declare oneWayTest3: boolean;
+  // @ts-expect-error
+  @oneWay('firstName', 'b') declare oneWayTest4: boolean;
+
+  // @ts-expect-error
+  @or declare orTest1: boolean;
+  @or() declare orTest2: boolean;
+  @or('firstName') declare orTest3: boolean;
+  @or('firstName', 'lastName') declare orTest4: boolean;
+
+  // @ts-expect-error
+  @readOnly declare readOnlyTest1: boolean;
+  // @ts-expect-error
+  @readOnly() declare readOnlyTest2: boolean;
+  @readOnly('firstName') declare readOnlyTest3: boolean;
+
+  // @ts-expect-error
+  @reads declare readsTest1: boolean;
+  // @ts-expect-error
+  @reads() declare readsTest2: boolean;
+  @reads('firstName') declare readsTest3: boolean;
+  // @ts-expect-error
+  @reads('firstName', 'a') declare readsTest4: boolean;
+
+  // @ts-expect-error
+  @setDiff declare setDiffTest1: number;
+  // @ts-expect-error
+  @setDiff() declare setDiffTest2: number;
+  // @ts-expect-error
+  @setDiff('values') declare setDiffTest3: number;
+  @setDiff('values', 'otherThing') declare setDiffTest4: number;
+  // @ts-expect-error
+  @setDiff('values', 'otherThing', 'a') declare setDiffTest5: number;
+
+  // @ts-expect-error
+  @sort declare sortTest1: number;
+  // @ts-expect-error
+  @sort() declare sortTest2: number;
+  // @ts-expect-error
+  @sort('values') declare sortTest3: number;
+  @sort('values', 'id') declare sortTest4: number;
+  // @ts-expect-error
+  @sort('values', 'id', 'a') declare sortTest5: number;
+  @sort('values', (a: number, b: number) => a - b) declare sortTest6: number;
+  @sort('values', ['id'], (a: number, b: number) => a - b) declare sortTest7: number;
+  // @ts-expect-error
+  @sort('values', 'id', (a, b) => a - b) declare sortTest8: number;
+  // @ts-expect-error
+  @sort(['id'], (a, b) => a - b) declare sortTest9: number;
+
+  // @ts-expect-error
+  @sum declare sumTest1: number;
+  // @ts-expect-error
+  @sum() declare sumTest2: number;
+  @sum('values') declare sumTest3: number;
+
+  // @ts-expect-error
+  @union declare unionTest1: never;
+  @union() declare unionTest2: [];
+  @union('firstName') declare unionTest3: string[];
+  @union('firstName', 'lastName') declare unionTest4: string[];
+
+  // @ts-expect-error
+  @uniq declare uniqTest1: number;
+  // @ts-expect-error
+  @uniq() declare uniqTest2: number;
+  @uniq('values') declare uniqTest3: number;
+
+  // @ts-expect-error
+  @uniqBy declare uniqByTest1: number;
+  // @ts-expect-error
+  @uniqBy() declare uniqByTest2: number;
+  // @ts-expect-error
+  @uniqBy('values') declare uniqByTest3: number;
+  @uniqBy('values', 'id') declare uniqByTest4: number;
+}
diff --git a/type-tests/preview/@ember/object-test/core.ts b/type-tests/preview/@ember/object-test/core.ts
new file mode 100644
index 00000000000..bc028dc41e4
--- /dev/null
+++ b/type-tests/preview/@ember/object-test/core.ts
@@ -0,0 +1,53 @@
+import CoreObject from '@ember/object/core';
+import { expectTypeOf } from 'expect-type';
+
+/** Newable tests */
+const co1 = new CoreObject();
+
+expectTypeOf(co1.isDestroyed).toEqualTypeOf<boolean>();
+expectTypeOf(co1.isDestroying).toEqualTypeOf<boolean>();
+expectTypeOf(co1.destroy()).toEqualTypeOf<CoreObject>();
+expectTypeOf(co1.toString()).toEqualTypeOf<string>();
+
+/** .create tests */
+const co2 = CoreObject.create();
+expectTypeOf(co2.isDestroyed).toEqualTypeOf<boolean>();
+expectTypeOf(co2.isDestroying).toEqualTypeOf<boolean>();
+expectTypeOf(co2.destroy()).toEqualTypeOf<CoreObject>();
+expectTypeOf(co2.toString()).toEqualTypeOf<string>();
+
+/** .create tests w/ initial instance data passed in */
+declare class CO3 extends CoreObject {
+  foo: string;
+  bar: number;
+}
+const co3 = CO3.create({ foo: '123', bar: 456 });
+
+expectTypeOf(co3.foo).toEqualTypeOf<string>();
+expectTypeOf(co3.bar).toEqualTypeOf<number>();
+
+/** .extend with a zero-argument .create()  */
+class CO4 extends CO3 {
+  baz(): [string, number] {
+    return [this.foo, this.bar];
+  }
+}
+const co4 = CO4.create();
+
+expectTypeOf(co4.foo).toEqualTypeOf<string>();
+expectTypeOf(co4.bar).toEqualTypeOf<number>();
+expectTypeOf(co4.baz).toEqualTypeOf<() => [string, number]>();
+
+/** .extend with inconsistent arguments passed into .create()  */
+class CO5 extends CoreObject {
+  foo: string | boolean = 'hello';
+  bar = 123;
+  baz() {
+    return [this.foo, this.bar];
+  }
+}
+// @ts-expect-error
+class05.create({ foo: 99 });
+expectTypeOf(CO5.create({ foo: true })).toEqualTypeOf<CO5>();
+expectTypeOf(CO5.create({ foo: 'abc' })).toEqualTypeOf<CO5>();
+expectTypeOf(CO5.create().foo).toEqualTypeOf<boolean | string>();
diff --git a/type-tests/preview/@ember/object-test/create-negative.ts b/type-tests/preview/@ember/object-test/create-negative.ts
new file mode 100644
index 00000000000..86557265951
--- /dev/null
+++ b/type-tests/preview/@ember/object-test/create-negative.ts
@@ -0,0 +1,8 @@
+import { Person } from './create';
+
+// @ts-expect-error
+Person.create({ firstName: 99 });
+// @ts-expect-error
+Person.create({}, { firstName: 99 });
+// @ts-expect-error
+Person.create({}, {}, { firstName: 99 });
diff --git a/type-tests/preview/@ember/object-test/create.ts b/type-tests/preview/@ember/object-test/create.ts
new file mode 100644
index 00000000000..e615991b6b4
--- /dev/null
+++ b/type-tests/preview/@ember/object-test/create.ts
@@ -0,0 +1,57 @@
+import EmberObject, { computed } from '@ember/object';
+import { expectTypeOf } from 'expect-type';
+
+/**
+ * Zero-argument case
+ */
+const o = EmberObject.create();
+// create returns an object
+expectTypeOf(o).toBeObject();
+// 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 EmberObject>(key: K) => EmberObject[K]>();
+
+/**
+ * One-argument case
+ */
+class O1 extends EmberObject {
+  declare x: number;
+  declare y: string;
+  declare z: boolean;
+}
+
+const o1 = O1.create({ x: 9, y: 'hello', z: false });
+expectTypeOf(o1.x).toBeNumber();
+expectTypeOf(o1.y).toBeString();
+expectTypeOf(o1.z).toBeBoolean();
+
+class O2 extends EmberObject {
+  declare a: number;
+  declare b: number;
+  declare c: number;
+}
+const obj = O2.create({ a: 1 }, { b: 2 }, { c: 3 });
+expectTypeOf(obj.b).toBeNumber();
+expectTypeOf(obj.a).toBeNumber();
+expectTypeOf(obj.c).toBeNumber();
+
+export class Person extends EmberObject {
+  declare firstName: string;
+  declare lastName: string;
+  declare age: number;
+
+  @computed('firstName', 'lastName')
+  get fullName() {
+    return [this.firstName + this.lastName].join(' ');
+  }
+}
+const p = Person.create();
+
+expectTypeOf(p.firstName).toBeString();
+expectTypeOf(p.fullName).toBeString();
+expectTypeOf(p.get('fullName')).toBeString();
+
+Person.create({ firstName: 'string' });
+Person.create({}, { firstName: 'string' });
+Person.create({}, {}, { firstName: 'string' });
diff --git a/type-tests/preview/@ember/object-test/event.ts b/type-tests/preview/@ember/object-test/event.ts
new file mode 100644
index 00000000000..dc80b26f1ec
--- /dev/null
+++ b/type-tests/preview/@ember/object-test/event.ts
@@ -0,0 +1,96 @@
+import EmberObject from '@ember/object';
+import { sendEvent, addListener, removeListener } from '@ember/object/events';
+import Evented, { on } from '@ember/object/evented';
+
+function testOn() {
+  const Job = EmberObject.extend({
+    logStartOrUpdate: on('started', 'updated', () => {
+      console.log('Job updated!');
+    }),
+    logCompleted: on('completed', () => {
+      console.log('Job completed!');
+    }),
+  });
+
+  const job = Job.create();
+
+  sendEvent(job, 'started'); // Logs 'Job started!'
+  sendEvent(job, 'updated'); // Logs 'Job updated!'
+  sendEvent(job, 'completed'); // Logs 'Job completed!'
+}
+
+function testEvented() {
+  interface Person extends Evented {}
+  class Person extends EmberObject {
+    greet() {
+      this.trigger('greet');
+    }
+  }
+
+  const person = Person.create();
+
+  person.on('potato', 'greet');
+
+  const target = {
+    hi() {
+      console.log('Hello!');
+    },
+  };
+
+  person.on('greet', () => {
+    console.log('Our person has greeted');
+  });
+
+  person
+    .on('greet', () => {
+      console.log('Our person has greeted');
+    })
+    .one('greet', () => {
+      console.log('Offer one-time special');
+    })
+    .off('event', {}, () => {});
+
+  person.on('greet', target, 'hi').one('greet', target, 'hi').off('event', target, 'hi');
+
+  person
+    .on('greet', target, target.hi)
+    .one('greet', target, target.hi)
+    .off('event', target, target.hi);
+
+  person.greet();
+}
+
+function testObserver() {
+  EmberObject.extend({
+    // TODO: enable after https://github.com/typed-ember/ember-cli-typescript/issues/290
+    // valueObserver: observer('value', () => {
+    //     // Executes whenever the "value" property changes
+    // })
+  });
+}
+
+function testListener() {
+  function willDestroyListener() {}
+
+  class Destroy extends EmberObject {
+    init() {
+      addListener(this, 'willDestroy', this, 'willDestroyListener');
+      addListener(this, 'willDestroy', this, 'willDestroyListener', true);
+      addListener(this, 'willDestroy', this, willDestroyListener);
+      addListener(this, 'willDestroy', this, willDestroyListener, true);
+      removeListener(this, 'willDestroy', this, 'willDestroyListener');
+      removeListener(this, 'willDestroy', this, willDestroyListener);
+
+      addListener(this, 'willDestroy', 'willDestroyListener');
+      addListener(this, 'willDestroy', 'willDestroyListener', true);
+      addListener(this, 'willDestroy', willDestroyListener);
+      addListener(this, 'willDestroy', willDestroyListener, true);
+      removeListener(this, 'willDestroy', 'willDestroyListener');
+      removeListener(this, 'willDestroy', willDestroyListener);
+    }
+
+    willDestroyListener() {
+      willDestroyListener();
+    }
+  }
+}
diff --git a/type-tests/preview/@ember/object-test/extend.ts b/type-tests/preview/@ember/object-test/extend.ts
new file mode 100644
index 00000000000..235271801e9
--- /dev/null
+++ b/type-tests/preview/@ember/object-test/extend.ts
@@ -0,0 +1,39 @@
+import EmberObject from '@ember/object';
+import { expectTypeOf } from 'expect-type';
+
+class Person extends EmberObject {
+  declare firstName: string;
+  declare lastName: string;
+
+  get fullName() {
+    return `${this.firstName} ${this.lastName}`;
+  }
+  get fullName2(): string {
+    return `${this.get('firstName')} ${this.get('lastName')}`;
+  }
+}
+
+expectTypeOf(Person.prototype.firstName).toBeString();
+expectTypeOf(Person.prototype.fullName).toBeString();
+
+const person = Person.create({
+  firstName: 'Joe',
+  lastName: 'Blow',
+  // @ts-expect-error
+  extra: 42,
+});
+
+expectTypeOf(person.fullName).toBeString();
+// @ts-expect-error
+person.extra;
+
+class PersonWithStatics extends EmberObject {
+  static isPerson = true;
+}
+const PersonWithStatics2 = PersonWithStatics.extend({});
+class PersonWithStatics3 extends PersonWithStatics {}
+class PersonWithStatics4 extends PersonWithStatics2 {}
+expectTypeOf(PersonWithStatics.isPerson).toBeBoolean();
+expectTypeOf(PersonWithStatics2.isPerson).toBeBoolean();
+expectTypeOf(PersonWithStatics3.isPerson).toBeBoolean();
+expectTypeOf(PersonWithStatics4.isPerson).toBeBoolean();
diff --git a/type-tests/preview/@ember/object-test/get-set.ts b/type-tests/preview/@ember/object-test/get-set.ts
new file mode 100644
index 00000000000..d17a7d3bb05
--- /dev/null
+++ b/type-tests/preview/@ember/object-test/get-set.ts
@@ -0,0 +1,15 @@
+import { get, set } from '@ember/object';
+import { expectTypeOf } from 'expect-type';
+
+const basicPojo = { greeting: 'hello' };
+
+expectTypeOf(get(basicPojo, 'greeting')).toEqualTypeOf<string>();
+expectTypeOf(get(basicPojo, 'salutation')).toEqualTypeOf<unknown>();
+expectTypeOf(set(basicPojo, 'greeting', 'ahoy')).toEqualTypeOf<string>();
+// @ts-expect-error
+set(basicPojo, 'salutation', 'heyo');
+
+declare let whoKnows: unknown;
+expectTypeOf(get(whoKnows, 'any-string')).toEqualTypeOf<unknown>();
+// @ts-expect-error
+set(whoKnows, 'any-string', 123);
diff --git a/type-tests/preview/@ember/object-test/internals.ts b/type-tests/preview/@ember/object-test/internals.ts
new file mode 100644
index 00000000000..5c70b399e5c
--- /dev/null
+++ b/type-tests/preview/@ember/object-test/internals.ts
@@ -0,0 +1,7 @@
+import { guidFor } from '@ember/object/internals';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf(guidFor('a string')).toBeString();
+expectTypeOf(guidFor(123)).toBeString();
+expectTypeOf(guidFor({ hello: 'world' })).toBeString();
+expectTypeOf(guidFor([1, 2, 3])).toBeString();
diff --git a/type-tests/preview/@ember/object-test/object.ts b/type-tests/preview/@ember/object-test/object.ts
new file mode 100644
index 00000000000..6a022f01099
--- /dev/null
+++ b/type-tests/preview/@ember/object-test/object.ts
@@ -0,0 +1,98 @@
+import Object, { computed, get, notifyPropertyChange, set, setProperties } from '@ember/object';
+import { expectTypeOf } from 'expect-type';
+
+class LifetimeHooks extends Object {
+  resource: {} | undefined;
+
+  init() {
+    this._super();
+    this.resource = {};
+  }
+
+  willDestroy() {
+    this.resource = undefined;
+    this._super();
+  }
+}
+
+class MyObject30 extends Object {
+  constructor() {
+    super();
+  }
+}
+
+class MyObject31 extends Object {
+  constructor(properties: object) {
+    super(properties);
+  }
+}
+
+class Foo extends Object {
+  @computed()
+  get a() {
+    return '';
+  }
+
+  set a(newVal: string) {
+    /* no-op */
+  }
+
+  b = 5;
+
+  baz() {
+    expectTypeOf(this.b).toBeNumber();
+    expectTypeOf(this.a).toBeString();
+    this.b = 10;
+
+    // For some reason, `this` type lookup does not resolve correctly here. Used
+    // outside a class, like `get(someFoo, 'name')`, this works correctly. Since
+    // there are basically no cases inside a class where you *have* to use `get`
+    // today, this is an acceptable workaround for now. It is assignable *or*
+    // castable.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const a: number = this.get('b');
+
+    expectTypeOf(this.get('b').toFixed(4)).toEqualTypeOf<string>();
+    expectTypeOf(this.set('a', 'abc').split(',')).toEqualTypeOf<string[]>();
+    expectTypeOf(this.set('b', 10).toFixed(4)).toEqualTypeOf<string>();
+
+    this.setProperties({ b: 11 });
+    // this.setProperties({ b: '11' }); // @ts-expect-error
+    this.setProperties({
+      a: 'def',
+      b: 11,
+    });
+  }
+}
+
+export class Foo2 extends Object {
+  name = '';
+
+  changeName(name: string) {
+    expectTypeOf(this.set('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
+    // there are basically no cases inside a class where you *have* to use `get`
+    // today, this is an acceptable workaround for now. It is assignable *or*
+    // castable.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const s: string = this.get('name');
+    expectTypeOf(get(this as Foo2, 'name')).toBeString();
+    expectTypeOf((this as Foo2).get('name')).toBeString();
+
+    expectTypeOf(this.setProperties({ name })).toEqualTypeOf<Pick<this, 'name'>>();
+    expectTypeOf(setProperties(this, { name })).toEqualTypeOf<Pick<this, 'name'>>();
+  }
+
+  bar() {
+    notifyPropertyChange(this, 'name');
+    // @ts-expect-error
+    notifyPropertyChange(this);
+    // @ts-expect-error
+    notifyPropertyChange('name');
+    // @ts-expect-error
+    notifyPropertyChange(this, 'name', 'bar');
+  }
+}
diff --git a/type-tests/preview/@ember/object-test/observable.ts b/type-tests/preview/@ember/object-test/observable.ts
new file mode 100644
index 00000000000..cec5a0f11c5
--- /dev/null
+++ b/type-tests/preview/@ember/object-test/observable.ts
@@ -0,0 +1,138 @@
+import { expectTypeOf } from 'expect-type';
+import EmberObject, { computed, getProperties, get, setProperties, set } from '@ember/object';
+import { removeObserver, addObserver } from '@ember/object/observers';
+
+class MyComponent extends EmberObject {
+  foo = 'bar';
+
+  init() {
+    this._super.apply(this);
+    this.addObserver('foo', this, 'fooDidChange');
+    this.addObserver('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);
+    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);
+    addObserver(this, 'foo', lambda);
+    removeObserver(this, 'foo', lambda);
+  }
+
+  fooDidChange(sender: this, key: string) {
+    // your code
+  }
+}
+
+const myComponent = MyComponent.create();
+myComponent.addObserver('foo', null, () => {});
+myComponent.set('foo', 'baz');
+
+class Person extends EmberObject {
+  name = 'Fred';
+  age = 29;
+
+  @computed()
+  get capitalized() {
+    return this.get('name').toUpperCase();
+  }
+}
+const person = Person.create();
+
+const pojo = { name: 'Fred', age: 29 };
+
+function testGet() {
+  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(get(pojo, 'name')).toEqualTypeOf<string>();
+}
+
+function testGetProperties() {
+  expectTypeOf(getProperties(person, 'name')).toEqualTypeOf<{ name: string }>();
+  expectTypeOf(getProperties(person, 'name', 'age')).toEqualTypeOf<{ name: string; age: number }>();
+  expectTypeOf(getProperties(person, ['name', 'age'])).toEqualTypeOf<{
+    name: string;
+    age: number;
+  }>();
+  expectTypeOf(getProperties(person, 'name', 'age', 'capitalized')).toEqualTypeOf<
+    Pick<Person, 'name' | 'age' | 'capitalized'>
+  >();
+  expectTypeOf(person.getProperties('name')).toEqualTypeOf<{ name: string }>();
+  expectTypeOf(person.getProperties('name', 'age')).toEqualTypeOf<{ name: string; age: number }>();
+  expectTypeOf(person.getProperties(['name', 'age'])).toEqualTypeOf<{
+    name: string;
+    age: number;
+  }>();
+  expectTypeOf(person.getProperties('name', 'age', 'capitalized')).toEqualTypeOf<
+    Pick<Person, 'name' | 'age' | 'capitalized'>
+  >();
+  expectTypeOf(getProperties(pojo, 'name', 'age')).toEqualTypeOf<{ name: string; age: number }>();
+}
+
+function testSet() {
+  expectTypeOf(set(person, 'name', 'Joe')).toEqualTypeOf<string>();
+  expectTypeOf(set(person, 'age', 35)).toEqualTypeOf<number>();
+  expectTypeOf(set(person, 'capitalized', 'JOE')).toEqualTypeOf<string>();
+  expectTypeOf(person.set('name', 'Joe')).toEqualTypeOf<string>();
+  expectTypeOf(person.set('age', 35)).toEqualTypeOf<number>();
+  expectTypeOf(person.set('capitalized', 'JOE')).toEqualTypeOf<string>();
+  expectTypeOf(set(pojo, 'name', 'Joe')).toEqualTypeOf<string>();
+}
+
+function testSetProperties() {
+  expectTypeOf(setProperties(person, { name: 'Joe' })).toEqualTypeOf<{ name: string }>();
+  expectTypeOf(setProperties(person, { name: 'Joe', age: 35 })).toEqualTypeOf<{
+    name: string;
+    age: number;
+  }>();
+  expectTypeOf(setProperties(person, { name: 'Joe', capitalized: 'JOE' })).toEqualTypeOf<
+    Pick<Person, 'name' | 'capitalized'>
+  >();
+  expectTypeOf(person.setProperties({ name: 'Joe' })).toEqualTypeOf<{ name: string }>();
+  expectTypeOf(person.setProperties({ name: 'Joe', age: 35 })).toEqualTypeOf<
+    Pick<Person, 'name' | 'age'>
+  >();
+  expectTypeOf(person.setProperties({ name: 'Joe', capitalized: 'JOE' })).toEqualTypeOf<
+    Pick<Person, 'name' | 'capitalized'>
+  >();
+  expectTypeOf(setProperties(pojo, { name: 'Joe', age: 35 })).toEqualTypeOf<
+    Pick<Person, 'name' | 'age'>
+  >();
+}
+
+function testDynamic() {
+  const obj: Record<string, string> = {};
+  const dynamicKey = 'dummy' as string;
+
+  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(setProperties(obj, { [dynamicKey]: 'value' })).toEqualTypeOf<
+    Record<string, string>
+  >();
+
+  // Test records with known types.
+  const x: Record<'a' | 'b', string> = {
+    a: 'a',
+    b: 'b',
+  };
+
+  expectTypeOf(get(x, 'a')).toBeString();
+  expectTypeOf(get(x, 'b')).toBeString();
+  expectTypeOf(get(x, 'anything else')).toBeUnknown();
+}
diff --git a/type-tests/preview/@ember/object-test/proxy.ts b/type-tests/preview/@ember/object-test/proxy.ts
new file mode 100644
index 00000000000..fec756a37c3
--- /dev/null
+++ b/type-tests/preview/@ember/object-test/proxy.ts
@@ -0,0 +1,108 @@
+import Ember from 'ember';
+import ObjectProxy from '@ember/object/proxy';
+import { expectTypeOf } from 'expect-type';
+
+interface Book {
+  title: string;
+  subtitle: string;
+  chapters: Array<{ title: string }>;
+}
+
+class DefaultProxy extends ObjectProxy {}
+expectTypeOf(DefaultProxy.create().content).toEqualTypeOf<object | undefined>();
+
+class BookProxy extends ObjectProxy<Book> {
+  private readonly baz = 'baz';
+
+  altTitle = 'Alt';
+
+  getTitle() {
+    return this.get('title');
+  }
+
+  getPropertiesTitleSubtitle() {
+    return this.getProperties('title', 'subtitle');
+  }
+}
+
+const book = BookProxy.create();
+expectTypeOf(book.content).toEqualTypeOf<Book | undefined>();
+
+// @ts-expect-error
+book.get('unknownProperty');
+expectTypeOf(book.get('title')).toEqualTypeOf<string | undefined>();
+expectTypeOf(book.get('altTitle')).toBeString();
+expectTypeOf(book.getTitle()).toEqualTypeOf<string | undefined>();
+
+// @ts-expect-error
+book.getProperties('title', 'unknownProperty');
+expectTypeOf(book.getProperties('title', 'subtitle')).toEqualTypeOf<
+  Pick<Partial<Book>, 'title' | 'subtitle'>
+>();
+expectTypeOf(book.getPropertiesTitleSubtitle()).toEqualTypeOf<
+  Pick<Partial<Book>, 'title' | 'subtitle'>
+>();
+expectTypeOf(book.getProperties(['subtitle', 'chapters'])).toEqualTypeOf<
+  Pick<Partial<Book>, 'subtitle' | 'chapters'>
+>();
+// @ts-expect-error
+book.getProperties(['title', 'unknownProperty']);
+
+// @ts-expect-error
+book.get('baz');
+
+book.set('title', 'New');
+// @ts-expect-error
+book.set('title', 1);
+book.set('altTitle', 'Alternate');
+// @ts-expect-error
+book.set('altTitle', 1);
+book.setProperties({
+  title: 'new',
+  subtitle: 'and improved',
+  altTitle: 'Alternate2',
+});
+// @ts-expect-error
+book.setProperties({ title: 1 });
+// @ts-expect-error
+book.setProperties({ altTitle: 1 });
+// @ts-expect-error
+book.setProperties({ invalid: true });
+
+class Person extends Ember.Object {
+  firstName = 'Peter';
+
+  lastName = 'Wagenet';
+
+  @Ember.computed('firstName', 'lastName')
+  get fullName() {
+    return `${this.firstName} ${this.lastName}`;
+  }
+
+  set fullName(value: string) {
+    const [firstName, lastName] = value.split(' ');
+
+    Ember.set(this, 'firstName', firstName ?? '');
+    Ember.set(this, 'lastName', lastName ?? '');
+  }
+}
+
+class PersonProxy extends ObjectProxy<Person> {}
+
+const person = PersonProxy.create();
+
+expectTypeOf(person.get('firstName')).toEqualTypeOf<string | undefined>();
+expectTypeOf(person.get('fullName')).toEqualTypeOf<string | undefined>();
+expectTypeOf(person.set('fullName', 'John Doe')).toBeString();
+// @ts-expect-error
+person.set('fullName', 1);
+// @ts-expect-error
+person.set('invalid', true);
+expectTypeOf(person.setProperties({ fullName: 'John Doe' })).toEqualTypeOf<
+  Pick<PersonProxy & Person, 'fullName'>
+>();
+expectTypeOf(person.setProperties({ fullName: 'John Doe' }).fullName).toBeString();
+// @ts-expect-error
+person.setProperties({ fullName: 1 });
+// @ts-expect-error
+person.setProperties({ fullName: 'John Doe', invalid: true });
diff --git a/type-tests/preview/@ember/object-test/reopen.ts b/type-tests/preview/@ember/object-test/reopen.ts
new file mode 100644
index 00000000000..cd361c11d5f
--- /dev/null
+++ b/type-tests/preview/@ember/object-test/reopen.ts
@@ -0,0 +1,79 @@
+import EmberObject from '@ember/object';
+import Mixin from '@ember/object/mixin';
+import { expectTypeOf } from 'expect-type';
+
+class Person extends EmberObject {
+  name = '';
+
+  sayHello() {
+    alert(`Hello. My name is ${this.get('name')}`);
+  }
+}
+
+expectTypeOf(Person.reopen()).toMatchTypeOf<typeof Person>();
+
+expectTypeOf(Person.create().name).toEqualTypeOf<string>();
+expectTypeOf(Person.create().sayHello()).toBeVoid();
+
+// Here, a basic check that `reopenClass` *works*, but we intentionally do not
+// provide types for how it changes the original class (as spec'd in RFC 0800).
+const Person2 = Person.reopenClass({
+  species: 'Homo sapiens',
+
+  createPerson(name: string): Person {
+    return Person.create({ name });
+  },
+});
+
+// The original class types are carried along
+expectTypeOf(Person2.create().name).toEqualTypeOf<string>();
+expectTypeOf(Person2.create().sayHello()).toBeVoid();
+// But we aren't trying to merge in new classes anymore.
+// @ts-expect-error
+Person2.species;
+
+const tom = Person2.create({
+  name: 'Tom Dale',
+});
+
+// @ts-expect-error
+const badTom = Person2.create({ name: 99 });
+
+// @ts-expect-error
+const yehuda = Person2.createPerson('Yehuda Katz');
+
+tom.sayHello(); // "Hello. My name is Tom Dale"
+yehuda.sayHello(); // "Hello. My name is Yehuda Katz"
+// @ts-expect-error
+alert(Person2.species); // "Homo sapiens"
+
+// The same goes for `.reopen()`: it will "work" in a bare minimum sense, but it
+// will not try to change the types.
+const Person3 = Person2.reopen({
+  goodbyeMessage: 'goodbye',
+
+  sayGoodbye(this: Person) {
+    alert(`${this.get('goodbyeMessage')}, ${this.get('name')}`);
+  },
+});
+
+const person3 = Person3.create();
+person3.get('name');
+person3.get('goodbyeMessage');
+person3.sayHello();
+// @ts-expect-error
+person3.sayGoodbye();
+
+interface AutoResizeMixin {
+  resizable: true;
+}
+const AutoResizeMixin = Mixin.create({ resizable: true });
+
+// And the same here.
+const Reopened = EmberObject.reopenClass({ a: 1 }, { b: 2 }, { c: 3 });
+// @ts-expect-error
+Reopened.a;
+// @ts-expect-error
+Reopened.b;
+// @ts-expect-error
+Reopened.c;
diff --git a/type-tests/preview/@ember/owner-tests.ts b/type-tests/preview/@ember/owner-tests.ts
new file mode 100644
index 00000000000..4effdfb996b
--- /dev/null
+++ b/type-tests/preview/@ember/owner-tests.ts
@@ -0,0 +1,148 @@
+import Owner, { Factory, FactoryManager, FullName, RegisterOptions } from '@ember/owner';
+import { expectTypeOf } from 'expect-type';
+
+// Just a class we can construct in the Factory and FactoryManager tests
+declare class ConstructThis {
+  hasProps: boolean;
+}
+
+// ----- RegisterOptions ----- //
+declare let regOptionsA: RegisterOptions;
+expectTypeOf(regOptionsA.instantiate).toEqualTypeOf<boolean | undefined>();
+expectTypeOf(regOptionsA.singleton).toEqualTypeOf<boolean | undefined>();
+
+// ----- Factory ----- //
+// This gives us coverage for the cases where you are *casting*.
+declare let aFactory: Factory<ConstructThis>;
+
+aFactory.create();
+aFactory.create({});
+aFactory.create({
+  hasProps: true,
+});
+aFactory.create({
+  hasProps: false,
+});
+
+// These should be rejected by way of EPC
+// @ts-expect-error
+aFactory.create({ unrelatedNonsense: 'yep yep yep' });
+// @ts-expect-error
+aFactory.create({ hasProps: true, unrelatedNonsense: 'yep yep yep' });
+
+// But this should be legal.
+const goodPojo = { hasProps: true, unrelatedNonsense: 'also true' };
+aFactory.create(goodPojo);
+
+// while this should be rejected for *type error* reasons, not EPC
+const badPojo = { hasProps: 'huzzah', unrelatedNonsense: 'also true' };
+// @ts-expect-error
+aFactory.create(badPojo);
+
+// ----- FactoryManager ----- //
+declare let aFactoryManager: FactoryManager<ConstructThis>;
+expectTypeOf(aFactoryManager.class).toEqualTypeOf<Factory<ConstructThis>>();
+expectTypeOf(aFactoryManager.create({})).toEqualTypeOf<ConstructThis>();
+expectTypeOf(aFactoryManager.create({ hasProps: true })).toEqualTypeOf<ConstructThis>();
+expectTypeOf(aFactoryManager.create({ hasProps: false })).toEqualTypeOf<ConstructThis>();
+// @ts-expect-error
+aFactoryManager.create({ otherStuff: 'nope' });
+// @ts-expect-error
+aFactoryManager.create({ hasProps: true, otherStuff: 'nope' });
+expectTypeOf(aFactoryManager.create(goodPojo)).toEqualTypeOf<ConstructThis>();
+// @ts-expect-error
+aFactoryManager.create(badPojo);
+
+// This one is last so it can reuse the bits from above!
+// ----- Owner ----- //
+declare let owner: Owner;
+
+// @ts-expect-error
+owner.lookup();
+expectTypeOf(owner.lookup('type:name')).toEqualTypeOf<unknown>();
+// @ts-expect-error
+owner.lookup('non-namespace-string');
+expectTypeOf(owner.lookup('namespace@type:name')).toEqualTypeOf<unknown>();
+
+expectTypeOf(owner.register('type:name', aFactory)).toEqualTypeOf<void>();
+expectTypeOf(owner.register('type:name', aFactory, {})).toEqualTypeOf<void>();
+expectTypeOf(owner.register('type:name', aFactory, { instantiate: true })).toEqualTypeOf<void>();
+expectTypeOf(owner.register('type:name', aFactory, { instantiate: false })).toEqualTypeOf<void>();
+expectTypeOf(owner.register('type:name', aFactory, { singleton: true })).toEqualTypeOf<void>();
+expectTypeOf(owner.register('type:name', aFactory, { singleton: false })).toEqualTypeOf<void>();
+expectTypeOf(
+  owner.register('type:name', aFactory, { instantiate: true, singleton: true })
+).toEqualTypeOf<void>();
+expectTypeOf(
+  owner.register('type:name', aFactory, { instantiate: true, singleton: false })
+).toEqualTypeOf<void>();
+expectTypeOf(
+  owner.register('type:name', aFactory, { instantiate: false, singleton: true })
+).toEqualTypeOf<void>();
+expectTypeOf(
+  owner.register('type:name', aFactory, { instantiate: false, singleton: false })
+).toEqualTypeOf<void>();
+// @ts-expect-error
+owner.register('non-namespace-string', aFactory);
+expectTypeOf(owner.register('namespace@type:name', aFactory)).toEqualTypeOf<void>();
+
+expectTypeOf(owner.factoryFor('type:name')).toEqualTypeOf<FactoryManager<unknown> | undefined>();
+expectTypeOf(owner.factoryFor('type:name')?.class).toEqualTypeOf<Factory<unknown> | undefined>();
+expectTypeOf(owner.factoryFor('type:name')?.create()).toEqualTypeOf<unknown>();
+expectTypeOf(owner.factoryFor('type:name')?.create({})).toEqualTypeOf<unknown>();
+expectTypeOf(
+  owner.factoryFor('type:name')?.create({ anythingGoes: true })
+).toEqualTypeOf<unknown>();
+// @ts-expect-error
+owner.factoryFor('non-namespace-string');
+expectTypeOf(owner.factoryFor('namespace@type:name')).toEqualTypeOf<
+  FactoryManager<unknown> | undefined
+>();
+
+// Tests deal with the fact that string literals are a special case! `let`
+// bindings will accordingly not "just work" as a result. The separate
+// assignments both satisfy the linter and show why it matters.
+let aName;
+aName = 'type:name';
+// @ts-expect-error
+owner.lookup(aName);
+
+let aTypedName: FullName;
+aTypedName = 'type:name';
+expectTypeOf(owner.lookup(aTypedName)).toBeUnknown();
+
+// Nor will callbacks work "out of the box". But they can work if they have the
+// correct type.
+declare const justStrings: string[];
+// @ts-expect-error
+justStrings.map((aString) => owner.lookup(aString));
+declare let typedStrings: FullName[];
+typedStrings.map((aString) => owner.lookup(aString));
+
+// Also make sure it keeps working with const bindings
+const aConstName = 'type:name';
+expectTypeOf(owner.lookup(aConstName)).toBeUnknown();
+
+// ----- Minimal further coverage for POJOs ----- //
+// `Factory` and `FactoryManager` don't have to deal in actual classes. :sigh:
+const Creatable = {
+  hasProps: true,
+};
+
+const pojoFactory: Factory<typeof Creatable> = {
+  create(initialValues?) {
+    const instance = Creatable;
+    if (initialValues) {
+      if (initialValues.hasProps) {
+        Object.defineProperty(instance, 'hasProps', {
+          value: initialValues.hasProps,
+          enumerable: true,
+          writable: true,
+        });
+      }
+    }
+    return instance;
+  },
+};
+
+expectTypeOf(pojoFactory.create()).toEqualTypeOf<{ hasProps: boolean }>();
diff --git a/type-tests/preview/@ember/polyfills-tests.ts b/type-tests/preview/@ember/polyfills-tests.ts
new file mode 100644
index 00000000000..b15e22e10b2
--- /dev/null
+++ b/type-tests/preview/@ember/polyfills-tests.ts
@@ -0,0 +1,26 @@
+import { assign } from '@ember/polyfills';
+import { expectTypeOf } from 'expect-type';
+
+(() => {
+  /* assign */
+  assign({}, { a: 'b' });
+  expectTypeOf(assign({}, { a: 'b' }).a).toBeString();
+  expectTypeOf(assign({ a: 6 }, { a: 'b' }).a).toBeString();
+  expectTypeOf(assign({ a: 6 }, {}).a).toBeNumber();
+  // @ts-expect-error
+  assign({ b: 6 }, {}).a;
+  expectTypeOf(assign({}, { b: 6 }, {}).b).toBeNumber();
+  expectTypeOf(assign({ a: 'hello' }, { b: 6 }, {}).a).toBeString();
+  expectTypeOf(assign({ a: 'hello' }, { b: 6 }, { a: true }).a).toBeBoolean();
+  // @ts-expect-error
+  assign({ a: 'hello' }, '', { a: true }).a;
+  expectTypeOf(
+    assign({ d: ['gobias industries'] }, { a: 'hello' }, { b: 6 }, { a: true }).d
+  ).toEqualTypeOf<string[]>();
+  // @ts-expect-error
+  assign({}, { a: 0 }, { b: 1 }, { c: 2 }, { d: 3 }).a;
+
+  // matches Object.assign
+  expectTypeOf(assign({}, null)).toBeNever();
+  expectTypeOf(assign({}, undefined)).toBeNever();
+})();
diff --git a/type-tests/preview/@ember/routing-test/built-ins.ts b/type-tests/preview/@ember/routing-test/built-ins.ts
new file mode 100644
index 00000000000..80efe6516b6
--- /dev/null
+++ b/type-tests/preview/@ember/routing-test/built-ins.ts
@@ -0,0 +1,5 @@
+import { LinkTo } from '@ember/routing';
+import { expectTypeOf } from 'expect-type';
+
+// Basic check taht we export both type and value correctly.
+expectTypeOf(LinkTo).toEqualTypeOf<LinkTo>();
diff --git a/type-tests/preview/@ember/routing-test/route.ts b/type-tests/preview/@ember/routing-test/route.ts
new file mode 100755
index 00000000000..2ce642ec79d
--- /dev/null
+++ b/type-tests/preview/@ember/routing-test/route.ts
@@ -0,0 +1,208 @@
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable prefer-const */
+import Route from '@ember/routing/route';
+import type Array from '@ember/array';
+import EmberObject from '@ember/object';
+import Controller from '@ember/controller';
+import type Transition from '@ember/routing/transition';
+import { expectTypeOf } from 'expect-type';
+
+class Post extends EmberObject {}
+
+interface Posts extends Array<Post> {}
+
+class BeforeModelText extends Route {
+  beforeModel(transition: Transition) {
+    this.transitionTo('someOtherRoute');
+  }
+}
+
+class AfterModel extends Route {
+  afterModel(posts: Posts, transition: Transition) {
+    if (posts.firstObject) {
+      this.transitionTo('post.show', posts.firstObject);
+    }
+  }
+}
+
+class ModelTest extends Route {
+  model() {
+    return this.modelFor('post');
+  }
+}
+
+class QPsTest extends Route {
+  queryParams = {
+    memberQp: { refreshModel: true },
+  };
+}
+
+class ResetControllerTest extends Route {
+  resetController(controller: Controller, isExiting: boolean, transition: Transition) {
+    if (isExiting) {
+      //   controller.set('page', 1);
+      transition.abort();
+    }
+  }
+}
+
+class ActivateRoute extends Route {
+  activate(transition: Transition) {
+    this.transitionTo('someOtherRoute');
+  }
+}
+
+class DeactivateRoute extends Route {
+  deactivate(transition: Transition) {
+    this.transitionTo('someOtherRoute');
+  }
+}
+
+class RedirectRoute extends Route {
+  redirect(model: {}, a: Transition) {
+    if (!model) {
+      this.transitionTo('there');
+    }
+  }
+}
+
+class InvalidRedirect extends Route {
+  // @ts-expect-error
+  redirect(model: {}, a: Transition, anOddArg: unknown) {
+    if (!model) {
+      this.transitionTo('there');
+    }
+  }
+}
+
+class TransitionToExamples extends Route {
+  // NOTE: this one won't check that `queryParams` has the right shape,
+  // because the overload for the version where `models` are passed
+  // necessarily includes all objects.
+  transitionToModelAndQP() {
+    expectTypeOf(
+      this.transitionTo('somewhere', { queryParams: { neat: true } })
+    ).toEqualTypeOf<Transition>();
+  }
+
+  transitionToJustQP() {
+    expectTypeOf(this.transitionTo({ queryParams: { neat: 'true' } })).toEqualTypeOf<Transition>();
+  }
+
+  transitionToNonsense() {
+    // @ts-expect-error
+    this.transitionTo({ cannotDoModelHere: true });
+  }
+
+  transitionToBadQP() {
+    // @ts-expect-error
+    this.transitionTo({ queryParams: 12 });
+  }
+
+  transitionToId() {
+    expectTypeOf(this.transitionTo('blog-post', 1)).toEqualTypeOf<Transition<unknown>>();
+  }
+
+  transitionToIdWithQP() {
+    expectTypeOf(
+      this.transitionTo('blog-post', 1, { queryParams: { includeComments: true } })
+    ).toEqualTypeOf<Transition<unknown>>();
+  }
+
+  transitionToIds() {
+    expectTypeOf(this.transitionTo('blog-comment', 1, '13')).toEqualTypeOf<Transition<unknown>>();
+  }
+
+  transitionToIdsWithQP() {
+    expectTypeOf(
+      this.transitionTo('blog-comment', 1, '13', { queryParams: { includePost: true } })
+    ).toEqualTypeOf<Transition<unknown>>();
+  }
+
+  buildRouteInfoMetadata() {
+    return { foo: 'bar' };
+  }
+}
+
+class ApplicationController extends Controller {}
+declare module '@ember/controller' {
+  interface Registry {
+    application: ApplicationController;
+  }
+}
+
+class SetupControllerTest extends Route {
+  setupController(controller: Controller, model: {}, transition: Transition) {
+    this._super(controller, model);
+    this.controllerFor('application').set('model', model);
+    transition.abort();
+  }
+}
+
+const route = Route.create();
+expectTypeOf(route.controllerFor('whatever')).toEqualTypeOf<Controller>();
+expectTypeOf(route.paramsFor('whatever')).toEqualTypeOf<object>();
+
+class RouteUsingClass extends Route.extend({
+  randomProperty: 'the .extend + extends bit type-checks properly',
+}) {
+  beforeModel() {
+    return Promise.resolve('beforeModel can return promises');
+  }
+  afterModel(resolvedModel: unknown, transition: Transition) {
+    return Promise.resolve('afterModel can also return promises');
+  }
+  intermediateTransitionWithoutModel() {
+    this.intermediateTransitionTo('some-route');
+  }
+  intermediateTransitionWithModel() {
+    this.intermediateTransitionTo('some.other.route', {});
+  }
+  intermediateTransitionWithMultiModel() {
+    this.intermediateTransitionTo('some.other.route', 1, 2, {});
+  }
+}
+
+class WithNonReturningBeforeAndModelHooks extends Route {
+  beforeModel(transition: Transition): void | Promise<unknown> {
+    return;
+  }
+
+  afterModel(resolvedModel: unknown, transition: Transition): void {
+    return;
+  }
+}
+
+class WithBadReturningBeforeAndModelHooks extends Route {
+  beforeModel(transition: Transition): void | Promise<unknown> {
+    // @ts-expect-error
+    return "returning anything else is nonsensical (if 'legal')";
+  }
+
+  afterModel(resolvedModel: unknown, transition: Transition): void {
+    // @ts-expect-error
+    return "returning anything else is nonsensical (if 'legal')";
+  }
+}
+
+interface RouteParams {
+  cool: string;
+}
+
+class WithParamsInModel extends Route<boolean, RouteParams> {
+  model(params: RouteParams, transition: Transition) {
+    return true;
+  }
+}
+
+// @ts-expect-error
+class WithNonsenseParams extends Route<boolean, number> {}
+
+class WithImplicitParams extends Route {
+  model(params: RouteParams) {
+    return { whatUp: 'dog' };
+  }
+}
+
+type ImplicitParams = WithImplicitParams extends Route<any, infer T> ? T : never;
+expectTypeOf<ImplicitParams>().toEqualTypeOf<RouteParams>();
diff --git a/type-tests/preview/@ember/routing-test/router-service.ts b/type-tests/preview/@ember/routing-test/router-service.ts
new file mode 100644
index 00000000000..7bd771ca82f
--- /dev/null
+++ b/type-tests/preview/@ember/routing-test/router-service.ts
@@ -0,0 +1,102 @@
+import RouteInfo, { RouteInfoWithAttributes } from '@ember/routing/route-info';
+import RouterService from '@ember/routing/router-service';
+import Transition from '@ember/routing/transition';
+import { expectTypeOf } from 'expect-type';
+
+declare let router: RouterService;
+
+router.transitionTo('someRoute');
+router.transitionTo('someRoute', { withModel: true });
+router.transitionTo('someRoute', { withModel: true }, { queryParams: {} });
+router.transitionTo(
+  'someRoute',
+  { withModel: true },
+  { withMultipleModels: 'still checks correctly' },
+  { queryParams: {} }
+);
+
+const routeWillChangeHandler = () => {};
+expectTypeOf(router.on('routeWillChange', routeWillChangeHandler)).toEqualTypeOf<RouterService>();
+expectTypeOf(router.has('routeWillChange')).toEqualTypeOf<boolean>();
+expectTypeOf(router.off('routeWillChange', routeWillChangeHandler)).toEqualTypeOf<RouterService>();
+expectTypeOf(router.one('routeWillChange', routeWillChangeHandler)).toEqualTypeOf<RouterService>();
+expectTypeOf(router.trigger('routeWillChange', 'boo')).toEqualTypeOf<void>();
+
+const transition = router.transitionTo('someRoute');
+
+expectTypeOf(transition.abort()).toEqualTypeOf<Transition<unknown>>();
+
+expectTypeOf(transition.catch()).toEqualTypeOf<Promise<unknown>>();
+transition.catch((err) => console.log(err), 'label');
+
+expectTypeOf(transition.finally()).toEqualTypeOf<Promise<unknown>>();
+transition.finally(() => console.log('finally!'));
+transition.finally(() => console.log('finally!'), 'label');
+
+expectTypeOf(transition.followRedirects()).toEqualTypeOf<Promise<unknown>>();
+
+expectTypeOf(transition.method()).toEqualTypeOf<Transition<unknown>>();
+transition.method('replace');
+
+expectTypeOf(transition.retry()).toEqualTypeOf<Transition<unknown>>();
+
+expectTypeOf(transition.then()).toEqualTypeOf<Promise<unknown>>();
+transition.then(
+  (result) => console.log(result),
+  (err) => console.log(err),
+  'label'
+);
+
+expectTypeOf(transition.trigger(false, 'error')).toEqualTypeOf<void>();
+
+expectTypeOf(transition.send(false, 'error')).toEqualTypeOf<void>();
+
+transition.data = { some: 'data' };
+
+expectTypeOf(transition.from).toEqualTypeOf<RouteInfoWithAttributes | null>();
+// @ts-expect-error
+transition.from = 'from';
+
+expectTypeOf(transition.promise).toEqualTypeOf<Promise<unknown>>();
+// @ts-expect-error
+transition.promise = 'promise';
+
+expectTypeOf(transition.to).toEqualTypeOf<RouteInfo | RouteInfoWithAttributes>();
+// @ts-expect-error
+transition.to = 'to';
+
+expectTypeOf(transition.to.metadata).toEqualTypeOf<unknown>();
+// @ts-expect-error
+transition.to.metadata = 'foo';
+
+// NOTE: we cannot check the validity of invocations with just route name and
+// query params beyond that the second argument is an object of some sort,
+// because TS will always resolve it to the `models` variant if the
+// `queryParams` variant fails.
+expectTypeOf(router.transitionTo('someRoute', { queryParams: { shouldWork: true } })).toEqualTypeOf<
+  Transition<unknown>
+>();
+expectTypeOf(router.transitionTo({ queryParams: { areSupported: true } })).toEqualTypeOf<
+  Transition<unknown>
+>();
+// @ts-expect-error
+router.transitionTo({ queryParams: 'potato' });
+expectTypeOf(router.transitionTo('someRoute', 1)).toEqualTypeOf<Transition<unknown>>();
+expectTypeOf(
+  router.transitionTo('someRoute', 1, { queryParams: { areSupported: true } })
+).toEqualTypeOf<Transition<unknown>>();
+expectTypeOf(router.transitionTo('someRoute', 1, '13')).toEqualTypeOf<Transition<unknown>>();
+expectTypeOf(
+  router.transitionTo('someRoute', 1, '13', { queryParams: { areSupported: true } })
+).toEqualTypeOf<Transition<unknown>>();
+
+expectTypeOf(router.recognize('foo/bar')).toEqualTypeOf<RouteInfo>();
+
+expectTypeOf(router.recognizeAndLoad('foo/bar')).toEqualTypeOf<RouteInfoWithAttributes>();
+
+expectTypeOf(router.rootURL).toEqualTypeOf<string>();
+// @ts-expect-error
+router.rootURL = 'foo';
+
+expectTypeOf(router.refresh()).toEqualTypeOf<Transition<unknown>>();
+expectTypeOf(router.refresh('my-route')).toEqualTypeOf<Transition<unknown>>();
diff --git a/type-tests/preview/@ember/routing-test/router.ts b/type-tests/preview/@ember/routing-test/router.ts
new file mode 100755
index 00000000000..fab3ba98b8b
--- /dev/null
+++ b/type-tests/preview/@ember/routing-test/router.ts
@@ -0,0 +1,87 @@
+import Router from '@ember/routing/router';
+import Service, { inject as service } from '@ember/service';
+import EmberObject, { get } from '@ember/object';
+import RouterService from '@ember/routing/router-service';
+import RouteInfo from '@ember/routing/route-info';
+
+import { expectTypeOf } from 'expect-type';
+
+const AppRouter = Router.extend({});
+
+AppRouter.map(function () {
+  this.route('index', { path: '/' });
+  this.route('about');
+  this.route('favorites', { path: '/favs' });
+  this.route('posts', function () {
+    this.route('index', { path: '/' });
+    this.route('new');
+    this.route('post', { path: '/post/:post_id', resetNamespace: true });
+    this.route('comments', { resetNamespace: true }, function () {
+      this.route('new');
+    });
+  });
+  this.route('photo', { path: '/photo/:id' }, function () {
+    this.route('comment', { path: '/comment/:id' });
+  });
+  this.route('not-found', { path: '/*path' });
+  this.mount('my-engine');
+  this.mount('my-engine', { as: 'some-other-engine', path: '/some-other-engine' });
+});
+
+class RouterServiceConsumer extends Service {
+  @service('router') declare router: RouterService;
+  currentRouteName() {
+    expectTypeOf(get(this, 'router').currentRouteName).toEqualTypeOf<string>();
+  }
+  currentURL() {
+    expectTypeOf(get(this, 'router').currentURL).toEqualTypeOf<string>();
+  }
+  rootURL() {
+    expectTypeOf(get(this, 'router').rootURL).toEqualTypeOf<string>();
+  }
+  transitionWithoutModel() {
+    get(this, 'router').transitionTo('some-route');
+  }
+  transitionWithModel() {
+    const model = EmberObject.create();
+    get(this, 'router').transitionTo('some.other.route', model);
+  }
+  transitionWithMultiModel() {
+    const model = EmberObject.create();
+    get(this, 'router').transitionTo('some.other.route', model, model);
+  }
+  transitionWithModelAndOptions() {
+    const model = EmberObject.create();
+    get(this, 'router').transitionTo('index', model, { queryParams: { search: 'ember' } });
+  }
+  onAndRouteInfo() {
+    const router = get(this, 'router');
+    router
+      .on('routeWillChange', (transition) => {
+        const to = transition.to;
+        expectTypeOf(to.child).toEqualTypeOf<RouteInfo | null>();
+        expectTypeOf(to.localName).toEqualTypeOf<string>();
+        expectTypeOf(to.name).toEqualTypeOf<string>();
+        expectTypeOf(to.paramNames).toEqualTypeOf<string[]>();
+        expectTypeOf(to.params['foo']).toEqualTypeOf<string | undefined>();
+        expectTypeOf(to.parent).toEqualTypeOf<RouteInfo | null>();
+        expectTypeOf(to.queryParams['foo']).toEqualTypeOf<string | undefined>();
+        expectTypeOf(to.find((info) => info.name === 'foo')).toEqualTypeOf<RouteInfo | undefined>();
+      })
+      .on('routeDidChange', (transition) => {
+        const from = transition.from;
+        if (from) {
+          expectTypeOf(from.child).toEqualTypeOf<RouteInfo | null>();
+          expectTypeOf(from.localName).toEqualTypeOf<string>();
+          expectTypeOf(from.name).toEqualTypeOf<string>();
+          expectTypeOf(from.paramNames).toEqualTypeOf<string[]>();
+          expectTypeOf(from.params['foo']).toEqualTypeOf<string | undefined>();
+          expectTypeOf(from.parent).toEqualTypeOf<RouteInfo | null>();
+          expectTypeOf(from.queryParams['foo']).toEqualTypeOf<string | undefined>();
+          expectTypeOf(from.find((info) => info.name === 'foo')).toEqualTypeOf<
+            RouteInfo | undefined
+          >();
+        }
+      });
+  }
+}
diff --git a/type-tests/preview/@ember/runloop-tests.ts b/type-tests/preview/@ember/runloop-tests.ts
new file mode 100644
index 00000000000..799d86ef5c6
--- /dev/null
+++ b/type-tests/preview/@ember/runloop-tests.ts
@@ -0,0 +1,307 @@
+import {
+  run,
+  begin,
+  bind,
+  cancel,
+  debounce,
+  end,
+  join,
+  later,
+  next,
+  once,
+  schedule,
+  scheduleOnce,
+  throttle,
+  // private, supported via `declare module` below
+  _backburner,
+} from '@ember/runloop';
+import EmberObject, { action } from '@ember/object';
+import type {
+  Backburner,
+  DebugInfo,
+  QueueItem,
+  DeferredActionQueues,
+} from '@ember/runloop/-private/backburner';
+
+// It will be the responsibility of each consuming package that needs access to the backburner property
+// to merge the private types in the public API.
+declare module '@ember/runloop' {
+  const _backburner: Backburner;
+}
+
+function testRun() {
+  run(() => {
+    // code to be executed within a RunLoop
+    return 123;
+  });
+
+  // run(target, method)
+  run({}, () => {
+    // code to be executed within a RunLoop
+    return 123;
+  });
+
+  // run(target, method, ...args)
+  run(
+    {},
+    (beforeExecute: () => void, extraLog: string, misc: unknown) => {
+      // code to be executed within a RunLoop
+      beforeExecute();
+      console.log(extraLog);
+      console.info(misc);
+      return 123;
+    },
+    () => {
+      console.log('foo');
+    },
+    'bar',
+    {}
+  );
+
+  function destroyApp(application: EmberObject) {
+    run(application, 'destroy');
+    run(application, function () {
+      this.destroy();
+    });
+  }
+}
+
+class TestBind extends EmberObject {
+  init() {
+    // NOTE: these don't actually preserve the underlying type. Critically,
+    // though, our types have *never* supported that for `bind`.
+    const bound = bind(this, this.setupEditor);
+    bound('hello');
+    const boundAgain = bind(this, 'setupEditor');
+    boundAgain('hello');
+  }
+
+  editor: string | null = null;
+
+  setupEditor(editor: string) {
+    this.set('editor', editor);
+  }
+}
+
+function testCancel() {
+  const myContext = {
+    method(arg: string, another: number): number {
+      return arg.length + another;
+    },
+  };
+
+  cancel(undefined);
+
+  const runNext = next(myContext, () => {
+    // will not be executed
+  });
+
+  cancel(runNext);
+
+  const anotherRunNext = next(myContext, 'method', 'hello', 123);
+  // @ts-expect-error
+  const aBadRunNext = next(myContext, 'method', false, 'goodbye');
+
+  const aSimpleNext = next((name: string) => name.length, 'hello');
+
+  const runLater = later(
+    myContext,
+    () => {
+      // will not be executed
+    },
+    500
+  );
+
+  cancel(runLater);
+
+  const runScheduleOnce = scheduleOnce('afterRender', myContext, () => {
+    // will not be executed
+  });
+
+  cancel(runScheduleOnce);
+
+  const anotherScheduleOnce = scheduleOnce('render', myContext, 'method', 'hello', 123);
+
+  const aBadScheduleOnce =
+    // @ts-expect-error
+    scheduleOnce('render', myContext, 'method', true, 'boo');
+
+  const runOnce = once(myContext, () => {
+    // will not be executed
+  });
+
+  cancel(runOnce);
+
+  const throttled = throttle(
+    myContext,
+    () => {
+      // will not be executed
+    },
+    1,
+    false
+  );
+
+  cancel(throttled);
+
+  const aGoodThrottled = throttle(myContext, 'method', 'hello', 123, 1_000);
+  const anotherGoodThrottled = throttle(myContext, 'method', 'hello', 123, 1_000, true);
+  // @ts-expect-error
+  const aBadThrottled = throttle(myContext, 'method', 1_000);
+  // @ts-expect-error
+  const anotherBadThrottled = throttle(myContext, 'method', false, {}, 1_000);
+
+  const debounced = debounce(
+    myContext,
+    () => {
+      // will not be executed
+    },
+    1
+  );
+
+  cancel(debounced);
+
+  const debounceImmediate = debounce(
+    myContext,
+    () => {
+      // will be executed since we passed in true (immediate)
+    },
+    100,
+    true
+  );
+
+  // the 100ms delay until this method can be called again will be canceled
+  cancel(debounceImmediate);
+}
+
+function testDebounce() {
+  function runIt() {}
+
+  const myContext = { name: 'debounce' };
+
+  debounce(runIt, 150);
+  debounce(myContext, runIt, 150);
+  debounce(myContext, runIt, 150, true);
+
+  class DebounceExample extends EmberObject {
+    searchValue = 'test';
+    fetchResults(value: string) {}
+
+    @action
+    handleTyping() {
+      // the fetchResults function is passed into the component from its parent
+      debounce(this, this.fetchResults, this.searchValue, 250);
+    }
+  }
+
+  EmberObject.extend({
+    searchValue: 'test',
+    fetchResults(value: string) {},
+  });
+}
+
+function testBegin() {
+  begin();
+  // code to be executed within a RunLoop
+  end();
+}
+
+function testJoin() {
+  join(() => {
+    // creates a new run-loop
+  });
+
+  run(() => {
+    // creates a new run-loop
+    join(() => {
+      // joins with the existing run-loop, and queues for invocation on
+      // the existing run-loops action queue.
+    });
+  });
+
+  later(() => {
+    console.log({ msg: 'Hold Your Horses' });
+  }, 3000);
+}
+
+function testLater() {
+  const myContext = {};
+  later(
+    myContext,
+    () => {
+      // code here will execute within a RunLoop in about 500ms with this == myContext
+    },
+    500
+  );
+}
+
+function testNext() {
+  const myContext = {};
+  next(myContext, () => {
+    // code to be executed in the next run loop,
+    // which will be scheduled after the current one
+  });
+  next(() => {
+    // code to be executed in the next run loop,
+    // which will be scheduled after the current one
+  });
+}
+
+class TestOnce extends EmberObject {
+  init() {
+    once(this as TestOnce, 'processFullName');
+    once(this, this.processFullName);
+  }
+
+  processFullName() {}
+}
+
+function testSchedule() {
+  EmberObject.extend({
+    init() {
+      schedule('sync', this, () => {
+        // this will be executed in the first RunLoop queue, when bindings are synced
+        console.log('scheduled on sync queue');
+      });
+
+      schedule('actions', this, () => {
+        // this will be executed in the 'actions' queue, after bindings have synced.
+        console.log('scheduled on actions queue');
+      });
+    },
+  });
+
+  schedule('actions', () => {
+    // Do more things
+  });
+}
+
+function testScheduleOnce() {
+  function sayHi() {
+    console.log('hi');
+  }
+
+  const myContext = {};
+  run(() => {
+    scheduleOnce('afterRender', myContext, sayHi);
+    scheduleOnce('afterRender', myContext, sayHi);
+    // sayHi will only be executed once, in the afterRender queue of the RunLoop
+  });
+  scheduleOnce('actions', myContext, () => {
+    console.log('Closure');
+  });
+}
+
+function testThrottle() {
+  function runIt() {}
+
+  const myContext = { name: 'throttle' };
+
+  throttle(runIt, 150);
+  throttle(myContext, runIt, 150);
+}
+
+function testBackburner() {
+  const debugInfo: DebugInfo = _backburner.getDebugInfo();
+  const queueItems: QueueItem[] = debugInfo.timers;
+  const deferredActionQueues: DeferredActionQueues[] = debugInfo.instanceStack;
+}
diff --git a/type-tests/preview/@ember/service-test.ts b/type-tests/preview/@ember/service-test.ts
new file mode 100644
index 00000000000..7ba6f553a86
--- /dev/null
+++ b/type-tests/preview/@ember/service-test.ts
@@ -0,0 +1,34 @@
+import Service, { inject, service } from '@ember/service';
+import EmberObject from '@ember/object';
+
+class FirstSvc extends Service {
+  foo = 'bar';
+  first() {
+    return '';
+  }
+}
+const SecondSvc = Service.extend({
+  foo: 'bar',
+  second() {
+    return '';
+  },
+});
+
+declare module '@ember/service' {
+  interface Registry {
+    first: FirstSvc;
+    second: InstanceType<typeof SecondSvc>;
+  }
+}
+
+class Foo extends EmberObject {
+  @inject declare foo: FirstSvc;
+  @inject('first') declare baz: FirstSvc;
+  @inject declare bar: FirstSvc;
+}
+
+class FooService extends EmberObject {
+  @service declare foo: FirstSvc;
+  @service('first') declare baz: FirstSvc;
+  @service declare bar: FirstSvc;
+}
diff --git a/type-tests/preview/@ember/string-tests.ts b/type-tests/preview/@ember/string-tests.ts
new file mode 100644
index 00000000000..bd5f513b4c2
--- /dev/null
+++ b/type-tests/preview/@ember/string-tests.ts
@@ -0,0 +1,52 @@
+import {
+  dasherize,
+  camelize,
+  capitalize,
+  classify,
+  decamelize,
+  underscore,
+  w,
+} from '@ember/string';
+import { expectTypeOf } from 'expect-type';
+
+// @ts-expect-error
+dasherize();
+expectTypeOf(dasherize('blue man group')).toEqualTypeOf<string>();
+// @ts-expect-error
+dasherize('', '');
+
+// @ts-expect-error
+camelize();
+expectTypeOf(camelize('blue man group')).toEqualTypeOf<string>();
+// @ts-expect-error
+camelize('', '');
+
+// @ts-expect-error
+decamelize();
+expectTypeOf(decamelize('blue man group')).toEqualTypeOf<string>();
+// @ts-expect-error
+decamelize('', '');
+
+// @ts-expect-error
+underscore();
+expectTypeOf(underscore('blue man group')).toEqualTypeOf<string>();
+// @ts-expect-error
+underscore('', '');
+
+// @ts-expect-error
+w();
+expectTypeOf(w('blue man group')).toEqualTypeOf<Array<string>>();
+// @ts-expect-error
+w('', '');
+
+// @ts-expect-error
+classify();
+expectTypeOf(classify('blue man group')).toEqualTypeOf<string>();
+// @ts-expect-error
+classify('', '');
+
+// @ts-expect-error
+capitalize();
+expectTypeOf(capitalize('blue man group')).toEqualTypeOf<string>();
+// @ts-expect-error
+capitalize('', '');
diff --git a/type-tests/preview/@ember/template-tests.ts b/type-tests/preview/@ember/template-tests.ts
new file mode 100644
index 00000000000..7c38e72387e
--- /dev/null
+++ b/type-tests/preview/@ember/template-tests.ts
@@ -0,0 +1,18 @@
+import { SafeString } from '@ember/template/-private/handlebars';
+import { htmlSafe, isHTMLSafe } from '@ember/template';
+import { expectTypeOf } from 'expect-type';
+
+const handlebarsSafeString: SafeString = htmlSafe('lorem ipsum...');
+expectTypeOf(htmlSafe('lorem ipsum...')).toEqualTypeOf<SafeString>();
+// @ts-expect-error
+const regularString: string = htmlSafe('lorem ipsum...');
+
+expectTypeOf(isHTMLSafe).guards.toEqualTypeOf<SafeString>();
+
+function isSafeTest(a: string | SafeString) {
+  if (isHTMLSafe(a)) {
+    a = a.toString();
+  }
+
+  a.toLowerCase();
+}
diff --git a/type-tests/preview/@ember/test-tests.ts b/type-tests/preview/@ember/test-tests.ts
new file mode 100644
index 00000000000..c21818e92aa
--- /dev/null
+++ b/type-tests/preview/@ember/test-tests.ts
@@ -0,0 +1,43 @@
+import { registerWaiter, registerHelper, registerAsyncHelper } from '@ember/test';
+import TestAdapter from '@ember/test/adapter';
+import { expectTypeOf } from 'expect-type';
+
+const pending = 0;
+registerWaiter(() => pending !== 0);
+
+declare const MyDb: {
+  hasPendingTransactions(): boolean;
+};
+
+registerWaiter(MyDb, MyDb.hasPendingTransactions);
+// @ts-expect-error
+registerWaiter();
+
+registerHelper('boot', (app) => {
+  expectTypeOf(app.advanceReadiness()).toBeVoid();
+  expectTypeOf(app.deferReadiness()).toBeVoid();
+  expectTypeOf(app.register('foo', class {})).toBeVoid();
+  // @ts-expect-error
+  app.register('foo');
+  // @ts-expect-error
+  app.register();
+});
+
+registerAsyncHelper('boot', (app) => {
+  app.advanceReadiness();
+  app.deferReadiness();
+  app.register('foo', class {});
+});
+
+registerAsyncHelper('waitForPromise', (app, promise) => {
+  app.advanceReadiness();
+  app.deferReadiness();
+  app.register('foo', class {});
+  return new Promise(() => {
+    const adapter = new TestAdapter();
+    adapter.asyncStart();
+    return promise.then(() => {
+      adapter.asyncEnd();
+    });
+  });
+});
diff --git a/type-tests/preview/@ember/utils-tests.ts b/type-tests/preview/@ember/utils-tests.ts
new file mode 100644
index 00000000000..506dfb94b1b
--- /dev/null
+++ b/type-tests/preview/@ember/utils-tests.ts
@@ -0,0 +1,143 @@
+/* eslint-disable no-new-wrappers */ // we have to test the new-wrappers!
+import { expectTypeOf } from 'expect-type';
+import EmberObject from '@ember/object';
+
+import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@ember/utils';
+
+(function () {
+  /** isNone */
+  const maybeUndefined: string | undefined = 'not actually undefined';
+  if (isNone(maybeUndefined)) {
+    return;
+  }
+  expectTypeOf(maybeUndefined).toBeString();
+  expectTypeOf(isNone()).toEqualTypeOf<boolean>();
+  expectTypeOf(isNone(null)).toEqualTypeOf<boolean>();
+  expectTypeOf(isNone(undefined)).toEqualTypeOf<boolean>();
+  expectTypeOf(isNone('')).toEqualTypeOf<boolean>();
+  expectTypeOf(isNone([])).toEqualTypeOf<boolean>();
+  expectTypeOf(isNone(function () {})).toEqualTypeOf<boolean>();
+})();
+
+(function () {
+  /** isPresent */
+  expectTypeOf(isPresent()).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent(null)).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent(undefined)).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent('')).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent('  ')).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent('\n\t')).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent([])).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent({ length: 0 })).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent(false)).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent(true)).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent('string')).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent(0)).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent(function () {})).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent({})).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent(false)).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent('\n\t Hello')).toEqualTypeOf<boolean>();
+  expectTypeOf(isPresent([1, 2, 3])).toEqualTypeOf<boolean>();
+})();
+
+(function () {
+  /** typeOf */
+  expectTypeOf(typeOf(null)).toEqualTypeOf<'null'>();
+  expectTypeOf(typeOf(undefined)).toEqualTypeOf<'undefined'>();
+  expectTypeOf(typeOf('michael')).toEqualTypeOf<'string'>();
+  expectTypeOf(typeOf(new String('michael'))).toEqualTypeOf<'string'>();
+  expectTypeOf(typeOf(101)).toEqualTypeOf<'number'>();
+  expectTypeOf(typeOf(new Number(101))).toEqualTypeOf<'number'>();
+  expectTypeOf(typeOf(true)).toEqualTypeOf<'boolean'>();
+  expectTypeOf(typeOf(new Boolean(true))).toEqualTypeOf<'boolean'>();
+  expectTypeOf(typeOf(() => 4)).toEqualTypeOf<'function'>();
+  expectTypeOf(typeOf([1, 2, 90])).toEqualTypeOf<'array'>();
+  expectTypeOf(typeOf(/abc/)).toEqualTypeOf<'regexp'>();
+  expectTypeOf(typeOf(new Date())).toEqualTypeOf<'date'>();
+  expectTypeOf(typeOf(new FileList())).toEqualTypeOf<'filelist'>();
+  expectTypeOf(typeOf(EmberObject.extend())).toEqualTypeOf<'class'>();
+  expectTypeOf(typeOf(EmberObject.create())).toEqualTypeOf<'instance'>();
+  expectTypeOf(typeOf(new Error('teamocil'))).toEqualTypeOf<'error'>();
+  expectTypeOf(typeOf({ justAPojo: true })).toEqualTypeOf<'object'>();
+
+  typeOf();
+  typeOf(null);
+  typeOf(undefined);
+  typeOf('michael');
+  typeOf(new String('michael'));
+  typeOf(101);
+  typeOf(new Number(101));
+  typeOf(true);
+  typeOf(new Boolean(true));
+  typeOf(() => 4);
+  typeOf([1, 2, 90]);
+  typeOf(/abc/);
+  typeOf(new Date());
+  typeOf(FileList);
+  typeOf(new Error('teamocil'));
+})();
+
+(function () {
+  /** isEqual */
+  expectTypeOf(isEqual('foo', 'bar')).toEqualTypeOf<boolean>();
+  expectTypeOf(isEqual(14, 37)).toEqualTypeOf<boolean>();
+  expectTypeOf(isEqual(14, '1')).toEqualTypeOf<boolean>();
+  expectTypeOf(
+    isEqual(
+      () => 4,
+      () => 37
+    )
+  ).toEqualTypeOf<boolean>();
+  // @ts-expect-error
+  isEqual(14);
+  // @ts-expect-error
+  isEqual();
+})();
+
+(function () {
+  /** compare */
+  expectTypeOf(compare('foo', 'bar')).toBeNumber();
+  expectTypeOf(compare(14, 37)).toBeNumber();
+  expectTypeOf(compare(class {}, class {})).toBeNumber();
+  expectTypeOf(compare([], class {})).toBeNumber();
+  expectTypeOf(compare([], undefined)).toBeNumber();
+  expectTypeOf(compare({}, () => 4)).toBeNumber();
+  // @ts-expect-error
+  compare(14);
+  // @ts-expect-error
+  compare();
+})();
+
+(function () {
+  /** isBlank */
+
+  expectTypeOf(isBlank()).toEqualTypeOf<boolean>();
+  expectTypeOf(isBlank(null)).toEqualTypeOf<boolean>();
+  expectTypeOf(isBlank(undefined)).toEqualTypeOf<boolean>();
+  expectTypeOf(isBlank('')).toEqualTypeOf<boolean>();
+  expectTypeOf(isBlank([])).toEqualTypeOf<boolean>();
+  expectTypeOf(isBlank('\n\t')).toEqualTypeOf<boolean>();
+  expectTypeOf(isBlank('  ')).toEqualTypeOf<boolean>();
+  expectTypeOf(isBlank({})).toEqualTypeOf<boolean>();
+  expectTypeOf(isBlank('\n\t Hello')).toEqualTypeOf<boolean>();
+  expectTypeOf(isBlank('Hello world')).toEqualTypeOf<boolean>();
+  expectTypeOf(isBlank([1, 2, 3])).toEqualTypeOf<boolean>();
+})();
+
+(function () {
+  /** isEmpty */
+
+  expectTypeOf(isEmpty()).toEqualTypeOf<boolean>();
+  expectTypeOf(isEmpty(null)).toEqualTypeOf<boolean>();
+  expectTypeOf(isEmpty(undefined)).toEqualTypeOf<boolean>();
+  expectTypeOf(isEmpty('')).toEqualTypeOf<boolean>();
+  expectTypeOf(isEmpty([])).toEqualTypeOf<boolean>();
+  expectTypeOf(isEmpty({ size: 0 })).toEqualTypeOf<boolean>();
+  expectTypeOf(isEmpty({})).toEqualTypeOf<boolean>();
+  expectTypeOf(isEmpty('Adam Hawkins')).toEqualTypeOf<boolean>();
+  expectTypeOf(isEmpty([0, 1, 2])).toEqualTypeOf<boolean>();
+  expectTypeOf(isEmpty('\n\t')).toEqualTypeOf<boolean>();
+  expectTypeOf(isEmpty('  ')).toEqualTypeOf<boolean>();
+  expectTypeOf(isEmpty({ size: 1 })).toEqualTypeOf<boolean>();
+  expectTypeOf(isEmpty({ size: () => 0 })).toEqualTypeOf<boolean>();
+})();
diff --git a/type-tests/preview/ember/application-instance.ts b/type-tests/preview/ember/application-instance.ts
new file mode 100644
index 00000000000..ecff4b7b087
--- /dev/null
+++ b/type-tests/preview/ember/application-instance.ts
@@ -0,0 +1,29 @@
+import ApplicationInstance from '@ember/application/instance';
+
+const appInstance = ApplicationInstance.create();
+appInstance.register('some:injection', class Foo {});
+
+appInstance.register('some:injection', class Foo {}, {
+  singleton: true,
+});
+
+appInstance.register('some:injection', class Foo {}, {
+  instantiate: false,
+});
+
+// just check basic registration, doesn't yet have to be a template
+appInstance.register('templates:foo/bar', {});
+
+appInstance.register('some:injection', class Foo {}, {
+  singleton: false,
+  instantiate: true,
+});
+
+appInstance.factoryFor('router:main');
+appInstance.lookup('route:basic');
+
+appInstance.boot();
+
+(async () => {
+  await appInstance.boot();
+})();
diff --git a/type-tests/preview/ember/application.ts b/type-tests/preview/ember/application.ts
new file mode 100755
index 00000000000..a59fc150578
--- /dev/null
+++ b/type-tests/preview/ember/application.ts
@@ -0,0 +1,43 @@
+import EmberObject from '@ember/object';
+import Ember from 'ember';
+
+const BaseApp = Ember.Application.extend({
+  modulePrefix: 'my-app',
+});
+
+class Obj extends EmberObject.extend({ foo: 'bar' }) {}
+
+BaseApp.initializer({
+  name: 'my-initializer',
+  initialize(app) {
+    app.register('foo:bar', Obj);
+  },
+});
+
+BaseApp.instanceInitializer({
+  name: 'my-instance-initializer',
+  initialize(app) {
+    (app.lookup('foo:bar') as Obj).get('foo');
+  },
+});
+
+const App1 = BaseApp.create({
+  rootElement: '#app-one',
+  customEvents: {
+    paste: 'paste',
+  },
+});
+
+const App2 = BaseApp.create({
+  rootElement: '#app-two',
+  customEvents: {
+    mouseenter: null,
+    mouseleave: null,
+  },
+});
+
+const App3 = BaseApp.create();
+
+const App3Instance1 = App3.buildInstance();
+
+const App3Instance2 = App3.buildInstance({ foo: 'bar' });
diff --git a/type-tests/preview/ember/array-proxy.ts b/type-tests/preview/ember/array-proxy.ts
new file mode 100644
index 00000000000..d88fe73fff8
--- /dev/null
+++ b/type-tests/preview/ember/array-proxy.ts
@@ -0,0 +1,27 @@
+import type Array from '@ember/array';
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+const pets = ['dog', 'cat', 'fish'];
+const proxy = Ember.ArrayProxy.create({ content: Ember.A(pets) });
+
+proxy.get('firstObject'); // 'dog'
+proxy.set('content', Ember.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 {
+    return (this.get('content') as Array<string>).objectAt(idx)?.toUpperCase();
+  },
+});
+
+overridden.get('firstObject'); // 'DOG'
+
+class MyNewProxy<T> extends Ember.ArrayProxy<T> {
+  isNew = true;
+}
+
+const x = MyNewProxy.create({ content: Ember.A([1, 2, 3]) }) as MyNewProxy<number>;
+expectTypeOf(x.get('firstObject')).toEqualTypeOf<number | undefined>();
+expectTypeOf(x.isNew).toBeBoolean();
diff --git a/type-tests/preview/ember/array.ts b/type-tests/preview/ember/array.ts
new file mode 100755
index 00000000000..b5db931246a
--- /dev/null
+++ b/type-tests/preview/ember/array.ts
@@ -0,0 +1,71 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+class Person extends Ember.Object {
+  name = '';
+  isHappy = false;
+}
+
+const people = Ember.A([
+  Person.create({ name: 'Yehuda', isHappy: true }),
+  Person.create({ name: 'Majd', isHappy: false }),
+]);
+
+expectTypeOf(people.get('length')).toBeNumber();
+expectTypeOf(people.get('lastObject')).toEqualTypeOf<Person | undefined>();
+expectTypeOf(people.get('firstObject')).toEqualTypeOf<Person | undefined>();
+expectTypeOf(people.isAny('isHappy')).toBeBoolean();
+expectTypeOf(people.isAny('isHappy', false)).toBeBoolean();
+// @ts-expect-error
+people.isAny('isHappy', 'false');
+
+expectTypeOf(people.objectAt(0)).toEqualTypeOf<Person | undefined>();
+expectTypeOf(people.objectsAt([1, 2, 3])).toEqualTypeOf<Ember.Array<Person | undefined>>();
+
+expectTypeOf(people.filterBy('isHappy')).toMatchTypeOf<Person[]>();
+expectTypeOf(people.filterBy('isHappy')).toMatchTypeOf<Ember.MutableArray<Person>>();
+expectTypeOf(people.rejectBy('isHappy')).toMatchTypeOf<Person[]>();
+expectTypeOf(people.rejectBy('isHappy')).toMatchTypeOf<Ember.MutableArray<Person>>();
+expectTypeOf(people.filter((person) => person.get('name') === 'Yehuda')).toMatchTypeOf<Person[]>();
+expectTypeOf(people.filter((person) => person.get('name') === 'Yehuda')).toMatchTypeOf<
+  Ember.MutableArray<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>>();
+
+const last = people.get('lastObject');
+expectTypeOf(last).toEqualTypeOf<Person | undefined>();
+if (last) {
+  expectTypeOf(last.get('name')).toBeString();
+}
+
+const first = people.get('lastObject');
+if (first) {
+  expectTypeOf(first.get('isHappy')).toBeBoolean();
+}
+
+const letters: Ember.Array<string> = Ember.A(['a', 'b', 'c']);
+const codes = letters.map((item, index, array) => {
+  expectTypeOf(item).toBeString();
+  expectTypeOf(index).toBeNumber();
+  expectTypeOf(array).toEqualTypeOf<Ember.Array<string>>();
+  return item.charCodeAt(0);
+});
+expectTypeOf(codes).toMatchTypeOf<number[]>();
+expectTypeOf(codes).toEqualTypeOf<Ember.NativeArray<number>>();
+
+const value = '1,2,3';
+const filters = Ember.A(value.split(','));
+filters.push('4');
+filters.sort();
+
+const multiSortArr = Ember.A([
+  { k: 'a', v: 'z' },
+  { k: 'a', v: 'y' },
+  { k: 'b', v: 'c' },
+]);
+multiSortArr.sortBy('k', 'v');
diff --git a/type-tests/preview/ember/component.ts b/type-tests/preview/ember/component.ts
new file mode 100755
index 00000000000..493645d31e2
--- /dev/null
+++ b/type-tests/preview/ember/component.ts
@@ -0,0 +1,119 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+Ember.Component.extend({
+  layout: 'my-layout',
+});
+
+const MyComponent = Ember.Component.extend();
+expectTypeOf(Ember.get(MyComponent, 'positionalParams')).toEqualTypeOf<string | string[]>();
+
+const component1 = Ember.Component.extend({
+  actions: {
+    hello(name: string) {
+      console.log('Hello', name);
+    },
+  },
+});
+
+class AnotherComponent extends Ember.Component {
+  name = '';
+
+  hello(name: string) {
+    this.set('name', name);
+    this.name = name;
+  }
+}
+
+Ember.Component.extend({
+  tagName: 'em',
+});
+
+Ember.Component.extend({
+  classNames: ['my-class', 'my-other-class'],
+});
+
+class Bindings extends Ember.Component {
+  classNameBindings = ['propertyA', 'propertyB'];
+  propertyA = 'from-a';
+
+  @Ember.computed()
+  get propertyB() {
+    if (!this.get('propertyA')) {
+      return 'from-b';
+    }
+  }
+}
+
+Ember.Component.extend({
+  classNameBindings: ['hovered'],
+  hovered: true,
+});
+
+class Message extends Ember.Object {
+  empty = false;
+}
+
+Ember.Component.extend({
+  classNameBindings: ['messages.empty'],
+  messages: Message.create({
+    empty: true,
+  }),
+});
+
+Ember.Component.extend({
+  classNameBindings: ['isEnabled:enabled:disabled'],
+  isEnabled: true,
+});
+
+Ember.Component.extend({
+  classNameBindings: ['isEnabled::disabled'],
+  isEnabled: true,
+});
+
+Ember.Component.extend({
+  tagName: 'a',
+  attributeBindings: ['href'],
+  href: 'http://google.com',
+});
+
+Ember.Component.extend({
+  tagName: 'a',
+  attributeBindings: ['url:href'],
+  url: 'http://google.com',
+});
+
+Ember.Component.extend({
+  tagName: 'use',
+  attributeBindings: ['xlinkHref:xlink:href'],
+  xlinkHref: '#triangle',
+});
+
+Ember.Component.extend({
+  tagName: 'input',
+  attributeBindings: ['disabled'],
+  disabled: false,
+});
+
+Ember.Component.extend({
+  tagName: 'input',
+  attributeBindings: ['disabled'],
+  disabled: Ember.computed(() => {
+    return someLogic();
+  }),
+});
+
+declare function someLogic(): boolean;
+
+Ember.Component.extend({
+  tagName: 'form',
+  attributeBindings: ['novalidate'],
+  novalidate: null,
+});
+
+Ember.Component.extend({
+  click(event: object) {
+    // will be called when an instance's
+    // rendered element is clicked
+  },
+});
diff --git a/type-tests/preview/ember/computed.ts b/type-tests/preview/ember/computed.ts
new file mode 100755
index 00000000000..24cbba4eaf0
--- /dev/null
+++ b/type-tests/preview/ember/computed.ts
@@ -0,0 +1,100 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+function customMacro(message: string) {
+  return Ember.computed(() => {
+    return [message, message];
+  });
+}
+
+class Person extends Ember.Object {
+  firstName = '';
+  lastName = '';
+  age = 0;
+
+  // Equivalent to a per-instance `defineProperty` call.
+  @Ember.computed()
+  get noArgs() {
+    return 'test';
+  }
+
+  @Ember.computed('firstName', 'lastName')
+  get fullName(): string {
+    return `${this.get('firstName')} ${this.get('lastName')}`;
+  }
+
+  @Ember.computed('fullName').readOnly()
+  get fullNameReadonly() {
+    return this.get('fullName');
+  }
+
+  @Ember.computed('firstName', 'lastName')
+  get fullNameWritable(): string {
+    return this.get('fullName');
+  }
+
+  set fullNameWritable(value: string) {
+    const [first, last] = value.split(' ');
+    this.set('firstName', first);
+    this.set('lastName', last);
+  }
+
+  @Ember.computed().meta({ foo: 'bar' }).readOnly()
+  get combinators() {
+    return this.get('firstName');
+  }
+
+  @customMacro('hi')
+  declare hiTwice: string[];
+}
+
+const person = Person.create({
+  firstName: 'Fred',
+  lastName: 'Smith',
+  age: 29,
+});
+
+expectTypeOf(person.firstName).toEqualTypeOf<string>();
+expectTypeOf(person.age).toEqualTypeOf<number>();
+expectTypeOf(person.noArgs).toEqualTypeOf<string>();
+expectTypeOf(person.fullName).toEqualTypeOf<string>();
+expectTypeOf(person.fullNameReadonly).toEqualTypeOf<string>();
+expectTypeOf(person.fullNameWritable).toEqualTypeOf<string>();
+expectTypeOf(person.combinators).toEqualTypeOf<string>();
+
+expectTypeOf(person.get('firstName')).toEqualTypeOf<string>();
+expectTypeOf(person.get('age')).toEqualTypeOf<number>();
+expectTypeOf(person.get('noArgs')).toEqualTypeOf<string>();
+expectTypeOf(person.get('fullName')).toEqualTypeOf<string>();
+expectTypeOf(person.get('fullNameReadonly')).toEqualTypeOf<string>();
+expectTypeOf(person.get('fullNameWritable')).toEqualTypeOf<string>();
+expectTypeOf(person.get('combinators')).toEqualTypeOf<string>();
+
+expectTypeOf(person.getProperties('firstName', 'fullName', 'age')).toMatchTypeOf<{
+  firstName: string;
+  fullName: string;
+  age: number;
+}>();
+
+const person2 = Person.create({
+  fullName: 'Fred Smith',
+});
+
+expectTypeOf(person2.get('firstName')).toEqualTypeOf<string>();
+expectTypeOf(person2.get('fullName')).toEqualTypeOf<string>();
+
+const person3 = Person.extend({
+  firstName: 'Fred',
+  fullName: 'Fred Smith',
+}).create();
+
+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'),
+}).create();
+
+expectTypeOf(person4.get('firstName')).toEqualTypeOf<string>();
+expectTypeOf(person4.get('fullName')).toEqualTypeOf<string>();
diff --git a/type-tests/preview/ember/controller.ts b/type-tests/preview/ember/controller.ts
new file mode 100755
index 00000000000..7e89a8d8334
--- /dev/null
+++ b/type-tests/preview/ember/controller.ts
@@ -0,0 +1,11 @@
+import Ember from 'ember';
+
+class MyController extends Ember.Controller {
+  queryParams = ['category'];
+  category = null;
+  isExpanded = false;
+
+  toggleBody() {
+    this.toggleProperty('isExpanded');
+  }
+}
diff --git a/type-tests/preview/ember/core-object.ts b/type-tests/preview/ember/core-object.ts
new file mode 100644
index 00000000000..98dfc21a3a1
--- /dev/null
+++ b/type-tests/preview/ember/core-object.ts
@@ -0,0 +1,55 @@
+import Ember from 'ember';
+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.toString()).toBeString();
+
+/** .create tests */
+const co2 = CoreObject.create();
+expectTypeOf(co2.isDestroyed).toBeBoolean();
+expectTypeOf(co2.isDestroying).toBeBoolean();
+expectTypeOf(co2.destroy()).toEqualTypeOf<Ember.CoreObject>();
+expectTypeOf(co2.toString()).toBeString();
+
+/** .create tests w/ initial instance data passed in */
+declare class CO3 extends CoreObject {
+  foo: string;
+  bar: number;
+}
+const co3 = CO3.create({ foo: '123', bar: 456 });
+
+expectTypeOf(co3.foo).toBeString();
+expectTypeOf(co3.bar).toBeNumber();
+
+/** .extend with a zero-argument .create()  */
+class CO4 extends CO3 {
+  baz(): [string, number] {
+    return [this.foo, this.bar];
+  }
+}
+const co4 = CO4.create();
+
+expectTypeOf(co4.foo).toBeString();
+expectTypeOf(co4.bar).toBeNumber();
+expectTypeOf(co4.baz).toEqualTypeOf<() => [string, number]>();
+
+/** .extend with inconsistent arguments passed into .create()  */
+class CO5 extends CoreObject {
+  foo: string | boolean = 'hello';
+  bar = 123;
+  baz() {
+    return [this.foo, this.bar];
+  }
+}
+// @ts-expect-error
+class05.create({ foo: 99 });
+expectTypeOf(CO5.create({ foo: true })).toEqualTypeOf<CO5>();
+expectTypeOf(CO5.create({ foo: 'abc' })).toEqualTypeOf<CO5>();
+expectTypeOf(CO5.create().foo).toEqualTypeOf<boolean | string>();
diff --git a/type-tests/preview/ember/create-negative.ts b/type-tests/preview/ember/create-negative.ts
new file mode 100644
index 00000000000..86557265951
--- /dev/null
+++ b/type-tests/preview/ember/create-negative.ts
@@ -0,0 +1,8 @@
+import { Person } from './create';
+
+// @ts-expect-error
+Person.create({ firstName: 99 });
+// @ts-expect-error
+Person.create({}, { firstName: 99 });
+// @ts-expect-error
+Person.create({}, {}, { firstName: 99 });
diff --git a/type-tests/preview/ember/create.ts b/type-tests/preview/ember/create.ts
new file mode 100755
index 00000000000..5846fd2b037
--- /dev/null
+++ b/type-tests/preview/ember/create.ts
@@ -0,0 +1,57 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+/**
+ * Zero-argument case
+ */
+const o = Ember.Object.create();
+// create returns an object
+expectTypeOf(o).toBeObject();
+// object returned by create type-checks as an instance of Ember.Object
+expectTypeOf(o.isDestroyed).toBeBoolean();
+expectTypeOf(o.isDestroying).toBeBoolean();
+expectTypeOf(o.get).toMatchTypeOf<<K extends keyof Ember.Object>(key: K) => Ember.Object[K]>();
+
+/**
+ * One-argument case
+ */
+class O1 extends Ember.Object {
+  declare x: number;
+  declare y: string;
+  declare z: boolean;
+}
+
+const o1 = O1.create({ x: 9, y: 'hello', z: false });
+expectTypeOf(o1.x).toBeNumber();
+expectTypeOf(o1.y).toBeString();
+expectTypeOf(o1.z).toBeBoolean();
+
+class O2 extends Ember.Object {
+  declare a: number;
+  declare b: number;
+  declare c: number;
+}
+const obj = O2.create({ a: 1 }, { b: 2 }, { c: 3 });
+expectTypeOf(obj.b).toBeNumber();
+expectTypeOf(obj.a).toBeNumber();
+expectTypeOf(obj.c).toBeNumber();
+
+export class Person extends Ember.Object {
+  declare firstName: string;
+  declare lastName: string;
+  declare age: number;
+
+  @Ember.computed('firstName', 'lastName')
+  get fullName() {
+    return [this.firstName + this.lastName].join(' ');
+  }
+}
+const p = Person.create();
+
+expectTypeOf(p.firstName).toBeString();
+expectTypeOf(p.fullName).toBeString();
+expectTypeOf(p.get('fullName')).toBeString();
+
+Person.create({ firstName: 'string' });
+Person.create({}, { firstName: 'string' });
+Person.create({}, {}, { firstName: 'string' });
diff --git a/type-tests/preview/ember/data-adapter.ts b/type-tests/preview/ember/data-adapter.ts
new file mode 100644
index 00000000000..2334803ccbb
--- /dev/null
+++ b/type-tests/preview/ember/data-adapter.ts
@@ -0,0 +1,62 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+const da = Ember.DataAdapter.create();
+
+const filters = da.getFilters();
+expectTypeOf(filters.includes({ name: 'foo', desc: 'bar' })).toBeBoolean();
+// @ts-expect-error
+filters.includes({});
+
+expectTypeOf(filters[0]?.name).toEqualTypeOf<string | undefined>();
+expectTypeOf(filters[0]?.desc).toEqualTypeOf<string | undefined>();
+
+expectTypeOf(
+  da.watchModelTypes(
+    function added(wrappedTypes) {
+      wrappedTypes;
+      expectTypeOf(wrappedTypes[0]?.release).toEqualTypeOf<(() => void) | undefined>();
+      expectTypeOf(wrappedTypes[0]?.type.columns[0]?.desc).toEqualTypeOf<string | undefined>();
+      expectTypeOf(wrappedTypes[0]?.type.columns[0]?.name).toEqualTypeOf<string | undefined>();
+      expectTypeOf(wrappedTypes[0]?.type.count).toEqualTypeOf<number | undefined>();
+      expectTypeOf(wrappedTypes[0]?.type.name).toEqualTypeOf<string | undefined>();
+    },
+    function updated(wrappedTypes) {
+      wrappedTypes;
+      expectTypeOf(wrappedTypes[0]?.release).toEqualTypeOf<(() => void) | undefined>();
+      expectTypeOf(wrappedTypes[0]?.type.columns[0]?.desc).toEqualTypeOf<string | undefined>();
+      expectTypeOf(wrappedTypes[0]?.type.columns[0]?.name).toEqualTypeOf<string | undefined>();
+      expectTypeOf(wrappedTypes[0]?.type.count).toEqualTypeOf<number | undefined>();
+      expectTypeOf(wrappedTypes[0]?.type.name).toEqualTypeOf<string | undefined>();
+    }
+  )
+).toEqualTypeOf<() => void>();
+// @ts-expect-error
+da.watchModelTypes(() => {});
+
+expectTypeOf(
+  da.watchRecords(
+    'house',
+    function added(records) {
+      expectTypeOf(records[0]?.object).toEqualTypeOf<object | undefined>();
+      expectTypeOf(records[0]?.columnValues).toEqualTypeOf<object | undefined>();
+    },
+    function updated(records) {
+      expectTypeOf(records[0]?.object).toEqualTypeOf<object | undefined>();
+      expectTypeOf(records[0]?.columnValues).toEqualTypeOf<object | undefined>();
+    },
+    function removed(idx, count) {
+      expectTypeOf(idx).toBeNumber();
+      expectTypeOf(count).toBeNumber();
+    }
+  )
+).toEqualTypeOf<() => void>();
+// @ts-expect-error
+da.watchRecords(() => {});
+
+expectTypeOf(da.acceptsModelName).toEqualTypeOf<boolean>();
+expectTypeOf(da.containerDebugAdapter).toEqualTypeOf<Ember.ContainerDebugAdapter>();
+
+const ca: Ember.ContainerDebugAdapter = da.containerDebugAdapter;
+expectTypeOf(ca.canCatalogEntriesByType('controller')).toEqualTypeOf<boolean>();
+expectTypeOf(ca.catalogEntriesByType('controller')).toEqualTypeOf<string[]>();
diff --git a/type-tests/preview/ember/debug.ts b/type-tests/preview/ember/debug.ts
new file mode 100644
index 00000000000..4c7f02ce410
--- /dev/null
+++ b/type-tests/preview/ember/debug.ts
@@ -0,0 +1,121 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+const {
+  runInDebug,
+  warn,
+  debug,
+  Debug: { registerDeprecationHandler, registerWarnHandler },
+} = Ember;
+
+// Workaround for https://github.com/microsoft/TypeScript/issues/36931.
+const assert: typeof Ember.assert = Ember.assert;
+
+/**
+ * @ember/debug tests
+ */
+// @ts-expect-error
+runInDebug();
+expectTypeOf(runInDebug(() => console.log('Should not show up in prod'))).toBeVoid();
+
+// Log a warning if we have more than 3 tomsters
+const tomsterCount = 2;
+// @ts-expect-error
+warn('Too many tomsters!');
+expectTypeOf(warn('Too many tomsters!', { id: 'some-warning' })).toBeVoid();
+// @ts-expect-error
+warn('Too many tomsters!', tomsterCount <= 3);
+expectTypeOf(warn('Too many tomsters!', tomsterCount <= 3, { id: 'some-warning' })).toBeVoid();
+expectTypeOf(
+  warn('Too many tomsters!', tomsterCount <= 3, {
+    id: 'ember-debug.too-many-tomsters',
+  })
+).toBeVoid();
+
+// @ts-expect-error
+debug();
+expectTypeOf(debug('Too many tomsters!')).toBeVoid();
+// @ts-expect-error
+debug('Too many tomsters!', 'foo');
+
+// next is not called, so no warnings get the default behavior
+// @ts-expect-error
+registerWarnHandler();
+expectTypeOf(registerWarnHandler(() => {})).toBeVoid();
+expectTypeOf(
+  registerWarnHandler((message, options, next) => {
+    expectTypeOf(message).toEqualTypeOf<string>();
+    expectTypeOf(options).toEqualTypeOf<{ id: string } | undefined>();
+    expectTypeOf(next).toEqualTypeOf<
+      (message: string, options?: { id: string } | undefined) => void
+    >();
+  })
+).toBeVoid();
+expectTypeOf(
+  registerWarnHandler((message, options, next) => {
+    expectTypeOf(message).toEqualTypeOf<string>();
+    expectTypeOf(options).toEqualTypeOf<{ id: string } | undefined>();
+    // @ts-expect-error
+    next();
+  })
+).toBeVoid();
+expectTypeOf(
+  registerWarnHandler((message, options, next) => {
+    expectTypeOf(message).toEqualTypeOf<string>();
+    expectTypeOf(options).toEqualTypeOf<{ id: string } | undefined>();
+    expectTypeOf(next(message)).toBeVoid();
+  })
+).toBeVoid();
+expectTypeOf(
+  registerWarnHandler((message, options, next) => {
+    expectTypeOf(message).toEqualTypeOf<string>();
+    expectTypeOf(options).toEqualTypeOf<{ id: string } | undefined>();
+    expectTypeOf(next(message, options)).toBeVoid();
+  })
+).toBeVoid();
+
+// next is not called, so no warnings get the default behavior
+// @ts-expect-error
+registerDeprecationHandler();
+expectTypeOf(registerDeprecationHandler(() => {})).toBeVoid();
+expectTypeOf(
+  registerDeprecationHandler((message, options, next) => {
+    expectTypeOf(message).toBeString();
+    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(next).toEqualTypeOf<
+      (message: string, options?: { id: string; until: string } | undefined) => void
+    >();
+  })
+).toBeVoid();
+expectTypeOf(
+  registerDeprecationHandler((message, options, next) => {
+    expectTypeOf(message).toBeString();
+    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    // @ts-expect-error
+    next();
+  })
+).toBeVoid();
+expectTypeOf(
+  registerDeprecationHandler((message, options, next) => {
+    expectTypeOf(message).toBeString();
+    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(next(message)).toBeVoid();
+  })
+).toBeVoid();
+expectTypeOf(
+  registerDeprecationHandler((message, options, next) => {
+    expectTypeOf(message).toBeString();
+    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(next(message, options)).toBeVoid();
+  })
+).toBeVoid();
+
+// Test for truthiness
+const str: unknown = 'hello';
+assert('Must pass a string', typeof str === 'string');
+expectTypeOf(str).toBeString();
+
+// Fail unconditionally
+// This has to be last because `assert never` will raise TS's checks for
+// unreachable code.
+expectTypeOf(assert('This code path should never be run')).toBeNever();
diff --git a/type-tests/preview/ember/ember-module-tests.ts b/type-tests/preview/ember/ember-module-tests.ts
new file mode 100644
index 00000000000..fd01363e59a
--- /dev/null
+++ b/type-tests/preview/ember/ember-module-tests.ts
@@ -0,0 +1,325 @@
+import type Owner from '@ember/owner';
+import type { SafeString } from '@ember/template/-private/handlebars';
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+const top = (<T>(x?: T): T => x!)();
+type Top = typeof top;
+declare function expectTypeNativeArrayTop(x: Ember.NativeArray<Top>): void;
+// A
+expectTypeNativeArrayTop(Ember.A());
+expectTypeOf(Ember.A([1, 2])).toEqualTypeOf<Ember.NativeArray<number>>();
+// addListener
+Ember.addListener({ a: 'foo' }, 'event', {}, () => {});
+Ember.addListener({ a: 'foo' }, 'event', {}, 'a');
+// @ts-expect-error
+Ember.addListener({ a: 'foo' }, 'event', {}, 'b');
+Ember.addListener({ a: 'foo' }, 'event', null, () => {});
+// addObserver
+Ember.addObserver({ a: 'foo' }, 'a', null, () => {});
+Ember.addObserver({ a: 'foo' }, 'a', {}, () => {});
+// assert
+Ember.assert('2+2 should always be 4', 2 + 2 === 4);
+// assign
+const o1 = Ember.assign({ a: 1 }, { b: 2 });
+expectTypeOf(o1.a).toBeNumber();
+expectTypeOf(o1.b).toBeNumber();
+// @ts-expect-error
+o1.c;
+// Ember.bind // @ts-expect-error
+// cacheFor
+expectTypeOf(Ember.cacheFor({ a: 123 }, 'a')).toEqualTypeOf<number | undefined>();
+// @ts-expect-error
+Ember.cacheFor({ a: 123 }, 'x');
+// compare
+expectTypeOf(Ember.compare('31', '114')).toEqualTypeOf<number>();
+// debug
+Ember.debug('some info for developers');
+// deprecate
+Ember.deprecate("you shouldn't use this anymore", 3 === 3, {
+  id: 'no-longer-allowed',
+  until: '99.0.0',
+});
+// get
+expectTypeOf(Ember.get({ z: 23 }, 'z')).toEqualTypeOf<number>();
+expectTypeOf(Ember.get({ z: 23 }, 'zz')).toEqualTypeOf<unknown>();
+// getEngineParent
+expectTypeOf(
+  Ember.getEngineParent(new Ember.EngineInstance())
+).toEqualTypeOf<Ember.EngineInstance>();
+// getOwner
+expectTypeOf(Ember.getOwner(new Ember.Component())).toEqualTypeOf<Owner>();
+// getProperties
+expectTypeOf(Ember.getProperties({ z: 23 }, 'z').z).toEqualTypeOf<number>();
+expectTypeOf(Ember.getProperties({ z: 23 }, 'z', 'z').z).toEqualTypeOf<number>();
+// @ts-expect-error
+Ember.getProperties({ z: 23 }, 'z', 'a').z;
+expectTypeOf(Ember.getProperties({ z: 23 }, ['z', 'z']).z).toEqualTypeOf<number>();
+// @ts-expect-error
+Ember.getProperties({ z: 23 }, ['z', 'a']).z;
+
+// guidFor
+expectTypeOf(Ember.guidFor({})).toEqualTypeOf<string>();
+expectTypeOf(Ember.guidFor('')).toEqualTypeOf<string>();
+// isArray
+expectTypeOf(Ember.isArray('')).toEqualTypeOf<boolean>();
+expectTypeOf(Ember.isArray([])).toEqualTypeOf<boolean>();
+// isBlank
+expectTypeOf(Ember.isBlank('')).toEqualTypeOf<boolean>();
+expectTypeOf(Ember.isBlank([])).toEqualTypeOf<boolean>();
+// isEmpty
+expectTypeOf(Ember.isEmpty('')).toEqualTypeOf<boolean>();
+expectTypeOf(Ember.isEmpty([])).toEqualTypeOf<boolean>();
+// isEqual
+expectTypeOf(Ember.isEqual('', 'foo')).toEqualTypeOf<boolean>();
+expectTypeOf(Ember.isEqual([], '')).toEqualTypeOf<boolean>();
+// isNone
+expectTypeOf(Ember.isNone('')).toEqualTypeOf<boolean>();
+expectTypeOf(Ember.isNone([])).toEqualTypeOf<boolean>();
+// isPresent
+expectTypeOf(Ember.isPresent('')).toEqualTypeOf<boolean>();
+expectTypeOf(Ember.isPresent([])).toEqualTypeOf<boolean>();
+// observer
+class O2 extends Ember.Object {
+  name = 'foo';
+  age = 3;
+
+  nameWatcher = Ember.observer('name', () => {});
+  nameWatcher2 = Ember.observer('name', 'fullName', () => {});
+}
+const o2 = O2.create({
+  name: 'foo',
+  age: 3,
+});
+// on
+class O3 extends Ember.Object {
+  name = 'foo';
+  nameWatcher = Ember.on('init', () => {});
+  nameWatcher2 = Ember.on('destroy', () => {});
+}
+const o3 = O3.create();
+// removeListener
+Ember.removeListener(O2, 'create', null, () => {});
+Ember.removeListener(O2, 'create', null, 'create');
+// @ts-expect-error
+Ember.removeListener({}, 'create', null, 'blah');
+// removeObserver
+Ember.removeObserver(O2, 'create', () => {});
+// @ts-expect-error
+Ember.removeObserver({}, 'create', () => {});
+// runInDebug
+Ember.runInDebug(() => {});
+// sendEvent
+expectTypeOf(Ember.sendEvent(o2, 'clicked', [1, 2])).toBeBoolean();
+// set
+expectTypeOf(Ember.set(O2.create(), 'name', 'bar')).toEqualTypeOf<string>();
+expectTypeOf(Ember.set(O2.create(), 'age', 4)).toEqualTypeOf<number>();
+// @ts-expect-error
+Ember.set(O2.create(), 'nam', 'bar');
+// setOwner
+declare let app: Ember.ApplicationInstance;
+Ember.setOwner(O2.create(), app);
+// setProperties
+expectTypeOf(Ember.setProperties(O2.create(), { name: 'bar' }).name).toEqualTypeOf<string>();
+// trySet
+expectTypeOf(Ember.trySet(O2, 'nam', '')).toBeUnknown();
+// typeOf
+expectTypeOf(Ember.typeOf('')).toEqualTypeOf<'string'>();
+// @ts-ignore -- this *should* work but the namespace version is not carrying
+// it through correctly. However, people can *and should* simply use the
+// module import instead!
+expectTypeOf(Ember.typeOf(Ember.A())).toEqualTypeOf<'array'>();
+// warn
+// @ts-expect-error
+Ember.warn('be caseful!');
+Ember.warn('be caseful!', { id: 'some-warning' });
+// VERSION
+expectTypeOf(Ember.VERSION).toEqualTypeOf<string>();
+
+// onerror
+
+Ember.onerror = (err: Error) => console.error(err);
+// @ts-expect-error
+Ember.onerror = (num: number, err: Error) => console.error(err);
+Ember.onerror = undefined;
+
+// Classes
+// TODO ContainerProxyMixin
+// Ember
+// Ember.Application
+expectTypeOf(new Ember.Application()).toEqualTypeOf<Ember.Application>();
+expectTypeOf(Ember.Application.create()).toEqualTypeOf<Ember.Application>();
+// Ember.ApplicationInstance
+expectTypeOf(new Ember.ApplicationInstance()).toEqualTypeOf<Ember.ApplicationInstance>();
+expectTypeOf(Ember.ApplicationInstance.create()).toEqualTypeOf<Ember.ApplicationInstance>();
+// Ember.Array
+const a1: Ember.Array<string> = Ember.A([]);
+// @ts-expect-error
+const a2: Ember.Array<string> = {};
+// Ember.ArrayProxy
+expectTypeOf(new Ember.ArrayProxy<number>([3, 3, 2])).toEqualTypeOf<Ember.ArrayProxy<number>>();
+// Ember.Component
+const C1 = Ember.Component.extend({ classNames: ['foo'] });
+class C2 extends Ember.Component {
+  classNames = ['foo'];
+}
+const c1 = new C1();
+const c2 = new C2();
+C1.create();
+C2.create();
+c1.didInsertElement();
+c2.didInsertElement();
+
+class Foo {
+  foo = '';
+
+  @Ember.computed('foo')
+  get wat(): string {
+    return this.foo;
+  }
+
+  set wat(newValue: string) {
+    this.foo = newValue;
+  }
+}
+
+// Ember.ContainerDebugAdapter
+expectTypeOf(new Ember.ContainerDebugAdapter()).toEqualTypeOf<Ember.ContainerDebugAdapter>();
+// Ember.Controller
+expectTypeOf(new Ember.Controller()).toEqualTypeOf<Ember.Controller>();
+// Ember.CoreObject
+expectTypeOf(new Ember.CoreObject()).toEqualTypeOf<Ember.CoreObject>();
+// Ember.DataAdapter
+expectTypeOf(new Ember.DataAdapter()).toEqualTypeOf<Ember.DataAdapter>();
+// Ember.Debug
+Ember.Debug.registerDeprecationHandler(() => {});
+Ember.Debug.registerWarnHandler(() => {});
+// Ember.Engine
+const e1 = new Ember.Engine();
+e1.register('data:foo', {}, { instantiate: false });
+// Ember.EngineInstance
+const ei1 = new Ember.EngineInstance();
+ei1.lookup('data:foo');
+// Ember.Error
+new Ember.Error('Halp!');
+// Ember.Evented
+interface OE1 extends Ember.Evented {}
+class OE1 extends Ember.Object.extend(Ember.Evented) {}
+const oe1 = OE1.create();
+oe1.trigger('foo');
+oe1.on('bar', () => {});
+oe1.on('bar', { foo() {} }, () => {});
+// Ember.HashLocation
+const hl = new Ember.HashLocation();
+expectTypeOf(hl).toEqualTypeOf<Ember.HashLocation>();
+// Ember.Helper
+class H1 extends Ember.Helper {
+  compute() {
+    this.recompute();
+    return '';
+  }
+}
+// Ember.HistoryLocation
+const hil = Ember.HistoryLocation.create();
+expectTypeOf(hil).toEqualTypeOf<Ember.HistoryLocation>();
+// Ember.Mixin
+interface UsesMixin {
+  foo: string;
+}
+class UsesMixin extends Ember.Object {
+  baz() {
+    expectTypeOf(this.foo).toBeString();
+  }
+}
+// Ember.MutableArray
+const ma1: Ember.MutableArray<string> = Ember.A(['money', 'in', 'the', 'bananna', 'stand']);
+expectTypeOf(ma1.addObject('!')).toBeString();
+// @ts-expect-error
+ma1.filterBy('');
+expectTypeOf(ma1.firstObject).toEqualTypeOf<string | undefined>();
+expectTypeOf(ma1.lastObject).toEqualTypeOf<string | undefined>();
+const ma2: Ember.MutableArray<{ name: string }> = Ember.A([
+  { name: 'chris' },
+  { name: 'dan' },
+  { name: 'james' },
+]);
+expectTypeOf(ma2.filterBy('name', 'chris')).toEqualTypeOf<Ember.NativeArray<{ name: string }>>();
+// Ember.MutableEnumerable
+const me1 = Ember.A(['foo', undefined, null]);
+expectTypeOf(me1.compact()).toEqualTypeOf<Ember.NativeArray<string>>();
+// Ember.Namespace
+const myNs = Ember.Namespace.extend({});
+// Ember.NativeArray
+const na: Ember.NativeArray<number> = Ember.A([2, 3, 4]);
+expectTypeOf(na).toEqualTypeOf<Ember.NativeArray<number>>();
+expectTypeOf(na.clear()).toEqualTypeOf<Ember.NativeArray<number>>();
+// Ember.NoneLocation
+expectTypeOf(new Ember.NoneLocation()).toEqualTypeOf<Ember.NoneLocation>();
+// Ember.Object
+new Ember.Object();
+// Ember.ObjectProxy
+expectTypeOf(new Ember.ObjectProxy()).toEqualTypeOf<Ember.ObjectProxy>();
+// Ember.Observable
+Ember.Object.extend(Ember.Observable, {});
+// Ember.PromiseProxyMixin
+interface PPM<T> extends Ember.PromiseProxyMixin<T> {}
+class PPM<T> extends Ember.Object.extend(Ember.PromiseProxyMixin) {
+  foo() {
+    expectTypeOf(this.reason).toEqualTypeOf<unknown>();
+    expectTypeOf(this.isPending).toEqualTypeOf<boolean>();
+  }
+}
+// Ember.Route
+new Ember.Route();
+// Ember.Router
+new Ember.Router();
+// Ember.Service
+new Ember.Service();
+// Ember.Test
+Ember.Test;
+// Ember.Test.Adapter
+new Ember.Test.Adapter();
+// Ember.Test.QUnitAdapter
+new Ember.Test.QUnitAdapter();
+// Ember.Helper
+// helper
+Ember.Helper.helper(([a, b]: [number, number]) => a + b);
+// Ember.String
+Ember.String;
+// htmlSafe
+expectTypeOf(Ember.String.htmlSafe('foo')).toEqualTypeOf<SafeString>();
+// isHTMLSafe
+expectTypeOf(Ember.String.isHTMLSafe('foo')).toEqualTypeOf<boolean>();
+// Ember.Test
+expectTypeOf(Ember.Test.checkWaiters()).toEqualTypeOf<boolean>();
+// checkWaiters
+
+/**
+ * == REMOVED FEATURES ==
+ * These are deprecated and/or private things that have been removed from the
+ * Ember.* namespace. These tests asserts that the types of these things
+ * stay gone
+ */
+
+// @ts-expect-error
+Ember.bind;
+// @ts-expect-error
+Ember.deprecate('foo', 'bar');
+// @ts-expect-error
+Ember.K;
+// @ts-expect-error
+Ember.Binding;
+// @ts-expect-error
+Ember.Transition;
+// @ts-expect-error
+Ember.create;
+// @ts-expect-error
+Ember.reset;
+// @ts-expect-error
+Ember.unsubscribe;
+// @ts-expect-error
+Ember.subscribe;
+// @ts-expect-error
+Ember.instrument;
+// @ts-expect-error
+Ember.Instrumentation;
diff --git a/type-tests/preview/ember/ember-tests.ts b/type-tests/preview/ember/ember-tests.ts
new file mode 100755
index 00000000000..18bfa6cccc7
--- /dev/null
+++ b/type-tests/preview/ember/ember-tests.ts
@@ -0,0 +1,185 @@
+import { A } from '@ember/array';
+import type { SafeString } from '@ember/template/-private/handlebars';
+import Ember from 'ember';
+import type { AnyFn } from 'ember/-private/type-utils';
+import { expectTypeOf } from 'expect-type';
+
+class President extends Ember.Object {
+  name = 'Barack Obama';
+}
+
+class DetailedPresident extends President {
+  firstName = 'Barack';
+  lastName = 'Obama';
+  @Ember.computed()
+  get fullName() {
+    return `${this.get('firstName')} ${this.get('lastName')}`;
+  }
+}
+
+class Country extends Ember.Object {
+  presidentNameBinding = 'MyApp.president.name';
+}
+
+class MyApp extends Ember.Application {
+  president = President.create();
+  country = Country.create();
+
+  todosController?: TodosController;
+}
+
+const App = MyApp.create();
+App.country.get('presidentName');
+App.president = DetailedPresident.create();
+App.president.get('fullName');
+
+declare class MyPerson extends Ember.Object {
+  static createMan(): MyPerson;
+}
+MyPerson.createMan();
+
+class Person1 extends Ember.Object {
+  name?: string;
+  say = (thing: string) => {
+    alert(thing);
+  };
+}
+
+declare class MyPerson2 extends Ember.Object {
+  helloWorld(): void;
+}
+MyPerson2.create().helloWorld();
+
+class Tom extends Person1 {
+  name = 'Tom Dale';
+  helloWorld() {
+    this.say('Hi my name is ' + this.get('name'));
+  }
+}
+const tom = Tom.create();
+tom.helloWorld();
+
+const PersonReopened = Person1.reopen({ isPerson: true });
+PersonReopened.create().get('isPerson');
+
+class Todo extends Ember.Object {
+  isDone = false;
+}
+
+class TodosController extends Ember.Object {
+  todos = A([Todo.create()]);
+
+  @Ember.computed('todos.@each.isDone')
+  get remaining() {
+    const todos = this.get('todos');
+    return todos.filterBy('isDone', false).get('length');
+  }
+}
+
+App.todosController = TodosController.create();
+
+const todos = App.todosController.get('todos');
+let todo = todos.objectAt(0);
+todo?.set('isDone', true);
+App.todosController.get('remaining');
+todo = Todo.create({ isDone: true });
+todos.pushObject(todo);
+App.todosController.get('remaining');
+
+const NormalApp = Ember.Application.create({
+  rootElement: '#sidebar',
+});
+
+Ember.Handlebars.registerHelper(
+  'highlight',
+  (property: string, options: any) =>
+    new Ember.Handlebars.SafeString('<span class="highlight">' + 'some value' + '</span>')
+);
+
+class Person2 extends Ember.Object {
+  name = '';
+
+  sayHello() {
+    console.log('Hello from ' + this.get('name'));
+  }
+}
+const people = Ember.A([
+  Person2.create({ name: 'Juan' }),
+  Person2.create({ name: 'Charles' }),
+  Person2.create({ name: 'Majd' }),
+]);
+people.invoke('sayHello');
+// @ts-expect-error
+people.invoke('name');
+
+type Arr = Ember.NativeArray<
+  Ember.Object & {
+    name?: string;
+  }
+>;
+const arr: Arr = Ember.A([Ember.Object.create(), Ember.Object.create()]);
+expectTypeOf(arr.setEach('name', 'unknown')).toEqualTypeOf<void>();
+expectTypeOf(arr.setEach('name', undefined)).toEqualTypeOf<void>();
+expectTypeOf(arr.getEach('name')).toEqualTypeOf<Ember.NativeArray<string | undefined>>();
+// @ts-expect-error
+arr.setEach('age', 123);
+// @ts-expect-error
+arr.getEach('age');
+
+class Person3 extends Ember.Object {
+  name?: string;
+  isHappy = false;
+}
+const people2 = Ember.A([
+  Person3.create({ name: 'Yehuda', isHappy: true }),
+  Person3.create({ name: 'Majd', isHappy: false }),
+]);
+const isHappy = (person: Person3): boolean => {
+  return Boolean(person.get('isHappy'));
+};
+people2.every(isHappy);
+people2.any(isHappy);
+people2.isEvery('isHappy');
+people2.isEvery('isHappy', true);
+// @ts-expect-error
+people2.isAny('isHappy', 'true');
+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) => {
+  // on success
+  resolve('ok!');
+
+  // on failure
+  reject('no-k!');
+});
+
+promise.then(
+  (value) => {
+    // on fulfillment
+    expectTypeOf(value).toBeString();
+  },
+  (reason: unknown) => {
+    // on rejection
+  }
+);
+
+// make sure Ember.RSVP.Promise can be reference as a type
+declare function promiseReturningFunction(urn: string): Ember.RSVP.Promise<string>;
+
+const mix1 = Ember.Mixin.create({
+  foo: 1,
+});
+
+const mix2 = Ember.Mixin.create({
+  bar: 2,
+});
+
+const component1 = Ember.Component.extend(mix1, mix2, {
+  lyft: Ember.inject.service(),
+  cars: Ember.computed.readOnly('lyft.cars'),
+});
+
+// make sure htmlSafe returns a SafeString
+expectTypeOf(Ember.String.htmlSafe('hello')).toEqualTypeOf<SafeString>();
diff --git a/type-tests/preview/ember/engine-instance.ts b/type-tests/preview/ember/engine-instance.ts
new file mode 100644
index 00000000000..0da036e13af
--- /dev/null
+++ b/type-tests/preview/ember/engine-instance.ts
@@ -0,0 +1,27 @@
+import Ember from 'ember';
+const { EngineInstance } = Ember;
+
+const engineInstance = EngineInstance.create();
+engineInstance.register('some:injection', class Foo {});
+
+engineInstance.register('some:injection', class Foo {}, {
+  singleton: true,
+});
+
+engineInstance.register('some:injection', class Foo {}, {
+  instantiate: false,
+});
+
+engineInstance.register('some:injection', class Foo {}, {
+  singleton: false,
+  instantiate: true,
+});
+
+engineInstance.factoryFor('router:main');
+engineInstance.lookup('route:basic');
+
+engineInstance.boot();
+
+(async () => {
+  await engineInstance.boot();
+})();
diff --git a/type-tests/preview/ember/engine.ts b/type-tests/preview/ember/engine.ts
new file mode 100755
index 00000000000..f8ebea2ce65
--- /dev/null
+++ b/type-tests/preview/ember/engine.ts
@@ -0,0 +1,44 @@
+import Ember from 'ember';
+
+class BaseEngine extends Ember.Engine {
+  modulePrefix = 'my-engine';
+}
+
+class Obj extends Ember.Object {
+  foo = 'bar';
+}
+
+BaseEngine.initializer({
+  name: 'my-initializer',
+  initialize(engine) {
+    engine.register('foo:bar', Obj);
+  },
+});
+
+BaseEngine.instanceInitializer({
+  name: 'my-instance-initializer',
+  initialize(engine) {
+    (engine.lookup('foo:bar') as Obj).get('foo');
+  },
+});
+
+class Engine1 extends BaseEngine {
+  rootElement = '#engine-one';
+  customEvents = {
+    paste: 'paste',
+  };
+}
+
+class Engine2 extends BaseEngine {
+  rootElement = '#engine-two';
+  customEvents = {
+    mouseenter: null,
+    mouseleave: null,
+  };
+}
+
+const Engine3 = BaseEngine.create();
+
+const Engine3Instance1 = Engine3.buildInstance();
+
+const Engine3Instance2 = Engine3.buildInstance({ foo: 'bar' });
diff --git a/type-tests/preview/ember/error.ts b/type-tests/preview/ember/error.ts
new file mode 100644
index 00000000000..b87de9ddddd
--- /dev/null
+++ b/type-tests/preview/ember/error.ts
@@ -0,0 +1,5 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+// uhhh, yeah.
+expectTypeOf(Ember.Error).toEqualTypeOf<typeof Ember.Error>();
diff --git a/type-tests/preview/ember/event.ts b/type-tests/preview/ember/event.ts
new file mode 100755
index 00000000000..90580d8ba9a
--- /dev/null
+++ b/type-tests/preview/ember/event.ts
@@ -0,0 +1,61 @@
+import Ember from 'ember';
+
+function testOn() {
+  const Job = Ember.Object.extend({
+    logCompleted: Ember.on('completed', () => {
+      console.log('Job completed!');
+    }),
+  });
+
+  const job = Job.create();
+
+  Ember.sendEvent(job, 'completed'); // Logs 'Job completed!'
+}
+
+function testEvented() {
+  interface Person extends Ember.Evented {}
+  class Person extends Ember.Object {
+    greet() {
+      this.trigger('greet');
+    }
+  }
+
+  const person = Person.create();
+
+  person.on('greet', () => {
+    console.log('Our person has greeted');
+  });
+
+  person
+    .on('greet', () => {
+      console.log('Our person has greeted');
+    })
+    .one('greet', () => {
+      console.log('Offer one-time special');
+    })
+    .off('event', {}, () => {});
+
+  person.greet();
+}
+
+function testObserver() {
+  Ember.Object.extend({
+    valueObserver: Ember.observer('value', () => {
+      // Executes whenever the "value" property changes
+    }),
+  });
+}
+
+function testListener() {
+  class TestListener extends Ember.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);
+    }
+    willDestroyListener() {}
+  }
+}
diff --git a/type-tests/preview/ember/extend.ts b/type-tests/preview/ember/extend.ts
new file mode 100755
index 00000000000..a8a50e1b0de
--- /dev/null
+++ b/type-tests/preview/ember/extend.ts
@@ -0,0 +1,39 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+class Person extends Ember.Object {
+  declare firstName: string;
+  declare lastName: string;
+
+  get fullName() {
+    return `${this.firstName} ${this.lastName}`;
+  }
+  get fullName2(): string {
+    return `${this.get('firstName')} ${this.get('lastName')}`;
+  }
+}
+
+expectTypeOf(Person.prototype.firstName).toBeString();
+expectTypeOf(Person.prototype.fullName).toBeString();
+
+const person = Person.create({
+  firstName: 'Joe',
+  lastName: 'Blow',
+  // @ts-expect-error
+  extra: 42,
+});
+
+expectTypeOf(person.fullName).toBeString();
+// @ts-expect-error
+person.extra;
+
+class PersonWithStatics extends Ember.Object {
+  static isPerson = true;
+}
+const PersonWithStatics2 = PersonWithStatics.extend({});
+class PersonWithStatics3 extends PersonWithStatics {}
+class PersonWithStatics4 extends PersonWithStatics2 {}
+expectTypeOf(PersonWithStatics.isPerson).toBeBoolean();
+expectTypeOf(PersonWithStatics2.isPerson).toBeBoolean();
+expectTypeOf(PersonWithStatics3.isPerson).toBeBoolean();
+expectTypeOf(PersonWithStatics4.isPerson).toBeBoolean();
diff --git a/type-tests/preview/ember/helper.ts b/type-tests/preview/ember/helper.ts
new file mode 100755
index 00000000000..2cfc4141a60
--- /dev/null
+++ b/type-tests/preview/ember/helper.ts
@@ -0,0 +1,44 @@
+import Ember from 'ember';
+
+const FormatCurrencyHelper = Ember.Helper.helper((params: [number], hash: { currency: string }) => {
+  const cents = params[0];
+  const currency = hash.currency;
+  return `${currency}${cents * 0.01}`;
+});
+
+class User extends Ember.Object {
+  declare email: string;
+}
+
+class SessionService extends Ember.Service {
+  declare currentUser: User;
+}
+
+declare module '@ember/service' {
+  interface Registry {
+    session: SessionService;
+  }
+}
+
+class CurrentUserEmailHelper extends Ember.Helper {
+  @Ember.inject.service('session')
+  declare session: SessionService;
+
+  compute(): string {
+    return this.get('session').get('currentUser').get('email');
+  }
+}
+
+import { helper } from '@ember/component/helper';
+
+function typedHelp(/*params, hash*/) {
+  return 'my type of help';
+}
+
+export default helper(typedHelp);
+
+function arrayNumHelp(/*params, hash*/) {
+  return [1, 2, 3];
+}
+
+helper(arrayNumHelp);
diff --git a/type-tests/preview/ember/inject.ts b/type-tests/preview/ember/inject.ts
new file mode 100755
index 00000000000..42df94317e7
--- /dev/null
+++ b/type-tests/preview/ember/inject.ts
@@ -0,0 +1,73 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+class AuthService extends Ember.Service {
+  declare isAuthenticated: boolean;
+}
+
+class ApplicationController extends Ember.Controller {
+  model = {};
+  declare string: string;
+  transitionToLogin() {}
+}
+
+declare module '@ember/service' {
+  interface Registry {
+    auth: AuthService;
+  }
+}
+
+declare module '@ember/controller' {
+  interface Registry {
+    emberApplication: ApplicationController;
+  }
+}
+
+class LoginRoute extends Ember.Route {
+  @Ember.inject.service('auth')
+  declare auth: AuthService;
+
+  @Ember.inject.controller('emberApplication')
+  declare application: ApplicationController;
+
+  didTransition() {
+    if (!this.get('auth').get('isAuthenticated')) {
+      this.get('application').transitionToLogin();
+    }
+  }
+
+  anyOldMethod() {
+    this.get('application').set('string', 'must be a string');
+    expectTypeOf(this.controllerFor('emberApplication')).toEqualTypeOf<Controller>();
+  }
+}
+
+// New module injection style.
+import RouterService from '@ember/routing/router-service';
+import Controller from '@ember/controller';
+
+class ComponentInjection extends Ember.Component {
+  @Ember.inject.controller('emberApplication')
+  declare applicationController: ApplicationController;
+
+  @Ember.inject.service('auth')
+  declare auth: AuthService;
+
+  @Ember.inject.service('router')
+  declare router: RouterService;
+
+  @Ember.inject.service
+  declare misc: Ember.Service;
+
+  testem() {
+    expectTypeOf(this.misc).toEqualTypeOf<Ember.Service>();
+
+    const url = this.router.urlFor('some-route', 1, 2, 3, {
+      queryParams: { seriously: 'yes' },
+    });
+    expectTypeOf(url).toBeString();
+    if (!this.get('auth').isAuthenticated) {
+      this.get('applicationController').transitionToLogin();
+    }
+  }
+}
diff --git a/type-tests/preview/ember/mixin.ts b/type-tests/preview/ember/mixin.ts
new file mode 100755
index 00000000000..55176a725ce
--- /dev/null
+++ b/type-tests/preview/ember/mixin.ts
@@ -0,0 +1,66 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+interface EditableMixin extends Ember.Mixin {
+  edit(): void;
+  isEditing: boolean;
+}
+
+const EditableMixin = Ember.Mixin.create({
+  edit(this: EditableMixin & Ember.Object) {
+    this.get('controller');
+    console.log('starting to edit');
+    this.set('isEditing', true);
+  },
+  isEditing: false,
+});
+
+interface EditableComment extends EditableMixin {}
+class EditableComment extends Ember.Route.extend(EditableMixin) {
+  postId = 0;
+
+  canEdit() {
+    return !this.isEditing;
+  }
+
+  tryEdit() {
+    if (this.canEdit()) {
+      this.edit();
+    }
+  }
+}
+
+const comment = EditableComment.create({
+  postId: 42,
+});
+
+comment.edit();
+comment.canEdit();
+comment.tryEdit();
+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 obj = LiteralMixins.create();
+// @ts-expect-error
+obj.a;
+// @ts-expect-error
+obj.b;
+// @ts-expect-error
+obj.c;
+
+/* Test composition of mixins */
+interface EditableAndCancelableMixin extends EditableMixin {
+  cancelled: boolean;
+}
+const EditableAndCancelableMixin = Ember.Mixin.create(EditableMixin, {
+  cancelled: false,
+});
+
+interface EditableAndCancelableComment extends EditableAndCancelableMixin {}
+class EditableAndCancelableComment extends Ember.Route.extend(EditableAndCancelableMixin) {}
+
+const editableAndCancelable = EditableAndCancelableComment.create();
+expectTypeOf(editableAndCancelable.isEditing).toBeBoolean();
+expectTypeOf(editableAndCancelable.cancelled).toBeBoolean();
diff --git a/type-tests/preview/ember/object.ts b/type-tests/preview/ember/object.ts
new file mode 100755
index 00000000000..ada59c9eff4
--- /dev/null
+++ b/type-tests/preview/ember/object.ts
@@ -0,0 +1,86 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+class LifetimeHooks extends Ember.Object {
+  resource: {} | undefined;
+
+  init() {
+    this._super();
+    this.resource = {};
+  }
+
+  willDestroy() {
+    this.resource = undefined;
+    this._super();
+  }
+}
+
+class MyObject30 extends Ember.Object {
+  constructor() {
+    super();
+  }
+}
+
+class MyObject31 extends Ember.Object {
+  constructor(properties: object) {
+    super(properties);
+  }
+}
+
+class Foo extends Ember.Object {
+  @Ember.computed()
+  get a() {
+    return '';
+  }
+
+  set a(newVal: string) {
+    /* no-op */
+  }
+
+  b = 5;
+
+  baz() {
+    this.b = 10;
+    expectTypeOf(this.get('b').toFixed(4)).toEqualTypeOf<string>();
+    expectTypeOf(this.set('a', 'abc').split(',')).toEqualTypeOf<string[]>();
+    expectTypeOf(this.set('b', 10).toFixed(4)).toEqualTypeOf<string>();
+
+    this.setProperties({ b: 11 });
+    // this.setProperties({ b: '11' }); // @ts-expect-error
+    this.setProperties({
+      a: 'def',
+      b: 11,
+    });
+  }
+}
+
+export class Foo2 extends Ember.Object {
+  name = '';
+
+  changeName(name: string) {
+    expectTypeOf(Ember.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
+    // there are basically no cases inside a class where you *have* to use `get`
+    // today, this is an acceptable workaround for now. It is assignable *or*
+    // 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((this as Foo2).get('name')).toBeString();
+
+    expectTypeOf(this.setProperties({ name })).toEqualTypeOf<Pick<this, 'name'>>();
+    expectTypeOf(Ember.setProperties(this, { name })).toEqualTypeOf<Pick<this, 'name'>>();
+  }
+
+  bar() {
+    Ember.notifyPropertyChange(this, 'name');
+    // @ts-expect-error
+    Ember.notifyPropertyChange(this);
+    // @ts-expect-error
+    Ember.notifyPropertyChange('name');
+    // @ts-expect-error
+    Ember.notifyPropertyChange(this, 'name', 'bar');
+  }
+}
diff --git a/type-tests/preview/ember/observable.ts b/type-tests/preview/ember/observable.ts
new file mode 100755
index 00000000000..013bf77e61b
--- /dev/null
+++ b/type-tests/preview/ember/observable.ts
@@ -0,0 +1,147 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+class MyComponent extends Ember.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);
+    this.removeObserver('foo', this, 'fooDidChange');
+    this.removeObserver('foo', this, this.fooDidChange);
+    Ember.removeObserver(this, 'foo', this, 'fooDidChange');
+    Ember.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);
+  }
+
+  @Ember.computed('foo')
+  get bar(): string {
+    return this.foo;
+  }
+
+  fooDidChange(sender: MyComponent, key: string) {
+    // your code
+  }
+}
+
+const myComponent = MyComponent.create();
+myComponent.addObserver('foo', null, () => {});
+myComponent.set('foo', 'baz');
+expectTypeOf(myComponent.get('foo')).toEqualTypeOf<string>();
+
+class Person extends Ember.Object {
+  name = '';
+  age = 0;
+
+  @Ember.computed()
+  get capitalized() {
+    return this.get('name').toUpperCase();
+  }
+}
+const person = Person.create({
+  name: 'Fred',
+  age: 29,
+});
+
+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(person.get('name')).toEqualTypeOf<string>();
+  expectTypeOf(person.get('age')).toEqualTypeOf<number>();
+  expectTypeOf(person.get('capitalized')).toEqualTypeOf<string>();
+  expectTypeOf(Ember.get(pojo, 'name')).toEqualTypeOf<string>();
+}
+
+function testGetProperties() {
+  expectTypeOf(Ember.getProperties(person, 'name')).toEqualTypeOf<{ name: string }>();
+  expectTypeOf(Ember.getProperties(person, 'name', 'age')).toEqualTypeOf<{
+    name: string;
+    age: number;
+  }>();
+  expectTypeOf(Ember.getProperties(person, ['name', 'age'])).toEqualTypeOf<{
+    name: string;
+    age: number;
+  }>();
+  expectTypeOf(Ember.getProperties(person, 'name', 'age', 'capitalized')).toEqualTypeOf<
+    Pick<Person, 'name' | 'age' | 'capitalized'>
+  >();
+  expectTypeOf(person.getProperties('name')).toEqualTypeOf<{ name: string }>();
+  expectTypeOf(person.getProperties('name', 'age')).toEqualTypeOf<{ name: string; age: number }>();
+  expectTypeOf(person.getProperties(['name', 'age'])).toEqualTypeOf<{
+    name: string;
+    age: number;
+  }>();
+  expectTypeOf(person.getProperties('name', 'age', 'capitalized')).toEqualTypeOf<
+    Pick<Person, 'name' | 'age' | 'capitalized'>
+  >();
+  expectTypeOf(Ember.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(person.set('name', 'Joe')).toBeString();
+  expectTypeOf(person.set('age', 35)).toBeNumber();
+  expectTypeOf(person.set('capitalized', 'JOE')).toBeString();
+  expectTypeOf(Ember.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<{
+    name: string;
+    age: number;
+  }>();
+  expectTypeOf(Ember.setProperties(person, { name: 'Joe', capitalized: 'JOE' })).toEqualTypeOf<
+    Pick<Person, 'name' | 'capitalized'>
+  >();
+  expectTypeOf(person.setProperties({ name: 'Joe' })).toEqualTypeOf<Pick<Person, 'name'>>();
+  expectTypeOf(person.setProperties({ name: 'Joe', age: 35 })).toEqualTypeOf<
+    Pick<Person, 'name' | 'age'>
+  >();
+  expectTypeOf(person.setProperties({ name: 'Joe', capitalized: 'JOE' })).toEqualTypeOf<
+    Pick<Person, 'name' | 'capitalized'>
+  >();
+  expectTypeOf(Ember.setProperties(pojo, { name: 'Joe', age: 35 })).toEqualTypeOf<
+    Pick<typeof pojo, 'name' | 'age'>
+  >();
+}
+
+function testDynamic() {
+  const obj: Record<string, string> = {};
+  const dynamicKey = 'dummy' as string;
+
+  // These all are "too loose" in `noUncheckedIndexedAccess`, but `get` has
+  // 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<
+    Record<'dummy', string>
+  >();
+  expectTypeOf(Ember.setProperties(obj, { [dynamicKey]: 'value' })).toEqualTypeOf<
+    Record<string, string>
+  >();
+}
diff --git a/type-tests/preview/ember/private/computed-tests.ts b/type-tests/preview/ember/private/computed-tests.ts
new file mode 100644
index 00000000000..7a5448faa93
--- /dev/null
+++ b/type-tests/preview/ember/private/computed-tests.ts
@@ -0,0 +1,26 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+class Example1 extends Ember.Object {
+  firstName = '';
+  lastName = '';
+
+  @Ember.computed('fullName')
+  get allNames() {
+    return [this.fullName];
+  }
+
+  @Ember.computed('firstName', 'lastName')
+  get fullName() {
+    return `${this.firstName} ${this.lastName}`;
+  }
+}
+
+class Example2 extends Example1 {
+  foo() {
+    expectTypeOf(this.get('fullName').split(',')).toEqualTypeOf<string[]>();
+    expectTypeOf(this.get('allNames')[0]).toEqualTypeOf<string | undefined>();
+    expectTypeOf(this.get('firstName').split(',')).toEqualTypeOf<string[]>();
+    expectTypeOf(this.get('lastName').split(',')).toEqualTypeOf<string[]>();
+  }
+}
diff --git a/type-tests/preview/ember/private/observable-tests.ts b/type-tests/preview/ember/private/observable-tests.ts
new file mode 100644
index 00000000000..abc323ed238
--- /dev/null
+++ b/type-tests/preview/ember/private/observable-tests.ts
@@ -0,0 +1,232 @@
+import Ember from 'ember';
+import { ExtractPropertyNamesOfType } from '@ember/object/-private/types';
+import Observable from '@ember/object/observable';
+import { expectTypeOf } from 'expect-type';
+
+class OtherThing {
+  observerOfDemo(target: DemoObservable, key: string) {}
+}
+
+class DemoObservable implements Observable {
+  foo: string;
+  isFoo = true;
+  bar: [boolean, boolean];
+  baz?: number | undefined;
+  constructor() {
+    this.foo = 'hello';
+    this.bar = [false, true];
+    this.baz = 9;
+    this.addObserver('foo', this, 'fooDidChange');
+    // @ts-expect-error
+    this.addObserver('foo', this, 'fooDidChangeProtected');
+    this.addObserver('foo', this, this.fooDidChange);
+    this.addObserver('foo', this, this.fooDidChangeProtected);
+    const ot = new OtherThing();
+    this.addObserver('foo', ot, ot.observerOfDemo);
+    Ember.addObserver(this, 'foo', this, 'fooDidChange');
+    // @ts-expect-error
+    Ember.addObserver(this, 'foo', this, 'fooDidChangeProtected');
+    Ember.addObserver(this, 'foo', this, this.fooDidChange);
+    Ember.addObserver(this, 'foo', this, this.fooDidChangeProtected);
+    this.removeObserver('foo', this, 'fooDidChange');
+    // @ts-expect-error
+    this.removeObserver('foo', this, 'fooDidChangeProtected');
+    this.removeObserver('foo', this, this.fooDidChange);
+    this.removeObserver('foo', this, this.fooDidChangeProtected);
+    Ember.removeObserver(this, 'foo', this, 'fooDidChange');
+    // @ts-expect-error
+    Ember.removeObserver(this, 'foo', this, 'fooDidChangeProtected');
+    Ember.removeObserver(this, 'foo', this, this.fooDidChange);
+    const lambda = () => {
+      this.fooDidChange(this, 'foo');
+    };
+    this.addObserver('foo', lambda);
+    this.addObserver('foo', (sender, key, value, rev) => {
+      // cannot check type equality with `this`, can only check assignability
+      let self = this;
+      self = sender;
+      sender = this;
+
+      expectTypeOf(key).toEqualTypeOf<'foo'>();
+      expectTypeOf(rev).toBeNumber();
+
+      // same issue with assignability and `this` types since `value` derives
+      // from `this['foo']`
+      this.foo = value;
+      value = this.foo;
+    });
+    this.removeObserver('foo', lambda);
+    Ember.addObserver(this, 'foo', lambda);
+    Ember.removeObserver(this, 'foo', lambda);
+  }
+  _super(...args: any[]) {
+    throw new Error('Method not implemented.');
+  }
+  init(): void {
+    throw new Error('Method not implemented.');
+  }
+  declare concatenatedProperties: string[] | null;
+  declare isDestroyed: boolean;
+  declare isDestroying: boolean;
+  destroy(): this {
+    throw new Error('Method not implemented.');
+  }
+  willDestroy(): void {
+    throw new Error('Method not implemented.');
+  }
+  toString(): string {
+    throw new Error('Method not implemented.');
+  }
+
+  fooDidChange(obj: this, propName: string) {}
+  protected fooDidChangeProtected(obj: this, propName: string) {}
+  get<K extends keyof this>(key: K): this[K] {
+    throw new Error('Method not implemented.');
+  }
+  getProperties(): {};
+  getProperties<K extends keyof this>(list: K[]): Pick<this, K>;
+  getProperties<K extends keyof this>(...list: K[]): Pick<this, K>;
+  getProperties(...rest: any[]): any {
+    throw new Error('Method not implemented.');
+  }
+  set<K extends keyof this>(key: K, value: this[K]): this[K] {
+    throw new Error('Method not implemented.');
+  }
+  setProperties<K extends keyof this>(hash: Pick<this, K>): Pick<this, K> {
+    throw new Error('Method not implemented.');
+  }
+  notifyPropertyChange(keyName: string): this {
+    throw new Error('Method not implemented.');
+  }
+  addObserver<Target>(
+    key: keyof this,
+    target: Target,
+    method:
+      | keyof Target
+      | ((this: Target, sender: this, key: string, value: any, rev: number) => void)
+  ): any;
+  addObserver<K extends keyof this>(
+    key: K,
+    method: keyof this | ((this: this, sender: this, key: K, value: this[K], rev: number) => void)
+  ): any;
+  addObserver(key: any, target: any, method?: any) {
+    throw new Error('Method not implemented.');
+  }
+  removeObserver<Target>(
+    key: keyof this,
+    target: Target,
+    method:
+      | keyof Target
+      | ((this: Target, sender: this, key: string, value: any, rev: number) => void)
+  ): any;
+  removeObserver(
+    key: keyof this,
+    method: keyof this | ((this: this, sender: this, key: string, value: any, rev: number) => void)
+  ): any;
+  removeObserver(key: any, target: any, method?: any): void {
+    throw new Error('Method not implemented.');
+  }
+  incrementProperty(
+    keyName: ExtractPropertyNamesOfType<this, number | undefined>,
+    increment?: number
+  ): number {
+    throw new Error('Method not implemented.');
+  }
+  decrementProperty(
+    keyName: ExtractPropertyNamesOfType<this, number | undefined>,
+    decrement?: number
+  ): number {
+    throw new Error('Method not implemented.');
+  }
+  toggleProperty(keyName: ExtractPropertyNamesOfType<this, boolean | undefined>): boolean {
+    throw new Error('Method not implemented.');
+  }
+  cacheFor<K extends keyof this>(key: K): this[K] | undefined {
+    throw new Error('Method not implemented.');
+  }
+}
+const o = new DemoObservable();
+
+/**
+ * get
+ */
+expectTypeOf(o.get('foo')).toBeString();
+expectTypeOf(o.get('bar')).toEqualTypeOf<[boolean, boolean]>();
+expectTypeOf(o.get('baz')).toEqualTypeOf<number | undefined>();
+
+/**
+ * incrementProperty, decrementProperty
+ */
+expectTypeOf(o.incrementProperty('baz')).toBeNumber();
+expectTypeOf(o.decrementProperty('baz')).toBeNumber();
+expectTypeOf(o.incrementProperty('baz', 3)).toBeNumber();
+expectTypeOf(o.decrementProperty('baz', 12)).toBeNumber();
+// non-numeric property case
+// @ts-expect-error
+o.incrementProperty('bar');
+// @ts-expect-error
+o.decrementProperty('bar');
+// empty case
+// @ts-expect-error
+o.incrementProperty();
+// @ts-expect-error
+o.decrementProperty();
+
+/**
+ * toggleProperty
+ */
+expectTypeOf(o.toggleProperty('isFoo')).toBeBoolean();
+// @ts-expect-error
+o.toggleProperty();
+
+/**
+ * getProperties
+ */
+// ('foo', 'bar')
+expectTypeOf(o.getProperties('foo', 'bar')).toEqualTypeOf<{
+  foo: string;
+  bar: [boolean, boolean];
+}>();
+// ['foo', 'bar']
+expectTypeOf(o.getProperties(['foo', 'bar'])).toEqualTypeOf<{
+  foo: string;
+  bar: [boolean, boolean];
+}>();
+// empty cases
+expectTypeOf(o.getProperties()).toEqualTypeOf<{}>();
+expectTypeOf(o.getProperties([])).toEqualTypeOf<{}>();
+// property that doesn't exist
+// @ts-expect-error
+o.getProperties('jeanShorts', 'foo');
+// @ts-expect-error
+o.getProperties(['foo', 'jeanShorts']);
+
+/**
+ * set
+ */
+expectTypeOf(o.set('foo', 'abc')).toBeString();
+expectTypeOf(o.set('bar', [false, false])).toEqualTypeOf<[boolean, boolean]>();
+expectTypeOf(o.set('baz', undefined)).toEqualTypeOf<number | undefined>();
+expectTypeOf(o.set('baz', 10)).toEqualTypeOf<number | undefined>();
+// property that doesn't exist
+// @ts-expect-error
+o.set('jeanShorts', 10);
+
+/**
+ * setProperties
+ */
+expectTypeOf(o.setProperties({ foo: 'abc', bar: [true, true] })).toEqualTypeOf<{
+  foo: string;
+  bar: [boolean, boolean];
+}>();
+// empty case
+expectTypeOf(o.setProperties({})).toEqualTypeOf<{}>();
+// property that doesn't exist
+// @ts-expect-error
+o.setProperties({ jeanShorts: 'under the pants' });
+
+/**
+ * notifyPropertyChange
+ */
+expectTypeOf(o.notifyPropertyChange('foo')).toEqualTypeOf<DemoObservable>();
+expectTypeOf(o.notifyPropertyChange('jeanShorts')).not.toMatchTypeOf<Observable>();
diff --git a/type-tests/preview/ember/reopen.ts b/type-tests/preview/ember/reopen.ts
new file mode 100755
index 00000000000..a4cf4673dcf
--- /dev/null
+++ b/type-tests/preview/ember/reopen.ts
@@ -0,0 +1,78 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+class Person extends Ember.Object {
+  name = '';
+
+  sayHello() {
+    alert(`Hello. My name is ${this.get('name')}`);
+  }
+}
+
+expectTypeOf(Person.reopen()).toMatchTypeOf<typeof Person>();
+
+expectTypeOf(Person.create().name).toEqualTypeOf<string>();
+expectTypeOf(Person.create().sayHello()).toBeVoid();
+
+// Here, a basic check that `reopenClass` *works*, but we intentionally do not
+// provide types for how it changes the original class (as spec'd in RFC 0800).
+const Person2 = Person.reopenClass({
+  species: 'Homo sapiens',
+
+  createPerson(name: string): Person {
+    return Person.create({ name });
+  },
+});
+
+// The original class types are carried along
+expectTypeOf(Person2.create().name).toEqualTypeOf<string>();
+expectTypeOf(Person2.create().sayHello()).toBeVoid();
+// But we aren't trying to merge in new classes anymore.
+// @ts-expect-error
+Person2.species;
+
+const tom = Person2.create({
+  name: 'Tom Dale',
+});
+
+// @ts-expect-error
+const badTom = Person2.create({ name: 99 });
+
+// @ts-expect-error
+const yehuda = Person2.createPerson('Yehuda Katz');
+
+tom.sayHello(); // "Hello. My name is Tom Dale"
+yehuda.sayHello(); // "Hello. My name is Yehuda Katz"
+// @ts-expect-error
+alert(Person2.species); // "Homo sapiens"
+
+// The same goes for `.reopen()`: it will "work" in a bare minimum sense, but it
+// will not try to change the types.
+const Person3 = Person2.reopen({
+  goodbyeMessage: 'goodbye',
+
+  sayGoodbye(this: Person) {
+    alert(`${this.get('goodbyeMessage')}, ${this.get('name')}`);
+  },
+});
+
+const person3 = Person3.create();
+person3.get('name');
+person3.get('goodbyeMessage');
+person3.sayHello();
+// @ts-expect-error
+person3.sayGoodbye();
+
+interface AutoResizeMixin {
+  resizable: true;
+}
+const AutoResizeMixin = Ember.Mixin.create({ resizable: true });
+
+// And the same here.
+const Reopened = Ember.Object.reopenClass({ a: 1 }, { b: 2 }, { c: 3 });
+// @ts-expect-error
+Reopened.a;
+// @ts-expect-error
+Reopened.b;
+// @ts-expect-error
+Reopened.c;
diff --git a/type-tests/preview/ember/route.ts b/type-tests/preview/ember/route.ts
new file mode 100755
index 00000000000..e532cfbbc05
--- /dev/null
+++ b/type-tests/preview/ember/route.ts
@@ -0,0 +1,86 @@
+import Route from '@ember/routing/route';
+import Array from '@ember/array';
+import Ember from 'ember'; // currently needed for Transition
+import Transition from '@ember/routing/transition';
+
+// Ensure that Ember.Transition is private
+// @ts-expect-error
+Ember.Transition;
+
+interface Post extends Ember.Object {
+  title: string;
+}
+
+interface Posts extends Array<Post> {}
+
+class Test extends Route {
+  queryParams = {
+    memberQp: { refreshModel: true },
+  };
+
+  beforeModel(transition: Transition) {
+    this.transitionTo('someOtherRoute');
+  }
+
+  model() {
+    return this.modelFor('post');
+  }
+
+  afterModel(posts: Posts, transition: Transition) {
+    if (posts.firstObject) {
+      this.transitionTo('post.show', posts.firstObject);
+    }
+  }
+
+  setupController(controller: Ember.Controller, model: {}) {
+    this._super(controller, model);
+    this.controllerFor('application').set('model', model);
+  }
+
+  resetController(controller: Ember.Controller, isExiting: boolean, transition: Transition) {
+    if (isExiting) {
+      //   controller.set('page', 1);
+    }
+  }
+
+  intermediateTransitionWithoutModel() {
+    this.intermediateTransitionTo('some-route');
+  }
+  intermediateTransitionWithModel() {
+    this.intermediateTransitionTo('some.other.route', {});
+  }
+  intermediateTransitionWithMultiModel() {
+    this.intermediateTransitionTo('some.other.route', 1, 2, {});
+  }
+}
+
+class ReturningPromises extends Route {
+  beforeModel() {
+    return Promise.resolve('beforeModel can return promises');
+  }
+  afterModel(resolvedModel: unknown, transition: Transition) {
+    return Promise.resolve('afterModel can also return promises');
+  }
+}
+
+class WithNonReturningBeforeAndModelHooks extends Route {
+  beforeModel(transition: Transition): void | Promise<unknown> {
+    return;
+  }
+
+  afterModel(resolvedModel: unknown, transition: Transition): void {
+    return;
+  }
+}
+
+class WithBadReturningBeforeAndModelHooks extends Route {
+  beforeModel(transition: Transition): void | Promise<unknown> {
+    // @ts-expect-error
+    return "returning anything else is nonsensical (if 'legal')";
+  }
+
+  afterModel(resolvedModel: unknown, transition: Transition): void {
+    // @ts-expect-error
+    return "returning anything else is nonsensical (if 'legal')";
+  }
+}
diff --git a/type-tests/preview/ember/router.ts b/type-tests/preview/ember/router.ts
new file mode 100755
index 00000000000..2519b2af204
--- /dev/null
+++ b/type-tests/preview/ember/router.ts
@@ -0,0 +1,52 @@
+import RouterService from '@ember/routing/router-service';
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+const AppRouter = Ember.Router.extend({});
+
+AppRouter.map(function () {
+  this.route('index', { path: '/' });
+  this.route('about');
+  this.route('favorites', { path: '/favs' });
+  this.route('posts', function () {
+    this.route('index', { path: '/' });
+    this.route('new');
+    this.route('post', { path: '/post/:post_id', resetNamespace: true });
+    this.route('comments', { resetNamespace: true }, function () {
+      this.route('new');
+    });
+  });
+  this.route('photo', { path: '/photo/:id' }, function () {
+    this.route('comment', { path: '/comment/:id' });
+  });
+  this.route('not-found', { path: '/*path' });
+  this.mount('my-engine');
+  this.mount('my-engine', { as: 'some-other-engine', path: '/some-other-engine' });
+});
+
+class RouterServiceConsumer extends Ember.Service {
+  @Ember.inject.service('router')
+  declare router: RouterService;
+
+  currentRouteName() {
+    expectTypeOf(Ember.get(this, 'router').currentRouteName).toEqualTypeOf<string>();
+  }
+  currentURL() {
+    expectTypeOf(Ember.get(this, 'router').currentURL).toEqualTypeOf<string>();
+  }
+  transitionWithoutModel() {
+    Ember.get(this, 'router').transitionTo('some-route');
+  }
+  transitionWithModel() {
+    const model = Ember.Object.create();
+    Ember.get(this, 'router').transitionTo('some.other.route', model);
+  }
+  transitionWithMultiModel() {
+    const model = Ember.Object.create();
+    Ember.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' } });
+  }
+}
diff --git a/type-tests/preview/ember/run.ts b/type-tests/preview/ember/run.ts
new file mode 100755
index 00000000000..9a6d829a2a1
--- /dev/null
+++ b/type-tests/preview/ember/run.ts
@@ -0,0 +1,215 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+import RSVP from 'rsvp';
+
+function testRun() {
+  const r = Ember.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 () {
+      this.destroy();
+    });
+  }
+}
+
+class TestBind extends Ember.Component {
+  init() {
+    const bound = Ember.run.bind(this, this.setupEditor);
+    bound();
+  }
+
+  editor: string | null = null;
+
+  setupEditor(editor: string) {
+    this.set('editor', editor);
+  }
+}
+
+function testCancel() {
+  const myContext = {};
+
+  const runNext = Ember.run.next(myContext, () => {
+    // will not be executed
+  });
+
+  Ember.run.cancel(runNext);
+
+  const runLater = Ember.run.later(
+    myContext,
+    () => {
+      // will not be executed
+    },
+    500
+  );
+
+  Ember.run.cancel(runLater);
+
+  const runScheduleOnce = Ember.run.scheduleOnce('afterRender', myContext, () => {
+    // will not be executed
+  });
+
+  Ember.run.cancel(runScheduleOnce);
+
+  const runOnce = Ember.run.once(myContext, () => {
+    // will not be executed
+  });
+
+  Ember.run.cancel(runOnce);
+
+  const throttle = Ember.run.throttle(
+    myContext,
+    () => {
+      // will not be executed
+    },
+    1,
+    false
+  );
+
+  Ember.run.cancel(throttle);
+
+  const debounce = Ember.run.debounce(
+    myContext,
+    () => {
+      // will not be executed
+    },
+    1
+  );
+
+  Ember.run.cancel(debounce);
+
+  const debounceImmediate = Ember.run.debounce(
+    myContext,
+    () => {
+      // will be executed since we passed in true (immediate)
+    },
+    100,
+    true
+  );
+
+  // the 100ms delay until this method can be called again will be canceled
+  Ember.run.cancel(debounceImmediate);
+}
+
+function testDebounce() {
+  function runIt() {}
+
+  const myContext = { name: 'debounce' };
+
+  Ember.run.debounce(runIt, 150);
+  Ember.run.debounce(myContext, runIt, 150);
+  Ember.run.debounce(myContext, runIt, 150, true);
+
+  class TestDebounce extends Ember.Component {
+    searchValue = 'test';
+    declare fetchResults: (value: string) => void;
+
+    handleTyping() {
+      // the fetchResults function is passed into the component from its parent
+      Ember.run.debounce(this, this.fetchResults, this.get('searchValue'), 250);
+    }
+  }
+}
+
+function testBegin() {
+  Ember.run.begin();
+  // code to be executed within a RunLoop
+  Ember.run.end();
+}
+
+function testJoin() {
+  Ember.run.join(() => {
+    // creates a new run-loop
+  });
+
+  Ember.run(() => {
+    // creates a new run-loop
+    Ember.run.join(() => {
+      // joins with the existing run-loop, and queues for invocation on
+      // the existing run-loops action queue.
+    });
+  });
+
+  new RSVP.Promise((resolve) => {
+    Ember.run.later(() => {
+      resolve({ msg: 'Hold Your Horses' });
+    }, 3000);
+  });
+}
+
+function testLater() {
+  const myContext = {};
+  Ember.run.later(
+    myContext,
+    () => {
+      // code here will execute within a RunLoop in about 500ms with this == myContext
+    },
+    500
+  );
+}
+
+function testNext() {
+  const myContext = {};
+  Ember.run.next(myContext, () => {
+    // code to be executed in the next run loop,
+    // which will be scheduled after the current one
+  });
+}
+
+class TestOnce extends Ember.Object {
+  init() {
+    Ember.run.once(this as TestOnce, 'processFullName');
+    Ember.run.once(this, this.processFullName);
+  }
+
+  processFullName() {}
+}
+
+{
+  class TestSchedule {
+    init() {
+      Ember.run.schedule('sync', this, () => {
+        // this will be executed in the first RunLoop queue, when bindings are synced
+        console.log('scheduled on sync queue');
+      });
+
+      Ember.run.schedule('actions', this, () => {
+        // this will be executed in the 'actions' queue, after bindings have synced.
+        console.log('scheduled on actions queue');
+      });
+    }
+  }
+
+  Ember.run.schedule('actions', () => {
+    // Do more things
+  });
+}
+
+function testScheduleOnce() {
+  function sayHi() {
+    console.log('hi');
+  }
+
+  const myContext = {};
+  Ember.run(() => {
+    Ember.run.scheduleOnce('afterRender', myContext, sayHi);
+    Ember.run.scheduleOnce('afterRender', myContext, sayHi);
+    // sayHi will only be executed once, in the afterRender queue of the RunLoop
+  });
+  Ember.run.scheduleOnce('actions', myContext, () => {
+    console.log('Closure');
+  });
+}
+
+function testThrottle() {
+  function runIt() {}
+
+  const myContext = { name: 'throttle' };
+
+  Ember.run.throttle(runIt, 150);
+  Ember.run.throttle(myContext, runIt, 150);
+}
diff --git a/type-tests/preview/ember/string.ts b/type-tests/preview/ember/string.ts
new file mode 100644
index 00000000000..5770a3a469a
--- /dev/null
+++ b/type-tests/preview/ember/string.ts
@@ -0,0 +1,52 @@
+import Ember from 'ember';
+import { SafeString } from '@ember/template/-private/handlebars';
+import { expectTypeOf } from 'expect-type';
+
+const { dasherize, camelize, capitalize, classify, decamelize, htmlSafe, underscore, w } =
+  Ember.String;
+
+// @ts-expect-error
+dasherize();
+expectTypeOf(dasherize('blue man group')).toEqualTypeOf<string>();
+// @ts-expect-error
+dasherize('', '');
+
+// @ts-expect-error
+camelize();
+expectTypeOf(camelize('blue man group')).toEqualTypeOf<string>();
+// @ts-expect-error
+camelize('', '');
+
+// @ts-expect-error
+decamelize();
+expectTypeOf(decamelize('blue man group')).toEqualTypeOf<string>();
+// @ts-expect-error
+decamelize('', '');
+
+// @ts-expect-error
+underscore();
+expectTypeOf(underscore('blue man group')).toEqualTypeOf<string>();
+// @ts-expect-error
+underscore('', '');
+
+// @ts-expect-error
+w();
+expectTypeOf(w('blue man group')).toEqualTypeOf<string[]>();
+// @ts-expect-error
+w('', '');
+
+// @ts-expect-error
+classify();
+expectTypeOf(classify('blue man group')).toEqualTypeOf<string>();
+// @ts-expect-error
+classify('', '');
+
+// @ts-expect-error
+capitalize();
+expectTypeOf(capitalize('blue man group')).toEqualTypeOf<string>();
+// @ts-expect-error
+capitalize('', '');
+
+const handlebarsSafeString = htmlSafe('lorem ipsum...');
+expectTypeOf(handlebarsSafeString).toEqualTypeOf<SafeString>();
+expectTypeOf(handlebarsSafeString).not.toEqualTypeOf<string>();
diff --git a/type-tests/preview/ember/techniques/properties-from-this.ts b/type-tests/preview/ember/techniques/properties-from-this.ts
new file mode 100644
index 00000000000..1c3b78a9f83
--- /dev/null
+++ b/type-tests/preview/ember/techniques/properties-from-this.ts
@@ -0,0 +1,73 @@
+/**
+ * These tests validate that the method of pulling property types off of this
+ * continues to work. We use this technique in the critical Observable interface
+ * that serves to implement a lot of Ember.CoreObject's functionality
+ */
+
+import { expectTypeOf } from 'expect-type';
+
+class BoxedProperty<Get, Set = Get> {
+  private declare [GetType]: Get;
+  private declare [SetType]: Set;
+}
+
+declare const GetType: unique symbol;
+declare const SetType: unique symbol;
+
+type UnboxGetProperty<T> = T extends BoxedProperty<infer V, unknown> ? V : T;
+type UnboxSetProperty<T> = T extends BoxedProperty<unknown, infer V> ? V : T;
+
+class GetAndSet {
+  get<K extends keyof this>(key: K): UnboxGetProperty<this[K]> {
+    return this[key] as UnboxGetProperty<this[K]>;
+  }
+  set<K extends keyof this>(key: K, newVal: UnboxSetProperty<this[K]>): UnboxSetProperty<this[K]> {
+    const rawVal = this[key];
+    if (rawVal instanceof BoxedProperty) {
+      rawVal[SetType] = newVal;
+    }
+    this[key] = newVal as this[K];
+    return newVal;
+  }
+}
+
+class Foo123 extends GetAndSet {
+  a: number;
+  b: [boolean, boolean];
+  c: string;
+  cpA!: BoxedProperty<string>;
+  constructor() {
+    super();
+    this.a = 1;
+    this.b = [true, false];
+    this.c = 'hello';
+  }
+}
+
+let f = new Foo123();
+
+expectTypeOf(f.get('a')).toEqualTypeOf<number>();
+// @ts-expect-error
+f.set('a');
+// @ts-expect-error
+f.set('a', '1');
+expectTypeOf(f.set('a', 1)).toEqualTypeOf<number>();
+
+expectTypeOf(f.get('b')).toEqualTypeOf<[boolean, boolean]>();
+// @ts-expect-error
+f.set('b', 1);
+// @ts-expect-error
+f.set('b', []);
+// @ts-expect-error
+f.set('b', [true]);
+expectTypeOf(f.set('b', [false, true])).toEqualTypeOf<[boolean, boolean]>();
+// @ts-expect-error
+f.set('b', [false, true, false]);
+
+expectTypeOf(f.get('c')).toEqualTypeOf<string>();
+expectTypeOf(f.set('c', '1')).toEqualTypeOf<string>();
+
+expectTypeOf(f.get('cpA')).toEqualTypeOf<string>();
+// @ts-expect-error
+f.set('cpA', ['newValue']);
+expectTypeOf(f.set('cpA', 'newValue')).toEqualTypeOf<string>();
diff --git a/type-tests/preview/ember/test.ts b/type-tests/preview/ember/test.ts
new file mode 100755
index 00000000000..f91b8c54f09
--- /dev/null
+++ b/type-tests/preview/ember/test.ts
@@ -0,0 +1,32 @@
+import Ember from 'ember';
+
+const pending = 0;
+Ember.Test.registerWaiter(() => pending !== 0);
+
+declare const MyDb: {
+  hasPendingTransactions(): boolean;
+};
+Ember.Test.registerWaiter(MyDb, MyDb.hasPendingTransactions);
+
+Ember.Test.promise((resolve) => {
+  window.setTimeout(resolve, 500);
+});
+
+Ember.Test.registerHelper('boot', (app) => {
+  Ember.run(app, app.advanceReadiness);
+});
+
+Ember.Test.registerAsyncHelper('boot', (app) => {
+  Ember.run(app, app.advanceReadiness);
+});
+
+Ember.Test.registerAsyncHelper('waitForPromise', (app, promise) => {
+  return new Ember.Test.Promise((resolve) => {
+    Ember.Test.adapter.asyncStart();
+
+    promise.then(() => {
+      Ember.run.schedule('afterRender', null, resolve);
+      Ember.Test.adapter.asyncEnd();
+    });
+  });
+});
diff --git a/type-tests/preview/ember/transition.ts b/type-tests/preview/ember/transition.ts
new file mode 100755
index 00000000000..303fe28ecdb
--- /dev/null
+++ b/type-tests/preview/ember/transition.ts
@@ -0,0 +1,5 @@
+import Ember from 'ember';
+import Transition from '@ember/routing/transition';
+import { expectTypeOf } from 'expect-type';
+
+expectTypeOf<Parameters<Ember.Route['beforeModel']>[0]>().toEqualTypeOf<Transition>();
diff --git a/type-tests/preview/ember/utils.ts b/type-tests/preview/ember/utils.ts
new file mode 100755
index 00000000000..5bc51392f0b
--- /dev/null
+++ b/type-tests/preview/ember/utils.ts
@@ -0,0 +1,154 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+function testTypeOf() {
+  expectTypeOf(Ember.typeOf()).toEqualTypeOf<'undefined'>();
+  const str: string = Ember.typeOf({});
+}
+
+function testIsNoneType() {
+  const maybeUndefined: string | undefined = 'not actually undefined';
+  if (Ember.isNone(maybeUndefined)) {
+    return;
+  }
+
+  const anotherString = maybeUndefined + 'another string';
+  expectTypeOf(Ember.isNone()).toBeBoolean();
+}
+
+function testIsBlank() {
+  expectTypeOf(Ember.isBlank()).toBeBoolean();
+  expectTypeOf(Ember.isBlank('')).toBeBoolean();
+  // @ts-expect-error
+  Ember.isBlank('', '');
+}
+
+function testIsEmpty() {
+  expectTypeOf(Ember.isEmpty()).toBeBoolean();
+  expectTypeOf(Ember.isEmpty('')).toBeBoolean();
+  // @ts-expect-error
+  Ember.isEmpty('', '');
+}
+
+function testIsPresent() {
+  expectTypeOf(Ember.isPresent()).toBeBoolean();
+  expectTypeOf(Ember.isPresent('')).toBeBoolean();
+  // @ts-expect-error
+  Ember.isPresent('', '');
+}
+
+function testIsNone() {
+  expectTypeOf(Ember.isNone()).toBeBoolean();
+  expectTypeOf(Ember.isNone('')).toBeBoolean();
+  // @ts-expect-error
+  Ember.isNone('', '');
+}
+
+function testAssign() {
+  expectTypeOf(Ember.assign({ first: 'Tom' }, { middle: 'M' }, { last: 'Dale' })).toEqualTypeOf<{
+    first: string;
+    middle: string;
+    last: string;
+  }>();
+}
+
+function testOnError() {
+  Ember.onerror = (error) => {
+    fetch('/report-error', {
+      method: 'POST',
+      body: JSON.stringify({
+        stack: error.stack,
+        otherInformation: 'whatever app state you want to provide',
+      }),
+    });
+  };
+}
+
+function testDeprecateFunc() {
+  function newMethod(first: string, second: number): string {
+    return '';
+  }
+
+  const oldMethod = Ember.deprecateFunc(
+    'Please use the new method',
+    { id: 'deprecated.id', until: '6.0' },
+    newMethod
+  );
+  expectTypeOf(newMethod('first', 123)).toEqualTypeOf<string>();
+  expectTypeOf(oldMethod('first', 123)).toEqualTypeOf<string>();
+}
+
+function testDefineProperty() {
+  type Contact = { firstName?: string; lastName?: string };
+  const contact: Contact = {};
+
+  // ES5 compatible mode
+  Ember.defineProperty(contact, 'firstName', {
+    writable: true,
+    configurable: false,
+    enumerable: true,
+    value: 'Charles',
+  });
+
+  // define a simple property
+  Ember.defineProperty(contact, 'lastName', undefined, 'Jolley');
+
+  // define a computed property
+  Ember.defineProperty(
+    contact,
+    'fullName',
+    Ember.computed('firstName', 'lastName', function (this: Contact) {
+      return `${this.firstName} ${this.lastName}`;
+    })
+  );
+}
+
+// For use in IIFE below.
+declare const fileList: FileList;
+
+(() => {
+  /** typeOf */
+  expectTypeOf(Ember.typeOf()).toEqualTypeOf<'undefined'>();
+  expectTypeOf(Ember.typeOf(null)).toEqualTypeOf<'null'>();
+  expectTypeOf(Ember.typeOf(undefined)).toEqualTypeOf<'undefined'>();
+  expectTypeOf(Ember.typeOf('michael')).toEqualTypeOf<'string'>();
+  expectTypeOf(Ember.typeOf(new String('michael'))).toEqualTypeOf<'string'>();
+  expectTypeOf(Ember.typeOf(101)).toEqualTypeOf<'number'>();
+  expectTypeOf(Ember.typeOf(new Number(101))).toEqualTypeOf<'number'>();
+  expectTypeOf(Ember.typeOf(true)).toEqualTypeOf<'boolean'>();
+  expectTypeOf(Ember.typeOf(new Boolean(true))).toEqualTypeOf<'boolean'>();
+  expectTypeOf(Ember.typeOf(() => 4)).toEqualTypeOf<'function'>();
+  // @ts-ignore -- this *should* work but the namespace version is not carrying
+  // it through correctly. However, people can *and should* simply use the
+  // module import instead!
+  expectTypeOf(Ember.typeOf([1, 2, 90])).toEqualTypeOf<'array'>();
+  expectTypeOf(Ember.typeOf(/abc/)).toEqualTypeOf<'regexp'>();
+  expectTypeOf(Ember.typeOf(new Date())).toEqualTypeOf<'date'>();
+  expectTypeOf(Ember.typeOf(fileList)).toEqualTypeOf<'filelist'>();
+  expectTypeOf(Ember.typeOf(Ember.Object.extend())).toEqualTypeOf<'class'>();
+  // @ts-ignore -- this *should* work but the namespace version is not carrying
+  // it through correctly. However, people can *and should* simply use the
+  // module import instead!
+  expectTypeOf(Ember.typeOf(Ember.Object.create())).toEqualTypeOf<'instance'>();
+  expectTypeOf(Ember.typeOf(new Error('teamocil'))).toEqualTypeOf<'error'>();
+  expectTypeOf(Ember.typeOf(new Date() as RegExp | Date)).toEqualTypeOf<'regexp' | 'date'>();
+  expectTypeOf(Ember.typeOf({ randomObject: true })).toEqualTypeOf<'object'>();
+})();
+
+(() => {
+  /* assign */
+  Ember.assign({}, { a: 'b' });
+  expectTypeOf(Ember.assign({}, { a: 'b' }).a).toBeString();
+  expectTypeOf(Ember.assign({ a: 6 }, { a: 'b' }).a).toBeString();
+  expectTypeOf(Ember.assign({ a: 6 }, {}).a).toBeNumber();
+  // @ts-expect-error
+  Ember.assign({ b: 6 }, {}).a;
+  expectTypeOf(Ember.assign({}, { b: 6 }, {}).b).toBeNumber();
+  expectTypeOf(Ember.assign({ a: 'hello' }, { b: 6 }, {}).a).toBeString();
+  expectTypeOf(Ember.assign({ a: 'hello' }, { b: 6 }, { a: true }).a).toBeBoolean();
+  // @ts-expect-error
+  Ember.assign({ a: 'hello' }, '', { a: true }).a;
+  expectTypeOf(
+    Ember.assign({ d: ['gobias industries'] }, { a: 'hello' }, { b: 6 }, { a: true }).d
+  ).toEqualTypeOf<string[]>();
+})();
diff --git a/type-tests/preview/ember/view-utils.ts b/type-tests/preview/ember/view-utils.ts
new file mode 100644
index 00000000000..d032ede90dc
--- /dev/null
+++ b/type-tests/preview/ember/view-utils.ts
@@ -0,0 +1,7 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+const {
+  ViewUtils: { isSimpleClick },
+} = Ember;
+expectTypeOf(isSimpleClick(new Event('wat'))).toBeBoolean();
diff --git a/type-tests/preview/index.d.ts b/type-tests/preview/index.d.ts
new file mode 100644
index 00000000000..6b492f831fb
--- /dev/null
+++ b/type-tests/preview/index.d.ts
@@ -0,0 +1 @@
+import '../../types/preview';
diff --git a/type-tests/preview/tsconfig.json b/type-tests/preview/tsconfig.json
new file mode 100644
index 00000000000..a205f6579ab
--- /dev/null
+++ b/type-tests/preview/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "@tsconfig/ember/tsconfig.json",
+}
diff --git a/types/preview/@ember/-internals/resolver.d.ts b/types/preview/@ember/-internals/resolver.d.ts
new file mode 100644
index 00000000000..9bb05c01fce
--- /dev/null
+++ b/types/preview/@ember/-internals/resolver.d.ts
@@ -0,0 +1,35 @@
+declare module '@ember/-internals/resolver' {
+  /**
+   * @module
+   * @private This is not a public API module, and in fact ***there is no such
+   *   module at runtime***. This module exists only to provide a public API for
+   *   `Resolver`, which will get a dedicated home as part of Ember's public API
+   *   via a future RFC. As an end user, if you need access to `Resolver` for now
+   *   you should ordinarily get it via `ember-resolver`.
+   */
+
+  import EmberObject from '@ember/object';
+  import type { Factory, FullName } from '@ember/owner';
+
+  export type KnownForTypeResult<Type extends string> = {
+    [fullName in `${Type}:${string}`]: boolean | undefined;
+  };
+
+  /**
+   * A `Resolver` is the mechanism responsible for looking up code in your
+   * application and converting its naming conventions into the actual classes,
+   * functions, and templates that Ember needs to resolve its dependencies, for
+   * example, what template to render for a given route. It is a system that helps
+   * the app resolve the lookup of JavaScript modules agnostic of what kind of
+   * module system is used, which can be AMD, CommonJS or just plain globals. It
+   * is used to lookup routes, models, components, templates, or anything that is
+   * used in your Ember app.
+   */
+  export interface Resolver extends EmberObject {
+    knownForType?: <TypeName extends string>(type: TypeName) => KnownForTypeResult<TypeName>;
+    lookupDescription?: (fullName: FullName) => string;
+    makeToString?: (factory: Factory<object>, fullName: FullName) => string;
+    normalize?: (fullName: FullName) => string;
+    resolve(name: string): Factory<object> | object | undefined;
+  }
+}
diff --git a/types/preview/@ember/application/-private/event-dispatcher.d.ts b/types/preview/@ember/application/-private/event-dispatcher.d.ts
new file mode 100644
index 00000000000..f88ebe85a7c
--- /dev/null
+++ b/types/preview/@ember/application/-private/event-dispatcher.d.ts
@@ -0,0 +1,18 @@
+declare module '@ember/application/-private/event-dispatcher' {
+  import { EventDispatcherEvents } from '@ember/application/types';
+
+  /**
+   * `Ember.EventDispatcher` handles delegating browser events to their
+   * corresponding `Ember.Views.` For example, when you click on a view,
+   * `Ember.EventDispatcher` ensures that that view's `mouseDown` method gets
+   * called.
+   */
+  export default class EventDispatcher extends Object {
+    /**
+     * The set of events names (and associated handler function names) to be setup
+     * and dispatched by the `EventDispatcher`. Modifications to this list can be done
+     * at setup time, generally via the `Ember.Application.customEvents` hash.
+     */
+    events: EventDispatcherEvents;
+  }
+}
diff --git a/types/preview/@ember/application/-private/registry.d.ts b/types/preview/@ember/application/-private/registry.d.ts
new file mode 100644
index 00000000000..1af8dff3ef8
--- /dev/null
+++ b/types/preview/@ember/application/-private/registry.d.ts
@@ -0,0 +1,15 @@
+declare module '@ember/application/-private/registry' {
+  import { EmberClassConstructor } from '@ember/object/-private/types';
+
+  /**
+   * A registry used to store factory and option information keyed
+   * by type.
+   */
+  export default class Registry {
+    register(
+      fullName: string,
+      factory: EmberClassConstructor<unknown>,
+      options?: { singleton?: boolean | undefined }
+    ): void;
+  }
+}
diff --git a/types/preview/@ember/application/deprecations.d.ts b/types/preview/@ember/application/deprecations.d.ts
new file mode 100644
index 00000000000..272cdbfc726
--- /dev/null
+++ b/types/preview/@ember/application/deprecations.d.ts
@@ -0,0 +1,24 @@
+declare module '@ember/application/deprecations' {
+  import { AnyFn } from 'ember/-private/type-utils';
+
+  interface DeprecationOptions {
+    id: string;
+    until: string;
+    url?: string | undefined;
+  }
+
+  /**
+   * Display a deprecation warning with the provided message and a stack trace
+   * (Chrome and Firefox only).
+   */
+  export function deprecate(message: string, test: boolean, options: DeprecationOptions): void;
+
+  /**
+   * Alias an old, deprecated method with its new counterpart.
+   */
+  export function deprecateFunc<Func extends AnyFn>(
+    message: string,
+    options: DeprecationOptions,
+    func: Func
+  ): Func;
+}
diff --git a/types/preview/@ember/application/index.d.ts b/types/preview/@ember/application/index.d.ts
new file mode 100644
index 00000000000..d4d9cd8c09b
--- /dev/null
+++ b/types/preview/@ember/application/index.d.ts
@@ -0,0 +1,153 @@
+declare module '@ember/application' {
+  import Engine from '@ember/engine';
+  import ApplicationInstance from '@ember/application/instance';
+  import EventDispatcher from '@ember/application/-private/event-dispatcher';
+  import { EventDispatcherEvents } from '@ember/application/types';
+  import { Router } from '@ember/routing';
+  import Registry from '@ember/application/-private/registry';
+  import type { Resolver } from '@ember/-internals/resolver';
+  import { AnyFn } from 'ember/-private/type-utils';
+  import Owner from '@ember/owner';
+  import type GlimmerComponent from '@glimmer/component';
+  import EmberObject from '@ember/object';
+
+  // Shut off default exporting; we don't want anything but the *intended*
+  // public API present.
+  export {};
+
+  /**
+   * An instance of Ember.Application is the starting point for every Ember application. It helps to
+   * instantiate, initialize and coordinate the many objects that make up your app.
+   */
+  export default class Application extends Engine {
+    /**
+     * Call advanceReadiness after any asynchronous setup logic has completed.
+     * Each call to deferReadiness must be matched by a call to advanceReadiness
+     * or the application will never become ready and routing will not begin.
+     */
+    advanceReadiness(): void;
+    /**
+     * Use this to defer readiness until some condition is true.
+     *
+     * This allows you to perform asynchronous setup logic and defer
+     * booting your application until the setup has finished.
+     *
+     * However, if the setup requires a loading UI, it might be better
+     * to use the router for this purpose.
+     */
+    deferReadiness(): void;
+    /**
+     * defines an injection or typeInjection
+     */
+    inject(factoryNameOrType: string, property: string, injectionName: string): void;
+    /**
+     * This injects the test helpers into the window's scope. If a function of the
+     * same name has already been defined it will be cached (so that it can be reset
+     * if the helper is removed with `unregisterHelper` or `removeTestHelpers`).
+     * Any callbacks registered with `onInjectHelpers` will be called once the
+     * helpers have been injected.
+     */
+    injectTestHelpers(): void;
+    /**
+     * registers a factory for later injection
+     * @param fullName type:name (e.g., 'model:user')
+     * @param factory (e.g., App.Person)
+     */
+    register(
+      fullName: string,
+      factory: unknown,
+      options?: { singleton?: boolean | undefined; instantiate?: boolean | undefined }
+    ): void;
+    /**
+     * This removes all helpers that have been registered, and resets and functions
+     * that were overridden by the helpers.
+     */
+    removeTestHelpers(): void;
+    /**
+     * Reset the application. This is typically used only in tests.
+     */
+    reset(): void;
+    /**
+     * This hook defers the readiness of the application, so that you can start
+     * the app when your tests are ready to run. It also sets the router's
+     * location to 'none', so that the window's location will not be modified
+     * (preventing both accidental leaking of state between tests and interference
+     * with your testing framework).
+     */
+    setupForTesting(): void;
+    /**
+     * The DOM events for which the event dispatcher should listen.
+     */
+    customEvents: EventDispatcherEvents;
+    /**
+     * The Ember.EventDispatcher responsible for delegating events to this application's views.
+     */
+    eventDispatcher: EventDispatcher;
+    /**
+     * Set this to provide an alternate class to `DefaultResolver`
+     */
+    resolver: Resolver | null;
+    /**
+     * The root DOM element of the Application. This can be specified as an
+     * element or a jQuery-compatible selector string.
+     *
+     * This is the element that will be passed to the Application's, eventDispatcher,
+     * which sets up the listeners for event delegation. Every view in your application
+     * should be a child of the element you specify here.
+     */
+    rootElement: HTMLElement | string;
+    /**
+     * Called when the Application has become ready.
+     * The call will be delayed until the DOM has become ready.
+     */
+    ready: AnyFn;
+    /**
+     * Application's router.
+     */
+    Router: Router;
+    registry: Registry;
+    /**
+     *  Initialize the application and return a promise that resolves with the `Application`
+     *  object when the boot process is complete.
+     */
+    boot(): Promise<Application>;
+    /**
+     * Create an ApplicationInstance for this Application.
+     */
+    buildInstance(options?: object): ApplicationInstance;
+  }
+
+  // Known framework objects, so that `getOwner` can always, accurately, return
+  // `Owner` when working with one of these classes, which the framework *does*
+  // guarantee will always have an `Owner`. NOTE: this must be kept up to date
+  // whenever we add new base classes to the framework. For example, if we
+  // introduce a standalone `Service` or `Route` base class which *does not*
+  // extend from `EmberObject`, it will need to be added here.
+  type FrameworkObject = EmberObject | GlimmerComponent;
+
+  /**
+   * Framework objects in an Ember application (components, services, routes, etc.)
+   * are created via a factory and dependency injection system. Each of these
+   * objects is the responsibility of an "owner", which handled its
+   * instantiation and manages its lifetime.
+   */
+  export function getOwner(object: FrameworkObject): Owner;
+  export function getOwner(object: unknown): Owner | undefined;
+  /**
+   * `setOwner` forces a new owner on a given object instance. This is primarily
+   * useful in some testing cases.
+   */
+  export function setOwner(object: unknown, owner: Owner): void;
+
+  /**
+   * Detects when a specific package of Ember (e.g. 'Ember.Application')
+   * has fully loaded and is available for extension.
+   */
+  export function onLoad(name: string, callback: AnyFn): unknown;
+
+  /**
+   * Called when an Ember.js package (e.g Ember.Application) has finished
+   * loading. Triggers any callbacks registered for this event.
+   */
+  export function runLoadHooks(name: string, object?: {}): unknown;
+}
diff --git a/types/preview/@ember/application/instance.d.ts b/types/preview/@ember/application/instance.d.ts
new file mode 100644
index 00000000000..37b60353c6f
--- /dev/null
+++ b/types/preview/@ember/application/instance.d.ts
@@ -0,0 +1,9 @@
+declare module '@ember/application/instance' {
+  import EngineInstance from '@ember/engine/instance';
+
+  /**
+   * The `ApplicationInstance` encapsulates all of the stateful aspects of a
+   * running `Application`.
+   */
+  export default class ApplicationInstance extends EngineInstance {}
+}
diff --git a/types/preview/@ember/application/tsconfig.json b/types/preview/@ember/application/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/application/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/application/types.d.ts b/types/preview/@ember/application/types.d.ts
new file mode 100644
index 00000000000..fa3692e2458
--- /dev/null
+++ b/types/preview/@ember/application/types.d.ts
@@ -0,0 +1,29 @@
+declare module '@ember/application/types' {
+  export interface EventDispatcherEvents {
+    touchstart?: string | null | undefined;
+    touchmove?: string | null | undefined;
+    touchend?: string | null | undefined;
+    touchcancel?: string | null | undefined;
+    keydown?: string | null | undefined;
+    keyup?: string | null | undefined;
+    keypress?: string | null | undefined;
+    mousedown?: string | null | undefined;
+    mouseup?: string | null | undefined;
+    contextmenu?: string | null | undefined;
+    click?: string | null | undefined;
+    dblclick?: string | null | undefined;
+    focusin?: string | null | undefined;
+    focusout?: string | null | undefined;
+    submit?: string | null | undefined;
+    input?: string | null | undefined;
+    change?: string | null | undefined;
+    dragstart?: string | null | undefined;
+    drag?: string | null | undefined;
+    dragenter?: string | null | undefined;
+    dragleave?: string | null | undefined;
+    dragover?: string | null | undefined;
+    drop?: string | null | undefined;
+    dragend?: string | null | undefined;
+    [event: string]: string | null | undefined;
+  }
+}
diff --git a/types/preview/@ember/array/-private/enumerable.d.ts b/types/preview/@ember/array/-private/enumerable.d.ts
new file mode 100644
index 00000000000..36b0120eb94
--- /dev/null
+++ b/types/preview/@ember/array/-private/enumerable.d.ts
@@ -0,0 +1,13 @@
+declare module '@ember/array/-private/enumerable' {
+  import Mixin from '@ember/object/mixin';
+
+  /**
+   * The methods in this mixin have been moved to `MutableArray`. This mixin has
+   * been intentionally preserved to avoid breaking `Enumerable.detect` checks
+   * until the community migrates away from them.
+   */
+  interface Enumerable {}
+
+  const Enumerable: Mixin;
+  export default Enumerable;
+}
diff --git a/types/preview/@ember/array/-private/mutable-enumerable.d.ts b/types/preview/@ember/array/-private/mutable-enumerable.d.ts
new file mode 100644
index 00000000000..d3bc4972cc3
--- /dev/null
+++ b/types/preview/@ember/array/-private/mutable-enumerable.d.ts
@@ -0,0 +1,13 @@
+declare module '@ember/array/-private/mutable-enumerable' {
+  import Mixin from '@ember/object/mixin';
+  import Enumerable from '@ember/array/-private/enumerable';
+
+  /**
+   * This Mixin exists for historical purposes only, and so that someone walking
+   * the types for Ember's arrays sees the same types as those which appear in
+   * the runtime hierarchy.
+   */
+  interface MutableEnumerable extends Enumerable {}
+  const MutableEnumerable: Mixin;
+  export default MutableEnumerable;
+}
diff --git a/types/preview/@ember/array/-private/native-array.d.ts b/types/preview/@ember/array/-private/native-array.d.ts
new file mode 100644
index 00000000000..814eb825abd
--- /dev/null
+++ b/types/preview/@ember/array/-private/native-array.d.ts
@@ -0,0 +1,23 @@
+declare module '@ember/array/-private/native-array' {
+  import Observable from '@ember/object/observable';
+  import MutableArray from '@ember/array/mutable';
+  import Mixin from '@ember/object/mixin';
+
+  // Get an alias to the global Array type to use in inner scope below.
+  type Array<T> = T[];
+
+  /**
+   * The NativeArray mixin contains the properties needed to make the native
+   * Array support Ember.MutableArray and all of its dependent APIs. Unless you
+   * have `EmberENV.EXTEND_PROTOTYPES` or `EmberENV.EXTEND_PROTOTYPES.Array` set to
+   * false, this will be applied automatically. Otherwise you can apply the mixin
+   * at anytime by calling `Ember.NativeArray.apply(Array.prototype)`.
+   */
+  interface NativeArray<T>
+    extends Omit<Array<T>, 'every' | 'filter' | 'find' | 'forEach' | 'map' | 'reduce' | 'slice'>,
+      Observable,
+      MutableArray<T> {}
+
+  const NativeArray: Mixin;
+  export default NativeArray;
+}
diff --git a/types/preview/@ember/array/index.d.ts b/types/preview/@ember/array/index.d.ts
new file mode 100644
index 00000000000..cd149da2d1b
--- /dev/null
+++ b/types/preview/@ember/array/index.d.ts
@@ -0,0 +1,243 @@
+declare module '@ember/array' {
+  import { MethodNamesOf, MethodParams, MethodReturns } from 'ember/-private/type-utils';
+  import Mixin from '@ember/object/mixin';
+  import Enumerable from '@ember/array/-private/enumerable';
+  import NativeArray from '@ember/array/-private/native-array';
+
+  /**
+   * This module implements Observer-friendly Array-like behavior. This mixin is picked up by the
+   * Array class as well as other controllers, etc. that want to appear to be arrays.
+   */
+  interface Array<T> extends Enumerable {
+    /**
+     * __Required.__ You must implement this method to apply this mixin.
+     */
+    length: number;
+    /**
+     * Returns the object at the given `index`. If the given `index` is negative
+     * or is greater or equal than the array length, returns `undefined`.
+     */
+    objectAt(idx: number): T | undefined;
+    /**
+     * This returns the objects at the specified indexes, using `objectAt`.
+     */
+    objectsAt(indexes: number[]): Array<T | undefined>;
+    /**
+     * Helper method returns the first object from a collection. This is usually
+     * used by bindings and other parts of the framework to extract a single
+     * object if the enumerable contains only one item.
+     */
+    firstObject: T | undefined;
+    /**
+     * Helper method returns the last object from a collection. If your enumerable
+     * contains only one object, this method should always return that object.
+     * If your enumerable is empty, this method should return `undefined`.
+     */
+    lastObject: T | undefined;
+    /**
+     * Returns a new array that is a slice of the receiver. This implementation
+     * uses the observable array methods to retrieve the objects for the new
+     * slice.
+     */
+    slice(beginIndex?: number, endIndex?: number): NativeArray<T>;
+    /**
+     * Returns the index of the given object's first occurrence.
+     * If no `startAt` argument is given, the starting location to
+     * search is 0. If it's negative, will count backward from
+     * the end of the array. Returns -1 if no match is found.
+     */
+    indexOf(searchElement: T, fromIndex?: number): number;
+    /**
+     * Returns the index of the given object's last occurrence.
+     * If no `startAt` argument is given, the search starts from
+     * the last position. If it's negative, will count backward
+     * from the end of the array. Returns -1 if no match is found.
+     */
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+    /**
+     * Iterates through the enumerable, calling the passed function on each
+     * item. This method corresponds to the `forEach()` method defined in
+     * JavaScript 1.6.
+     */
+    forEach<Target>(
+      callback: (this: Target, item: T, index: number, arr: this) => void,
+      target?: Target
+    ): this;
+    /**
+     * Alias for `mapBy`
+     */
+    getEach<K extends keyof T>(key: K): NativeArray<T[K]>;
+    /**
+     * Sets the value on the named property for each member. This is more
+     * ergonomic than using other methods defined on this helper. If the object
+     * implements Ember.Observable, the value will be changed to `set(),` otherwise
+     * it will be set directly. `null` objects are skipped.
+     */
+    setEach<K extends keyof T>(key: K, value: T[K]): void;
+    /**
+     * Maps all of the items in the enumeration to another value, returning
+     * a new array. This method corresponds to `map()` defined in JavaScript 1.6.
+     */
+    map<U, Target>(
+      callback: (this: Target, item: T, index: number, arr: this) => U,
+      target?: Target
+    ): NativeArray<U>;
+    /**
+     * Similar to map, this specialized function returns the value of the named
+     * property on all items in the enumeration.
+     */
+    mapBy<K extends keyof T>(key: K): NativeArray<T[K]>;
+    mapBy(key: string): NativeArray<unknown>;
+    /**
+     * Returns an array with all of the items in the enumeration that the passed
+     * function returns true for. This method corresponds to `filter()` defined in
+     * JavaScript 1.6.
+     */
+    filter<Target>(
+      callback: (this: Target, item: T, index: number, arr: this) => unknown,
+      target?: Target
+    ): NativeArray<T>;
+    /**
+     * Returns an array with all of the items in the enumeration where the passed
+     * function returns false. This method is the inverse of filter().
+     */
+    reject<Target>(
+      callback: (this: Target, item: T, index: number, arr: this) => unknown,
+      target?: Target
+    ): NativeArray<T>;
+    /**
+     * Returns an array with just the items with the matched property. You
+     * can pass an optional second argument with the target value. Otherwise
+     * this will match any property that evaluates to `true`.
+     */
+    filterBy<K extends keyof T>(key: K, value?: T[K]): NativeArray<T>;
+    /**
+     * Returns an array with the items that do not have truthy values for
+     * key.  You can pass an optional second argument with the target value.  Otherwise
+     * this will match any property that evaluates to false.
+     */
+    rejectBy<K extends keyof T>(key: K, value?: T[K]): NativeArray<T>;
+    /**
+     * Returns the first item in the array for which the callback returns true.
+     * This method works similar to the `filter()` method defined in JavaScript 1.6
+     * except that it will stop working on the array once a match is found.
+     */
+    find<S extends T, Target = void>(
+      predicate: (this: void, value: T, index: number, obj: T[]) => value is S,
+      thisArg?: Target
+    ): S | undefined;
+    find<Target = void>(
+      callback: (this: Target, item: T, index: number, arr: this) => unknown,
+      target?: Target
+    ): T | undefined;
+    /**
+     * Returns the first item with a property matching the passed value. You
+     * can pass an optional second argument with the target value. Otherwise
+     * this will match any property that evaluates to `true`.
+     */
+    findBy<K extends keyof T>(key: K, value?: T[K]): T | undefined;
+    /**
+     * Returns `true` if the passed function returns true for every item in the
+     * enumeration. This corresponds with the `every()` method in JavaScript 1.6.
+     */
+    every<Target = void>(
+      callback: (this: Target, item: T, index: number, arr: this) => unknown,
+      target?: Target
+    ): boolean;
+    /**
+     * Returns `true` if the passed property resolves to the value of the second
+     * argument for all items in the enumerable. This method is often simpler/faster
+     * than using a callback.
+     */
+    isEvery<K extends keyof T>(key: K, value?: T[K]): boolean;
+    /**
+     * Returns `true` if the passed function returns true for any item in the
+     * enumeration.
+     */
+    any<Target = void>(
+      callback: (this: Target, item: T, index: number, arr: this) => unknown,
+      target?: Target
+    ): boolean;
+    /**
+     * Returns `true` if the passed property resolves to the value of the second
+     * argument for any item in the enumerable. This method is often simpler/faster
+     * than using a callback.
+     */
+    isAny<K extends keyof T>(key: K, value?: T[K]): boolean;
+    /**
+     * This will combine the values of the enumerator into a single value. It
+     * is a useful way to collect a summary value from an enumeration. This
+     * corresponds to the `reduce()` method defined in JavaScript 1.8.
+     */
+    reduce: T[]['reduce'];
+    /**
+     * Invokes the named method on every object in the receiver that
+     * implements it. This method corresponds to the implementation in
+     * Prototype 1.6.
+     */
+    invoke<M extends MethodNamesOf<T>>(
+      methodName: M,
+      ...args: MethodParams<T, M>
+    ): Array<MethodReturns<T, M>>;
+    /**
+     * Simply converts the enumerable into a genuine array. The order is not
+     * guaranteed. Corresponds to the method implemented by Prototype.
+     */
+    toArray(): T[];
+    /**
+     * Returns a copy of the array with all `null` and `undefined` elements removed.
+     */
+    compact(): NativeArray<NonNullable<T>>;
+    /**
+     * Returns `true` if the passed object can be found in the enumerable.
+     */
+    includes(searchElement: T, fromIndex?: number): boolean;
+    /**
+     * Converts the enumerable into an array and sorts by the keys
+     * specified in the argument.
+     */
+    sortBy(...properties: string[]): NativeArray<T>;
+    /**
+     * Returns a new enumerable that excludes the passed value. The default
+     * implementation returns an array regardless of the receiver type.
+     * If the receiver does not contain the value it returns the original enumerable.
+     */
+    without(value: T): NativeArray<T>;
+    /**
+     * Returns a new enumerable that contains only unique values. The default
+     * implementation returns an array regardless of the receiver type.
+     */
+    uniq(): NativeArray<T>;
+    /**
+     * Returns a new enumerable that contains only items containing a unique property value.
+     * The default implementation returns an array regardless of the receiver type.
+     */
+    uniqBy(property: string): NativeArray<T>;
+    uniqBy(callback: (value: T) => unknown): NativeArray<T>;
+    /**
+     * This is the handler for the special array content property. If you get
+     * this property, it will return this. If you set this property to a new
+     * array, it will replace the current content.
+     */
+    get '[]'(): NativeArray<T>;
+    set '[]'(newValue: NativeArray<T>);
+  }
+  // Ember.Array rather than Array because the `array-type` lint rule doesn't realize the global is shadowed
+  const Array: Mixin;
+  export default Array;
+
+  /**
+   * Creates an `Ember.NativeArray` from an Array like object.
+   * Does not modify the original object's contents. Ember.A is not needed if
+   * `EmberENV.EXTEND_PROTOTYPES` is `true` (the default value). However,
+   * it is recommended that you use Ember.A when creating addons for
+   * ember or when you can not guarantee that `EmberENV.EXTEND_PROTOTYPES`
+   * will be `true`.
+   */
+  export function A<T>(arr?: T[]): NativeArray<T>;
+
+  /**
+   * Returns true if the passed object is an array or Array-like.
+   */
+  export function isArray(obj: unknown): obj is ArrayLike<unknown>;
+}
diff --git a/types/preview/@ember/array/mutable.d.ts b/types/preview/@ember/array/mutable.d.ts
new file mode 100644
index 00000000000..30c365bb953
--- /dev/null
+++ b/types/preview/@ember/array/mutable.d.ts
@@ -0,0 +1,94 @@
+declare module '@ember/array/mutable' {
+  import Mixin from '@ember/object/mixin';
+  import MutableEnumerable from '@ember/array/-private/mutable-enumerable';
+  import EmberArray from '@ember/array';
+
+  type AnyArray<T> = EmberArray<T> | Array<T>;
+
+  /**
+   * This mixin defines the API for modifying array-like objects. These methods
+   * can be applied only to a collection that keeps its items in an ordered set.
+   * It builds upon the Array mixin and adds methods to modify the array.
+   * One concrete implementations of this class include ArrayProxy.
+   */
+  interface MutableArray<T> extends EmberArray<T>, MutableEnumerable {
+    /**
+     * __Required.__ You must implement this method to apply this mixin.
+     */
+    replace(idx: number, amt: number, objects: T[]): this;
+    /**
+     * Remove all elements from the array. This is useful if you
+     * want to reuse an existing array without having to recreate it.
+     */
+    clear(): this;
+    /**
+     * This will use the primitive `replace()` method to insert an object at the
+     * specified index.
+     */
+    insertAt(idx: number, object: T): this;
+    /**
+     * Remove an object at the specified index using the `replace()` primitive
+     * method. You can pass either a single index, or a start and a length.
+     */
+    removeAt(start: number, len?: number): this;
+    /**
+     * Push the object onto the end of the array. Works just like `push()` but it
+     * is KVO-compliant.
+     */
+    pushObject(obj: T): T;
+    /**
+     * Add the objects in the passed numerable to the end of the array. Defers
+     * notifying observers of the change until all objects are added.
+     */
+    pushObjects(objects: AnyArray<T>): this;
+    /**
+     * Pop object from array or nil if none are left. Works just like `pop()` but
+     * it is KVO-compliant.
+     */
+    popObject(): T;
+    /**
+     * Shift an object from start of array or nil if none are left. Works just
+     * like `shift()` but it is KVO-compliant.
+     */
+    shiftObject(): T;
+    /**
+     * Unshift an object to start of array. Works just like `unshift()` but it is
+     * KVO-compliant.
+     */
+    unshiftObject(obj: T): T;
+    /**
+     * Adds the named objects to the beginning of the array. Defers notifying
+     * observers until all objects have been added.
+     */
+    unshiftObjects(objects: AnyArray<T>): this;
+    /**
+     * Reverse objects in the array. Works just like `reverse()` but it is
+     * KVO-compliant.
+     */
+    reverseObjects(): this;
+    /**
+     * Replace all the receiver's content with content of the argument.
+     * If argument is an empty array receiver will be cleared.
+     */
+    setObjects(objects: AnyArray<T>): this;
+    /**
+     * __Required.__ You must implement this method to apply this mixin.
+     */
+    removeObject(object: T): T;
+    /**
+     * Removes each object in the passed array from the receiver.
+     */
+    removeObjects(objects: AnyArray<T>): this;
+    /**
+     * __Required.__ You must implement this method to apply this mixin.
+     */
+    addObject(object: T): T;
+    /**
+     * Adds each object in the passed enumerable to the receiver.
+     */
+    addObjects(objects: AnyArray<T>): this;
+  }
+
+  const MutableArray: Mixin;
+  export default MutableArray;
+}
diff --git a/types/preview/@ember/array/proxy.d.ts b/types/preview/@ember/array/proxy.d.ts
new file mode 100644
index 00000000000..37efc898204
--- /dev/null
+++ b/types/preview/@ember/array/proxy.d.ts
@@ -0,0 +1,29 @@
+declare module '@ember/array/proxy' {
+  import Array from '@ember/array';
+  import type MutableArray from '@ember/array/mutable';
+  import EmberObject from '@ember/object';
+
+  /**
+   * An ArrayProxy wraps any other object that is a native or Ember `Array`
+   * (checked with [`Ember.isArray`](https://api.emberjs.com/ember/release/functions/@ember%2Farray/isArray)),
+   * forwarding all requests. This makes it very useful for a number of
+   * binding use cases or other cases where being able to swap out the
+   * underlying array is useful.
+   *
+   * NOTE: Attempting to mutate the underlying content of an object that
+   * is not a `MutableArray` (e.g. a native Javascript Array) may not
+   * behave as expected. [`Ember.A`](https://api.emberjs.com/ember/release/functions/@ember%2Farray/A)
+   * may be used in this case.
+   */
+  export default interface ArrayProxy<T> extends MutableArray<T> {}
+  export default class ArrayProxy<T> extends EmberObject {
+    content: T[] | Array<T>;
+
+    /**
+     * Should actually retrieve the object at the specified index from the
+     * content. You can override this method in subclasses to transform the
+     * content item to something new.
+     */
+    objectAtContent(idx: number): T | undefined;
+  }
+}
diff --git a/types/preview/@ember/array/tsconfig.json b/types/preview/@ember/array/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/array/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/component/-private/class-names-support.d.ts b/types/preview/@ember/component/-private/class-names-support.d.ts
new file mode 100644
index 00000000000..a8dc9cf4e28
--- /dev/null
+++ b/types/preview/@ember/component/-private/class-names-support.d.ts
@@ -0,0 +1,27 @@
+declare module '@ember/component/-private/class-names-support' {
+  import Mixin from '@ember/object/mixin';
+
+  interface ClassNamesSupport {
+    /**
+     * A list of properties of the view to apply as class names. If the property is a string value,
+     * the value of that string will be applied as a class name.
+     *
+     * If the value of the property is a Boolean, the name of that property is added as a dasherized
+     * class name.
+     *
+     * If you would prefer to use a custom value instead of the dasherized property name, you can
+     * pass a binding like this: `classNameBindings: ['isUrgent:urgent']`
+     *
+     * This list of properties is inherited from the component's superclasses as well.
+     */
+    classNameBindings: string[];
+    /**
+     * Standard CSS class names to apply to the view's outer element. This
+     * property automatically inherits any class names defined by the view's
+     * superclasses as well.
+     */
+    classNames: string[];
+  }
+  const ClassNamesSupport: Mixin;
+  export default ClassNamesSupport;
+}
diff --git a/types/preview/@ember/component/-private/core-view.d.ts b/types/preview/@ember/component/-private/core-view.d.ts
new file mode 100644
index 00000000000..cc1b307640f
--- /dev/null
+++ b/types/preview/@ember/component/-private/core-view.d.ts
@@ -0,0 +1,14 @@
+declare module '@ember/component/-private/core-view' {
+  import EmberObject from '@ember/object';
+  import type Evented from '@ember/object/evented';
+  import type ActionHandler from '@ember/object/-private/action-handler';
+
+  /**
+   * Ember.CoreView is an abstract class that exists to give view-like behavior to both Ember's main
+   * view class Ember.Component and other classes that don't need the full functionality of Ember.Component.
+   *
+   * Unless you have specific needs for CoreView, you will use Ember.Component in your applications.
+   */
+  export default class CoreView extends EmberObject {}
+  export default interface CoreView extends Evented, ActionHandler {}
+}
diff --git a/types/preview/@ember/component/-private/glimmer-interfaces.d.ts b/types/preview/@ember/component/-private/glimmer-interfaces.d.ts
new file mode 100644
index 00000000000..f5412750c3a
--- /dev/null
+++ b/types/preview/@ember/component/-private/glimmer-interfaces.d.ts
@@ -0,0 +1,45 @@
+declare module '@ember/component/-private/glimmer-interfaces' {
+  // NOTE: this is a bare-minimum subset of the definitions of the types in
+  // `@glimmer/interfaces`, supplied to make the public types in this package
+  // accurate.
+
+  // This is only present to "brand" the type, and it brands it in a way that
+  // matches [the implementation][1], which *also* uses it as a type-only brand.
+  //
+  // [1]: https://github.com/glimmerjs/glimmer-vm/blob/d6d776cf3797dafa923bcdad47e1897231ef6539/packages/%40glimmer/interfaces/lib/managers/capabilities.d.ts#L1
+  const CAPABILITIES: unique symbol;
+
+  export interface Capabilities {
+    [CAPABILITIES]: true;
+  }
+
+  export interface Arguments {
+    positional: readonly unknown[];
+    named: Record<string, unknown>;
+  }
+
+  export interface ComponentCapabilitiesVersions {
+    '3.4': {
+      asyncLifecycleCallbacks?: boolean;
+      destructor?: boolean;
+    };
+
+    '3.13': {
+      asyncLifecycleCallbacks?: boolean;
+      destructor?: boolean;
+      updateHook?: boolean;
+    };
+  }
+
+  export interface ComponentCapabilities extends Capabilities {
+    asyncLifeCycleCallbacks: boolean;
+    destructor: boolean;
+    updateHook: boolean;
+  }
+
+  export interface ComponentManager<ComponentStateBucket> {
+    capabilities: ComponentCapabilities;
+    createComponent(factory: object, args: Arguments): ComponentStateBucket;
+    getContext(instance: ComponentStateBucket): unknown;
+  }
+}
diff --git a/types/preview/@ember/component/-private/signature-utils.d.ts b/types/preview/@ember/component/-private/signature-utils.d.ts
new file mode 100644
index 00000000000..e21679429e4
--- /dev/null
+++ b/types/preview/@ember/component/-private/signature-utils.d.ts
@@ -0,0 +1,107 @@
+declare module '@ember/component/-private/signature-utils' {
+  /**
+   * @module Type utilities for signatures
+   */
+
+  // Type-only "symbol" to use with `EmptyObject` below, so that it is *not*
+  // equivalent to an empty interface.
+  const Empty: unique symbol;
+
+  /**
+   * This provides us a way to have a "fallback" which represents an empty object,
+   * without the downsides of how TS treats `{}`. Specifically: this will
+   * correctly leverage "excess property checking" so that, given a component
+   * which has no named args, if someone invokes it with any named args, they will
+   * get a type error.
+   *
+   * @internal This is exported so declaration emit works (if it were not emitted,
+   *   declarations which fall back to it would not work). It is *not* intended for
+   *   public usage, and the specific mechanics it uses may change at any time.
+   *   The location of this export *is* part of the public API, because moving it
+   *   will break existing declarations, but is not legal for end users to import
+   *   themselves, so ***DO NOT RELY ON IT***.
+   */
+  export interface EmptyObject {
+    [Empty]?: true;
+  }
+
+  type DefaultPositional = unknown[];
+  type DefaultNamed = EmptyObject;
+
+  type GetOrElse<Obj, K, Fallback> = K extends keyof Obj ? Obj[K] : Fallback;
+
+  /** Given a signature `S`, get back the `Args` type. */
+  type ArgsFor<S> = 'Args' extends keyof S
+    ? {
+        Named: GetOrElse<S['Args'], 'Named', DefaultNamed>;
+        Positional: GetOrElse<S['Args'], 'Positional', []>;
+      }
+    : { Named: DefaultNamed; Positional: [] };
+
+  interface LegacyArgsFor<T> {
+    Named: GetOrElse<T, 'NamedArgs', DefaultNamed>;
+    Positional: GetOrElse<T, 'PositionalArgs', DefaultPositional>;
+  }
+
+  // This type allows us to present a slightly-less-obtuse error message
+  // when attempting to resolve the signature of a helper that doesn't have
+  // one declared from within a tool like Glint.
+  const BadType: unique symbol;
+  /** @internal This is *only* exported to use in tests! */
+  export interface BadType<Message> {
+    [BadType]: Message;
+  }
+
+  interface MissingSignatureArgs {
+    Named: BadType<'This helper is missing a signature'>;
+    Positional: unknown[];
+  }
+
+  /**
+   * Given any allowed shorthand form of a signature, desugars it to its full
+   * expanded type.
+   *
+   * @internal This is only exported so we can avoid duplicating it in
+   *   [Glint](https://github.com/typed-ember/glint) or other such tooling. It is
+   *   *not* intended for public usage, and the specific mechanics it uses may
+   *   change at any time. Although the signature produced by is part of Glimmer's
+   *   public API the existence and mechanics of this specific symbol are *not*,
+   *   so ***DO NOT RELY ON IT***.
+   */
+  // This is similar but not identical to the `ExpandSignature` type used in the
+  // Glimmer Component API: it uses the same basic mechanics, but does not have
+  // an identical signature because we had not yet normalized the `Signature` when
+  // we designed the first pass of this. In the future, we will be able to make
+  // all `ExpandSignature` types fully general to work with *any* invokable. But
+  // "future" here probably means Ember v5. :sobbing:
+  // prettier-ignore
+  export interface ExpandSignature<T> {
+  Args:
+    // Is this the default (i.e. unspecified) signature?
+    // Then return our special "missing signature" type
+    unknown extends T ? MissingSignatureArgs :
+    // Is this a `Signature`? Then use `Signature` args
+    keyof T extends 'Args' | 'Return' ? ArgsFor<T> :
+    // Otherwise fall back to classic `Args`.
+    LegacyArgsFor<T>;
+  Return: 'Return' extends keyof T ? T['Return'] : unknown;
+}
+
+  // The `unknown extends S` checks on both of these are here to preserve backward
+  // compatibility with the existing non-`Signature` definition. When migrating
+  // into Ember or otherwise making a breaking change, we can drop the "default"
+  // in favor of just using `ExpandSignature`.
+  // prettier-ignore
+  export type NamedArgs<S> =
+  unknown extends S
+  ? Record<string, unknown>
+  : ExpandSignature<S>['Args']['Named'];
+
+  // prettier-ignore
+  export type PositionalArgs<S> =
+  unknown extends S
+  ? unknown[]
+  : ExpandSignature<S>['Args']['Positional'];
+
+  export type Return<S> = GetOrElse<S, 'Return', unknown>;
+}
diff --git a/types/preview/@ember/component/-private/view-mixin.d.ts b/types/preview/@ember/component/-private/view-mixin.d.ts
new file mode 100644
index 00000000000..152f75af973
--- /dev/null
+++ b/types/preview/@ember/component/-private/view-mixin.d.ts
@@ -0,0 +1,59 @@
+declare module '@ember/component/-private/view-mixin' {
+  import Mixin from '@ember/object/mixin';
+
+  interface ViewMixin {
+    /**
+     * A list of properties of the view to apply as attributes. If the property
+     * is a string value, the value of that string will be applied as the value
+     * for an attribute of the property's name.
+     */
+    attributeBindings: string[];
+    /**
+     * Returns the current DOM element for the view.
+     */
+    element: Element;
+    /**
+     * The HTML `id` of the view's element in the DOM. You can provide this
+     * value yourself but it must be unique (just as in HTML):
+     */
+    elementId: string;
+    /**
+     * Tag name for the view's outer element. The tag name is only used when an
+     * element is first created. If you change the `tagName` for an element, you
+     * must destroy and recreate the view element.
+     */
+    tagName: string;
+    /**
+     * Renders the view again. This will work regardless of whether the
+     * view is already in the DOM or not. If the view is in the DOM, the
+     * rendering process will be deferred to give bindings a chance
+     * to synchronize.
+     */
+    rerender(): void;
+    /**
+     * Called when a view is going to insert an element into the DOM.
+     */
+    willInsertElement(): void;
+    /**
+     * Called when the element of the view has been inserted into the DOM.
+     * Override this function to do any set up that requires an element
+     * in the document body.
+     */
+    didInsertElement(): void;
+    /**
+     * Called when the view is about to rerender, but before anything has
+     * been torn down. This is a good opportunity to tear down any manual
+     * observers you have installed based on the DOM state
+     */
+    willClearRender(): void;
+    /**
+     * Called when the element of the view is going to be destroyed. Override
+     * this function to do any teardown that requires an element, like removing
+     * event listeners.
+     */
+    willDestroyElement(): void;
+  }
+  const ViewMixin: Mixin;
+
+  export default ViewMixin;
+}
diff --git a/types/preview/@ember/component/helper.d.ts b/types/preview/@ember/component/helper.d.ts
new file mode 100644
index 00000000000..d4c00902a8c
--- /dev/null
+++ b/types/preview/@ember/component/helper.d.ts
@@ -0,0 +1,122 @@
+declare module '@ember/component/helper' {
+  import EmberObject from '@ember/object';
+  import { Opaque } from 'ember/-private/type-utils';
+  import {
+    DefaultNamed,
+    DefaultPositional,
+    EmptyObject,
+    ExpandSignature,
+    NamedArgs,
+    PositionalArgs,
+    Return,
+  } from '@ember/component/-private/signature-utils';
+
+  // Immediately re-export these.
+  export { EmptyObject, ExpandSignature };
+
+  /**
+   * The public shape of a helper.
+   * @deprecated Do not use this directly. Instead, write a `Signature` with the
+   *   "normal" signature shape: `Args: { Named: { ... }, Positional: [...] }`.
+   */
+  export interface HelperSignature {
+    NamedArgs?: DefaultNamed;
+    PositionalArgs?: DefaultPositional;
+    Return?: unknown;
+  }
+
+  /**
+   * Ember Helpers are functions that can compute values, and are used in templates.
+   * For example, this code calls a helper named `format-currency`:
+   */
+  export default class Helper<S = unknown> extends EmberObject {
+    /**
+     * In many cases, the ceremony of a full `Ember.Helper` class is not required.
+     * The `helper` method create pure-function helpers without instances. For
+     * example:
+     */
+    static helper<P extends DefaultPositional, N = EmptyObject, R = unknown>(
+      helper: (positional: P, named: N) => R
+    ): Helper<{ Args: { Positional: P; Named: N }; Return: R }>;
+    /**
+     * Override this function when writing a class-based helper.
+     */
+    compute(positional: PositionalArgs<S>, named: NamedArgs<S>): Return<S>;
+    /**
+     * On a class-based helper, it may be useful to force a recomputation of that
+     * helpers value. This is akin to `rerender` on a component.
+     */
+    recompute(): void;
+  }
+
+  // The generic here is for a *signature*: a way to hang information for tools
+  // like Glint which can provide type checking for component templates using
+  // information supplied via this generic. While it may appear useless on this
+  // class definition and extension, it is used by external tools and should not
+  // be removed.
+  export default interface Helper<S> extends Opaque<S> {}
+
+  // This type exists to provide a non-user-constructible, non-subclassable
+  // type representing the conceptual "instance type" of a function helper.
+  // The abstract field of type `never` presents subclassing in userspace of
+  // the value returned from `helper()`. By extending `Helper<S>`, any
+  // augmentations of the `Helper` type performed by tools like Glint will
+  // also apply to function-based helpers as well.
+  export abstract class FunctionBasedHelperInstance<S> extends Helper<S> {
+    protected abstract __concrete__: never;
+  }
+
+  /**
+   * The type of a function-based helper.
+   *
+   * @note This is *not* user-constructible: it is exported only so that the type
+   *   returned by the `helper` function can be named (and indeed can be exported
+   *   like `export default helper(...)` safely).
+   */
+  // Making `FunctionBasedHelper` a bare constructor type allows for type
+  // parameters to be preserved when `helper()` is passed a generic function.
+  // By making it `abstract` and impossible to subclass (see above), we prevent
+  // users from attempting to instantiate a return value from `helper()`.
+  export type FunctionBasedHelper<S> = abstract new () => FunctionBasedHelperInstance<S>;
+
+  /**
+   * In many cases, the ceremony of a full `Helper` class is not required.
+   * The `helper` method create pure-function helpers without instances. For
+   * example:
+   * ```app/helpers/format-currency.js
+   * import { helper } from '@ember/component/helper';
+   * export default helper(function(params, hash) {
+   *   let cents = params[0];
+   *   let currency = hash.currency;
+   *   return `${currency}${cents * 0.01}`;
+   * });
+   * ```
+   */
+  // This overload allows users to write types directly on the callback passed to
+  // the `helper` function and infer the resulting type correctly.
+  export function helper<P extends DefaultPositional, N = EmptyObject, R = unknown>(
+    helperFn: (positional: P, named: N) => R
+  ): FunctionBasedHelper<{
+    Args: {
+      Positional: P;
+      Named: N;
+    };
+    Return: R;
+  }>;
+
+  // This overload allows users to provide a `Signature` type explicitly at the
+  // helper definition site, e.g. `helper<Sig>((pos, named) => {...})`. **Note:**
+  // this overload must appear second, since TS' inference engine will not
+  // correctly infer the type of `S` here from the types on the supplied callback.
+  export function helper<S>(
+    helperFn: (positional: PositionalArgs<S>, named: NamedArgs<S>) => Return<S>
+  ): FunctionBasedHelper<{
+    Args: {
+      Positional: PositionalArgs<S>;
+      Named: NamedArgs<S>;
+    };
+    Return: Return<S>;
+  }>;
+
+  export {};
+}
diff --git a/types/preview/@ember/component/index.d.ts b/types/preview/@ember/component/index.d.ts
new file mode 100644
index 00000000000..ced33f71e48
--- /dev/null
+++ b/types/preview/@ember/component/index.d.ts
@@ -0,0 +1,132 @@
+declare module '@ember/component' {
+  import CoreView from '@ember/component/-private/core-view';
+  import ClassNamesSupport from '@ember/component/-private/class-names-support';
+  import ViewMixin from '@ember/component/-private/view-mixin';
+  import { ComponentManager, Capabilities } from '@ember/component/-private/glimmer-interfaces';
+  import { Opaque } from 'ember/-private/type-utils';
+
+  // Re-export these types so people can use them!
+  export { ComponentManager, Capabilities };
+
+  interface TemplateFactory {
+    __htmlbars_inline_precompile_template_factory: any;
+  }
+
+  // The generic here is for a *signature: a way to hang information for tools
+  // like Glint which can provide typey checking for component templates using
+  // information supplied via this generic. While it may appear useless on this
+  // class definition and extension, it is used by external tools and should not
+  // be removed.
+  export default interface Component<S = unknown> extends ViewMixin, ClassNamesSupport, Opaque<S> {}
+  export default class Component<S = unknown> extends CoreView {
+    // methods
+    readDOMAttr(name: string): string;
+    // properties
+    /**
+     * The WAI-ARIA role of the control represented by this view. For example, a button may have a
+     * role of type 'button', or a pane may have a role of type 'alertdialog'. This property is
+     * used by assistive software to help visually challenged users navigate rich web applications.
+     */
+    ariaRole: string;
+    /**
+     * The HTML id of the component's element in the DOM. You can provide this value yourself but
+     * it must be unique (just as in HTML):
+     *
+     * If not manually set a default value will be provided by the framework. Once rendered an
+     * element's elementId is considered immutable and you should never change it. If you need
+     * to compute a dynamic value for the elementId, you should do this when the component or
+     * element is being instantiated:
+     */
+    elementId: string;
+    /**
+     * A component may contain a layout. A layout is a regular template but supersedes the template
+     * property during rendering. It is the responsibility of the layout template to retrieve the
+     * template property from the component (or alternatively, call Handlebars.helpers.yield,
+     * {{yield}}) to render it in the correct location. This is useful for a component that has a
+     * shared wrapper, but which delegates the rendering of the contents of the wrapper to the
+     * template property on a subclass.
+     */
+    layout: TemplateFactory | string;
+    /**
+     * Enables components to take a list of parameters as arguments.
+     */
+    static positionalParams: string[] | string;
+    // events
+    /**
+     * Called when the attributes passed into the component have been updated. Called both during the
+     * initial render of a container and during a rerender. Can be used in place of an observer; code
+     * placed here will be executed every time any attribute updates.
+     */
+    didReceiveAttrs(): void;
+    /**
+     * Called after a component has been rendered, both on initial render and in subsequent rerenders.
+     */
+    didRender(): void;
+    /**
+     * Called when the component has updated and rerendered itself. Called only during a rerender,
+     * not during an initial render.
+     */
+    didUpdate(): void;
+    /**
+     * Called when the attributes passed into the component have been changed. Called only during a
+     * rerender, not during an initial render.
+     */
+    didUpdateAttrs(): void;
+    /**
+     * Called before a component has been rendered, both on initial render and in subsequent rerenders.
+     */
+    willRender(): void;
+    /**
+     * Called when the component is about to update and rerender itself. Called only during a rerender,
+     * not during an initial render.
+     */
+    willUpdate(): void;
+
+    /**
+     * `reopen()` was deprecated and removed from `Component`. It is given an
+     * illegitimate type in these types so that you cannot call it or use it!
+     * Unfortunately, it cannot actually be *removed* from this type, because TS
+     * rightly complains that `Component` is no longer a valid subtype of the
+     * `EmberObject` base class, and will not let you use it.
+     */
+    static reopen(): never;
+  }
+
+  /**
+   * Associate a class with a component manager (an object that is responsible for
+   * coordinating the lifecycle events that occurs when invoking, rendering and
+   * re-rendering a component).
+   *
+   * @param managerFactory a function to create the owner for an object
+   * @param object the object to associate with the componetn manager
+   * @return the same object passed in, now associated with the manager
+   */
+  export function setComponentManager<T>(
+    managerFactory: (owner: unknown) => ComponentManager<unknown>,
+    object: T
+  ): T;
+
+  // In normal TypeScript, these built-in components are essentially opaque tokens
+  // that just need to be importable. Declaring them with unique interfaces
+  // like this, however, gives tools like Glint (that DO have a richer
+  // notion of what they are) a place to install more detailed type information.
+  export interface Input extends Opaque<'component:input'> {}
+  export interface Textarea extends Opaque<'component:textarea'> {}
+
+  /**
+   * The `Input` component lets you create an HTML `<input>` element.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.components/methods/Input?anchor=Input
+   */
+  export const Input: Input;
+
+  /**
+   * The `Textarea` component inserts a new instance of `<textarea>` tag into the template.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.components/methods/Textarea?anchor=Textarea
+   */
+  export const Textarea: Textarea;
+
+  // Do not export anything but what we *explicitly* say to export.
+  export {};
+}
diff --git a/types/preview/@ember/component/template-only.d.ts b/types/preview/@ember/component/template-only.d.ts
new file mode 100644
index 00000000000..86762e3dab8
--- /dev/null
+++ b/types/preview/@ember/component/template-only.d.ts
@@ -0,0 +1,47 @@
+declare module '@ember/component/template-only' {
+  import { Opaque } from 'ember/-private/type-utils';
+
+  /**
+   * Template-only components have no backing class instance, so this in their
+   * templates is null. This means that you can only reference passed in arguments
+   * via named argument syntax (e.g. `{{@arg}}`):
+   *
+   * ```hbs
+   * {{!--
+   *   This does not work, since `this` does not exist
+   * --}}
+   * <label for="title">Title</label>
+   * <Input @value={{this.value}} id="title" />
+   * ```
+   *
+   * Additionally, the mut helper generally can't be used for the same reason:
+   *
+   * ```hbs
+   * {{!-- This does not work --}}
+   * <input
+   *   value={{this.value}}
+   *   onkeyup={{action (mut this.value) target="value"}}
+   * />
+   * ```
+   *
+   * Since Octane, a template-only component shares a subset of features that are
+   * available in `@glimmer/component`. Such component can be seamlessly
+   * "upgraded" to a Glimmer component, when you add a JavaScript file alongside
+   * the template.
+   */
+  export interface TemplateOnlyComponent<S = unknown> extends Opaque<S> {
+    toString(): string;
+  }
+
+  /**
+   * A convenience alias for {@link TemplateOnlyComponent}
+   */
+  export type TOC<S> = TemplateOnlyComponent<S>;
+
+  // The generic here is for a *signature: a way to hang information for tools
+  // like Glint which can provide typey checking for component templates using
+  // information supplied via this generic. While it may appear useless on this
+  // class definition and extension, it is used by external tools and should not
+  // be removed.
+  export default function templateOnly<S>(moduleName?: string): TemplateOnlyComponent<S>;
+}
diff --git a/types/preview/@ember/component/tsconfig.json b/types/preview/@ember/component/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/component/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/controller/index.d.ts b/types/preview/@ember/controller/index.d.ts
new file mode 100644
index 00000000000..5d7dcbc4d2b
--- /dev/null
+++ b/types/preview/@ember/controller/index.d.ts
@@ -0,0 +1,48 @@
+declare module '@ember/controller' {
+  import ActionHandler from '@ember/object/-private/action-handler';
+  import Mixin from '@ember/object/mixin';
+  import EmberObject from '@ember/object';
+  import type { BasicComputedProperty } from '@ember/object/computed';
+
+  type QueryParamTypes = 'boolean' | 'number' | 'array' | 'string';
+  type QueryParamScopeTypes = 'controller' | 'model';
+
+  interface QueryParamConfig {
+    type?: QueryParamTypes | undefined;
+    scope?: QueryParamScopeTypes | undefined;
+    as?: string | undefined;
+  }
+
+  /**
+   * Additional methods for the Controller.
+   */
+  export interface ControllerMixin extends ActionHandler {
+    /**
+     * @deprecated until 5.0. Use `RouterService.replaceWith` instead.
+     */
+    replaceRoute(name: string, ...args: any[]): void;
+    /**
+     * @deprecated until 5.0. Use `RouterService.transitionTo` instead.
+     */
+    transitionToRoute(name: string, ...args: any[]): void;
+    /**
+     * @deprecated until 5.0. Use `RouterService.transitionTo` instead.
+     */
+    transitionToRoute(...args: any[]): void;
+    model: unknown;
+    queryParams: Array<string | Record<string, QueryParamConfig | string | undefined>>;
+    target: object;
+  }
+  export const ControllerMixin: Mixin;
+
+  export default class Controller extends EmberObject {}
+  export default interface Controller extends ControllerMixin {}
+
+  export function inject(): Controller;
+  export function inject<K extends keyof Registry>(name: K): Registry[K] & BasicComputedProperty;
+  export function inject(target: object, propertyKey: string | symbol): void;
+
+  // A type registry for Ember `Controller`s. Meant to be declaration-merged
+  // so string lookups resolve to the correct type.
+  export interface Registry {}
+}
diff --git a/types/preview/@ember/controller/tsconfig.json b/types/preview/@ember/controller/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/controller/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/debug/container-debug-adapter.d.ts b/types/preview/@ember/debug/container-debug-adapter.d.ts
new file mode 100644
index 00000000000..edc16cc568b
--- /dev/null
+++ b/types/preview/@ember/debug/container-debug-adapter.d.ts
@@ -0,0 +1,13 @@
+declare module '@ember/debug/container-debug-adapter' {
+  import type { Resolver } from '@ember/-internals/resolver';
+
+  /**
+   * The ContainerDebugAdapter helps the container and resolver interface
+   * with tools that debug Ember such as the Ember Inspector for Chrome and Firefox.
+   */
+  export default class ContainerDebugAdapter extends Object {
+    resolver: Resolver;
+    canCatalogEntriesByType(type: string): boolean;
+    catalogEntriesByType(type: string): string[];
+  }
+}
diff --git a/types/preview/@ember/debug/data-adapter.d.ts b/types/preview/@ember/debug/data-adapter.d.ts
new file mode 100644
index 00000000000..0159212085b
--- /dev/null
+++ b/types/preview/@ember/debug/data-adapter.d.ts
@@ -0,0 +1,64 @@
+declare module '@ember/debug/data-adapter' {
+  import ContainerDebugAdapter from '@ember/debug/container-debug-adapter';
+  import EmberObject from '@ember/object';
+
+  namespace DataAdapter {
+    interface Column {
+      name: string;
+      desc: string;
+    }
+    interface WrappedRecord {
+      columnValues: object;
+      object: object;
+    }
+    interface WrappedType {
+      type: {
+        name: string;
+        count: number;
+        columns: Column[];
+        object: typeof Object;
+      };
+      release: () => void;
+    }
+  }
+
+  /**
+   * The `DataAdapter` helps a data persistence library
+   * interface with tools that debug Ember such as Chrome and Firefox.
+   */
+  export default class DataAdapter extends EmberObject {
+    /**
+     * The container-debug-adapter which is used
+     * to list all models.
+     */
+    containerDebugAdapter: ContainerDebugAdapter;
+    /**
+     * Ember Data > v1.0.0-beta.18
+     * requires string model names to be passed
+     * around instead of the actual factories.
+     */
+    acceptsModelName: boolean;
+    /**
+     * Specifies how records can be filtered.
+     * Records returned will need to have a `filterValues`
+     * property with a key for every name in the returned array.
+     */
+    getFilters(): DataAdapter.Column[];
+    /**
+     * Fetch the model types and observe them for changes.
+     */
+    watchModelTypes(
+      typesAdded: (types: DataAdapter.WrappedType[]) => void,
+      typesUpdated: (types: DataAdapter.WrappedType[]) => void
+    ): () => void;
+    /**
+     * Fetch the records of a given type and observe them for changes.
+     */
+    watchRecords(
+      modelName: string,
+      recordsAdded: (records: DataAdapter.WrappedRecord[]) => void,
+      recordsUpdated: (records: DataAdapter.WrappedRecord[]) => void,
+      recordsRemoved: (idx: number, count: number) => void
+    ): () => void;
+  }
+}
diff --git a/types/preview/@ember/debug/index.d.ts b/types/preview/@ember/debug/index.d.ts
new file mode 100644
index 00000000000..6febb97a22d
--- /dev/null
+++ b/types/preview/@ember/debug/index.d.ts
@@ -0,0 +1,98 @@
+declare module '@ember/debug' {
+  /**
+   * Define an assertion that will throw an exception if the condition is not met.
+   */
+  export function assert(desc: string): never;
+  export function assert(desc: string, test: unknown): asserts test;
+
+  /**
+   * Display a debug notice.
+   */
+  export function debug(message: string): void;
+
+  /**
+   * Allows for runtime registration of handler functions that override the default deprecation behavior.
+   * Deprecations are invoked by calls to [Ember.deprecate](http://emberjs.com/api/classes/Ember.html#method_deprecate).
+   * The following example demonstrates its usage by registering a handler that throws an error if the
+   * message contains the word "should", otherwise defers to the default handler.
+   */
+  export function registerDeprecationHandler(
+    handler: (
+      message: string,
+      options: { id: string; until: string } | undefined,
+      next: (message: string, options?: { id: string; until: string }) => void
+    ) => void
+  ): void;
+  /**
+   * Allows for runtime registration of handler functions that override the default warning behavior.
+   * Warnings are invoked by calls made to [Ember.warn](http://emberjs.com/api/classes/Ember.html#method_warn).
+   * The following example demonstrates its usage by registering a handler that does nothing overriding Ember's
+   * default warning behavior.
+   */
+  export function registerWarnHandler(
+    handler: (
+      message: string,
+      options: { id: string } | undefined,
+      next: (message: string, options?: { id: string }) => void
+    ) => void
+  ): void;
+
+  /**
+   * Run a function meant for debugging.
+   */
+  export function runInDebug(func: () => unknown): void;
+
+  /**
+   * Display a warning with the provided message.
+   */
+  export function warn(message: string, test: boolean, options: { id: string }): void;
+  export function warn(message: string, options: { id: string }): void;
+
+  /**
+   * Display a deprecation warning with the provided message and a stack trace
+   * (Chrome and Firefox only).
+   *
+   * In a production build, this method is defined as an empty function (NOP).
+   * Uses of this method in Ember itself are stripped from the ember.prod.js build.
+   *
+   * @param message A description of the deprecation.
+   * @param test If falsy, the deprecation will be displayed.
+   * @param options The deprecation options.
+   */
+  export function deprecate(
+    message: string,
+    test: boolean,
+    options: {
+      /**
+       * A unique id for this deprecation. The id can be used by Ember debugging
+       * tools to change the behavior (raise, log or silence) for that specific
+       * deprecation. The id should be namespaced by dots, e.g.
+       * `"view.helper.select"`.
+       */
+      id: string;
+      /**
+       * The version of Ember when this deprecation warning will be removed.
+       */
+      until: string;
+      /**
+       * An optional url to the transition guide on the emberjs.com website.
+       */
+      url?: string | undefined;
+      /**
+       * A namespace for the deprecation, usually the package name.
+       */
+      for: string;
+      /**
+       * Describes when the deprecation became available and enabled.
+       */
+      since: Available | Enabled;
+    }
+  ): void;
+
+  export interface Available {
+    available: string;
+  }
+  export interface Enabled extends Available {
+    enabled: string;
+  }
+}
diff --git a/types/preview/@ember/debug/tsconfig.json b/types/preview/@ember/debug/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/debug/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/destroyable/index.d.ts b/types/preview/@ember/destroyable/index.d.ts
new file mode 100644
index 00000000000..302dd6d4240
--- /dev/null
+++ b/types/preview/@ember/destroyable/index.d.ts
@@ -0,0 +1,23 @@
+declare module '@ember/destroyable' {
+  export function associateDestroyableChild<T extends object>(parent: object, child: T): T;
+
+  export function isDestroying(destroyable: object): boolean;
+
+  export function isDestroyed(destroyable: object): boolean;
+
+  export function destroy(destroyable: object): void;
+
+  export function assertDestroyablesDestroyed(): void;
+
+  export function enableDestroyableTracking(): void;
+
+  export function registerDestructor<T extends object>(
+    destroyable: T,
+    destructor: (destroyable: T) => void
+  ): (destroyable: T) => void;
+
+  export function unregisterDestructor<T extends object>(
+    destroyable: T,
+    destructor: (destroyable: T) => void
+  ): void;
+}
diff --git a/types/preview/@ember/destroyable/tsconfig.json b/types/preview/@ember/destroyable/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/destroyable/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts b/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts
new file mode 100644
index 00000000000..fbedd3127a9
--- /dev/null
+++ b/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts
@@ -0,0 +1,17 @@
+declare module '@ember/engine/-private/container-proxy-mixin' {
+  import Owner from '@ember/owner';
+  import Mixin from '@ember/object/mixin';
+
+  /**
+   * Given a fullName return a factory manager.
+   */
+  interface ContainerProxyMixin extends Owner {
+    /**
+     * Returns an object that can be used to provide an owner to a
+     * manually created instance.
+     */
+    ownerInjection(): {};
+  }
+  const ContainerProxyMixin: Mixin;
+  export default ContainerProxyMixin;
+}
diff --git a/types/preview/@ember/engine/-private/registry-proxy-mixin.d.ts b/types/preview/@ember/engine/-private/registry-proxy-mixin.d.ts
new file mode 100644
index 00000000000..a9f9599f8f3
--- /dev/null
+++ b/types/preview/@ember/engine/-private/registry-proxy-mixin.d.ts
@@ -0,0 +1,54 @@
+declare module '@ember/engine/-private/registry-proxy-mixin' {
+  import Owner from '@ember/owner';
+  import Mixin from '@ember/object/mixin';
+
+  /**
+   * RegistryProxyMixin is used to provide public access to specific
+   * registry functionality.
+   */
+  interface RegistryProxyMixin extends Owner {
+    /**
+     * Given a fullName return the corresponding factory.
+     */
+    resolveRegistration(fullName: string): unknown;
+    /**
+     * Unregister a factory.
+     */
+    unregister(fullName: string): unknown;
+    /**
+     * Check if a factory is registered.
+     */
+    hasRegistration(fullName: string): boolean;
+    /**
+     * Register an option for a particular factory.
+     */
+    registerOption(fullName: string, optionName: string, options: {}): unknown;
+    /**
+     * Return a specific registered option for a particular factory.
+     */
+    registeredOption(fullName: string, optionName: string): {};
+    /**
+     * Register options for a particular factory.
+     */
+    registerOptions(fullName: string, options: {}): unknown;
+    /**
+     * Return registered options for a particular factory.
+     */
+    registeredOptions(fullName: string): {};
+    /**
+     * Allow registering options for all factories of a type.
+     */
+    registerOptionsForType(type: string, options: {}): unknown;
+    /**
+     * Return the registered options for all factories of a type.
+     */
+    registeredOptionsForType(type: string): {};
+    /**
+     * Define a dependency injection onto a specific factory or all factories
+     * of a type.
+     */
+    inject(factoryNameOrType: string, property: string, injectionName: string): unknown;
+  }
+  const RegistryProxyMixin: Mixin;
+  export default RegistryProxyMixin;
+}
diff --git a/types/preview/@ember/engine/-private/types/initializer.d.ts b/types/preview/@ember/engine/-private/types/initializer.d.ts
new file mode 100644
index 00000000000..25953dee71b
--- /dev/null
+++ b/types/preview/@ember/engine/-private/types/initializer.d.ts
@@ -0,0 +1,8 @@
+declare module '@ember/engine/-private/types/initializer' {
+  export default interface Initializer<T> {
+    name: string;
+    before?: string[] | undefined;
+    after?: string[] | undefined;
+    initialize(application: T): void;
+  }
+}
diff --git a/types/preview/@ember/engine/index.d.ts b/types/preview/@ember/engine/index.d.ts
new file mode 100644
index 00000000000..561e251d620
--- /dev/null
+++ b/types/preview/@ember/engine/index.d.ts
@@ -0,0 +1,45 @@
+declare module '@ember/engine' {
+  import EmberObject from '@ember/object';
+  import type RegistryProxyMixin from '@ember/engine/-private/registry-proxy-mixin';
+  import type Initializer from '@ember/engine/-private/types/initializer';
+  import type EngineInstance from '@ember/engine/instance';
+  import type { Resolver } from '@ember/-internals/resolver';
+
+  /**
+   * The `Engine` class contains core functionality for both applications and
+   * engines.
+   */
+  export default class Engine extends EmberObject {
+    /**
+     * The goal of initializers should be to register dependencies and injections.
+     * This phase runs once. Because these initializers may load code, they are
+     * allowed to defer application readiness and advance it. If you need to access
+     * the container or store you should use an InstanceInitializer that will be run
+     * after all initializers and therefore after all code is loaded and the app is
+     * ready.
+     */
+    static initializer(initializer: Initializer<Engine>): void;
+    /**
+     * Instance initializers run after all initializers have run. Because
+     * instance initializers run after the app is fully set up. We have access
+     * to the store, container, and other items. However, these initializers run
+     * after code has loaded and are not allowed to defer readiness.
+     */
+    static instanceInitializer(instanceInitializer: Initializer<EngineInstance>): void;
+    /**
+     * Set this to provide an alternate class to `DefaultResolver`
+     */
+    resolver: Resolver | null;
+    /**
+     * Create an EngineInstance for this Engine.
+     */
+    buildInstance(options?: object): EngineInstance;
+  }
+
+  export default interface Engine extends RegistryProxyMixin {}
+
+  /**
+   * `getEngineParent` retrieves an engine instance's parent instance.
+   */
+  export function getEngineParent(engine: EngineInstance): EngineInstance;
+}
diff --git a/types/preview/@ember/engine/instance.d.ts b/types/preview/@ember/engine/instance.d.ts
new file mode 100644
index 00000000000..2f8c03015da
--- /dev/null
+++ b/types/preview/@ember/engine/instance.d.ts
@@ -0,0 +1,24 @@
+declare module '@ember/engine/instance' {
+  import ContainerProxyMixin from '@ember/engine/-private/container-proxy-mixin';
+  import RegistryProxyMixin from '@ember/engine/-private/registry-proxy-mixin';
+  import EmberObject from '@ember/object';
+
+  /**
+   * The `EngineInstance` encapsulates all of the stateful aspects of a
+   * running `Engine`.
+   */
+  export default class EngineInstance extends EmberObject {
+    /**
+     * Unregister a factory.
+     */
+    unregister(fullName: string): unknown;
+
+    /**
+     *  Initialize the `EngineInstance` and return a promise that resolves
+     *  with the instance itself when the boot process is complete.
+     */
+    boot(): Promise<EngineInstance>;
+  }
+
+  export default interface EngineInstance extends RegistryProxyMixin, ContainerProxyMixin {}
+}
diff --git a/types/preview/@ember/engine/tsconfig.json b/types/preview/@ember/engine/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/engine/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/error/index.d.ts b/types/preview/@ember/error/index.d.ts
new file mode 100644
index 00000000000..6a8636372b6
--- /dev/null
+++ b/types/preview/@ember/error/index.d.ts
@@ -0,0 +1,6 @@
+declare module '@ember/error' {
+  /**
+   * A subclass of the JavaScript Error object for use in Ember.
+   */
+  export default class EmberError extends Error {}
+}
diff --git a/types/preview/@ember/error/tsconfig.json b/types/preview/@ember/error/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/error/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/helper/index.d.ts b/types/preview/@ember/helper/index.d.ts
new file mode 100644
index 00000000000..01977dc729c
--- /dev/null
+++ b/types/preview/@ember/helper/index.d.ts
@@ -0,0 +1,49 @@
+declare module '@ember/helper' {
+  import type { Opaque } from 'ember/-private/type-utils';
+
+  // In normal TypeScript, these helpers are essentially opaque tokens that just
+  // need to be importable. Declaring them with unique interfaces like this,
+  // however, gives tools like Glint (that DO have a richer notion of what they
+  // are) a place to install more detailed type information.
+  export interface ArrayHelper extends Opaque<'helper:array'> {}
+  export interface ConcatHelper extends Opaque<'helper:concat'> {}
+  export interface FnHelper extends Opaque<'helper:fn'> {}
+  export interface GetHelper extends Opaque<'helper:get'> {}
+  export interface HashHelper extends Opaque<'helper:hash'> {}
+
+  /**
+   * Use the `{{array}}` helper to create an array to pass as an option to your components.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/array?anchor=array
+   */
+  export const array: ArrayHelper;
+
+  /**
+   * Concatenates the given arguments into a string.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/concat?anchor=concat
+   */
+  export const concat: ConcatHelper;
+
+  /**
+   * The `fn` helper allows you to ensure a function that you are passing off to another component, helper, or modifier
+   * has access to arguments that are available in the template.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/fn?anchor=fn
+   */
+  export const fn: FnHelper;
+
+  /**
+   * Dynamically look up a property on an object.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/get?anchor=get
+   */
+  export const get: GetHelper;
+
+  /**
+   * Use the `{{hash}}` helper to create a hash to pass as an option to your components.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/hash?anchor=hash
+   */
+  export const hash: HashHelper;
+}
diff --git a/types/preview/@ember/helper/tsconfig.json b/types/preview/@ember/helper/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/helper/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/modifier/index.d.ts b/types/preview/@ember/modifier/index.d.ts
new file mode 100644
index 00000000000..5a4f782b24d
--- /dev/null
+++ b/types/preview/@ember/modifier/index.d.ts
@@ -0,0 +1,33 @@
+declare module '@ember/modifier' {
+  import type Owner from '@ember/owner';
+  import type { Opaque } from 'ember/-private/type-utils';
+
+  // In normal TypeScript, this modifier is essentially an opaque token
+  // that just needs to be importable. Declaring it with a unique interface
+  // like this, however, gives tools like Glint (that DO have a richer
+  // notion of what it is) a place to install more detailed type information.
+  export interface OnModifier extends Opaque<'modifier:on'> {}
+
+  /**
+   * The `{{on}}` modifier lets you easily add event listeners.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/on?anchor=on
+   */
+  export const on: OnModifier;
+
+  /**
+   * Given a modifier manager factory and a modifier, tell Ember to set the
+   * manager returned by that factory as the manager for the modifier.
+   *
+   * @param factory A function which takes an `owner` and returns a [modifier
+   *   manager](https://emberjs.github.io/rfcs/0373-Element-Modifier-Managers.html).
+   * @param modifier The modifier definition to associate with the manager.
+   */
+  export function setModifierManager<T>(factory: (owner: Owner) => unknown, modifier: T): T;
+
+  /**
+   * Given a target version of Ember, return an opaque token which Ember can use
+   * to determine what a given modifier manager supports.
+   */
+  export function capabilities(version: string): unknown;
+}
diff --git a/types/preview/@ember/modifier/tsconfig.json b/types/preview/@ember/modifier/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/modifier/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/object/-private/action-handler.d.ts b/types/preview/@ember/object/-private/action-handler.d.ts
new file mode 100644
index 00000000000..331207994f7
--- /dev/null
+++ b/types/preview/@ember/object/-private/action-handler.d.ts
@@ -0,0 +1,31 @@
+declare module '@ember/object/-private/action-handler' {
+  import { AnyFn } from 'ember/-private/type-utils';
+  import type Mixin from '@ember/object/mixin';
+
+  interface ActionsHash {
+    [index: string]: AnyFn;
+  }
+
+  /**
+   * Ember.ActionHandler is available on some familiar classes including Ember.Route,
+   * Ember.Component, and Ember.Controller. (Internally the mixin is used by Ember.CoreView,
+   * Ember.ControllerMixin, and Ember.Route and available to the above classes through inheritance.)
+   */
+  interface ActionHandler {
+    /**
+     * Triggers a named action on the ActionHandler. Any parameters supplied after the actionName
+     * string will be passed as arguments to the action target function.
+     *
+     * If the ActionHandler has its target property set, actions may bubble to the target.
+     * Bubbling happens when an actionName can not be found in the ActionHandler's actions
+     * hash or if the action target function returns true.
+     */
+    send(actionName: string, ...args: any[]): void;
+    /**
+     * The collection of functions, keyed by name, available on this ActionHandler as action targets.
+     */
+    actions: ActionsHash;
+  }
+  const ActionHandler: Mixin;
+  export default ActionHandler;
+}
diff --git a/types/preview/@ember/object/-private/types.d.ts b/types/preview/@ember/object/-private/types.d.ts
new file mode 100644
index 00000000000..efe9bb7a7b9
--- /dev/null
+++ b/types/preview/@ember/object/-private/types.d.ts
@@ -0,0 +1,63 @@
+declare module '@ember/object/-private/types' {
+  import type Mixin from '@ember/object/mixin';
+
+  /**
+   * Map type `T` to a plain object hash with the identity mapping.
+   *
+   * Discards any additional object identity like the ability to `new()` up the class.
+   * The `new()` capability is added back later by merging `EmberClassConstructor<T>`
+   *
+   * Implementation is carefully chosen for the reasons described in
+   * https://github.com/typed-ember/ember-typings/pull/29
+   */
+  export type Objectify<T> = Readonly<T>;
+
+  export type ExtractPropertyNamesOfType<T, S> = {
+    [K in keyof T]: T[K] extends S ? K : never;
+  }[keyof T];
+
+  export type Fix<T> = { [K in keyof T]: T[K] };
+
+  /**
+   * Used to infer the type of ember classes of type `T`.
+   *
+   * Generally you would use `EmberClass.create()` instead of `new EmberClass()`.
+   *
+   * The single-arg constructor is required by the typescript compiler.
+   * The multi-arg constructor is included for better ergonomics.
+   *
+   * Implementation is carefully chosen for the reasons described in
+   * https://github.com/typed-ember/ember-typings/pull/29
+   */
+  export type EmberClassConstructor<T> = (new (properties?: object) => T) &
+    (new (...args: any[]) => T);
+
+  /**
+   * Check that any arguments to `create()` match the type's properties.
+   *
+   * Accept any additional properties and add merge them into the instance.
+   */
+  export type EmberInstanceArguments<T> = Partial<T> & {
+    [key: string]: unknown;
+  };
+
+  /**
+   * Accept any additional properties and add merge them into the prototype.
+   */
+  export interface EmberClassArguments {
+    [key: string]: unknown;
+  }
+
+  /**
+   * Ember.Object.extend(...) accepts any number of mixins or literals.
+   */
+  export type MixinOrLiteral<T> = Mixin | T;
+
+  export type ObserverMethod<Target, Sender> =
+    | keyof Target
+    | ((this: Target, sender: Sender, key: string, value: any, rev: number) => void);
+
+  // This type looks weird, but is correct: from a list of "bottom" to "top", in
+  // type theory terms.
+  export type AnyFunction = (...args: never[]) => unknown;
+}
diff --git a/types/preview/@ember/object/compat.d.ts b/types/preview/@ember/object/compat.d.ts
new file mode 100644
index 00000000000..fbc5605ec02
--- /dev/null
+++ b/types/preview/@ember/object/compat.d.ts
@@ -0,0 +1,9 @@
+declare module '@ember/object/compat' {
+  /**
+   * `@dependentKeyCompat` is a decorator that can be used on native getters that
+   * use tracked properties. It exposes the getter to Ember's classic computed
+   * property and observer systems, so they can watch it for changes. It can be
+   * used in both native and classic classes.
+   */
+  export const dependentKeyCompat: PropertyDecorator;
+}
diff --git a/types/preview/@ember/object/computed.d.ts b/types/preview/@ember/object/computed.d.ts
new file mode 100644
index 00000000000..30fa4938739
--- /dev/null
+++ b/types/preview/@ember/object/computed.d.ts
@@ -0,0 +1,263 @@
+declare module '@ember/object/computed' {
+  /**
+   * A computed property transforms an objects function into a property.
+   * By default the function backing the computed property will only be called once and the result
+   * will be cached. You can specify various properties that your computed property is dependent on.
+   * This will force the cached result to be recomputed if the dependencies are modified.
+   */
+  export default class ComputedProperty {
+    /**
+     * Call on a computed property to set it into read-only mode. When in this
+     * mode the computed property will throw an error when set.
+     */
+    readOnly(): this;
+    /**
+     * In some cases, you may want to annotate computed properties with additional
+     * metadata about how they function or what values they operate on. For example,
+     * computed property functions may close over variables that are then no longer
+     * available for introspection.
+     */
+    meta(meta: Record<string, unknown>): this;
+    meta(): Record<string, unknown>;
+  }
+
+  // Computed property definitions also act as property decorators, including those
+  // returned from "macros" in third-party code.
+  export type BasicComputedProperty = ComputedProperty & PropertyDecorator;
+
+  /**
+   * Creates a new property that is an alias for another property
+   * on an object. Calls to `get` or `set` this property behave as
+   * though they were called on the original property.
+   */
+  export function alias(dependentKey: string): BasicComputedProperty;
+  /**
+   * A computed property that performs a logical `and` on the
+   * original values for the provided dependent properties.
+   */
+  export function and(...dependentKeys: string[]): BasicComputedProperty;
+  /**
+   * A computed property that converts the provided dependent property
+   * into a boolean value.
+   */
+  export function bool(dependentKey: string): BasicComputedProperty;
+
+  /**
+   * A computed property that returns the array of values
+   * for the provided dependent properties.
+   */
+  export function collect(...dependentKeys: string[]): BasicComputedProperty;
+
+  /**
+   * Creates a new property that is an alias for another property
+   * on an object. Calls to `get` or `set` this property behave as
+   * though they were called on the original property, but also
+   * print a deprecation warning.
+   */
+  export function deprecatingAlias(
+    dependentKey: string,
+    options: { id: string; until: string }
+  ): BasicComputedProperty;
+
+  /**
+   * A computed property that returns true if the value of the dependent
+   * property is null, an empty string, empty array, or empty function.
+   */
+  export function empty(dependentKey: string): BasicComputedProperty;
+  /**
+   * A computed property that returns true if the provided dependent property
+   * is equal to the given value.
+   */
+  export function equal(dependentKey: string, value: unknown): BasicComputedProperty;
+  /**
+   * Expands `pattern`, invoking `callback` for each expansion.
+   */
+  export function expandProperties(pattern: string, callback: (expanded: string) => void): void;
+
+  /**
+   * Filters the array by the callback.
+   */
+  export function filter(
+    dependentKey: string,
+    callback: (value: unknown, index: number, array: unknown[]) => boolean
+  ): BasicComputedProperty;
+
+  /**
+   * Filters the array by the callback and an array of additional dependent keys.
+   */
+  export function filter(
+    dependentKey: string,
+    additionalDependentKeys: string[],
+    callback: (value: unknown, index: number, array: unknown[]) => boolean
+  ): BasicComputedProperty;
+
+  /**
+   * Filters the array by the property and value
+   */
+  export function filterBy(
+    dependentKey: string,
+    propertyKey: string,
+    value?: unknown
+  ): BasicComputedProperty;
+
+  /**
+   * A computed property that returns true if the provided dependent property
+   * is greater than the provided value.
+   */
+  export function gt(dependentKey: string, value: number): BasicComputedProperty;
+  /**
+   * A computed property that returns true if the provided dependent property
+   * is greater than or equal to the provided value.
+   */
+  export function gte(dependentKey: string, value: number): BasicComputedProperty;
+
+  /**
+   * A computed property which returns a new array with all the elements
+   * two or more dependent arrays have in common.
+   */
+  export function intersect(...propertyKeys: string[]): BasicComputedProperty;
+
+  /**
+   * A computed property that returns true if the provided dependent property
+   * is less than the provided value.
+   */
+  export function lt(dependentKey: string, value: number): BasicComputedProperty;
+  /**
+   * A computed property that returns true if the provided dependent property
+   * is less than or equal to the provided value.
+   */
+  export function lte(dependentKey: string, value: number): BasicComputedProperty;
+
+  /**
+   * Returns an array mapped via the callback
+   */
+  export function map(
+    dependentKey: string,
+    callback: (value: unknown, index: number, array: unknown[]) => unknown
+  ): BasicComputedProperty;
+
+  /**
+   * Returns an array mapped to the specified key.
+   */
+  export function mapBy(dependentKey: string, propertyKey: string): BasicComputedProperty;
+
+  /**
+   * A computed property which matches the original value for the
+   * dependent property against a given RegExp, returning `true`
+   * if the value matches the RegExp and `false` if it does not.
+   */
+  export function match(dependentKey: string, regexp: RegExp): BasicComputedProperty;
+
+  /**
+   * A computed property that calculates the maximum value in the
+   * dependent array. This will return `-Infinity` when the dependent
+   * array is empty.
+   */
+  export function max(dependentKey: string): BasicComputedProperty;
+
+  /**
+   * A computed property that calculates the minimum value in the
+   * dependent array. This will return `Infinity` when the dependent
+   * array is empty.
+   */
+  export function min(dependentKey: string): BasicComputedProperty;
+
+  /**
+   * A computed property that returns true if the value of the dependent
+   * property is null or undefined. This avoids errors from JSLint complaining
+   * about use of ==, which can be technically confusing.
+   */
+  export function none(dependentKey: string): BasicComputedProperty;
+  /**
+   * A computed property that returns the inverse boolean value
+   * of the original value for the dependent property.
+   */
+  export function not(dependentKey: string): BasicComputedProperty;
+  /**
+   * A computed property that returns true if the value of the dependent
+   * property is NOT null, an empty string, empty array, or empty function.
+   */
+  export function notEmpty(dependentKey: string): BasicComputedProperty;
+  /**
+   * Where `computed.alias` aliases `get` and `set`, and allows for bidirectional
+   * data flow, `computed.oneWay` only provides an aliased `get`. The `set` will
+   * not mutate the upstream property, rather causes the current property to
+   * become the value set. This causes the downstream property to permanently
+   * diverge from the upstream property.
+   */
+  export function oneWay(dependentKey: string): BasicComputedProperty;
+  /**
+   * A computed property which performs a logical `or` on the
+   * original values for the provided dependent properties.
+   */
+  export function or(...dependentKeys: string[]): BasicComputedProperty;
+  /**
+   * Where `computed.oneWay` provides oneWay bindings, `computed.readOnly` provides
+   * a readOnly one way binding. Very often when using `computed.oneWay` one does
+   * not also want changes to propagate back up, as they will replace the value.
+   */
+  export function readOnly(dependentKey: string): BasicComputedProperty;
+  /**
+   * This is a more semantically meaningful alias of `computed.oneWay`,
+   * whose name is somewhat ambiguous as to which direction the data flows.
+   */
+  export function reads(dependentKey: string): BasicComputedProperty;
+
+  /**
+   * A computed property which returns a new array with all the
+   * properties from the first dependent array that are not in the second
+   * dependent array.
+   */
+  export function setDiff(setAProperty: string, setBProperty: string): BasicComputedProperty;
+
+  /**
+   * A computed property which returns a new array with all the properties from
+   * the first dependent array sorted based on a property or sort function.
+   *
+   * If used with an array of sort properties, it must receive exactly two
+   * arguments: the key of the array to sort, and the key of the array of sort
+   * properties. Alternatively the key of the array to sort, and a the sort
+   * function may be used.
+   */
+  export function sort<T>(
+    itemsKey: string,
+    sortDefinition: string | ((itemA: T, itemB: T) => number)
+  ): BasicComputedProperty;
+
+  /**
+   * A computed property which returns a new array with all the properties from
+   * the first dependent array sorted based on a property or sort function.
+   *
+   * It may receive three arguments: the key of the array to sort, an array of
+   * dependent keys for the computed property, and the sort function.
+   */
+  export function sort<T>(
+    itemsKey: string,
+    dependentKeys: string[],
+    sortDefinition: string | ((itemA: T, itemB: T) => number)
+  ): BasicComputedProperty;
+
+  /**
+   * A computed property that returns the sum of the values
+   * in the dependent array.
+   */
+  export function sum(dependentKey: string): BasicComputedProperty;
+
+  /**
+   * A computed property which returns a new array with all the unique
+   * elements from one or more dependent arrays.
+   */
+  export function uniq(propertyKey: string): BasicComputedProperty;
+
+  /**
+   * A computed property which returns a new array with all the unique
+   * elements from one or more dependent arrays.
+   */
+  export function union(...propertyKeys: string[]): BasicComputedProperty;
+
+  /**
+   * A computed property which returns a new array with all the unique
+   * elements from an array, with uniqueness determined by specific key.
+   */
+  export function uniqBy(dependentKey: string, propertyKey: string): BasicComputedProperty;
+}
diff --git a/types/preview/@ember/object/core.d.ts b/types/preview/@ember/object/core.d.ts
new file mode 100644
index 00000000000..ea8506f9b01
--- /dev/null
+++ b/types/preview/@ember/object/core.d.ts
@@ -0,0 +1,89 @@
+declare module '@ember/object/core' {
+  import type { EmberClassConstructor, Objectify } from '@ember/object/-private/types';
+  import type Mixin from '@ember/object/mixin';
+
+  export default class CoreObject {
+    /**
+     * As of Ember 3.1, CoreObject constructor takes initial object properties as an argument.
+     * See: https://github.com/emberjs/ember.js/commit/4709935854d4c29b0d2c054614d53fa2c55309b1
+     */
+    constructor(properties?: object);
+
+    _super(...args: any[]): any;
+
+    /**
+     * An overridable method called when objects are instantiated. By default,
+     * does nothing unless it is overridden during class definition.
+     */
+    init(): void;
+
+    /**
+     * Defines the properties that will be concatenated from the superclass (instead of overridden).
+     * @default null
+     */
+    concatenatedProperties: string[] | null;
+
+    /**
+     * Destroyed object property flag. If this property is true the observers and bindings were
+     * already removed by the effect of calling the destroy() method.
+     * @default false
+     */
+    isDestroyed: boolean;
+    /**
+     * Destruction scheduled flag. The destroy() method has been called. The object stays intact
+     * until the end of the run loop at which point the isDestroyed flag is set.
+     * @default false
+     */
+    isDestroying: boolean;
+
+    /**
+     * Destroys an object by setting the `isDestroyed` flag and removing its
+     * metadata, which effectively destroys observers and bindings.
+     * If you try to set a property on a destroyed object, an exception will be
+     * raised.
+     * Note that destruction is scheduled for the end of the run loop and does not
+     * happen immediately.  It will set an isDestroying flag immediately.
+     * @return receiver
+     */
+    destroy(): CoreObject;
+
+    /**
+     * Override to implement teardown.
+     */
+    willDestroy(): void;
+
+    /**
+     * Returns a string representation which attempts to provide more information than Javascript's toString
+     * typically does, in a generic way for all Ember objects (e.g., "<App.Person:ember1024>").
+     * @return string representation
+     */
+    toString(): string;
+
+    static create<Class extends typeof CoreObject>(
+      this: Class,
+      ...initialValues: Array<Mixin | MembersOf<Class>>
+    ): InstanceType<Class>;
+
+    static extend<Statics, Instance>(
+      this: Statics & EmberClassConstructor<Instance>,
+      ...mixins: Array<Mixin | Record<string, unknown>>
+    ): Objectify<Statics> & EmberClassConstructor<Instance>;
+
+    static reopen<Statics, Instance>(
+      this: Statics & EmberClassConstructor<Instance>,
+      ...mixins: Array<Mixin | Record<string, unknown>>
+    ): Objectify<Statics> & EmberClassConstructor<Instance>;
+
+    static reopenClass<Statics>(
+      this: Statics,
+      ...extraStatics: Array<Mixin | Record<string, unknown>>
+    ): Statics;
+
+    static isClass: boolean;
+    static isMethod: boolean;
+  }
+
+  type MembersOf<Class extends typeof CoreObject> = {
+    [Key in keyof InstanceType<Class>]?: InstanceType<Class>[Key];
+  };
+}
diff --git a/types/preview/@ember/object/evented.d.ts b/types/preview/@ember/object/evented.d.ts
new file mode 100644
index 00000000000..d60f3524b00
--- /dev/null
+++ b/types/preview/@ember/object/evented.d.ts
@@ -0,0 +1,45 @@
+declare module '@ember/object/evented' {
+  import Mixin from '@ember/object/mixin';
+  import { AnyFn, EmberMethod } from 'ember/-private/type-utils';
+
+  /**
+   * This mixin allows for Ember objects to subscribe to and emit events.
+   */
+  interface Evented {
+    /**
+     * Subscribes to a named event with given function.
+     */
+    on<T>(name: string, target: T, method: EmberMethod<T>): this;
+    on(name: string, method: EmberMethod<this>): this;
+    /**
+     * Subscribes a function to a named event and then cancels the subscription
+     * after the first time the event is triggered. It is good to use ``one`` when
+     * you only care about the first time an event has taken place.
+     */
+    one<T>(name: string, target: T, method: EmberMethod<T>): this;
+    one(name: string, method: EmberMethod<this>): this;
+    /**
+     * Triggers a named event for the object. Any additional arguments
+     * will be passed as parameters to the functions that are subscribed to the
+     * event.
+     */
+    trigger(name: string, ...args: unknown[]): unknown;
+    /**
+     * Cancels subscription for given name, target, and method.
+     */
+    off<T>(name: string, target: T, method: EmberMethod<T>): this;
+    off(name: string, method: EmberMethod<this>): this;
+    /**
+     * Checks to see if object has any subscriptions for named event.
+     */
+    has(name: string): boolean;
+  }
+  const Evented: Mixin;
+  export default Evented;
+
+  /**
+   * Define a property as a function that should be executed when
+   * a specified event or events are triggered.
+   */
+  export function on<F extends AnyFn>(...args: [...eventNames: string[], func: F]): F;
+}
diff --git a/types/preview/@ember/object/events.d.ts b/types/preview/@ember/object/events.d.ts
new file mode 100644
index 00000000000..281ec80aab4
--- /dev/null
+++ b/types/preview/@ember/object/events.d.ts
@@ -0,0 +1,47 @@
+declare module '@ember/object/events' {
+  import { AnyFunction } from '@ember/object/-private/types';
+
+  /**
+   * Add an event listener
+   */
+  export function addListener<Context>(
+    obj: Context,
+    eventName: string,
+    target: unknown,
+    method: keyof Context | AnyFunction,
+    once?: boolean
+  ): void;
+  export function addListener<Context>(
+    obj: Context,
+    eventName: string,
+    method: keyof Context | AnyFunction,
+    once?: boolean
+  ): void;
+
+  /**
+   * Remove an event listener
+   */
+  export function removeListener<Context>(
+    obj: Context,
+    eventName: string,
+    target: unknown,
+    method: keyof Context | AnyFunction
+  ): void;
+  export function removeListener<Context>(
+    obj: Context,
+    eventName: string,
+    method: keyof Context | AnyFunction
+  ): void;
+
+  /**
+   * Send an event. The execution of suspended listeners
+   * is skipped, and once listeners are removed. A listener without
+   * a target is executed on the passed object. If an array of actions
+   * is not passed, the actions stored on the passed object are invoked.
+   *
+   * @param eventName
+   * @param params Optional parameters for each listener.
+   * @returns if the event was delivered to one or more actions
+   */
+  export function sendEvent(obj: unknown, eventName: string, params?: unknown[]): boolean;
+}
diff --git a/types/preview/@ember/object/index.d.ts b/types/preview/@ember/object/index.d.ts
new file mode 100644
index 00000000000..5eb4d03ce46
--- /dev/null
+++ b/types/preview/@ember/object/index.d.ts
@@ -0,0 +1,126 @@
+declare module '@ember/object' {
+  import CoreObject from '@ember/object/core';
+  import type Observable from '@ember/object/observable';
+  import type ComputedProperty from '@ember/object/computed';
+  import type { BasicComputedProperty } from '@ember/object/computed';
+  import type { AnyFunction } from '@ember/object/-private/types';
+
+  /**
+   * `Ember.Object` is the main base class for all Ember objects. It is a subclass
+   * of `Ember.CoreObject` with the `Ember.Observable` mixin applied. For details,
+   * see the documentation for each of these.
+   */
+  export default class EmberObject extends CoreObject {}
+  export default interface EmberObject extends Observable {}
+
+  /**
+   * This helper returns a new property descriptor that wraps the passed computed
+   * property function. You can use this helper to define properties with native
+   * decorator syntax, mixins, or via `defineProperty()`.
+   *
+   * @param dependentKeys Optional dependent keys that trigger this computed
+   *   property.
+   */
+  export function computed(...dependentKeys: string[]): ComputedProperty & MethodDecorator;
+
+  export function computed(
+    ...args: [...dependentKeys: string[], callback: AnyFunction]
+  ): BasicComputedProperty;
+
+  /**
+   * Specify a method that observes property changes.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  export function observer<Fn extends (target: any, key: string) => void>(
+    ...args: [...propertyNames: string[], func: Fn]
+  ): Fn;
+
+  /**
+   * Gets the value of a property on an object. If the property is computed,
+   * the function will be invoked. If the property is not defined but the
+   * object implements the `unknownProperty` method then that will be invoked.
+   */
+  export function get<T, K extends keyof T>(obj: T, key: K): T[K];
+  export function get(obj: unknown, key: string): unknown;
+
+  /**
+   * Sets the value of a property on an object, respecting computed properties
+   * and notifying observers and other listeners of the change. If the
+   * property is not defined but the object implements the `setUnknownProperty`
+   * method then that will be invoked as well.
+   */
+  export function set<T, K extends keyof T, V extends T[K]>(obj: T, key: K, value: V): V;
+
+  /**
+   * To get multiple properties at once, call `getProperties` with an object
+   * followed by a list of strings or an array.
+   */
+  export function getProperties<T, K extends keyof T>(obj: T, list: K[]): Pick<T, K>;
+  export function getProperties<T, K extends keyof T>(obj: T, ...list: K[]): Pick<T, K>;
+
+  /**
+   * Set a list of properties on an object. These properties are set inside
+   * a single `beginPropertyChanges` and `endPropertyChanges` batch, so
+   * observers will be buffered.
+   */
+  export function setProperties<T, K extends keyof T>(obj: T, hash: Pick<T, K>): Pick<T, K>;
+
+  /**
+   * Error-tolerant form of `Ember.set`. Will not blow up if any part of the
+   * chain is `undefined`, `null`, or destroyed.
+   */
+  export function trySet(root: object, path: string, value: unknown): unknown;
+
+  /**
+   * NOTE: This is a low-level method used by other parts of the API. You almost
+   * never want to call this method directly. Instead you should use mixin() to
+   * define new properties.
+   *
+   * @param obj the object to define this property on. This may be a prototype.
+   * @param keyName the name of the property
+   * @param desc an instance of `Descriptor` (typically a computed property) or an
+   *   ES5 descriptor. You must provide this or `data` but not both.
+   * @param meta Normally this method takes only three parameters. However if you
+   *   pass an instance of Descriptor as the third param then you can pass an
+   *   optional value as the fourth parameter. This is often more efficient than
+   *   creating new descriptor hashes for each property.
+   */
+  export function defineProperty(
+    obj: object,
+    keyName: string,
+    desc: PropertyDescriptor | ComputedProperty,
+    meta?: unknown
+  ): void;
+
+  /**
+   * NOTE: This is a low-level method used by other parts of the API. You almost
+   * never want to call this method directly. Instead you should use mixin() to
+   * define new properties.
+   *
+   * @param obj the object to define this property on. This may be a prototype.
+   * @param keyName the name of the property
+   * @param desc an instance of `Descriptor` (typically a computed property) or an
+   *   ES5 descriptor. You must provide this or `data` but not both.
+   * @param data something other than a descriptor, that will become the explicit
+   *   value of this property.
+   */
+  export function defineProperty(
+    obj: object,
+    keyName: string,
+    desc: undefined,
+    data: unknown
+  ): void;
+
+  export function notifyPropertyChange(obj: object, keyName: string): void;
+
+  export const action: MethodDecorator;
+}
+
+declare module '@ember/utils/-private/types' {
+  import EmberObject from '@ember/object';
+
+  interface TypeLookup {
+    class: typeof EmberObject;
+    instance: EmberObject;
+  }
+}
diff --git a/types/preview/@ember/object/internals.d.ts b/types/preview/@ember/object/internals.d.ts
new file mode 100644
index 00000000000..9d9ea53784b
--- /dev/null
+++ b/types/preview/@ember/object/internals.d.ts
@@ -0,0 +1,17 @@
+declare module '@ember/object/internals' {
+  /**
+   * Returns the cached value for a property, if one exists.
+   * This can be useful for peeking at the value of a computed
+   * property that is generated lazily, without accidentally causing
+   * it to be created.
+   */
+  export function cacheFor<T, K extends keyof T>(obj: T, key: K): T[K] | undefined;
+
+  /**
+   * Returns a unique id for the object. If the object does not yet have a guid,
+   * one will be assigned to it. You can call this on any object,
+   * `Ember.Object`-based or not, but be aware that it will add a `_guid`
+   * property.
+   */
+  export function guidFor(obj: unknown): string;
+}
diff --git a/types/preview/@ember/object/mixin.d.ts b/types/preview/@ember/object/mixin.d.ts
new file mode 100644
index 00000000000..af3475c7bfc
--- /dev/null
+++ b/types/preview/@ember/object/mixin.d.ts
@@ -0,0 +1,19 @@
+declare module '@ember/object/mixin' {
+  const __ember_mixin__: unique symbol;
+
+  /**
+   * The `Ember.Mixin` class allows you to create mixins, whose properties can be
+   * added to other classes.
+   */
+  export default class Mixin {
+    /**
+     * Mixin needs to have *something* on its prototype, otherwise it's treated
+     * like an empty interface. It cannot be private, sadly. We can use this to
+     * carry around the types of the mixin so they don't get lost, though, so
+     * that's... something?
+     */
+    [__ember_mixin__]: never;
+
+    static create(...args: Array<Record<string, unknown> | Mixin>): Mixin;
+  }
+}
diff --git a/types/preview/@ember/object/observable.d.ts b/types/preview/@ember/object/observable.d.ts
new file mode 100644
index 00000000000..e64774959c7
--- /dev/null
+++ b/types/preview/@ember/object/observable.d.ts
@@ -0,0 +1,89 @@
+declare module '@ember/object/observable' {
+  import { ObserverMethod } from '@ember/object/-private/types';
+  import Mixin from '@ember/object/mixin';
+  import CoreObject from '@ember/object/core';
+
+  /**
+   * This mixin provides properties and property observing functionality, core features of the Ember object model.
+   */
+  interface Observable extends CoreObject {
+    /**
+     * Retrieves the value of a property from the object.
+     */
+    get<K extends keyof this>(key: K): this[K];
+    get(key: string): unknown;
+    /**
+     * To get the values of multiple properties at once, call `getProperties`
+     * with a list of strings or an array:
+     */
+    getProperties<K extends keyof this>(list: K[]): Pick<this, K>;
+    getProperties<K extends keyof this>(...list: K[]): Pick<this, K>;
+    getProperties(list: string[]): Record<string, unknown>;
+    getProperties(...list: string[]): Record<string, unknown>;
+    /**
+     * Sets the provided key or path to the value.
+     */
+    set<K extends keyof this>(key: K, value: this[K]): this[K];
+    set<T>(key: keyof this, value: T): T;
+    set<T>(key: string, value: T): T;
+    /**
+     * Sets a list of properties at once. These properties are set inside
+     * a single `beginPropertyChanges` and `endPropertyChanges` batch, so
+     * observers will be buffered.
+     */
+    setProperties<K extends keyof this>(hash: Pick<this, K>): Pick<this, K>;
+    setProperties<K extends keyof this>(hash: Record<K, unknown>): Pick<this, K>;
+    setProperties<R extends Record<string, unknown>>(hash: R): R;
+    /**
+     * Notify the observer system that a property has just changed.
+     *
+     * Sometimes you need to change a value directly or indirectly without
+     * actually calling `get()` or `set()` on it. In this case, you can use this
+     * method instead. Calling this method will notify all observers that the
+     * property has potentially changed value.
+     */
+    notifyPropertyChange(keyName: string): this;
+    /**
+     * Adds an observer on a property.
+     */
+    addObserver<Target>(
+      key: keyof this,
+      target: Target,
+      method: ObserverMethod<Target, this>
+    ): this;
+    addObserver(key: keyof this, method: ObserverMethod<this, this>): this;
+    /**
+     * Remove an observer you have previously registered on this object. Pass
+     * the same key, target, and method you passed to `addObserver()` and your
+     * target will no longer receive notifications.
+     */
+    removeObserver<Target>(
+      key: keyof this,
+      target: Target,
+      method: ObserverMethod<Target, this>
+    ): this;
+    removeObserver(key: keyof this, method: ObserverMethod<this, this>): this;
+    /**
+     * Set the value of a property to the current value plus some amount.
+     */
+    incrementProperty(keyName: keyof this, increment?: number): number;
+    /**
+     * Set the value of a property to the current value minus some amount.
+     */
+    decrementProperty(keyName: keyof this, decrement?: number): number;
+    /**
+     * Set the value of a boolean property to the opposite of its
+     * current value.
+     */
+    toggleProperty(keyName: keyof this): boolean;
+    /**
+     * Returns the cached value of a computed property, if it exists.
+     * This allows you to inspect the value of a computed property
+     * without accidentally invoking it if it is intended to be
+     * generated lazily.
+     */
+    cacheFor<K extends keyof this>(key: K): this[K] | undefined;
+  }
+  const Observable: Mixin;
+  export default Observable;
+}
diff --git a/types/preview/@ember/object/observers.d.ts b/types/preview/@ember/object/observers.d.ts
new file mode 100644
index 00000000000..36fb7de3325
--- /dev/null
+++ b/types/preview/@ember/object/observers.d.ts
@@ -0,0 +1,34 @@
+declare module '@ember/object/observers' {
+  import { ObserverMethod } from '@ember/object/-private/types';
+
+  /**
+   * Adds an observer on a property.
+   */
+  export function addObserver<Context, Target>(
+    obj: Context,
+    key: keyof Context,
+    target: Target,
+    method: ObserverMethod<Target, Context>
+  ): void;
+  export function addObserver<Context>(
+    obj: Context,
+    key: keyof Context,
+    method: ObserverMethod<Context, Context>
+  ): void;
+  /**
+   * Remove an observer you have previously registered on this object. Pass
+   * the same key, target, and method you passed to `addObserver()` and your
+   * target will no longer receive notifications.
+   */
+  export function removeObserver<Context, Target>(
+    obj: Context,
+    key: keyof Context,
+    target: Target,
+    method: ObserverMethod<Target, Context>
+  ): any;
+  export function removeObserver<Context>(
+    obj: Context,
+    key: keyof Context,
+    method: ObserverMethod<Context, Context>
+  ): any;
+}
diff --git a/types/preview/@ember/object/promise-proxy-mixin.d.ts b/types/preview/@ember/object/promise-proxy-mixin.d.ts
new file mode 100644
index 00000000000..a834447639f
--- /dev/null
+++ b/types/preview/@ember/object/promise-proxy-mixin.d.ts
@@ -0,0 +1,37 @@
+declare module '@ember/object/promise-proxy-mixin' {
+  import Mixin from '@ember/object/mixin';
+  import RSVP from 'rsvp';
+
+  /**
+   * A low level mixin making ObjectProxy promise-aware.
+   */
+  interface PromiseProxyMixin<T> extends RSVP.Promise<T> {
+    /**
+     * If the proxied promise is rejected this will contain the reason
+     * provided.
+     */
+    reason: unknown;
+    /**
+     * Once the proxied promise has settled this will become `false`.
+     */
+    isPending: boolean;
+    /**
+     * Once the proxied promise has settled this will become `true`.
+     */
+    isSettled: boolean;
+    /**
+     * Will become `true` if the proxied promise is rejected.
+     */
+    isRejected: boolean;
+    /**
+     * Will become `true` if the proxied promise is fulfilled.
+     */
+    isFulfilled: boolean;
+    /**
+     * The promise whose fulfillment value is being proxied by this object.
+     */
+    promise: RSVP.Promise<T>;
+  }
+  const PromiseProxyMixin: Mixin;
+  export default PromiseProxyMixin;
+}
diff --git a/types/preview/@ember/object/proxy.d.ts b/types/preview/@ember/object/proxy.d.ts
new file mode 100644
index 00000000000..a28ec6ebbda
--- /dev/null
+++ b/types/preview/@ember/object/proxy.d.ts
@@ -0,0 +1,27 @@
+declare module '@ember/object/proxy' {
+  import EmberObject from '@ember/object';
+
+  /**
+   * `Ember.ObjectProxy` forwards all properties not defined by the proxy itself
+   * to a proxied `content` object.
+   */
+  export default class ObjectProxy<T extends object = object> extends EmberObject {
+    /**
+     * The object whose properties will be forwarded.
+     */
+    content: T | undefined;
+
+    get<K extends keyof this>(key: K): this[K];
+    get<K extends keyof T>(key: K): T[K] | undefined;
+
+    getProperties<K extends keyof this>(list: K[]): Pick<this, K>;
+    getProperties<K extends keyof this>(...list: K[]): Pick<this, K>;
+    getProperties<K extends keyof T>(list: K[]): Pick<Partial<T>, K>;
+    getProperties<K extends keyof T>(...list: K[]): Pick<Partial<T>, K>;
+
+    set<K extends keyof this>(key: K, value: this[K]): this[K];
+    set<K extends keyof T>(key: K, value: T[K]): T[K];
+
+    setProperties<K extends keyof this | keyof T>(hash: Pick<this & T, K>): Pick<this & T, K>;
+  }
+}
diff --git a/types/preview/@ember/object/tsconfig.json b/types/preview/@ember/object/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/object/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/owner/index.d.ts b/types/preview/@ember/owner/index.d.ts
new file mode 100644
index 00000000000..31ca3476d4c
--- /dev/null
+++ b/types/preview/@ember/owner/index.d.ts
@@ -0,0 +1,102 @@
+declare module '@ember/owner' {
+  /**
+   * The name for a factory consists of a namespace and the name of a specific
+   * type within that namespace, like `'service:session'`.
+   */
+  export type FullName = `${string}:${string}`;
+
+  // TODO: when migrating into Ember proper, evaluate whether we should introduce
+  // a registry which users can provide to resolve known types, so e.g.
+  // `owner.lookup('service:session')` can return the right thing.
+  /**
+   * Framework objects in an Ember application (components, services, routes,
+   * etc.) are created via a factory and dependency injection system. Each of
+   * these objects is the responsibility of an "owner", which handled its
+   * instantiation and manages its lifetime.
+   */
+  export default interface Owner {
+    /**
+     * Given a {@linkcode FullName} return a corresponding instance.
+     */
+    lookup(fullName: FullName): unknown;
+
+    /**
+     * Registers a factory or value that can be used for dependency injection
+     * (with `inject`) or for service lookup. Each factory is registered with a
+     * full name including two parts: `'type:name'`.
+     *
+     * - To override the default of instantiating the class on the `Factory`,
+     *   pass the `{ instantiate: false }` option. This is useful when you have
+     *   already instantiated the class to use with this factory.
+     * - To override the default singleton behavior and instead create multiple
+     *   instances, pass the `{ singleton: false }` option.
+     */
+    // Dear future maintainer: yes, I know that `Factory<unknown> | object` is
+    // an exceedingly weird type here. This is how we type it internally in
+    // Ember itself. We actually allow more or less *anything* to be passed
+    // here. In the future, we may possibly be able to update this to actually
+    // take advantage of the `FullName` here to require that the registered
+    // factory and corresponding options do the right thing (passing an *actual*
+    // factory, not needing `create` if `options.instantiate` is `false`, etc.)
+    // but doing so will require rationalizing Ember's own internals and may
+    // need a full Ember RFC.
+    register(
+      fullName: FullName,
+      factory: Factory<unknown> | object,
+      options?: RegisterOptions
+    ): void;
+
+    /**
+     * Given a fullName of the form `'type:name'`, like `'route:application'`,
+     * return a corresponding factory manager.
+     *
+     * Any instances created via the factory's `.create()` method must be
+     * destroyed manually by the caller of `.create()`. Typically, this is done
+     * during the creating objects own `destroy` or `willDestroy` methods.
+     */
+    factoryFor(fullName: FullName): FactoryManager<unknown> | undefined;
+  }
+
+  export interface RegisterOptions {
+    instantiate?: boolean | undefined;
+    singleton?: boolean | undefined;
+  }
+
+  /**
+   * Registered factories are instantiated by having create called on them.
+   * Additionally they are singletons by default, so each time they are looked up
+   * they return the same instance.
+   *
+   * However, that behavior can be modified with the `instantiate` and `singleton`
+   * options to the {@linkcode Owner.register} method.
+   */
+  export interface Factory<T> {
+    /**
+     * A function that will create an instance of the class with any
+     * dependencies injected.
+     *
+     * @param initialValues Any values to set on an instance of the class
+     */
+    create(initialValues?: Partial<T>): T;
+  }
+
+  /**
+   * A manager which can be used for introspection of the factory's class or for
+   * the creation of factory instances with initial properties. The manager is an
+   * object with the following properties:
+   *
+   * - `class` - The registered or resolved class.
+   * - `create` - A function that will create an instance of the class with any
+   *   dependencies injected.
+   *
+   * @note `FactoryManager` is *not* user-constructible; the only legal way to get
+   *   a `FactoryManager` is via {@linkcode Owner.factoryFor}.
+   */
+  export interface FactoryManager<T> extends Factory<T> {
+    /** The registered or resolved class. */
+    readonly class: Factory<T>;
+  }
+
+  // Don't export things unless we *intend* to.
+  export {};
+}
diff --git a/types/preview/@ember/owner/tsconfig.json b/types/preview/@ember/owner/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/owner/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/polyfills/index.d.ts b/types/preview/@ember/polyfills/index.d.ts
new file mode 100644
index 00000000000..4fbe04bcaa9
--- /dev/null
+++ b/types/preview/@ember/polyfills/index.d.ts
@@ -0,0 +1,23 @@
+declare module '@ember/polyfills' {
+  import type { Mix, Mix3, Mix4 } from '@ember/polyfills/types';
+
+  /**
+   * Copy properties from a source object to a target object.
+   * @deprecated until v5.0. You should replace any calls to `Ember.assign` with
+   *   `Object.assign` or use the object spread operator.
+   */
+  export function assign<T extends object, U extends object>(target: T, source: U): Mix<T, U>;
+  export function assign<T extends object, U extends object, V extends object>(
+    target: T,
+    source1: U,
+    source2: V
+  ): Mix3<T, U, V>;
+  export function assign<T extends object, U extends object, V extends object, W extends object>(
+    target: T,
+    source1: U,
+    source2: V,
+    source3: W
+  ): Mix4<T, U, V, W>;
+  export function assign(target: object, ...sources: object[]): unknown;
+  export function assign(target: object, final: undefined | null): never;
+}
diff --git a/types/preview/@ember/polyfills/tsconfig.json b/types/preview/@ember/polyfills/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/polyfills/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/polyfills/types.d.ts b/types/preview/@ember/polyfills/types.d.ts
new file mode 100644
index 00000000000..be2a75c4ccc
--- /dev/null
+++ b/types/preview/@ember/polyfills/types.d.ts
@@ -0,0 +1,6 @@
+declare module '@ember/polyfills/types' {
+  export type Mix<A, B> = B & Pick<A, Exclude<keyof A, keyof B>>;
+  export type Mix3<A, B, C> = Mix<Mix<A, B>, C>;
+  export type Mix4<A, B, C, D> = Mix3<Mix<A, B>, C, D>;
+  export default Mix;
+}
diff --git a/types/preview/@ember/routing/-private/router-dsl.d.ts b/types/preview/@ember/routing/-private/router-dsl.d.ts
new file mode 100644
index 00000000000..8499aec45c8
--- /dev/null
+++ b/types/preview/@ember/routing/-private/router-dsl.d.ts
@@ -0,0 +1,20 @@
+declare module '@ember/routing/-private/router-dsl' {
+  export default class RouterDSL {
+    constructor(name: string | null, options: object);
+    route(name: string, callback: (this: RouterDSL) => void): void;
+    route(
+      name: string,
+      options?: { path?: string | undefined; resetNamespace?: boolean | undefined },
+      callback?: (this: RouterDSL) => void
+    ): void;
+    mount(
+      name: string,
+      options?: {
+        as?: string | undefined;
+        path?: string | undefined;
+        resetNamespace?: boolean | undefined;
+        engineInfo?: unknown;
+      }
+    ): void;
+  }
+}
diff --git a/types/preview/@ember/routing/auto-location.d.ts b/types/preview/@ember/routing/auto-location.d.ts
new file mode 100644
index 00000000000..ef226556850
--- /dev/null
+++ b/types/preview/@ember/routing/auto-location.d.ts
@@ -0,0 +1,8 @@
+declare module '@ember/routing/auto-location' {
+  import EmberObject from '@ember/object';
+
+  /**
+   * AutoLocation will select the best location option based off browser support with the priority order: history, hash, none.
+   */
+  export default class AutoLocation extends EmberObject {}
+}
diff --git a/types/preview/@ember/routing/hash-location.d.ts b/types/preview/@ember/routing/hash-location.d.ts
new file mode 100644
index 00000000000..ce78e1d4ada
--- /dev/null
+++ b/types/preview/@ember/routing/hash-location.d.ts
@@ -0,0 +1,10 @@
+declare module '@ember/routing/hash-location' {
+  import EmberObject from '@ember/object';
+
+  /**
+   * `Ember.HashLocation` implements the location API using the browser's
+   * hash. At present, it relies on a `hashchange` event existing in the
+   * browser.
+   */
+  export default class HashLocation extends EmberObject {}
+}
diff --git a/types/preview/@ember/routing/history-location.d.ts b/types/preview/@ember/routing/history-location.d.ts
new file mode 100644
index 00000000000..71b2c015298
--- /dev/null
+++ b/types/preview/@ember/routing/history-location.d.ts
@@ -0,0 +1,9 @@
+declare module '@ember/routing/history-location' {
+  import EmberObject from '@ember/object';
+
+  /**
+   * Ember.HistoryLocation implements the location API using the browser's
+   * history.pushState API.
+   */
+  export default class HistoryLocation extends EmberObject {}
+}
diff --git a/types/preview/@ember/routing/index.d.ts b/types/preview/@ember/routing/index.d.ts
new file mode 100644
index 00000000000..1fc19e3d27b
--- /dev/null
+++ b/types/preview/@ember/routing/index.d.ts
@@ -0,0 +1,20 @@
+declare module '@ember/routing' {
+  export { default as Route } from '@ember/routing/route';
+  export { default as Router } from '@ember/routing/router';
+
+  import { Opaque } from 'ember/-private/type-utils';
+
+  // In normal TypeScript, this component is essentially an opaque token
+  // that just needs to be importable. Declaring it with a unique interface
+  // like this, however, gives tools like Glint (that DO have a richer
+  // notion of what it is) a place to install more detailed type information.
+  export interface LinkTo extends Opaque<'component:link-to'> {}
+
+  /**
+   * The `LinkTo` component renders a link to the supplied `route` passing
+   * an optionally supplied model to the route as its `model` context of the route.
+   *
+   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.components/methods/LinkTo?anchor=LinkTo
+   */
+  export const LinkTo: LinkTo;
+}
diff --git a/types/preview/@ember/routing/none-location.d.ts b/types/preview/@ember/routing/none-location.d.ts
new file mode 100644
index 00000000000..8fface47a39
--- /dev/null
+++ b/types/preview/@ember/routing/none-location.d.ts
@@ -0,0 +1,11 @@
+declare module '@ember/routing/none-location' {
+  import EmberObject from '@ember/object';
+
+  /**
+   * Ember.NoneLocation does not interact with the browser. It is useful for
+   * testing, or when you need to manage state with your Router, but temporarily
+   * don't want it to muck with the URL (for example when you embed your
+   * application in a larger page).
+   */
+  export default class NoneLocation extends EmberObject {}
+}
diff --git a/types/preview/@ember/routing/route-info.d.ts b/types/preview/@ember/routing/route-info.d.ts
new file mode 100644
index 00000000000..ead7d39900b
--- /dev/null
+++ b/types/preview/@ember/routing/route-info.d.ts
@@ -0,0 +1,74 @@
+declare module '@ember/routing/route-info' {
+  // https://api.emberjs.com/ember/4.0/classes/RouteInfo
+  /**
+   * A `RouteInfo` is an object that contains metadata about a specific route within a `Transition`.
+   * It is read-only and internally immutable.
+   * It is also not observable, because a `Transition` instance is never changed after creation.
+   */
+  export default interface RouteInfo {
+    /**
+     * A reference to the childe route's `RouteInfo`.
+     * This can be used to traverse downward to the leafmost `RouteInfo`.
+     */
+    readonly child: RouteInfo | null;
+    /**
+     * The final segment of the fully-qualified name of the route, like "index".
+     */
+    readonly localName: string;
+    /**
+     * The dot-separated, fully-qualified name of the route, like "people.index".
+     */
+    readonly name: string;
+    /**
+     * The ordered list of the names of the params required for this route.
+     * It will contain the same strings as `Object.keys(params)`, but here the order is significant.
+     * This allows users to correctly pass params into routes programmatically.
+     */
+    readonly paramNames: string[];
+    /**
+     * The values of the route's parameters.
+     * These are the same params that are received as arguments to the route's `model` hook.
+     * Contains only the parameters valid for this route, if any (params for parent or child routes are not merged).
+     */
+    readonly params: { [key: string]: string | undefined };
+    /**
+     * A reference to the parent route's `RouteInfo`.
+     * This can be used to traverse upward to the topmost `RouteInfo`.
+     */
+    readonly parent: RouteInfo | null;
+    /**
+     * The values of any query params on this route.
+     */
+    readonly queryParams: { [key: string]: string | undefined };
+    /**
+     * Will contain the result `Route#buildRouteInfoMetadata`
+     * for the corresponding Route.
+     */
+    readonly metadata: unknown;
+    /**
+     * Allows you to traverse through the linked list of `RouteInfo`s from the topmost to leafmost.
+     * Returns the first `RouteInfo` in the linked list for which the callback returns true.
+     *
+     * @param callback the callback to execute.
+     */
+    find(callback: (item: RouteInfo) => boolean): RouteInfo | undefined;
+  }
+
+  // https://api.emberjs.com/ember/4.0/classes/RouteInfoWithAttributes
+  /**
+   * A `RouteInfoWithAttributes` is an object that contains
+   * metadata, including the resolved value from the routes
+   * `model` hook. Like `RouteInfo`, a `RouteInfoWithAttributes`
+   * represents a specific route within a Transition.
+   * It is read-only and internally immutable. It is also not
+   * observable, because a Transition instance is never
+   * changed after creation.
+   */
+  export interface RouteInfoWithAttributes extends RouteInfo {
+    /**
+     * This is the resolved return value from the
+     * route's model hook.
+     */
+    readonly attributes: unknown;
+  }
+}
diff --git a/types/preview/@ember/routing/route.d.ts b/types/preview/@ember/routing/route.d.ts
new file mode 100644
index 00000000000..c2005e66153
--- /dev/null
+++ b/types/preview/@ember/routing/route.d.ts
@@ -0,0 +1,533 @@
+declare module '@ember/routing/route' {
+  import EmberObject from '@ember/object';
+  import ActionHandler from '@ember/object/-private/action-handler';
+  import Transition from '@ember/routing/transition';
+  import Evented from '@ember/object/evented';
+  import { RouteQueryParam } from '@ember/routing/types';
+  import Controller from '@ember/controller';
+
+  type RouteModel = object | string | number;
+
+  /**
+   * The `Ember.Route` class is used to define individual routes. Refer to
+   * the [routing guide](http://emberjs.com/guides/routing/) for documentation.
+   */
+  export default class Route<
+    Model = unknown,
+    Params extends object = object
+  > extends EmberObject.extend(ActionHandler, Evented) {
+    // methods
+    /**
+     * This hook is called after this route's model has resolved. It follows
+     * identical async/promise semantics to `beforeModel` but is provided the
+     * route's resolved model in addition to the `transition`, and is therefore
+     * suited to performing logic that can only take place after the model has
+     * already resolved.
+     *
+     * @returns if the value returned from this hook is a promise, the
+     *   transition will pause until the transition resolves. Otherwise,
+     *   non-promise return values are not utilized in any way.
+     */
+    afterModel(resolvedModel: Model, transition: Transition): Promise<unknown> | void;
+
+    /**
+     * This hook is the first of the route entry validation hooks called when an
+     * attempt is made to transition into a route or one of its children. It is
+     * called before `model` and `afterModel`, and is appropriate for cases
+     * when:
+     *
+     * 1. A decision can be made to redirect elsewhere without needing to
+     *     resolve the model first.
+     * 2. Any async operations need to occur first before the model is attempted
+     *     to be resolved.
+     *
+     * This hook is provided the current `transition` attempt as a parameter,
+     * which can be used to `.abort()` the transition, save it for a later
+     * `.retry()`, or retrieve values set on it from a previous hook. You can
+     * also just call `this.transitionTo` to another route to implicitly abort
+     * the `transition`. You can return a promise from this hook to pause the
+     * transition until the promise resolves (or rejects). This could be useful,
+     * for instance, for retrieving async code from the server that is required
+     * to enter a route.
+     *
+     * @returns if the value returned from this hook is a promise, the
+     *   transition will pause until the transition resolves. Otherwise,
+     *   non-promise return values are not utilized in any way.
+     */
+    beforeModel(transition: Transition): Promise<unknown> | void;
+
+    /**
+     * Returns the controller of the current route, or a parent (or any
+     * ancestor) route in a route hierarchy.
+     *
+     * The controller instance must already have been created, either through
+     * entering the associated route or using `generateController`.
+     *
+     * @param name the name of the route or controller
+     */
+    controllerFor(name: string): Controller;
+
+    /**
+     * A hook you can implement to convert the URL into the model for
+     * this route.
+     */
+    model(params: Params, transition: Transition): Model | PromiseLike<Model>;
+
+    /**
+     * Returns the model of a parent (or any ancestor) route
+     * in a route hierarchy.  During a transition, all routes
+     * must resolve a model object, and if a route
+     * needs access to a parent route's model in order to
+     * resolve a model (or just reuse the model from a parent),
+     * it can call `this.modelFor(theNameOfParentRoute)` to
+     * retrieve it.
+     */
+    modelFor(name: string): unknown;
+
+    /**
+     * Retrieves parameters, for current route using the state.params
+     * variable and getQueryParamsFor, using the supplied routeName.
+     */
+    paramsFor(name: string): object;
+
+    /**
+     * A hook you can implement to optionally redirect to another route.
+     *
+     * If you call `this.transitionTo` from inside of this hook, this route
+     * will not be entered in favor of the other hook.
+     *
+     * `redirect` and `afterModel` behave very similarly and are
+     * called almost at the same time, but they have an important
+     * distinction in the case that, from one of these hooks, a
+     * redirect into a child route of this route occurs: redirects
+     * from `afterModel` essentially invalidate the current attempt
+     * to enter this route, and will result in this route's `beforeModel`,
+     * `model`, and `afterModel` hooks being fired again within
+     * the new, redirecting transition. Redirects that occur within
+     * the `redirect` hook, on the other hand, will _not_ cause
+     * these hooks to be fired again the second time around; in
+     * other words, by the time the `redirect` hook has been called,
+     * both the resolved model and attempted entry into this route
+     * are considered to be fully validated.
+     */
+    redirect(model: Model, transition: Transition): void;
+
+    /**
+     * Refresh the model on this route and any child routes, firing the
+     * `beforeModel`, `model`, and `afterModel` hooks in a similar fashion
+     * to how routes are entered when transitioning in from other route.
+     * The current route params (e.g. `article_id`) will be passed in
+     * to the respective model hooks, and if a different model is returned,
+     * `setupController` and associated route hooks will re-fire as well.
+     * An example usage of this method is re-querying the server for the
+     * latest information using the same parameters as when the route
+     * was first entered.
+     * Note that this will cause `model` hooks to fire even on routes
+     * that were provided a model object when the route was initially
+     * entered.
+     */
+    refresh(): Transition;
+
+    /**
+     * Transition into another route while replacing the current URL, if possible.
+     * This will replace the current history entry instead of adding a new one.
+     * Beside that, it is identical to `transitionTo` in all other respects. See
+     * 'transitionTo' for additional information regarding multiple models.
+     *
+     * @param name    the name of the route or a URL
+     * @param models  the model(s) or identifier(s) to be used while
+     *                transitioning to the route.
+     * @param options optional hash with a queryParams property
+     *                containing a mapping of query parameters. May be supplied
+     *                as the only parameter to trigger a query-parameter-only
+     *                transition.
+     * @returns       the Transition object associated with this attempted
+     *                transition
+     * @deprecated    until 5.0. Inject the router service and use its methods.
+     */
+    replaceWith(name: string, ...args: unknown[]): Transition;
+
+    /**
+     * A hook you can use to reset controller values either when the model
+     * changes or the route is exiting.
+     */
+    resetController(controller: Controller, isExiting: boolean, transition: Transition): void;
+
+    /**
+     * Sends an action to the router, which will delegate it to the currently active
+     * route hierarchy per the bubbling rules explained under actions.
+     */
+    send(name: string, ...args: unknown[]): void;
+
+    /**
+     * A hook you can implement to convert the route's model into parameters
+     * for the URL.
+     *
+     * The default `serialize` method will insert the model's `id` into the
+     * route's dynamic segment (in this case, `:post_id`) if the segment contains '_id'.
+     * If the route has multiple dynamic segments or does not contain '_id', `serialize`
+     * will return `Ember.getProperties(model, params)`
+     * This method is called when `transitionTo` is called with a context
+     * in order to populate the URL.
+     */
+    serialize(model: Model, params: string[]): string | object;
+
+    /**
+     * A hook you can use to setup the controller for the current route.
+     * This method is called with the controller for the current route and the
+     * model supplied by the `model` hook.
+     * By default, the `setupController` hook sets the `model` property of
+     * the controller to the `model`.
+     * If you implement the `setupController` hook in your Route, it will
+     * prevent this default behavior. If you want to preserve that behavior
+     * when implementing your `setupController` function, make sure to call
+     * `_super`
+     */
+    setupController(controller: Controller, model: Model, transition: Transition): void;
+
+    /**
+     * Transition the application into another route. The route may
+     * be either a single route or route path:
+     *
+     * ```javascript
+     * this.transitionTo('blogPosts');
+     * this.transitionTo('blogPosts.recentEntries');
+     * ```
+     *
+     * Optionally supply a model for the route in question. The model
+     * will be serialized into the URL using the `serialize` hook of
+     * the route:
+     *
+     * ```javascript
+     * this.transitionTo('blogPost', aPost);
+     * ```
+     *
+     * If a literal is passed (such as a number or a string), it will
+     * be treated as an identifier instead. In this case, the `model`
+     * hook of the route will be triggered:
+     *
+     * ```javascript
+     * this.transitionTo('blogPost', 1);
+     * ```
+     *
+     * Multiple models will be applied last to first recursively up the
+     * route tree.
+     *
+     * ```app/routes.js
+     * // ...
+     *
+     * Router.map(function() {
+     *   this.route('blogPost', { path:':blogPostId' }, function() {
+     *     this.route('blogComment', { path: ':blogCommentId' });
+     *   });
+     * });
+     *
+     * export default Router;
+     * ```
+     *
+     * ```javascript
+     * this.transitionTo('blogComment', aPost, aComment);
+     * this.transitionTo('blogComment', 1, 13);
+     * ```
+     *
+     * It is also possible to pass a URL (a string that starts with a
+     * `/`).
+     *
+     * ```javascript
+     * this.transitionTo('/');
+     * this.transitionTo('/blog/post/1/comment/13');
+     * this.transitionTo('/blog/posts?sort=title');
+     * ```
+     *
+     * An options hash with a `queryParams` property may be provided as
+     * the final argument to add query parameters to the destination URL.
+     *
+     * ```javascript
+     * this.transitionTo('blogPost', 1, {
+     *   queryParams: { showComments: 'true' }
+     * });
+     *
+     * // if you just want to transition the query parameters without changing the route
+     * this.transitionTo({ queryParams: { sort: 'date' } });
+     * ```
+     *
+     * See also [replaceWith](#method_replaceWith).
+     *
+     * Simple Transition Example
+     *
+     * ```app/routes.js
+     * // ...
+     *
+     * Router.map(function() {
+     *   this.route('index');
+     *   this.route('secret');
+     *   this.route('fourOhFour', { path: '*:' });
+     * });
+     *
+     * export default Router;
+     * ```
+     *
+     * ```app/routes/index.js
+     * import Route from '@ember/routing/route';
+     * import { action } from '@ember/object';
+     *
+     * export default class IndexRoute extends Route {
+     *   @action
+     *   moveToSecret(context) {
+     *     if (authorized()) {
+     *       this.transitionTo('secret', context);
+     *     } else {
+     *       this.transitionTo('fourOhFour');
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * Transition to a nested route
+     *
+     * ```app/router.js
+     * // ...
+     *
+     * Router.map(function() {
+     *   this.route('articles', { path: '/articles' }, function() {
+     *     this.route('new');
+     *   });
+     * });
+     *
+     * export default Router;
+     * ```
+     *
+     * ```app/routes/index.js
+     * import Route from '@ember/routing/route';
+     * import { action } from '@ember/object';
+     *
+     * export default class IndexRoute extends Route {
+     *   @action
+     *   transitionToNewArticle() {
+     *     this.transitionTo('articles.new');
+     *   }
+     * }
+     * ```
+     *
+     * Multiple Models Example
+     *
+     * ```app/router.js
+     * // ...
+     *
+     * Router.map(function() {
+     *   this.route('index');
+     *
+     *   this.route('breakfast', { path: ':breakfastId' }, function() {
+     *     this.route('cereal', { path: ':cerealId' });
+     *   });
+     * });
+     *
+     * export default Router;
+     * ```
+     *
+     * ```app/routes/index.js
+     * import Route from '@ember/routing/route';
+     * import { action } from '@ember/object';
+     *
+     * export default class IndexRoute extends Route {
+     *   @action
+     *   moveToChocolateCereal() {
+     *     let cereal = { cerealId: 'ChocolateYumminess' };
+     *     let breakfast = { breakfastId: 'CerealAndMilk' };
+     *
+     *     this.transitionTo('breakfast.cereal', breakfast, cereal);
+     *   }
+     * }
+     * ```
+     *
+     * Nested Route with Query String Example
+     *
+     * ```app/routes.js
+     * // ...
+     *
+     * Router.map(function() {
+     *   this.route('fruits', function() {
+     *     this.route('apples');
+     *   });
+     * });
+     *
+     * export default Router;
+     * ```
+     *
+     * ```app/routes/index.js
+     * import Route from '@ember/routing/route';
+     *
+     * export default class IndexRoute extends Route {
+     *   @action
+     *   transitionToApples() {
+     *     this.transitionTo('fruits.apples', { queryParams: { color: 'red' } });
+     *   }
+     * }
+     * ```
+     *
+     * @param name    the name of the route or a URL.
+     * @param models  the model(s) or identifier(s) to be used while
+     *                transitioning to the route.
+     * @param options optional hash with a queryParams property
+     *                containing a mapping of query parameters. May be supplied
+     *                as the only parameter to trigger a query-parameter-only
+     *                transition.
+     * @returns       the Transition object associated with this attempted
+     *                transition
+     * @deprecated    until 5.0. Inject the router service and use its methods.
+     */
+    transitionTo(name: string, options?: { queryParams: object }): Transition;
+    transitionTo(name: string, modelsA: RouteModel, options?: { queryParams: object }): Transition;
+    transitionTo(
+      name: string,
+      modelsA: RouteModel,
+      modelsB: RouteModel,
+      options?: { queryParams: object }
+    ): Transition;
+    transitionTo(
+      name: string,
+      modelsA: RouteModel,
+      modelsB: RouteModel,
+      modelsC: RouteModel,
+      options?: { queryParams: object }
+    ): Transition;
+    transitionTo(
+      name: string,
+      modelsA: RouteModel,
+      modelsB: RouteModel,
+      modelsC: RouteModel,
+      modelsD: RouteModel,
+      options?: { queryParams: object }
+    ): Transition;
+    transitionTo(options: { queryParams: object }): Transition;
+
+    // https://emberjs.com/api/ember/release/classes/Route/methods/intermediateTransitionTo?anchor=intermediateTransitionTo
+    /**
+     * Perform a synchronous transition into another route without attempting to resolve promises,
+     * update the URL, or abort any currently active asynchronous transitions
+     * (i.e. regular transitions caused by transitionTo or URL changes).
+     *
+     * @param name           the name of the route or a URL
+     * @param models         the model(s) or identifier(s) to be used while
+     *                       transitioning to the route.
+     * @returns              the Transition object associated with this attempted transition
+     */
+    intermediateTransitionTo(name: string, ...models: unknown[]): Transition;
+
+    // properties
+    /**
+     * The controller associated with this route.
+     */
+    controller: Controller;
+
+    /**
+     * The name of the controller to associate with this route.
+     * By default, Ember will lookup a route's controller that matches the name
+     * of the route (i.e. `App.PostController` for `App.PostRoute`). However,
+     * if you would like to define a specific controller to use, you can do so
+     * using this property.
+     * This is useful in many ways, as the controller specified will be:
+     * * p assed to the `setupController` method.
+     * * used as the controller for the view being rendered by the route.
+     * * returned from a call to `controllerFor` for the route.
+     */
+    controllerName: string;
+
+    /**
+     * The name of the route, dot-delimited, including the engine prefix if applicable.
+     */
+    fullRouteName: string;
+
+    /**
+     * Configuration hash for this route's queryParams.
+     */
+    queryParams: { [key: string]: RouteQueryParam };
+
+    /**
+     * The name of the route, dot-delimited
+     */
+    routeName: string;
+
+    /**
+     * The name of the template to use by default when rendering this routes
+     * template.
+     * This is similar with `viewName`, but is useful when you just want a custom
+     * template without a view.
+     */
+    templateName: string;
+
+    // events
+    /**
+     * This hook is executed when the router enters the route. It is not executed
+     * when the model for the route changes.
+     */
+    activate(transition: Transition): void;
+
+    /**
+     * This hook is executed when the router completely exits this route. It is
+     * not executed when the model for the route changes.
+     */
+    deactivate(transition: Transition): void;
+
+    /**
+     * The didTransition action is fired after a transition has successfully been
+     * completed. This occurs after the normal model hooks (beforeModel, model,
+     * afterModel, setupController) have resolved. The didTransition action has
+     * no arguments, however, it can be useful for tracking page views or resetting
+     * state on the controller.
+     */
+    didTransition(): void;
+
+    /**
+     * When attempting to transition into a route, any of the hooks may return a promise
+     * that rejects, at which point an error action will be fired on the partially-entered
+     * routes, allowing for per-route error handling logic, or shared error handling logic
+     * defined on a parent route.
+     */
+    error(error: unknown, transition: Transition): void;
+
+    /**
+     * The loading action is fired on the route when a route's model hook returns a
+     * promise that is not already resolved. The current Transition object is the first
+     * parameter and the route that triggered the loading event is the second parameter.
+     */
+    loading(transition: Transition, route: Route): void;
+
+    /**
+     * The willTransition action is fired at the beginning of any attempted transition
+     * with a Transition object as the sole argument. This action can be used for aborting,
+     * redirecting, or decorating the transition from the currently active routes.
+     */
+    willTransition(transition: Transition): void;
+
+    /**
+     * Allows you to produce custom metadata for the route.
+     * The return value of this method will be attached to
+     * its corresponding RouteInfoWithAttributes object.
+     * Example
+     * ```app/routes/posts/index.js
+     * import Route from '@ember/routing/route';
+     * export default class PostsIndexRoute extends Route {
+     *   buildRouteInfoMetadata() {
+     *     return { title: 'Posts Page' }
+     *   }
+     * }
+     * ```
+     * ```app/routes/application.js
+     * import Route from '@ember/routing/route';
+     * import { inject as service } from '@ember/service';
+     * export default class ApplicationRoute extends Route {
+     *   @service router
+     *   constructor() {
+     *     super(...arguments);
+     *     this.router.on('routeDidChange', transition => {
+     *       document.title = transition.to.metadata.title;
+     *       // would update document's title to "Posts Page"
+     *     });
+     *   }
+     * }
+     * ```
+     */
+    buildRouteInfoMetadata(): unknown;
+  }
+}
diff --git a/types/preview/@ember/routing/router-service.d.ts b/types/preview/@ember/routing/router-service.d.ts
new file mode 100644
index 00000000000..35b16927e85
--- /dev/null
+++ b/types/preview/@ember/routing/router-service.d.ts
@@ -0,0 +1,351 @@
+declare module '@ember/routing/router-service' {
+  import RouteInfo, { RouteInfoWithAttributes } from '@ember/routing/route-info';
+  import Transition from '@ember/routing/transition';
+  import Service from '@ember/service';
+
+  type RouteModel = object | string | number;
+
+  // https://emberjs.com/api/ember/release/classes/RouterService
+  /**
+   * The Router service is the public API that provides component/view layer access to the router.
+   */
+  export default class RouterService extends Service {
+    //
+    /**
+     * A `RouteInfo` that represents the current leaf route.
+     * It is guaranteed to change whenever a route transition happens
+     * (even when that transition only changes parameters and doesn't change the active route)
+     */
+    readonly currentRoute: RouteInfo;
+    /**
+     * Name of the current route.
+     * This property represent the logical name of the route,
+     * which is comma separated.
+     * For the following router:
+     * ```app/router.js
+     * Router.map(function() {
+     * this.route('about');
+     * this.route('blog', function () {
+     *     this.route('post', { path: ':post_id' });
+     * });
+     * });
+     * ```
+     * It will return:
+     * * `index` when you visit `/`
+     * * `about` when you visit `/about`
+     * * `blog.index` when you visit `/blog`
+     * * `blog.post` when you visit `/blog/some-post-id`
+     */
+    readonly currentRouteName: string;
+    //
+    /**
+     * Current URL for the application.
+     * This property represent the URL path for this route.
+     * For the following router:
+     * ```app/router.js
+     * Router.map(function() {
+     * this.route('about');
+     * this.route('blog', function () {
+     *     this.route('post', { path: ':post_id' });
+     * });
+     * });
+     * ```
+     * It will return:
+     * * `/` when you visit `/`
+     * * `/about` when you visit `/about`
+     * * `/blog` when you visit `/blog`
+     * * `/blog/some-post-id` when you visit `/blog/some-post-id`
+     */
+    readonly currentURL: string;
+
+    /**
+     * The `rootURL` property represents the URL of the root of
+     * the application, '/' by default.
+     * This prefix is assumed on all routes defined on this app.
+     * If you change the `rootURL` in your environment configuration
+     * like so:
+     * ```config/environment.js
+     * 'use strict';
+     * module.exports = function(environment) {
+     *   let ENV = {
+     *     modulePrefix: 'router-service',
+     *     environment,
+     *     rootURL: '/my-root',
+     *   …
+     *   }
+     * ]
+     * ```
+     * This property will return `/my-root`.
+     */
+    readonly rootURL: string;
+
+    /**
+     * Determines whether a route is active.
+     *
+     * @param routeName the name of the route
+     * @param models    the model(s) or identifier(s) to be used while
+     *                  transitioning to the route
+     * @param options   optional hash with a queryParams property containing a
+     *                  mapping of query parameters
+     */
+    isActive(routeName: string, options?: { queryParams: object }): boolean;
+    isActive(routeName: string, models: RouteModel, options?: { queryParams: object }): boolean;
+    isActive(
+      routeName: string,
+      modelsA: RouteModel,
+      modelsB: RouteModel,
+      options?: { queryParams: object }
+    ): boolean;
+    isActive(
+      routeName: string,
+      modelsA: RouteModel,
+      modelsB: RouteModel,
+      modelsC: RouteModel,
+      options?: { queryParams: object }
+    ): boolean;
+    isActive(
+      routeName: string,
+      modelsA: RouteModel,
+      modelsB: RouteModel,
+      modelsC: RouteModel,
+      modelsD: RouteModel,
+      options?: { queryParams: object }
+    ): boolean;
+
+    // https://emberjs.com/api/ember/4.0/classes/RouterService/methods/isActive?anchor=replaceWith
+    /**
+     * Transition into another route while replacing the current URL, if
+     * possible. The route may be either a single route or route path.
+     *
+     * @param routeNameOrUrl the name of the route or a URL
+     * @param models         the model(s) or identifier(s) to be used while
+     *                       transitioning to the route.
+     * @param options        optional hash with a queryParams property
+     *                       containing a mapping of query parameters
+     * @returns              the Transition object associated with this attempted transition
+     */
+    replaceWith(routeNameOrUrl: string, options?: { queryParams: object }): Transition;
+    replaceWith(
+      routeNameOrUrl: string,
+      models: RouteModel,
+      options?: { queryParams: object }
+    ): Transition;
+    replaceWith(
+      routeNameOrUrl: string,
+      modelsA: RouteModel,
+      modelsB: RouteModel,
+      options?: { queryParams: object }
+    ): Transition;
+    replaceWith(
+      routeNameOrUrl: string,
+      modelsA: RouteModel,
+      modelsB: RouteModel,
+      modelsC: RouteModel,
+      options?: { queryParams: object }
+    ): Transition;
+    replaceWith(
+      routeNameOrUrl: string,
+      modelsA: RouteModel,
+      modelsB: RouteModel,
+      modelsC: RouteModel,
+      modelsD: RouteModel,
+      options?: { queryParams: object }
+    ): Transition;
+
+    // https://emberjs.com/api/ember/release/classes/RouterService/methods/isActive?anchor=transitionTo
+    /**
+     * Transition the application into another route. The route may
+     * be either a single route or route path:
+     *
+     * See [transitionTo](https://api.emberjs.com/ember/release/classes/Route/methods/transitionTo?anchor=transitionTo) for more info.
+     *
+     * Calling `transitionTo` from the Router service will cause default query parameter values to be included in the URL.
+     * This behavior is different from calling `transitionTo` on a route or `transitionToRoute` on a controller.
+     * See the [Router Service RFC](https://github.com/emberjs/rfcs/blob/master/text/0095-router-service.md#query-parameter-semantics) for more info.
+     *
+     * In the following example we use the Router service to navigate to a route with a
+     * specific model from a Component.
+     *
+     * ```app/components/example.js
+     * import Component from '@glimmer/component';
+     * import { action } from '@ember/object';
+     * import { inject as service } from '@ember/service';
+     *
+     * export default class extends Component {
+     *   @service router;
+     *
+     *   @action
+     *   goToComments(post) {
+     *     this.router.transitionTo('comments', post);
+     *   }
+     * }
+     * ```
+     *
+     * @param routeNameOrUrl the name of the route or a URL
+     * @param models         the model(s) or identifier(s) to be used while
+     *                       transitioning to the route.
+     * @param options        optional hash with a queryParams property
+     *                       containing a mapping of query parameters. May be
+     *                       supplied as the only parameter to trigger a
+     *                       query-parameter-only transition.
+     * @returns              the Transition object associated with this attempted transition
+     */
+    transitionTo(routeNameOrUrl: string, options?: { queryParams: object }): Transition;
+    transitionTo(
+      routeNameOrUrl: string,
+      models: RouteModel,
+      options?: { queryParams: object }
+    ): Transition;
+    transitionTo(
+      routeNameOrUrl: string,
+      modelsA: RouteModel,
+      modelsB: RouteModel,
+      options?: { queryParams: object }
+    ): Transition;
+    transitionTo(
+      routeNameOrUrl: string,
+      modelsA: RouteModel,
+      modelsB: RouteModel,
+      modelsC: RouteModel,
+      options?: { queryParams: object }
+    ): Transition;
+    transitionTo(
+      routeNameOrUrl: string,
+      modelsA: RouteModel,
+      modelsB: RouteModel,
+      modelsC: RouteModel,
+      modelsD: RouteModel,
+      options?: { queryParams: object }
+    ): Transition;
+    transitionTo(options: { queryParams: object }): Transition;
+
+    // https://emberjs.com/api/ember/4.3.0/classes/RouterService/methods/isActive?anchor=urlFor
+    /**
+     * Generate a URL based on the supplied route name.
+     *
+     * @param routeName the name of the route or a URL
+     * @param models    the model(s) or identifier(s) to be used while
+     *                  transitioning to the route.
+     * @param options   optional hash with a queryParams property containing
+     *                  a mapping of query parameters
+     * @returns         the string representing the generated URL
+     */
+    urlFor(
+      routeName: string,
+      ...args: RouteModel[] | [...RouteModel[], { queryParams: object }]
+    ): string;
+
+    // https://api.emberjs.com/ember/3.6/classes/RouterService/events/routeDidChange?anchor=routeDidChange
+    /**
+     * Register a callback for an event.
+     *
+     * The `routeWillChange` event is fired at the beginning of any attempted transition with a `Transition` object as the sole argument.
+     * This action can be used for aborting, redirecting, or decorating the transition from the currently active routes.
+     *
+     * The `routeDidChange` event only fires once a transition has settled.
+     * This includes aborts and error substates.
+     * Like the `routeWillChange` event it recieves a `Transition` as the sole argument.
+     *
+     * @param name     the name of the event
+     * @param callback the callback to execute
+     */
+    on(
+      name: 'routeDidChange' | 'routeWillChange',
+      callback: (transition: Transition) => void
+    ): RouterService;
+
+    // https://api.emberjs.com/ember/3.28/classes/Evented/methods/off?anchor=off
+    /**
+     * Removes a callback for an event.
+     *
+     * The `routeWillChange` event is fired at the beginning of any attempted transition with a `Transition` object as the sole argument.
+     * This action can be used for aborting, redirecting, or decorating the transition from the currently active routes.
+     *
+     * The `routeDidChange` event only fires once a transition has settled.
+     * This includes aborts and error substates.
+     *
+     * @param name     the name of the event 'routeWillChange' | 'routeDidChange'
+     * @param callback the callback to remove
+     */
+    off(
+      name: 'routeDidChange' | 'routeWillChange',
+      callback: (transition: Transition) => void
+    ): RouterService;
+
+    /**
+     * https://api.emberjs.com/ember/3.28/classes/Evented/methods/off?anchor=has
+     *
+     * Checks to see if object has any subscriptions for named event.
+     *
+     * @param name
+     */
+    has(name: string): boolean;
+
+    /**
+     * https://api.emberjs.com/ember/3.28/classes/Evented/methods/off?anchor=one
+     *
+     * Subscribes a function to a named event and then cancels the subscription after the first time the
+     * event is triggered. It is good to use one when you only care about the first time an event has taken place.
+     *
+     * @param name     the name of the event
+     * @param callback the callback to execute
+     */
+    one(
+      name: 'routeDidChange' | 'routeWillChange',
+      callback: (transition: Transition) => void
+    ): RouterService;
+
+    /**
+     * https://api.emberjs.com/ember/3.28/classes/Evented/methods/off?anchor=trigger
+     *
+     * Triggers a named event for the object.
+     * Any additional arguments will be passed as parameters to the functions that are subscribed to the event.
+     *
+     * @param name the name of the event
+     * @param args arguments to pass to the event
+     */
+    trigger(name: string, args: any): void;
+
+    /**
+     * Takes a string URL and returns a `RouteInfo` for the leafmost route represented
+     * by the URL. Returns `null` if the URL is not recognized. This method expects to
+     * receive the actual URL as seen by the browser including the app's `rootURL`.
+     * See [RouteInfo](/ember/release/classes/RouteInfo) for more info.
+     * In the following example `recognize` is used to verify if a path belongs to our
+     * application before transitioning to it.
+     * ```
+     * import Component from '@ember/component';
+     * import { inject as service } from '@ember/service';
+     * export default class extends Component {
+     *   @service router;
+     *   path = '/';
+     *   click() {
+     *     if (this.router.recognize(this.path)) {
+     *       this.router.transitionTo(this.path);
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    recognize(url: string): RouteInfo;
+
+    /**
+     * Takes a string URL and returns a promise that resolves to a
+     * `RouteInfoWithAttributes` for the leafmost route represented by the URL.
+     * The promise rejects if the URL is not recognized or an unhandled exception
+     * is encountered. This method expects to receive the actual URL as seen by
+     * the browser including the app's `rootURL`.
+     */
+    recognizeAndLoad(url: string): RouteInfoWithAttributes;
+
+    /**
+     * Refreshes all currently active routes, doing a full transition.
+     * If a route name is provided and refers to a currently active route,
+     * it will refresh only that route and its descendents.
+     * Returns a promise that will be resolved once the refresh is complete.
+     * All resetController, beforeModel, model, afterModel, redirect, and setupController
+     * hooks will be called again. You will get new data from the model hook.
+     */
+    refresh(pivotRouteName?: string): Transition;
+  }
+}
diff --git a/types/preview/@ember/routing/router.d.ts b/types/preview/@ember/routing/router.d.ts
new file mode 100644
index 00000000000..299dc3f43df
--- /dev/null
+++ b/types/preview/@ember/routing/router.d.ts
@@ -0,0 +1,49 @@
+declare module '@ember/routing/router' {
+  import EmberObject from '@ember/object';
+  import Evented from '@ember/object/evented';
+  import RouterDSL from '@ember/routing/-private/router-dsl';
+  import Transition from '@ember/routing/transition';
+
+  /**
+   * The `Ember.Router` class manages the application state and URLs. Refer to
+   * the [routing guide](http://emberjs.com/guides/routing/) for documentation.
+   */
+  export default class Router extends EmberObject {
+    /**
+     * The `Router.map` function allows you to define mappings from URLs to routes
+     * in your application. These mappings are defined within the
+     * supplied callback function using `this.route`.
+     */
+    static map(callback: (this: RouterDSL) => void): void;
+    /**
+     * The `location` property determines the type of URL's that your
+     * application will use.
+     *
+     * @note the `'auto'` location is [deprecated](https://deprecations.emberjs.com/v4.x/#toc_deprecate-auto-location).
+     */
+    location: 'history' | 'hash' | 'none' | 'auto';
+    /**
+     * Represents the URL of the root of the application, often '/'. This prefix is
+     * assumed on all routes defined on this router.
+     */
+    rootURL: string;
+    /**
+     * Transition the application into another route. The route may
+     * be either a single route or route path:
+     */
+    transitionTo(name: string, options?: {}): Transition;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transitionTo(name: string, ...models: any[]): Transition;
+    transitionTo(name: string, options: {}): Transition;
+  }
+
+  export default interface RouterService extends Evented {}
+}
+
+declare module '@ember/service' {
+  import RouterService from '@ember/routing/router-service';
+
+  interface Registry {
+    router: RouterService;
+  }
+}
diff --git a/types/preview/@ember/routing/transition.d.ts b/types/preview/@ember/routing/transition.d.ts
new file mode 100644
index 00000000000..0d36e8437d8
--- /dev/null
+++ b/types/preview/@ember/routing/transition.d.ts
@@ -0,0 +1,126 @@
+declare module '@ember/routing/transition' {
+  import RouteInfo, { RouteInfoWithAttributes } from '@ember/routing/route-info';
+
+  /**
+   * A Transition is a thennable (a promise-like object) that represents an
+   * attempt to transition to another route. It can be aborted, either explicitly
+   * via `abort` or by attempting another transition while a previous one is still
+   * underway. An aborted transition can also be `retry()`d later.
+   *
+   * @note This is a non-user-constructible type. The only legal way to get a
+   *   transition is using one of the public API methods on routes, controllers,
+   *   the router service, etc.
+   */
+  export default interface Transition<T = unknown> extends Partial<Promise<T>> {
+    /**
+     * Custom state can be stored on a Transition's `data` object.
+     * This can be useful for decorating a Transition within an earlier hook and shared with a later hook.
+     * Properties set on `data` will be copied to new transitions generated by calling `retry` on this transition.
+     */
+    data: Record<string, unknown>;
+    /**
+     * This property is a `RouteInfo` object that represents where transition originated from.
+     * It's important to note that a `RouteInfo` is a linked list and this property is simply the head node of the list.
+     * In the case of an initial render, `from` will be set to `null`.
+     */
+    readonly from: RouteInfoWithAttributes | null;
+    /**
+     * The Transition's internal promise.
+     * Calling `.then` on this property is that same as calling `.then` on the Transition object itself,
+     * but this property is exposed for when you want to pass around a Transition's promise,
+     * but not the Transition object itself, since Transition object can be externally `abort`ed,
+     * while the promise cannot.
+     */
+    readonly promise: Promise<T>;
+    /**
+     * This property is a `RouteInfo` object that represents where the router is transitioning to.
+     * It's important to note that a `RouteInfo` is a linked list and this property is simply the leafmost route.
+     */
+    readonly to: RouteInfo | RouteInfoWithAttributes;
+    /**
+     * Aborts the Transition. Note you can also implicitly abort a transition
+     * by initiating another transition while a previous one is underway.
+     */
+    abort(): Transition<T>;
+    /**
+     * Forwards to the internal `promise` property which you can use in situations where you want to pass around a thennable,
+     * but not the Transition itself.
+     *
+     * @param onRejection
+     * @param label optional string for labeling the promise. Useful for tooling.
+     */
+    catch<TResult = never>(
+      onRejected?: (reason: unknown) => TResult | PromiseLike<TResult>,
+      label?: string
+    ): Promise<TResult | T>;
+    /**
+     * Forwards to the internal `promise` property which you can use in situations where you want to pass around a thennable,
+     * but not the Transition itself.
+     *
+     * @param onFinally
+     * @param label optional string for labeling the promise. Useful for tooling.
+     */
+    finally(onFinally?: () => void, label?: string): Promise<T>;
+    /**
+     * Transitions are aborted and their promises rejected when redirects occur;
+     * this method returns a promise that will follow any redirects that occur and
+     * fulfill with the value fulfilled by any redirecting transitions that occur.
+     *
+     * @return a promise that fulfills with the same value that the final redirecting transition fulfills with
+     */
+    followRedirects(): Promise<T>;
+    /**
+     * Sets the URL-changing method to be employed at the end of a successful transition.
+     * By default, a new Transition will just use `updateURL`,
+     * but passing 'replace' to this method will cause the URL to update using 'replaceWith' instead.
+     * Omitting a parameter will disable the URL change,
+     * allowing for transitions that don't update the URL at completion
+     * (this is also used for handleURL, since the URL has already changed before the transition took place).
+     *
+     * @param  method the type of URL-changing method to use at the end of a transition. Accepted values are 'replace',
+     *                falsy values, or any other non-falsy value (which is interpreted as an updateURL transition).
+     * @return        This transition
+     */
+    method(method?: string): Transition<T>;
+    /**
+     * Retries a previously-aborted transition (making sure to abort the
+     * transition if it's still active). Returns a new transition that
+     * represents the new attempt to transition.
+     */
+    retry(): Transition<T>;
+    /**
+     * A standard promise hook that resolves if the transition succeeds and rejects if it fails/redirects/aborts.
+     *
+     * Forwards to the internal `promise` property which you can use in situations where you want to pass around a thennable,
+     * but not the Transition itself.
+     *
+     * @param  onFulfilled
+     * @param  onRejected
+     * @param  label label optional string for labeling the promise. Useful for tooling.
+     */
+    then<TResult1 = T, TResult2 = never>(
+      onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>,
+      onrejected?: (reason: unknown) => TResult2 | PromiseLike<TResult2>,
+      label?: string
+    ): Promise<TResult1 | TResult2>;
+    /**
+     * Fires an event on the current list of resolved/resolving handlers within this transition.
+     * Useful for firing events on route hierarchies that haven't fully been entered yet.
+     *
+     * @param  ignoreFailure a boolean specifying whether unhandled events throw an error
+     * @param  name          the name of the event to fire
+     */
+    send(ignoreFailure: boolean, name: string): void;
+    /**
+     * Fires an event on the current list of resolved/resolving handlers within this transition.
+     * Useful for firing events on route hierarchies that haven't fully been entered yet.
+     * Note: This method is also aliased as `send`
+     *
+     * @alias send
+     *
+     * @param  ignoreFailure a boolean specifying whether unhandled events throw an error
+     * @param  name          the name of the event to fire
+     */
+    trigger(ignoreFailure: boolean, name: string): void;
+  }
+}
diff --git a/types/preview/@ember/routing/tsconfig.json b/types/preview/@ember/routing/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/routing/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/routing/types.d.ts b/types/preview/@ember/routing/types.d.ts
new file mode 100644
index 00000000000..c8483e79e47
--- /dev/null
+++ b/types/preview/@ember/routing/types.d.ts
@@ -0,0 +1,15 @@
+declare module '@ember/routing/types' {
+  export interface RenderOptions {
+    into?: string | undefined;
+    controller?: string | undefined;
+    model?: unknown;
+    outlet?: string | undefined;
+    view?: string | undefined;
+  }
+
+  export interface RouteQueryParam {
+    refreshModel?: boolean | undefined;
+    replace?: boolean | undefined;
+    as?: string | undefined;
+  }
+}
diff --git a/types/preview/@ember/runloop/-private/backburner.d.ts b/types/preview/@ember/runloop/-private/backburner.d.ts
new file mode 100644
index 00000000000..20fc9cff668
--- /dev/null
+++ b/types/preview/@ember/runloop/-private/backburner.d.ts
@@ -0,0 +1,43 @@
+declare module '@ember/runloop/-private/backburner' {
+  import { EmberMethod, EmberMethodParams } from 'ember/-private/type-utils';
+
+  export interface QueueItem {
+    method: string;
+    target: object;
+    args: object[];
+    stack: string | undefined;
+  }
+
+  export interface DeferredActionQueues {
+    [index: string]: unknown;
+    queues: object;
+    schedule<T, M extends EmberMethod<T>>(
+      ...args: [
+        queueName: string,
+        target: T,
+        method: M,
+        ...methodArgs: EmberMethodParams<T, M>,
+        onceFlag: boolean,
+        stack: unknown
+      ]
+    ): any;
+    flush(fromAutorun: boolean): any;
+  }
+
+  export interface DebugInfo {
+    autorun: Error | undefined | null;
+    counters: object;
+    timers: QueueItem[];
+    instanceStack: DeferredActionQueues[];
+  }
+
+  export interface Backburner {
+    join(...args: any[]): void;
+    on(...args: any[]): void;
+    scheduleOnce(...args: any[]): void;
+    schedule(queueName: string, target: object | null, method: () => void | string): void;
+    ensureInstance(): void;
+    DEBUG: boolean;
+    getDebugInfo(): DebugInfo;
+  }
+}
diff --git a/types/preview/@ember/runloop/-private/types.d.ts b/types/preview/@ember/runloop/-private/types.d.ts
new file mode 100644
index 00000000000..8fa9ccf9bf2
--- /dev/null
+++ b/types/preview/@ember/runloop/-private/types.d.ts
@@ -0,0 +1,9 @@
+declare module '@ember/runloop/-private/types' {
+  export type EmberRunQueues =
+    | 'sync'
+    | 'actions'
+    | 'routerTransitions'
+    | 'render'
+    | 'afterRender'
+    | 'destroy';
+}
diff --git a/types/preview/@ember/runloop/index.d.ts b/types/preview/@ember/runloop/index.d.ts
new file mode 100644
index 00000000000..160276e858c
--- /dev/null
+++ b/types/preview/@ember/runloop/index.d.ts
@@ -0,0 +1,175 @@
+declare module '@ember/runloop' {
+  import {
+    EmberMethod,
+    EmberMethodParams,
+    AnyFn,
+    EmberMethodReturn,
+  } from 'ember/-private/type-utils';
+  import { EmberRunQueues } from '@ember/runloop/-private/types';
+  import { EmberRunTimer } from '@ember/runloop/types';
+  import '@ember/runloop/-private/backburner';
+
+  /**
+   * Runs the passed target and method inside of a RunLoop, ensuring any
+   * deferred actions including bindings and views updates are flushed at the
+   * end.
+   */
+  export function run<M extends AnyFn>(method: M): ReturnType<M>;
+  export function run<T, M extends EmberMethod<T>>(
+    target: T,
+    method: M,
+    ...args: EmberMethodParams<T, M>
+  ): EmberMethodReturn<T, M>;
+
+  /**
+   * If no run-loop is present, it creates a new one. If a run loop is
+   * present it will queue itself to run on the existing run-loops action
+   * queue.
+   */
+  export function join<M extends AnyFn>(
+    method: M,
+    ...args: Parameters<M>
+  ): ReturnType<M> | undefined;
+  export function join<T, M extends EmberMethod<T>>(
+    target: T,
+    method: M,
+    ...args: EmberMethodParams<T, M>
+  ): EmberMethodReturn<T, M> | undefined;
+
+  /**
+   * Allows you to specify which context to call the specified function in while
+   * adding the execution of that function to the Ember run loop. This ability
+   * makes this method a great way to asynchronously integrate third-party libraries
+   * into your Ember application.
+   */
+  // NOTE: it would be nice to make this curry arguments, which is how it actually
+  // works, but that is a *lot* of type shenanigans, and also diverges from the
+  // `Function.prototype.bind` implementation. We should track the latter, despite
+  // the loss of safety, because it makes interop cleaner.
+  export function bind<T, M extends EmberMethod<T>>(
+    target: T,
+    method: M,
+    ...args: any[]
+  ): (...args: any[]) => EmberMethodReturn<T, M>;
+
+  /**
+   * Begins a new RunLoop. Any deferred actions invoked after the begin will
+   * be buffered until you invoke a matching call to `run.end()`. This is
+   * a lower-level way to use a RunLoop instead of using `run()`.
+   */
+  export function begin(): void;
+
+  /**
+   * Ends a RunLoop. This must be called sometime after you call
+   * `run.begin()` to flush any deferred actions. This is a lower-level way
+   * to use a RunLoop instead of using `run()`.
+   */
+  export function end(): void;
+
+  /**
+   * Adds the passed target/method and any optional arguments to the named
+   * queue to be executed at the end of the RunLoop. If you have not already
+   * started a RunLoop when calling this method one will be started for you
+   * automatically.
+   */
+  export function schedule<T, M extends EmberMethod<T>>(
+    queue: EmberRunQueues,
+    target: T,
+    method: M,
+    ...args: EmberMethodParams<T, M>
+  ): EmberRunTimer;
+  export function schedule<M extends AnyFn>(
+    queue: EmberRunQueues,
+    method: M,
+    ...args: Parameters<M>
+  ): EmberRunTimer;
+
+  /**
+   * Invokes the passed target/method and optional arguments after a specified
+   * period of time. The last parameter of this method must always be a number
+   * of milliseconds.
+   */
+  export function later(method: AnyFn, wait: number): EmberRunTimer;
+  export function later<T, M extends EmberMethod<T>>(
+    ...args: [target: T, method: M, ...args: EmberMethodParams<T, M>, wait: number]
+  ): EmberRunTimer;
+
+  /**
+   * Schedule a function to run one time during the current RunLoop. This is equivalent
+   * to calling `scheduleOnce` with the "actions" queue.
+   */
+  export function once<T, M extends EmberMethod<T>>(
+    target: T,
+    method: M,
+    ...args: EmberMethodParams<T, M>
+  ): EmberRunTimer;
+
+  export function once<T, M extends keyof T>(
+    target: T,
+    method: M,
+    ...args: EmberMethodParams<T, M>
+  ): EmberRunTimer;
+
+  /**
+   * Schedules a function to run one time in a given queue of the current RunLoop.
+   * Calling this method with the same queue/target/method combination will have
+   * no effect (past the initial call).
+   */
+  export function scheduleOnce<T, M extends EmberMethod<T>>(
+    queue: EmberRunQueues,
+    target: T,
+    method: M,
+    ...args: EmberMethodParams<T, M>
+  ): EmberRunTimer;
+
+  /**
+   * Schedules an item to run from within a separate run loop, after
+   * control has been returned to the system. This is equivalent to calling
+   * `run.later` with a wait time of 1ms.
+   */
+  export function next<T, M extends EmberMethod<T>>(
+    target: T,
+    method: M,
+    ...args: EmberMethodParams<T, M>
+  ): EmberRunTimer;
+  export function next<M extends AnyFn>(method: M, ...args: Parameters<M>): EmberRunTimer;
+
+  /**
+   * Cancels a scheduled item. Must be a value returned by `run.later()`,
+   * `run.once()`, `run.scheduleOnce()`, `run.next()`, `run.debounce()`, or
+   * `run.throttle()`.
+   */
+  export function cancel(timer?: EmberRunTimer): boolean;
+
+  /**
+   * Delay calling the target method until the debounce period has elapsed
+   * with no additional debounce calls. If `debounce` is called again before
+   * the specified time has elapsed, the timer is reset and the entire period
+   * must pass again before the target method is called.
+   */
+  export function debounce(method: AnyFn, wait: number, immediate?: boolean): EmberRunTimer;
+  export function debounce<Target, M extends EmberMethod<Target>>(
+    ...args: [
+      target: Target,
+      method: M,
+      ...args: EmberMethodParams<Target, M>,
+      wait: number,
+      immediate?: boolean
+    ]
+  ): EmberRunTimer;
+
+  /**
+   * Ensure that the target method is never called more frequently than
+   * the specified spacing period. The target method is called immediately.
+   */
+  export function throttle(method: AnyFn, spacing: number, immediate?: boolean): EmberRunTimer;
+  export function throttle<T, M extends EmberMethod<T>>(
+    ...args: [
+      target: T,
+      method: M,
+      ...methodArgs: EmberMethodParams<T, M>,
+      spacing: number,
+      immediate?: boolean
+    ]
+  ): EmberRunTimer;
+}
diff --git a/types/preview/@ember/runloop/tsconfig.json b/types/preview/@ember/runloop/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/runloop/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/runloop/types.d.ts b/types/preview/@ember/runloop/types.d.ts
new file mode 100644
index 00000000000..f1c79f14c6c
--- /dev/null
+++ b/types/preview/@ember/runloop/types.d.ts
@@ -0,0 +1,5 @@
+declare module '@ember/runloop/types' {
+  export interface EmberRunTimer {
+    __ember_run_timer_brand__: boolean;
+  }
+}
diff --git a/types/preview/@ember/service/index.d.ts b/types/preview/@ember/service/index.d.ts
new file mode 100644
index 00000000000..323494f3b35
--- /dev/null
+++ b/types/preview/@ember/service/index.d.ts
@@ -0,0 +1,25 @@
+declare module '@ember/service' {
+  import EmberObject from '@ember/object';
+  import type { BasicComputedProperty } from '@ember/object/computed';
+
+  export default class Service extends EmberObject {}
+  /**
+   * Creates a property that lazily looks up a service in the container. There
+   * are no restrictions as to what objects a service can be injected into.
+   */
+  export function inject(): Service; // @inject() foo, foo: inject()
+  export function inject(target: object, propertyKey: string | symbol): void; // @inject foo
+  export function inject<K extends keyof Registry>(name: K): Registry[K] & BasicComputedProperty; // @inject('store') foo      @inject() foo
+
+  /**
+   * Creates a property that lazily looks up a service in the container. There
+   * are no restrictions as to what objects a service can be injected into.
+   */
+  export function service(): Service; // @service() foo, foo: service()
+  export function service(target: object, propertyKey: string | symbol): void; // @service foo
+  export function service<K extends keyof Registry>(name: K): Registry[K] & BasicComputedProperty; // @service('store') foo      @service() foo
+
+  // A type registry for Ember `Service`s. Meant to be declaration-merged so
+  // string lookups resolve to the correct type.
+  interface Registry {}
+}
diff --git a/types/preview/@ember/service/tsconfig.json b/types/preview/@ember/service/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/service/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/string/index.d.ts b/types/preview/@ember/string/index.d.ts
new file mode 100644
index 00000000000..965bfd7b842
--- /dev/null
+++ b/types/preview/@ember/string/index.d.ts
@@ -0,0 +1,9 @@
+declare module '@ember/string' {
+  export function camelize(str: string): string;
+  export function capitalize(str: string): string;
+  export function classify(str: string): string;
+  export function dasherize(str: string): string;
+  export function decamelize(str: string): string;
+  export function underscore(str: string): string;
+  export function w(str: string): string[];
+}
diff --git a/types/preview/@ember/string/tsconfig.json b/types/preview/@ember/string/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/string/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/template/-private/handlebars.d.ts b/types/preview/@ember/template/-private/handlebars.d.ts
new file mode 100644
index 00000000000..6b4d0985f92
--- /dev/null
+++ b/types/preview/@ember/template/-private/handlebars.d.ts
@@ -0,0 +1,7 @@
+declare module '@ember/template/-private/handlebars' {
+  export class SafeString {
+    constructor(str: string);
+    toString(): string;
+    toHTML(): string;
+  }
+}
diff --git a/types/preview/@ember/template/index.d.ts b/types/preview/@ember/template/index.d.ts
new file mode 100644
index 00000000000..32b7d70da6f
--- /dev/null
+++ b/types/preview/@ember/template/index.d.ts
@@ -0,0 +1,5 @@
+declare module '@ember/template' {
+  import { SafeString } from '@ember/template/-private/handlebars';
+  export function htmlSafe(str: string): SafeString;
+  export function isHTMLSafe(str: unknown): str is SafeString;
+}
diff --git a/types/preview/@ember/template/tsconfig.json b/types/preview/@ember/template/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/template/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/test/adapter.d.ts b/types/preview/@ember/test/adapter.d.ts
new file mode 100644
index 00000000000..ac38cd059ba
--- /dev/null
+++ b/types/preview/@ember/test/adapter.d.ts
@@ -0,0 +1,22 @@
+declare module '@ember/test/adapter' {
+  /**
+   * The primary purpose of this class is to create hooks that can be implemented
+   * by an adapter for various test frameworks.
+   */
+  export default class Adapter {
+    /**
+     * This callback will be called whenever an async operation is about to start.
+     */
+    asyncStart(): unknown;
+    /**
+     * This callback will be called whenever an async operation has completed.
+     */
+    asyncEnd(): unknown;
+    /**
+     * Override this method with your testing framework's false assertion.
+     * This function is called whenever an exception occurs causing the testing
+     * promise to fail.
+     */
+    exception(error: string): unknown;
+  }
+}
diff --git a/types/preview/@ember/test/index.d.ts b/types/preview/@ember/test/index.d.ts
new file mode 100644
index 00000000000..8d754a27286
--- /dev/null
+++ b/types/preview/@ember/test/index.d.ts
@@ -0,0 +1,49 @@
+declare module '@ember/test' {
+  import Application from '@ember/application';
+
+  /**
+   * `registerHelper` is used to register a test helper that will be injected
+   * when `App.injectTestHelpers` is called.
+   */
+  export function registerHelper(
+    name: string,
+    helperMethod: (app: Application, ...args: any[]) => unknown,
+    options?: object
+  ): unknown;
+  /**
+   * `registerAsyncHelper` is used to register an async test helper that will be injected
+   * when `App.injectTestHelpers` is called.
+   */
+  export function registerAsyncHelper(
+    name: string,
+    helperMethod: (app: Application, ...args: any[]) => unknown
+  ): void;
+
+  /**
+   * Remove a previously added helper method.
+   */
+  export function unregisterHelper(name: string): void;
+
+  /**
+   * This allows ember-testing to play nicely with other asynchronous
+   * events, such as an application that is waiting for a CSS3
+   * transition or an IndexDB transaction. The waiter runs periodically
+   * after each async helper (i.e. `click`, `andThen`, `visit`, etc) has executed,
+   * until the returning result is truthy. After the waiters finish, the next async helper
+   * is executed and the process repeats.
+   */
+  export function registerWaiter(callback: () => boolean): unknown;
+  export function registerWaiter<Context>(
+    context: Context,
+    callback: (this: Context) => boolean
+  ): unknown;
+  /**
+   * `unregisterWaiter` is used to unregister a callback that was
+   * registered with `registerWaiter`.
+   */
+  export function unregisterWaiter(callback: () => boolean): unknown;
+  export function unregisterWaiter<Context>(
+    context: Context,
+    callback: (this: Context) => boolean
+  ): unknown;
+}
diff --git a/types/preview/@ember/test/tsconfig.json b/types/preview/@ember/test/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/test/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/@ember/utils/-private/types.d.ts b/types/preview/@ember/utils/-private/types.d.ts
new file mode 100644
index 00000000000..de5bf83173a
--- /dev/null
+++ b/types/preview/@ember/utils/-private/types.d.ts
@@ -0,0 +1,39 @@
+declare module '@ember/utils/-private/types' {
+  import type { AnyFn } from 'ember/-private/type-utils';
+  import NativeArray from '@ember/array/-private/native-array';
+
+  // prettier-ignore
+  type _KeysOfType<Key extends keyof TypeLookup, Type> =
+    // Checks non-`const` versions, and correctly resolves those types
+    // constructed via e.g. the `Number` constructor.
+    TypeLookup[Key] extends Type ? Key :
+    // Checks `const` versions, e.g. handling strict function types when also
+    // using a const-valued function like `const x = () => 4 as const`.
+    Type extends TypeLookup[Key] ? Key : never;
+
+  // prettier-ignore
+  type KeysOfType<Type> =
+    { [Key in keyof TypeLookup]: _KeysOfType<Key, Type> }[keyof TypeLookup];
+
+  // Since `TypeLookup` resolves all *other* types, including `null` and
+  // `undefined`, we can assume that if the type does *not* resolve from
+  // `KeysOfType`, it is safe to treat it as 'object'.
+  export type TypeOf<T> = KeysOfType<T> extends never ? 'object' : KeysOfType<T>;
+
+  export interface TypeLookup {
+    string: string;
+    number: number;
+    boolean: boolean;
+    regexp: RegExp;
+    function: AnyFn;
+    array: Array<unknown> | NativeArray<unknown>;
+    error: Error;
+    filelist: FileList;
+    date: Date;
+    null: null;
+    undefined: undefined;
+  }
+
+  // Don't export anything but the required type util
+  export {};
+}
diff --git a/types/preview/@ember/utils/index.d.ts b/types/preview/@ember/utils/index.d.ts
new file mode 100644
index 00000000000..be432898ad4
--- /dev/null
+++ b/types/preview/@ember/utils/index.d.ts
@@ -0,0 +1,42 @@
+declare module '@ember/utils' {
+  import { TypeOf } from '@ember/utils/-private/types';
+
+  /**
+   * Compares two javascript values and returns:
+   */
+  export function compare(v: unknown, w: unknown): number;
+
+  /**
+   * A value is blank if it is empty or a whitespace string.
+   */
+  export function isBlank(obj?: unknown): boolean;
+
+  /**
+   * Verifies that a value is `null` or an empty string, empty array,
+   * or empty function.
+   */
+  export function isEmpty(obj?: unknown): boolean;
+
+  /**
+   * Compares two objects, returning true if they are equal.
+   */
+  export function isEqual(a: unknown, b: unknown): boolean;
+
+  /**
+   * Returns true if the passed value is null or undefined. This avoids errors
+   * from JSLint complaining about use of ==, which can be technically
+   * confusing.
+   */
+  export function isNone(obj?: unknown): obj is null | undefined;
+
+  /**
+   * A value is present if it not `isBlank`.
+   */
+  export function isPresent(obj?: unknown): boolean;
+
+  /**
+   * Returns a consistent type for the passed object.
+   */
+  export function typeOf<T>(value: T): TypeOf<T>;
+  export function typeOf(): 'undefined';
+}
diff --git a/types/preview/@ember/utils/tsconfig.json b/types/preview/@ember/utils/tsconfig.json
new file mode 100644
index 00000000000..4082f16a5d9
--- /dev/null
+++ b/types/preview/@ember/utils/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../../tsconfig.json"
+}
diff --git a/types/preview/ember/-private/type-utils.d.ts b/types/preview/ember/-private/type-utils.d.ts
new file mode 100644
index 00000000000..f0dca1fab68
--- /dev/null
+++ b/types/preview/ember/-private/type-utils.d.ts
@@ -0,0 +1,54 @@
+declare module 'ember/-private/type-utils' {
+  // These are utility types used throughout the Ember type definitions. They
+  // should *never* be used in end user code.
+
+  /** A safe-ish type representing any function. */
+  export type AnyFn = (...args: any[]) => unknown;
+
+  export type AnyMethod<Target> = (this: Target, ...args: any[]) => unknown;
+
+  export type MethodsOf<O> = {
+    [K in keyof O]: O[K] extends AnyFn ? O[K] : never;
+  };
+
+  // Not just `keyof MethodsOf<O>` because that doesn't correctly exclude all the
+  // `never` fields.
+  export type MethodNamesOf<O> = {
+    [K in keyof O]: O[K] extends AnyFn ? K : never;
+  }[keyof O];
+
+  export type MethodParams<T, M extends MethodNamesOf<T>> = Parameters<MethodsOf<T>[M]>;
+
+  export type MethodReturns<T, M extends MethodNamesOf<T>> = ReturnType<MethodsOf<T>[M]>;
+
+  // prettier-ignore
+  /** Get the return value of a method string name or a function. */
+  export type EmberMethodParams<T, M extends EmberMethod<T>> =
+  M extends AnyMethod<T> ? Parameters<M> :
+  M extends keyof T ? T[M] extends AnyMethod<T> ? Parameters<MethodsOf<T>[M]> : never :
+  never;
+
+  // prettier-ignore
+  /** Get the return value of a method string name or a function. */
+  export type EmberMethodReturn<T, M extends EmberMethod<T>> =
+  M extends AnyMethod<T> ? ReturnType<M> :
+  M extends keyof T ? T[M] extends AnyMethod<T> ? ReturnType<MethodsOf<T>[M]> : never :
+  never;
+
+  /**
+   * A type utility for Ember's common name-of-object-on-target-or-function
+   * pattern for e.g. event handlers.
+   */
+  export type EmberMethod<Target> = AnyMethod<Target> | keyof Target;
+
+  // A way of representing non-user-constructible types. You can conveniently use
+  // this by doing `interface Type extends Data<'some-type-name'> { ... }` for
+  // simple types, and/or you can type-parameterize it as makes sense for your use
+  // case (see e.g. `@ember/component/helper`'s use with functional helpers).
+  const Data: unique symbol;
+  export class Opaque<Data> {
+    private declare [Data]: Data;
+  }
+
+  export {};
+}
diff --git a/types/preview/ember/index.d.ts b/types/preview/ember/index.d.ts
new file mode 100755
index 00000000000..59270bbcbb8
--- /dev/null
+++ b/types/preview/ember/index.d.ts
@@ -0,0 +1,381 @@
+declare module 'ember' {
+  // Capitalization is intentional: this makes it much easier to re-export RSVP on
+  // the Ember namespace.
+  import Rsvp from 'rsvp';
+
+  import type { Registry as ControllerRegistry } from '@ember/controller';
+  import type * as EmberStringNs from '@ember/string';
+  import type * as EmberTemplateNs from '@ember/template';
+  import * as EmberTemplateHandlebarsNs from '@ember/template/-private/handlebars';
+  import type * as EmberServiceNs from '@ember/service';
+  import type * as EmberPolyfillsNs from '@ember/polyfills';
+  import type * as EmberUtilsNs from '@ember/utils';
+  import type * as EmberRunloopNs from '@ember/runloop';
+  import * as EmberObjectNs from '@ember/object';
+  import type * as EmberObjectObserversNs from '@ember/object/observers';
+  import * as EmberObjectProxyNs from '@ember/object/proxy';
+  import type * as EmberObjectPromiseProxyNs from '@ember/object/promise-proxy-mixin';
+  import type * as EmberObjectInternalsNs from '@ember/object/internals';
+  import * as EmberObjectComputedNs from '@ember/object/computed';
+  import type * as EmberObjectEventedNs from '@ember/object/evented';
+  import type * as EmberObjectEventsNs from '@ember/object/events';
+  // @ember/debug
+  import type * as EmberDebugNs from '@ember/debug';
+  import _ContainerDebugAdapter from '@ember/debug/container-debug-adapter';
+  import EmberDataAdapter from '@ember/debug/data-adapter';
+  // @ember/engine
+  import * as EmberEngineNs from '@ember/engine';
+  import * as EmberEngineInstanceNs from '@ember/engine/instance';
+  import EmberCoreObject from '@ember/object/core';
+  import * as EmberApplicationNs from '@ember/application';
+  import * as EmberApplicationInstanceNs from '@ember/application/instance';
+  import type * as EmberApplicationDeprecateNs from '@ember/application/deprecations';
+  import type * as EmberTestNs from '@ember/test';
+  import * as EmberControllerNs from '@ember/controller';
+  import EmberMixin from '@ember/object/mixin';
+  import type EmberObservable from '@ember/object/observable';
+  // @ember/array
+  import type * as EmberArrayNs from '@ember/array';
+  import type EmberMutableArray from '@ember/array/mutable';
+  import type EmberNativeArray from '@ember/array/-private/native-array';
+  import EmberArrayProxy from '@ember/array/proxy';
+  import type EmberEnumerable from '@ember/array/-private/enumerable';
+  import type EmberMutableEnumerable from '@ember/array/-private/mutable-enumerable';
+  // @ember/error
+  import type EmberError from '@ember/error';
+
+  type EmberArray<T> = EmberArrayNs.default<T>;
+  import type EmberActionHandler from '@ember/object/-private/action-handler';
+  import EmberComponent from '@ember/component';
+  import EmberHelper from '@ember/component/helper';
+  // @ember/routing
+  import EmberRoutingRouter from '@ember/routing/router';
+  import EmberRoutingRoute from '@ember/routing/route';
+  import EmberRoutingHashLocation from '@ember/routing/hash-location';
+  import EmberRoutingHistoryLocation from '@ember/routing/history-location';
+  import EmberRoutingNoneLocation from '@ember/routing/none-location';
+  // @ember/application
+  import EmberEventDispatcher from '@ember/application/-private/event-dispatcher';
+  import EmberRegistry from '@ember/application/-private/registry';
+  // @ember/test
+  import EmberTestAdapter from '@ember/test/adapter';
+
+  namespace Ember {
+    export const A: typeof EmberArrayNs.A;
+    export const isArray: typeof EmberArrayNs.isArray;
+    export type Enumerable = EmberEnumerable;
+    export const Enumerable: typeof EmberEnumerable;
+    export class ArrayProxy<T> extends EmberArrayProxy<T> {}
+    export type Array<T> = EmberArray<T>;
+    export const Array: typeof EmberArrayNs.default;
+    export type MutableArray<T> = EmberMutableArray<T>;
+    export const MutableArray: typeof EmberMutableArray;
+    export type NativeArray<T> = EmberNativeArray<T>;
+    export const NativeArray: typeof EmberNativeArray;
+    export type MutableEnumerable = EmberMutableEnumerable;
+    export const MutableEnumerable: typeof EmberMutableEnumerable;
+    export class Router extends EmberRoutingRouter {}
+    export class Route extends EmberRoutingRoute {}
+    export const ActionHandler: typeof EmberActionHandler;
+    export class Controller extends EmberControllerNs.default {}
+    export class Component extends EmberComponent {}
+    export class Helper extends EmberHelper {}
+
+    export class HashLocation extends EmberRoutingHashLocation {}
+    export class NoneLocation extends EmberRoutingNoneLocation {}
+    export class HistoryLocation extends EmberRoutingHistoryLocation {}
+    export const deprecateFunc: typeof EmberApplicationDeprecateNs.deprecateFunc;
+    export const deprecate: typeof EmberApplicationDeprecateNs.deprecate;
+    export const getOwner: typeof EmberApplicationNs.getOwner;
+    export const setOwner: typeof EmberApplicationNs.setOwner;
+    export class EventDispatcher extends EmberEventDispatcher {}
+    export class Registry extends EmberRegistry {}
+
+    /**
+     * Implements some standard methods for comparing objects. Add this mixin to
+     * any class you create that can compare its instances.
+     */
+    export interface Comparable {
+      compare(a: unknown, b: unknown): number;
+    }
+    const Comparable: EmberMixin;
+    class ComputedProperty extends EmberObjectComputedNs.default {}
+    /**
+     * A container used to instantiate and cache objects.
+     */
+    class Container {
+      /**
+       * Given a fullName, return the corresponding factory. The consumer of the factory
+       * is responsible for the destruction of any factory instances, as there is no
+       * way for the container to ensure instances are destroyed when it itself is
+       * destroyed.
+       */
+      factoryFor(fullName: string, options?: {}): unknown;
+    }
+    class ContainerDebugAdapter extends _ContainerDebugAdapter {}
+
+    class Object extends EmberObjectNs.default {}
+    class ObjectProxy extends EmberObjectProxyNs.default {}
+    const Observable: typeof EmberObservable;
+    const PromiseProxyMixin: typeof EmberObjectPromiseProxyNs.default;
+    interface PromiseProxyMixin<T> extends EmberObjectPromiseProxyNs.default<T> {}
+    class CoreObject extends EmberCoreObject {}
+    class DataAdapter extends EmberDataAdapter {}
+    const Debug: {
+      registerDeprecationHandler: typeof EmberDebugNs.registerDeprecationHandler;
+      registerWarnHandler: typeof EmberDebugNs.registerWarnHandler;
+    };
+    class EngineInstance extends EmberEngineInstanceNs.default {}
+    class Engine extends EmberEngineNs.default {}
+
+    /**
+     * A subclass of the JavaScript Error object for use in Ember.
+     */
+    const Error: typeof EmberError;
+
+    const Evented: typeof EmberObjectEventedNs.default;
+    interface Evented extends EmberObjectEventedNs.default {}
+
+    class Mixin extends EmberMixin {}
+
+    /**
+     * A Namespace is an object usually used to contain other objects or methods
+     * such as an application or framework. Create a namespace anytime you want
+     * to define one of these new containers.
+     */
+    class Namespace extends Object {}
+
+    class Service extends Object {}
+
+    interface ViewTargetActionSupport {
+      target: unknown;
+      actionContext: unknown;
+    }
+    const ViewTargetActionSupport: Mixin;
+    const ViewUtils: {
+      isSimpleClick(event: Event): boolean;
+    };
+
+    // FYI - RSVP source comes from https://github.com/tildeio/rsvp.js/blob/master/lib/rsvp/promise.js
+    const RSVP: typeof Rsvp;
+    namespace RSVP {
+      type Promise<T> = Rsvp.Promise<T>;
+    }
+    class Application extends EmberApplicationNs.default {}
+    class ApplicationInstance extends EmberApplicationInstanceNs.default {}
+    /**
+     * This is a container for an assortment of testing related functionality
+     */
+    namespace Test {
+      class Adapter extends EmberTestAdapter {}
+      const registerHelper: typeof EmberTestNs.registerHelper;
+      const unregisterHelper: typeof EmberTestNs.unregisterHelper;
+      const registerWaiter: typeof EmberTestNs.registerWaiter;
+      const unregisterWaiter: typeof EmberTestNs.unregisterWaiter;
+      const registerAsyncHelper: typeof EmberTestNs.registerAsyncHelper;
+      /**
+       * Used to register callbacks to be fired whenever `App.injectTestHelpers`
+       * is called.
+       */
+      function onInjectHelpers(callback: (app: Application) => void): void;
+      /**
+       * This returns a thenable tailored for testing.  It catches failed
+       * `onSuccess` callbacks and invokes the `Ember.Test.adapter.exception`
+       * callback in the last chained then.
+       */
+      function promise<T>(
+        resolver: (
+          resolve: (value?: T | PromiseLike<T>) => void,
+          reject: (reason?: unknown) => void
+        ) => void,
+        label?: string
+      ): Promise<T>;
+      /**
+       * Replacement for `Ember.RSVP.resolve`
+       * The only difference is this uses
+       * an instance of `Ember.Test.Promise`
+       */
+      function resolve<T>(value?: T | PromiseLike<T>, label?: string): Promise<T>;
+
+      /**
+       * Iterates through each registered test waiter, and invokes
+       * its callback. If any waiter returns false, this method will return
+       * true indicating that the waiters have not settled yet.
+       */
+      function checkWaiters(): boolean;
+      /**
+       * Used to allow ember-testing to communicate with a specific testing
+       * framework.
+       */
+      const adapter: EmberTestAdapter;
+
+      /**
+       * This class implements the methods defined by Ember.Test.Adapter for the
+       * QUnit testing framework.
+       */
+      class QUnitAdapter extends EmberTestAdapter {}
+      class Promise<T> extends Rsvp.Promise<T> {
+        constructor(
+          executor: (
+            resolve: (value?: T | PromiseLike<T>) => void,
+            reject: (reason?: unknown) => void
+          ) => void
+        );
+      }
+    }
+    /**
+     * Namespace for injection helper methods.
+     */
+    namespace inject {
+      /**
+       * Creates a property that lazily looks up another controller in the container.
+       * Can only be used when defining another controller.
+       */
+      function controller(): Controller;
+      function controller<K extends keyof ControllerRegistry>(
+        name: K
+      ): ControllerRegistry[K] & EmberObjectComputedNs.BasicComputedProperty;
+      const service: typeof EmberServiceNs.inject;
+    }
+    namespace ENV {
+      const EXTEND_PROTOTYPES: {
+        Array: boolean;
+        Function: boolean;
+        String: boolean;
+      };
+      const LOG_BINDINGS: boolean;
+      const LOG_STACKTRACE_ON_DEPRECATION: boolean;
+      const LOG_VERSION: boolean;
+      const MODEL_FACTORY_INJECTIONS: boolean;
+      const RAISE_ON_DEPRECATION: boolean;
+    }
+    namespace Handlebars {
+      function compile(string: string): (...args: any[]) => any;
+      function compile(environment: any, options?: any, context?: any, asObject?: any): any;
+      function precompile(string: string, options: any): void;
+      class Compiler {}
+      class JavaScriptCompiler {}
+      function registerPartial(name: string, str: any): void;
+      function createFrame(objec: any): any;
+      function Exception(message: string): void;
+      class SafeString extends EmberTemplateHandlebarsNs.SafeString {}
+      function parse(string: string): any;
+      function print(ast: any): void;
+      function log(level: string, str: string): void;
+      function registerHelper(name: string, helper: any): void;
+    }
+    namespace String {
+      const camelize: typeof EmberStringNs.camelize;
+      const capitalize: typeof EmberStringNs.capitalize;
+      const classify: typeof EmberStringNs.classify;
+      const dasherize: typeof EmberStringNs.dasherize;
+      const decamelize: typeof EmberStringNs.decamelize;
+      function fmt(...args: string[]): string;
+      const htmlSafe: typeof EmberTemplateNs.htmlSafe;
+      const isHTMLSafe: typeof EmberTemplateNs.isHTMLSafe;
+      const underscore: typeof EmberStringNs.underscore;
+      const w: typeof EmberStringNs.w;
+    }
+    namespace Template {
+      const htmlSafe: typeof EmberTemplateNs.htmlSafe;
+      const isHTMLSafe: typeof EmberTemplateNs.isHTMLSafe;
+    }
+    const computed: typeof EmberObjectNs.computed & typeof EmberObjectComputedNs;
+
+    // Shenanigans to make `run` both callable and a namespace safely, while not
+    // making the `run.bind` call resolve to `Function.prototype.bind`. (Yes,
+    // insert :upside-down-smiley: here.)
+    // 1. Get the type side of the namespace.
+    type EmberRunloop = typeof EmberRunloopNs;
+    // 2. Use it to get an interface representing the callable side of `run`.
+    type RunFn = EmberRunloop['run'];
+    // type RunFn = Pick<EmberRunloop, 'run'>['run'];
+    // 3. Merge the two together so that the public-facing type of `run` is both
+    //    the plucked-off run type *and* the namespace.
+    interface Run extends RunFn, EmberRunloop {}
+    const run: Run;
+
+    const platform: {
+      defineProperty: boolean;
+      hasPropertyAccessors: boolean;
+    };
+
+    /**
+     * `getEngineParent` retrieves an engine instance's parent instance.
+     */
+    function getEngineParent(engine: EngineInstance): EngineInstance;
+
+    const assert: typeof EmberDebugNs.assert;
+    const debug: typeof EmberDebugNs.debug;
+    const defineProperty: typeof EmberObjectNs.defineProperty;
+
+    const runInDebug: typeof EmberDebugNs.runInDebug;
+    const warn: typeof EmberDebugNs.warn;
+    const cacheFor: typeof EmberObjectInternalsNs.cacheFor;
+    const addListener: typeof EmberObjectEventsNs.addListener;
+    const removeListener: typeof EmberObjectEventsNs.removeListener;
+    const sendEvent: typeof EmberObjectEventsNs.sendEvent;
+    const on: typeof EmberObjectEventedNs.on;
+
+    const htmlSafe: typeof EmberTemplateNs.htmlSafe;
+    const isHTMLSafe: typeof EmberTemplateNs.isHTMLSafe;
+
+    const isBlank: typeof EmberUtilsNs.isBlank;
+    const isEmpty: typeof EmberUtilsNs.isEmpty;
+    const isNone: typeof EmberUtilsNs.isNone;
+    const isPresent: typeof EmberUtilsNs.isPresent;
+
+    const observer: typeof EmberObjectNs.observer;
+    const addObserver: typeof EmberObjectObserversNs.addObserver;
+    const removeObserver: typeof EmberObjectObserversNs.removeObserver;
+    const get: typeof EmberObjectNs.get;
+    const notifyPropertyChange: typeof EmberObjectNs.notifyPropertyChange;
+    const getProperties: typeof EmberObjectNs.getProperties;
+    const setProperties: typeof EmberObjectNs.setProperties;
+    const set: typeof EmberObjectNs.set;
+    const trySet: typeof EmberObjectNs.trySet;
+    const compare: typeof EmberUtilsNs.compare;
+    /**
+     * Creates a shallow copy of the passed object. A deep copy of the object is
+     * returned if the optional `deep` argument is `true`.
+     */
+    const isEqual: typeof EmberUtilsNs.isEqual;
+    const typeOf: typeof EmberUtilsNs.typeOf;
+    /**
+     * Copy properties from a source object to a target object.
+     * @deprecated until v5.0. You should replace any calls to `Ember.assign`
+     *   with `Object.assign` or use the object spread operator.
+     */
+    const assign: typeof EmberPolyfillsNs.assign;
+    const guidFor: typeof EmberObjectInternalsNs.guidFor;
+
+    /**
+     * A function may be assigned to `Ember.onerror` to be called when Ember
+     * internals encounter an error. This is useful for specialized error handling
+     * and reporting code.
+     */
+    let onerror: ((error: Error) => void) | undefined;
+
+    /**
+     * The semantic version
+     */
+    const VERSION: string;
+    /**
+     * This property indicates whether or not this application is currently in
+     * testing mode. This is set when `setupForTesting` is called on the current
+     * application.
+     */
+    const testing: boolean;
+
+    const expandProperties: typeof EmberObjectComputedNs.expandProperties;
+  }
+
+  export default Ember;
+}
+
+declare module 'htmlbars-inline-precompile' {
+  interface TemplateFactory {
+    __htmlbars_inline_precompile_template_factory: any;
+  }
+  export default function hbs(tagged: TemplateStringsArray): TemplateFactory;
+}
diff --git a/types/preview/ember/tsconfig.json b/types/preview/ember/tsconfig.json
new file mode 100755
index 00000000000..3c43903cfdd
--- /dev/null
+++ b/types/preview/ember/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../tsconfig.json"
+}
diff --git a/types/preview/index.d.ts b/types/preview/index.d.ts
new file mode 100644
index 00000000000..e887be9736a
--- /dev/null
+++ b/types/preview/index.d.ts
@@ -0,0 +1,120 @@
+/**
+  @module
+  Makes Ember's types for the packages it publishes available by importing this
+  path from `ember-source`:
+
+  ```ts
+  import 'ember-source/preview';
+  ```
+ */
+
+// This works because each of these modules presents `declare module` definition
+// of the module and *only* that, so importing this file in turn makes those
+// module declarations "visible" automatically throughout a consuming project.
+// Combined with use of `typesVersions` (or, in the future, possibly `exports`)
+// in `package.json`, this allows users to import the types without knowing the
+// exact layout details.
+//
+// Somewhat annoyingly, every single module in the graph must appear here. For
+// now, while we are publishing ambient types, that means we must maintain this
+// by hand. When we start emitting types from the source, we will need to do the
+// same work, but automatically.
+
+import './ember';
+import './ember/-private/type-utils';
+
+import './@ember/-internals/resolver';
+
+import './@ember/application';
+import './@ember/application/-private/event-dispatcher';
+import './@ember/application/-private/registry';
+import './@ember/application/deprecations';
+import './@ember/application/instance';
+import './@ember/application/types';
+
+import './@ember/array';
+import './@ember/array/-private/enumerable';
+import './@ember/array/-private/mutable-enumerable';
+import './@ember/array/-private/native-array';
+import './@ember/array/mutable';
+import './@ember/array/proxy';
+
+import './@ember/component';
+import './@ember/component/-private/class-names-support';
+import './@ember/component/-private/core-view';
+import './@ember/component/-private/glimmer-interfaces';
+import './@ember/component/-private/signature-utils';
+import './@ember/component/-private/view-mixin';
+import './@ember/component/helper';
+import './@ember/component/template-only';
+
+import './@ember/controller';
+
+import './@ember/debug';
+import './@ember/debug/container-debug-adapter';
+import './@ember/debug/data-adapter';
+
+import './@ember/destroyable';
+
+import './@ember/engine';
+import './@ember/engine/-private/container-proxy-mixin';
+import './@ember/engine/-private/registry-proxy-mixin';
+import './@ember/engine/-private/types/initializer';
+import './@ember/engine/instance';
+
+import './@ember/error';
+
+import './@ember/helper';
+
+import './@ember/modifier';
+
+import './@ember/object';
+import './@ember/object/-private/action-handler';
+import './@ember/object/-private/types';
+import './@ember/object/compat';
+import './@ember/object/computed';
+import './@ember/object/core';
+import './@ember/object/evented';
+import './@ember/object/events';
+import './@ember/object/internals';
+import './@ember/object/mixin';
+import './@ember/object/observable';
+import './@ember/object/observers';
+import './@ember/object/promise-proxy-mixin';
+import './@ember/object/proxy';
+
+import './@ember/owner';
+
+import './@ember/polyfills';
+import './@ember/polyfills/types';
+
+import './@ember/routing';
+import './@ember/routing/-private/router-dsl';
+import './@ember/routing/auto-location';
+import './@ember/routing/hash-location';
+import './@ember/routing/history-location';
+import './@ember/routing/none-location';
+import './@ember/routing/route';
+import './@ember/routing/route-info';
+import './@ember/routing/router';
+import './@ember/routing/router-service';
+import './@ember/routing/transition';
+import './@ember/routing/types';
+
+import './@ember/runloop';
+import './@ember/runloop/-private/backburner';
+import './@ember/runloop/-private/types';
+import './@ember/runloop/types';
+
+import './@ember/service';
+
+import './@ember/string';
+
+import './@ember/template';
+import './@ember/template/-private/handlebars';
+
+import './@ember/test';
+import './@ember/test/adapter';
+
+import './@ember/utils';
+import './@ember/utils/-private/types';
diff --git a/types/preview/tsconfig.json b/types/preview/tsconfig.json
new file mode 100644
index 00000000000..8fa576671fd
--- /dev/null
+++ b/types/preview/tsconfig.json
@@ -0,0 +1,6 @@
+{
+  "extends": "@tsconfig/ember/tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": "."
+  }
+}
diff --git a/yarn.lock b/yarn.lock
index 695e9003ca4..9d217f1714b 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -16,6 +16,13 @@
   dependencies:
     "@babel/highlight" "^7.16.7"
 
+"@babel/code-frame@^7.18.6":
+  version "7.18.6"
+  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.18.6.tgz#3b25d38c89600baa2dcc219edfa88a74eb2c427a"
+  integrity sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==
+  dependencies:
+    "@babel/highlight" "^7.18.6"
+
 "@babel/compat-data@^7.13.11", "@babel/compat-data@^7.16.4", "@babel/compat-data@^7.16.8":
   version "7.17.0"
   resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.17.0.tgz#86850b8597ea6962089770952075dcaabb8dba34"
@@ -51,6 +58,15 @@
     jsesc "^2.5.1"
     source-map "^0.5.0"
 
+"@babel/generator@^7.18.13":
+  version "7.18.13"
+  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.18.13.tgz#59550cbb9ae79b8def15587bdfbaa388c4abf212"
+  integrity sha512-CkPg8ySSPuHTYPJYo7IRALdqyjM9HCbt/3uOBEFbzyGVP6Mn8bwFPB0jX6982JVNBlYzM1nnPkfjuXSOPtQeEQ==
+  dependencies:
+    "@babel/types" "^7.18.13"
+    "@jridgewell/gen-mapping" "^0.3.2"
+    jsesc "^2.5.1"
+
 "@babel/helper-annotate-as-pure@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.16.7.tgz#bb2339a7534a9c128e3102024c60760a3a7f3862"
@@ -58,6 +74,13 @@
   dependencies:
     "@babel/types" "^7.16.7"
 
+"@babel/helper-annotate-as-pure@^7.18.6":
+  version "7.18.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.18.6.tgz#eaa49f6f80d5a33f9a5dd2276e6d6e451be0a6bb"
+  integrity sha512-duORpUiYrEpzKIop6iNbjnwKLAKnJ47csTyRACyEmWj0QdUrm5aqNJGHSSEQSUAvNW0ojX0dOmK9dZduvkfeXA==
+  dependencies:
+    "@babel/types" "^7.18.6"
+
 "@babel/helper-builder-binary-assignment-operator-visitor@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.16.7.tgz#38d138561ea207f0f69eb1626a418e4f7e6a580b"
@@ -89,6 +112,19 @@
     "@babel/helper-replace-supers" "^7.16.7"
     "@babel/helper-split-export-declaration" "^7.16.7"
 
+"@babel/helper-create-class-features-plugin@^7.5.5":
+  version "7.18.13"
+  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.18.13.tgz#63e771187bd06d234f95fdf8bd5f8b6429de6298"
+  integrity sha512-hDvXp+QYxSRL+23mpAlSGxHMDyIGChm0/AwTfTAAK5Ufe40nCsyNdaYCGuK91phn/fVu9kqayImRDkvNAgdrsA==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.18.6"
+    "@babel/helper-environment-visitor" "^7.18.9"
+    "@babel/helper-function-name" "^7.18.9"
+    "@babel/helper-member-expression-to-functions" "^7.18.9"
+    "@babel/helper-optimise-call-expression" "^7.18.6"
+    "@babel/helper-replace-supers" "^7.18.9"
+    "@babel/helper-split-export-declaration" "^7.18.6"
+
 "@babel/helper-create-regexp-features-plugin@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.16.7.tgz#0cb82b9bac358eb73bfbd73985a776bfa6b14d48"
@@ -132,6 +168,11 @@
   dependencies:
     "@babel/types" "^7.16.7"
 
+"@babel/helper-environment-visitor@^7.18.9":
+  version "7.18.9"
+  resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz#0c0cee9b35d2ca190478756865bb3528422f51be"
+  integrity sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==
+
 "@babel/helper-explode-assignable-expression@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.16.7.tgz#12a6d8522fdd834f194e868af6354e8650242b7a"
@@ -148,6 +189,14 @@
     "@babel/template" "^7.16.7"
     "@babel/types" "^7.16.7"
 
+"@babel/helper-function-name@^7.18.9":
+  version "7.18.9"
+  resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.18.9.tgz#940e6084a55dee867d33b4e487da2676365e86b0"
+  integrity sha512-fJgWlZt7nxGksJS9a0XdSaI4XvpExnNIgRP+rVefWh5U7BL8pPuir6SJUmFKRfjWQ51OtWSzwOxhaH/EBWWc0A==
+  dependencies:
+    "@babel/template" "^7.18.6"
+    "@babel/types" "^7.18.9"
+
 "@babel/helper-get-function-arity@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/helper-get-function-arity/-/helper-get-function-arity-7.16.7.tgz#ea08ac753117a669f1508ba06ebcc49156387419"
@@ -162,6 +211,13 @@
   dependencies:
     "@babel/types" "^7.16.7"
 
+"@babel/helper-hoist-variables@^7.18.6":
+  version "7.18.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz#d4d2c8fb4baeaa5c68b99cc8245c56554f926678"
+  integrity sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==
+  dependencies:
+    "@babel/types" "^7.18.6"
+
 "@babel/helper-member-expression-to-functions@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.16.7.tgz#42b9ca4b2b200123c3b7e726b0ae5153924905b0"
@@ -169,6 +225,13 @@
   dependencies:
     "@babel/types" "^7.16.7"
 
+"@babel/helper-member-expression-to-functions@^7.18.9":
+  version "7.18.9"
+  resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.18.9.tgz#1531661e8375af843ad37ac692c132841e2fd815"
+  integrity sha512-RxifAh2ZoVU67PyKIO4AMi1wTenGfMR/O/ae0CCRqwgBAt5v7xjdtRw7UoSbsreKrQn5t7r89eruK/9JjYHuDg==
+  dependencies:
+    "@babel/types" "^7.18.9"
+
 "@babel/helper-module-imports@^7.12.13", "@babel/helper-module-imports@^7.14.5", "@babel/helper-module-imports@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.16.7.tgz#25612a8091a999704461c8a222d0efec5d091437"
@@ -197,11 +260,23 @@
   dependencies:
     "@babel/types" "^7.16.7"
 
+"@babel/helper-optimise-call-expression@^7.18.6":
+  version "7.18.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.18.6.tgz#9369aa943ee7da47edab2cb4e838acf09d290ffe"
+  integrity sha512-HP59oD9/fEHQkdcbgFCnbmgH5vIQTJbxh2yf+CdM89/glUNnuzr87Q8GIjGEnOktTROemO0Pe0iPAYbqZuOUiA==
+  dependencies:
+    "@babel/types" "^7.18.6"
+
 "@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.13.0", "@babel/helper-plugin-utils@^7.14.5", "@babel/helper-plugin-utils@^7.16.7", "@babel/helper-plugin-utils@^7.8.0", "@babel/helper-plugin-utils@^7.8.3":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.16.7.tgz#aa3a8ab4c3cceff8e65eb9e73d87dc4ff320b2f5"
   integrity sha512-Qg3Nk7ZxpgMrsox6HreY1ZNKdBq7K72tDSliA6dCl5f007jR4ne8iD5UzuNnCJH2xBf2BEEVGr+/OL6Gdp7RxA==
 
+"@babel/helper-plugin-utils@^7.18.6":
+  version "7.18.9"
+  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.18.9.tgz#4b8aea3b069d8cb8a72cdfe28ddf5ceca695ef2f"
+  integrity sha512-aBXPT3bmtLryXaoJLyYPXPlSD4p1ld9aYeR+sJNOZjJJGiOpb+fKfh3NkcCu7J54nUJwCERPBExCCpyCOHnu/w==
+
 "@babel/helper-remap-async-to-generator@^7.16.8":
   version "7.16.8"
   resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.16.8.tgz#29ffaade68a367e2ed09c90901986918d25e57e3"
@@ -222,6 +297,17 @@
     "@babel/traverse" "^7.16.7"
     "@babel/types" "^7.16.7"
 
+"@babel/helper-replace-supers@^7.18.9":
+  version "7.18.9"
+  resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.18.9.tgz#1092e002feca980fbbb0bd4d51b74a65c6a500e6"
+  integrity sha512-dNsWibVI4lNT6HiuOIBr1oyxo40HvIVmbwPUm3XZ7wMh4k2WxrxTqZwSqw/eEmXDS9np0ey5M2bz9tBmO9c+YQ==
+  dependencies:
+    "@babel/helper-environment-visitor" "^7.18.9"
+    "@babel/helper-member-expression-to-functions" "^7.18.9"
+    "@babel/helper-optimise-call-expression" "^7.18.6"
+    "@babel/traverse" "^7.18.9"
+    "@babel/types" "^7.18.9"
+
 "@babel/helper-simple-access@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.16.7.tgz#d656654b9ea08dbb9659b69d61063ccd343ff0f7"
@@ -243,11 +329,28 @@
   dependencies:
     "@babel/types" "^7.16.7"
 
+"@babel/helper-split-export-declaration@^7.18.6":
+  version "7.18.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz#7367949bc75b20c6d5a5d4a97bba2824ae8ef075"
+  integrity sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==
+  dependencies:
+    "@babel/types" "^7.18.6"
+
+"@babel/helper-string-parser@^7.18.10":
+  version "7.18.10"
+  resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.18.10.tgz#181f22d28ebe1b3857fa575f5c290b1aaf659b56"
+  integrity sha512-XtIfWmeNY3i4t7t4D2t02q50HvqHybPqW2ki1kosnvWCwuCMeo81Jf0gwr85jy/neUdg5XDdeFE/80DXiO+njw==
+
 "@babel/helper-validator-identifier@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.16.7.tgz#e8c602438c4a8195751243da9031d1607d247cad"
   integrity sha512-hsEnFemeiW4D08A5gUAZxLBTXpZ39P+a+DGDsHw1yxqyQ/jzFEnxf5uTEGp+3bzAbNOxU1paTgYS4ECU/IgfDw==
 
+"@babel/helper-validator-identifier@^7.18.6":
+  version "7.18.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.18.6.tgz#9c97e30d31b2b8c72a1d08984f2ca9b574d7a076"
+  integrity sha512-MmetCkz9ej86nJQV+sFCxoGGrUbU3q02kgLciwkrt9QqEB7cP39oKEY0PakknEO0Gu20SskMRi+AYZ3b1TpN9g==
+
 "@babel/helper-validator-option@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.16.7.tgz#b203ce62ce5fe153899b617c08957de860de4d23"
@@ -281,11 +384,25 @@
     chalk "^2.0.0"
     js-tokens "^4.0.0"
 
+"@babel/highlight@^7.18.6":
+  version "7.18.6"
+  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.18.6.tgz#81158601e93e2563795adcbfbdf5d64be3f2ecdf"
+  integrity sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==
+  dependencies:
+    "@babel/helper-validator-identifier" "^7.18.6"
+    chalk "^2.0.0"
+    js-tokens "^4.0.0"
+
 "@babel/parser@^7.16.7", "@babel/parser@^7.17.3", "@babel/parser@^7.4.5":
   version "7.17.3"
   resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.17.3.tgz#b07702b982990bf6fdc1da5049a23fece4c5c3d0"
   integrity sha512-7yJPvPV+ESz2IUTPbOL+YkIGyCqOyNIzdguKQuJGnH7bg1WTIifuM21YqokFt/THWh1AkCRn9IgoykTRCBVpzA==
 
+"@babel/parser@^7.18.10", "@babel/parser@^7.18.13":
+  version "7.18.13"
+  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.18.13.tgz#5b2dd21cae4a2c5145f1fbd8ca103f9313d3b7e4"
+  integrity sha512-dgXcIfMuQ0kgzLB2b9tRZs7TTFFaGM2AbtA4fJgUUYukzGH4jwsS7hzQHEGs67jdehpm22vkgKwvbU+aEflgwg==
+
 "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.16.7.tgz#4eda6d6c2a0aa79c70fa7b6da67763dfe2141050"
@@ -549,6 +666,13 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.16.7"
 
+"@babel/plugin-syntax-typescript@^7.2.0":
+  version "7.18.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.18.6.tgz#1c09cd25795c7c2b8a4ba9ae49394576d4133285"
+  integrity sha512-mAWAuq4rvOepWCBid55JuRNvpTNf2UGVgoz4JV0fXEKolsVZDzsa4NqCef758WZJj/GDu0gVGItjKFiClTAmZA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.18.6"
+
 "@babel/plugin-transform-arrow-functions@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.16.7.tgz#44125e653d94b98db76369de9c396dc14bef4154"
@@ -805,6 +929,15 @@
     "@babel/helper-plugin-utils" "^7.16.7"
     "@babel/plugin-syntax-typescript" "^7.16.7"
 
+"@babel/plugin-transform-typescript@~7.5.0":
+  version "7.5.5"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.5.5.tgz#6d862766f09b2da1cb1f7d505fe2aedab6b7d4b8"
+  integrity sha512-pehKf4m640myZu5B2ZviLaiBlxMCjSZ1qTEO459AXKX5GnPueyulJeCqZFs1nz/Ya2dDzXQ1NxZ/kKNWyD4h6w==
+  dependencies:
+    "@babel/helper-create-class-features-plugin" "^7.5.5"
+    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/plugin-syntax-typescript" "^7.2.0"
+
 "@babel/plugin-transform-unicode-escapes@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.16.7.tgz#da8717de7b3287a2c6d659750c964f302b31ece3"
@@ -942,6 +1075,15 @@
     "@babel/parser" "^7.16.7"
     "@babel/types" "^7.16.7"
 
+"@babel/template@^7.18.6":
+  version "7.18.10"
+  resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.18.10.tgz#6f9134835970d1dbf0835c0d100c9f38de0c5e71"
+  integrity sha512-TI+rCtooWHr3QJ27kJxfjutghu44DLnasDMwpDqCXVTal9RLp3RSYNh4NdBrRP2cQAoG9A8juOQl6P6oZG4JxA==
+  dependencies:
+    "@babel/code-frame" "^7.18.6"
+    "@babel/parser" "^7.18.10"
+    "@babel/types" "^7.18.10"
+
 "@babel/traverse@^7.13.0", "@babel/traverse@^7.16.7", "@babel/traverse@^7.16.8", "@babel/traverse@^7.17.0", "@babel/traverse@^7.17.3", "@babel/traverse@^7.4.5":
   version "7.17.3"
   resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.17.3.tgz#0ae0f15b27d9a92ba1f2263358ea7c4e7db47b57"
@@ -958,6 +1100,22 @@
     debug "^4.1.0"
     globals "^11.1.0"
 
+"@babel/traverse@^7.18.9":
+  version "7.18.13"
+  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.18.13.tgz#5ab59ef51a997b3f10c4587d648b9696b6cb1a68"
+  integrity sha512-N6kt9X1jRMLPxxxPYWi7tgvJRH/rtoU+dbKAPDM44RFHiMH8igdsaSBgFeskhSl/kLWLDUvIh1RXCrTmg0/zvA==
+  dependencies:
+    "@babel/code-frame" "^7.18.6"
+    "@babel/generator" "^7.18.13"
+    "@babel/helper-environment-visitor" "^7.18.9"
+    "@babel/helper-function-name" "^7.18.9"
+    "@babel/helper-hoist-variables" "^7.18.6"
+    "@babel/helper-split-export-declaration" "^7.18.6"
+    "@babel/parser" "^7.18.13"
+    "@babel/types" "^7.18.13"
+    debug "^4.1.0"
+    globals "^11.1.0"
+
 "@babel/types@^7.16.0", "@babel/types@^7.16.7", "@babel/types@^7.16.8", "@babel/types@^7.17.0", "@babel/types@^7.4.4", "@babel/types@^7.7.2":
   version "7.17.0"
   resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.17.0.tgz#a826e368bccb6b3d84acd76acad5c0d87342390b"
@@ -966,6 +1124,15 @@
     "@babel/helper-validator-identifier" "^7.16.7"
     to-fast-properties "^2.0.0"
 
+"@babel/types@^7.18.10", "@babel/types@^7.18.13", "@babel/types@^7.18.6", "@babel/types@^7.18.9":
+  version "7.18.13"
+  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.18.13.tgz#30aeb9e514f4100f7c1cb6e5ba472b30e48f519a"
+  integrity sha512-ePqfTihzW0W6XAU+aMw2ykilisStJfDnsejDCXRchCcMJ4O0+8DhPXf2YUbZ6wjBlsEmZwLK/sPweWtu8hcJYQ==
+  dependencies:
+    "@babel/helper-string-parser" "^7.18.10"
+    "@babel/helper-validator-identifier" "^7.18.6"
+    to-fast-properties "^2.0.0"
+
 "@cnakazawa/watch@^1.0.3":
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/@cnakazawa/watch/-/watch-1.0.3.tgz#099139eaec7ebf07a27c1786a3ff64f39464d2ef"
@@ -1037,6 +1204,26 @@
     "@glimmer/wire-format" "0.84.2"
     "@simple-dom/interface" "^1.4.0"
 
+"@glimmer/component@^1.1.2":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@glimmer/component/-/component-1.1.2.tgz#892ec0c9f0b6b3e41c112be502fde073cf24d17c"
+  integrity sha512-XyAsEEa4kWOPy+gIdMjJ8XlzA3qrGH55ZDv6nA16ibalCR17k74BI0CztxuRds+Rm6CtbUVgheCVlcCULuqD7A==
+  dependencies:
+    "@glimmer/di" "^0.1.9"
+    "@glimmer/env" "^0.1.7"
+    "@glimmer/util" "^0.44.0"
+    broccoli-file-creator "^2.1.1"
+    broccoli-merge-trees "^3.0.2"
+    ember-cli-babel "^7.7.3"
+    ember-cli-get-component-path-option "^1.0.0"
+    ember-cli-is-package-missing "^1.0.0"
+    ember-cli-normalize-entity-name "^1.0.0"
+    ember-cli-path-utils "^1.0.0"
+    ember-cli-string-utils "^1.1.0"
+    ember-cli-typescript "3.0.0"
+    ember-cli-version-checker "^3.1.3"
+    ember-compatibility-helpers "^1.1.2"
+
 "@glimmer/destroyable@0.84.2":
   version "0.84.2"
   resolved "https://registry.yarnpkg.com/@glimmer/destroyable/-/destroyable-0.84.2.tgz#67009d931346f4988a6dd329cd8b95141726a453"
@@ -1047,6 +1234,11 @@
     "@glimmer/interfaces" "0.84.2"
     "@glimmer/util" "0.84.2"
 
+"@glimmer/di@^0.1.9":
+  version "0.1.11"
+  resolved "https://registry.yarnpkg.com/@glimmer/di/-/di-0.1.11.tgz#a6878c07a13a2c2c76fcde598a5c97637bfc4280"
+  integrity sha512-moRwafNDwHTnTHzyyZC9D+mUSvYrs1Ak0tRPjjmCghdoHHIvMshVbEnwKb/1WmW5CUlKc2eL9rlAV32n3GiItg==
+
 "@glimmer/encoder@0.84.2":
   version "0.84.2"
   resolved "https://registry.yarnpkg.com/@glimmer/encoder/-/encoder-0.84.2.tgz#3e6038f4115cde40a1252f13ae33774341325d40"
@@ -1185,6 +1377,11 @@
     "@glimmer/interfaces" "0.84.2"
     "@simple-dom/interface" "^1.4.0"
 
+"@glimmer/util@^0.44.0":
+  version "0.44.0"
+  resolved "https://registry.yarnpkg.com/@glimmer/util/-/util-0.44.0.tgz#45df98d73812440206ae7bda87cfe04aaae21ed9"
+  integrity sha512-duAsm30uVK9jSysElCbLyU6QQYO2X9iLDLBIBUcCqck9qN1o3tK2qWiHbGK5d6g8E2AJ4H88UrfElkyaJlGrwg==
+
 "@glimmer/validator@0.84.2":
   version "0.84.2"
   resolved "https://registry.yarnpkg.com/@glimmer/validator/-/validator-0.84.2.tgz#29394d262cf8373fe20f4e225c1adc9857a4164b"
@@ -1235,11 +1432,25 @@
   resolved "https://registry.yarnpkg.com/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz#b520529ec21d8e5945a1851dfd1c32e94e39ff45"
   integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==
 
+"@jridgewell/gen-mapping@^0.3.2":
+  version "0.3.2"
+  resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz#c1aedc61e853f2bb9f5dfe6d4442d3b565b253b9"
+  integrity sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==
+  dependencies:
+    "@jridgewell/set-array" "^1.0.1"
+    "@jridgewell/sourcemap-codec" "^1.4.10"
+    "@jridgewell/trace-mapping" "^0.3.9"
+
 "@jridgewell/resolve-uri@^3.0.3":
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.0.4.tgz#b876e3feefb9c8d3aa84014da28b5e52a0640d72"
   integrity sha512-cz8HFjOFfUBtvN+NXYSFMHYRdxZMaEl0XypVrhzxBgadKIXhIkRd8aMeHhmF56Sl7SuS8OnUpQ73/k9LE4VnLg==
 
+"@jridgewell/set-array@^1.0.1":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@jridgewell/set-array/-/set-array-1.1.2.tgz#7c6cf998d6d20b914c0a55a91ae928ff25965e72"
+  integrity sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==
+
 "@jridgewell/sourcemap-codec@^1.4.10":
   version "1.4.10"
   resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.10.tgz#baf57b4e2a690d4f38560171f91783656b7f8186"
@@ -1253,6 +1464,14 @@
     "@jridgewell/resolve-uri" "^3.0.3"
     "@jridgewell/sourcemap-codec" "^1.4.10"
 
+"@jridgewell/trace-mapping@^0.3.9":
+  version "0.3.15"
+  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.15.tgz#aba35c48a38d3fd84b37e66c9c0423f9744f9774"
+  integrity sha512-oWZNOULl+UbhsgB51uuZzglikfIKSUBO/M9W2OfEjn7cmqoAiCgmv9lyACTUacZwBz0ITnJ2NqjU8Tx0DHL88g==
+  dependencies:
+    "@jridgewell/resolve-uri" "^3.0.3"
+    "@jridgewell/sourcemap-codec" "^1.4.10"
+
 "@nodelib/fs.scandir@2.1.3":
   version "2.1.3"
   resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.3.tgz#3a582bdb53804c6ba6d146579c46e52130cf4a3b"
@@ -1317,6 +1536,11 @@
   dependencies:
     defer-to-connect "^1.0.1"
 
+"@tsconfig/ember@^1.0.1":
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/@tsconfig/ember/-/ember-1.0.1.tgz#d7556d81f108438c17e4030acb4e1be6b2974e88"
+  integrity sha512-aPzLw5BfQxsFPrh5fNDOK4SbSkp2q5fMlrKVeniVjMz1lAcyOh2eH5THkKKcBi1YN1/fbMdAWN/dKGW6lg2+8g==
+
 "@types/acorn@^4.0.3":
   version "4.0.3"
   resolved "https://registry.yarnpkg.com/@types/acorn/-/acorn-4.0.3.tgz#d1f3e738dde52536f9aad3d3380d14e448820afd"
@@ -1796,6 +2020,13 @@ ansi-styles@^4.0.0, ansi-styles@^4.1.0:
   dependencies:
     color-convert "^2.0.1"
 
+ansi-to-html@^0.6.6:
+  version "0.6.15"
+  resolved "https://registry.yarnpkg.com/ansi-to-html/-/ansi-to-html-0.6.15.tgz#ac6ad4798a00f6aa045535d7f6a9cb9294eebea7"
+  integrity sha512-28ijx2aHJGdzbs+O5SNQF65r6rrKYnkuwTYm8lZlChuoJ9P1vVzIpWO20sQTqTPDXYp6NFwk326vApTtLVFXpQ==
+  dependencies:
+    entities "^2.0.0"
+
 ansicolors@~0.2.1:
   version "0.2.1"
   resolved "https://registry.yarnpkg.com/ansicolors/-/ansicolors-0.2.1.tgz#be089599097b74a5c9c4a84a0cdbcdb62bd87aef"
@@ -2055,6 +2286,13 @@ babel-messages@^6.23.0:
   dependencies:
     babel-runtime "^6.22.0"
 
+babel-plugin-debug-macros@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/babel-plugin-debug-macros/-/babel-plugin-debug-macros-0.2.0.tgz#0120ac20ce06ccc57bf493b667cf24b85c28da7a"
+  integrity sha512-Wpmw4TbhR3Eq2t3W51eBAQSdKlr+uAyF0GI4GtPfMCD12Y4cIdpKC9l0RjNTH/P9isFypSqqewMPm7//fnZlNA==
+  dependencies:
+    semver "^5.3.0"
+
 babel-plugin-debug-macros@^0.3.4:
   version "0.3.4"
   resolved "https://registry.yarnpkg.com/babel-plugin-debug-macros/-/babel-plugin-debug-macros-0.3.4.tgz#22961d0cb851a80654cece807a8b4b73d85c6075"
@@ -3607,6 +3845,13 @@ debug@^3.0.1, debug@^3.1.0, debug@^3.1.1, debug@^3.2.7:
   dependencies:
     ms "^2.1.1"
 
+debug@^4.0.0:
+  version "4.3.4"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865"
+  integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
+  dependencies:
+    ms "2.1.2"
+
 decamelize-keys@^1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/decamelize-keys/-/decamelize-keys-1.1.0.tgz#d171a87933252807eb3cb61dc1c1445d078df2d9"
@@ -3846,12 +4091,12 @@ ember-auto-import@^2.4.1:
     typescript-memoize "^1.0.0-alpha.3"
     walk-sync "^3.0.0"
 
-ember-cli-babel-plugin-helpers@^1.1.1:
+ember-cli-babel-plugin-helpers@^1.0.0, ember-cli-babel-plugin-helpers@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/ember-cli-babel-plugin-helpers/-/ember-cli-babel-plugin-helpers-1.1.1.tgz#5016b80cdef37036c4282eef2d863e1d73576879"
   integrity sha512-sKvOiPNHr5F/60NLd7SFzMpYPte/nnGkq/tMIfXejfKHIhaiIkYFqX8Z9UFTKWLLn+V7NOaby6niNPZUdvKCRw==
 
-ember-cli-babel@^7.26.11, ember-cli-babel@^7.26.6:
+ember-cli-babel@^7.26.11, ember-cli-babel@^7.26.6, ember-cli-babel@^7.7.3:
   version "7.26.11"
   resolved "https://registry.yarnpkg.com/ember-cli-babel/-/ember-cli-babel-7.26.11.tgz#50da0fe4dcd99aada499843940fec75076249a9f"
   integrity sha512-JJYeYjiz/JTn34q7F5DSOjkkZqy8qwFOOxXfE6pe9yEJqWGu4qErKxlz8I22JoVEQ/aBUO+OcKTpmctvykM9YA==
@@ -3990,6 +4235,31 @@ ember-cli-typescript-blueprint-polyfill@^0.1.0:
     chalk "^4.0.0"
     remove-types "^1.0.0"
 
+ember-cli-typescript@3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/ember-cli-typescript/-/ember-cli-typescript-3.0.0.tgz#3b838d1ce9e4d22a98e68da22ceac6dc0cfd9bfc"
+  integrity sha512-lo5YArbJzJi5ssvaGqTt6+FnhTALnSvYVuxM7lfyL1UCMudyNJ94ovH5C7n5il7ATd6WsNiAPRUO/v+s5Jq/aA==
+  dependencies:
+    "@babel/plugin-transform-typescript" "~7.5.0"
+    ansi-to-html "^0.6.6"
+    debug "^4.0.0"
+    ember-cli-babel-plugin-helpers "^1.0.0"
+    execa "^2.0.0"
+    fs-extra "^8.0.0"
+    resolve "^1.5.0"
+    rsvp "^4.8.1"
+    semver "^6.0.0"
+    stagehand "^1.0.0"
+    walk-sync "^2.0.0"
+
+ember-cli-version-checker@^3.1.3:
+  version "3.1.3"
+  resolved "https://registry.yarnpkg.com/ember-cli-version-checker/-/ember-cli-version-checker-3.1.3.tgz#7c9b4f5ff30fdebcd480b1c06c4de43bb51c522c"
+  integrity sha512-PZNSvpzwWgv68hcXxyjREpj3WWb81A7rtYNQq1lLEgrWIchF8ApKJjWP3NBpHjaatwILkZAV8klair5WFlXAKg==
+  dependencies:
+    resolve-package-path "^1.2.6"
+    semver "^5.6.0"
+
 ember-cli-version-checker@^4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/ember-cli-version-checker/-/ember-cli-version-checker-4.1.0.tgz#7fc9836bdbc87451d286ba6a9a89b23591d8bbb7"
@@ -3999,7 +4269,7 @@ ember-cli-version-checker@^4.1.0:
     semver "^6.3.0"
     silent-error "^1.1.1"
 
-ember-cli-version-checker@^5.1.2:
+ember-cli-version-checker@^5.1.1, ember-cli-version-checker@^5.1.2:
   version "5.1.2"
   resolved "https://registry.yarnpkg.com/ember-cli-version-checker/-/ember-cli-version-checker-5.1.2.tgz#649c7b6404902e3b3d69c396e054cea964911ab0"
   integrity sha512-rk7GY+FmLn/2e22HsZs0Ycrz8HQ1W3Fv+2TFOuEFW9optnDXDgkntPBIl6gact/LHsfBM5RKbM3dHsIIeLgl0Q==
@@ -4116,6 +4386,17 @@ ember-cli@^4.2.0:
     workerpool "^6.1.4"
     yam "^1.0.0"
 
+ember-compatibility-helpers@^1.1.2:
+  version "1.2.6"
+  resolved "https://registry.yarnpkg.com/ember-compatibility-helpers/-/ember-compatibility-helpers-1.2.6.tgz#603579ab2fb14be567ef944da3fc2d355f779cd8"
+  integrity sha512-2UBUa5SAuPg8/kRVaiOfTwlXdeVweal1zdNPibwItrhR0IvPrXpaqwJDlEZnWKEoB+h33V0JIfiWleSG6hGkkA==
+  dependencies:
+    babel-plugin-debug-macros "^0.2.0"
+    ember-cli-version-checker "^5.1.1"
+    find-up "^5.0.0"
+    fs-extra "^9.1.0"
+    semver "^5.4.1"
+
 ember-publisher@0.0.7:
   version "0.0.7"
   resolved "https://registry.yarnpkg.com/ember-publisher/-/ember-publisher-0.0.7.tgz#865ca69ef47bafb38120a84244aa58b950ca4850"
@@ -4191,6 +4472,11 @@ ensure-posix-path@^1.0.0, ensure-posix-path@^1.0.1, ensure-posix-path@^1.0.2, en
   resolved "https://registry.yarnpkg.com/ensure-posix-path/-/ensure-posix-path-1.1.1.tgz#3c62bdb19fa4681544289edb2b382adc029179ce"
   integrity sha512-VWU0/zXzVbeJNXvME/5EmLuEj2TauvoaTz6aFYK1Z92JCBlDlZ3Gu0tuGR42kpW1754ywTs+QB0g5TP0oj9Zaw==
 
+entities@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/entities/-/entities-2.2.0.tgz#098dc90ebb83d8dffa089d55256b351d34c4da55"
+  integrity sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==
+
 entities@~1.1.1:
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/entities/-/entities-1.1.2.tgz#bdfa735299664dfafd34529ed4f8522a275fea56"
@@ -4624,6 +4910,21 @@ execa@^1.0.0:
     signal-exit "^3.0.0"
     strip-eof "^1.0.0"
 
+execa@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/execa/-/execa-2.1.0.tgz#e5d3ecd837d2a60ec50f3da78fd39767747bbe99"
+  integrity sha512-Y/URAVapfbYy2Xp/gb6A0E7iR8xeqOCXsuuaoMn7A5PzrXUK84E1gyiEfq0wQd/GHA6GsoHWwhNq8anb0mleIw==
+  dependencies:
+    cross-spawn "^7.0.0"
+    get-stream "^5.0.0"
+    is-stream "^2.0.0"
+    merge-stream "^2.0.0"
+    npm-run-path "^3.0.0"
+    onetime "^5.1.0"
+    p-finally "^2.0.0"
+    signal-exit "^3.0.2"
+    strip-final-newline "^2.0.0"
+
 execa@^4.0.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/execa/-/execa-4.1.0.tgz#4e5491ad1572f2f17a77d388c6c857135b22847a"
@@ -5176,7 +5477,7 @@ fs-extra@^7.0.0, fs-extra@^7.0.1:
     jsonfile "^4.0.0"
     universalify "^0.1.0"
 
-fs-extra@^8.0.1, fs-extra@^8.1.0:
+fs-extra@^8.0.0, fs-extra@^8.0.1, fs-extra@^8.1.0:
   version "8.1.0"
   resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-8.1.0.tgz#49d43c45a88cd9677668cb7be1b46efdb8d2e1c0"
   integrity sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==
@@ -7626,6 +7927,13 @@ npm-run-path@^2.0.0:
   dependencies:
     path-key "^2.0.0"
 
+npm-run-path@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-3.1.0.tgz#7f91be317f6a466efed3c9f2980ad8a4ee8b0fa5"
+  integrity sha512-Dbl4A/VfiVGLgQv29URL9xshU8XDY1GeLy+fsaZ1AA8JDSfjvr5P5+pzRbWqRSBxk6/DW7MIh8lTM/PaGnP2kg==
+  dependencies:
+    path-key "^3.0.0"
+
 npm-run-path@^4.0.0, npm-run-path@^4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea"
@@ -7807,6 +8115,11 @@ p-finally@^1.0.0:
   resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-1.0.0.tgz#3fbcfb15b899a44123b34b6dcc18b724336a2cae"
   integrity "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4= sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow=="
 
+p-finally@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-2.0.1.tgz#bd6fcaa9c559a096b680806f4d657b3f0f240561"
+  integrity sha512-vpm09aKwq6H9phqRQzecoDpD8TmVyGw70qmWlyq5onxY7tqyTTFVvxMykxQSQKILBSFlbXpypIw2T1Ml7+DDtw==
+
 p-limit@^1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-1.1.0.tgz#b07ff2d9a5d88bec806035895a2bab66a27988bc"
@@ -8623,7 +8936,7 @@ resolve-from@^4.0.0:
   resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
   integrity "sha1-SrzYUq0y3Xuqv+m0DgCjbbXzkuY= sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="
 
-resolve-package-path@^1.0.11:
+resolve-package-path@^1.0.11, resolve-package-path@^1.2.6:
   version "1.2.7"
   resolved "https://registry.yarnpkg.com/resolve-package-path/-/resolve-package-path-1.2.7.tgz#2a7bc37ad96865e239330e3102c31322847e652e"
   integrity sha512-fVEKHGeK85bGbVFuwO9o1aU0n3vqQGrezPc51JGu9UTXpFQfWq5qCeKxyaRUSvephs+06c5j5rPq/dzHGEo8+Q==
@@ -8796,7 +9109,7 @@ rsvp@^3.0.14, rsvp@^3.0.17, rsvp@^3.0.18, rsvp@^3.0.21:
   resolved "https://registry.yarnpkg.com/rsvp/-/rsvp-3.6.2.tgz#2e96491599a96cde1b515d5674a8f7a91452926a"
   integrity sha512-OfWGQTb9vnwRjwtA2QwpG2ICclHC3pgXZO5xt8H2EfgDquO0qVdSb5T88L4qJVAEugbS56pAuV4XZM58UX8ulw==
 
-rsvp@^4.7.0, rsvp@^4.8.4, rsvp@^4.8.5:
+rsvp@^4.7.0, rsvp@^4.8.1, rsvp@^4.8.4, rsvp@^4.8.5:
   version "4.8.5"
   resolved "https://registry.yarnpkg.com/rsvp/-/rsvp-4.8.5.tgz#c8f155311d167f68f21e168df71ec5b083113734"
   integrity sha512-nfMOlASu9OnRJo1mbEk2cz0D56a1MBNrJ7orjRZQG10XDyuvwksKbuXNp6qa+kbn839HwjwhBzhFmdsaEAfauA==
@@ -8930,6 +9243,11 @@ semver@7.0.0:
   resolved "https://registry.yarnpkg.com/semver/-/semver-7.0.0.tgz#5f3ca35761e47e05b206c6daff2cf814f0316b8e"
   integrity sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A==
 
+semver@^5.4.1, semver@^5.6.0:
+  version "5.7.1"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
+  integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
+
 semver@^6.0.0, semver@^6.1.0, semver@^6.1.1, semver@^6.1.2, semver@^6.2.0, semver@^6.3.0:
   version "6.3.0"
   resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
@@ -9308,6 +9626,13 @@ sprintf-js@~1.0.2:
   resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
   integrity "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw= sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g=="
 
+stagehand@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/stagehand/-/stagehand-1.0.0.tgz#79515e2ad3a02c63f8720c7df9b6077ae14276d9"
+  integrity sha512-zrXl0QixAtSHFyN1iv04xOBgplbT4HgC8T7g+q8ESZbDNi5uZbMtxLukFVXPJ5Nl7zCYvYcrT3Mj24WYCH93hw==
+  dependencies:
+    debug "^4.1.0"
+
 static-extend@^0.1.1:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6"
@@ -10206,7 +10531,7 @@ walk-sync@^1.0.0, walk-sync@^1.1.3:
     ensure-posix-path "^1.1.0"
     matcher-collection "^1.1.1"
 
-walk-sync@^2.0.2, walk-sync@^2.1.0, walk-sync@^2.2.0:
+walk-sync@^2.0.0, walk-sync@^2.0.2, walk-sync@^2.1.0, walk-sync@^2.2.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/walk-sync/-/walk-sync-2.2.0.tgz#80786b0657fcc8c0e1c0b1a042a09eae2966387a"
   integrity sha512-IC8sL7aB4/ZgFcGI2T1LczZeFWZ06b3zoHH7jBPyHxOtIIz1jppWHjjEXkOFvFojBVAK9pV7g47xOZ4LW3QLfg==