From 6278a8b7cfe55ef2b138ec7d1324bc5cc79544c3 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 22 Aug 2022 21:32:04 -0600
Subject: [PATCH 01/39] [FEATURE] Introduce a preview types package

Copy the types from DefinitelyTyped, and set up a bare minimum config
to make it possible to iterate on them. This particular commit fails all
type checking and has an enormous amount of work to do, but provides a
foundation on which we can iterate.
---
 .eslintrc.js                                  |  21 +
 package.json                                  |   5 +
 .../-private/event-dispatcher.d.ts            |  16 +
 .../@ember/application/-private/registry.d.ts |   9 +
 .../@ember/application/deprecations.d.ts      |  23 +
 types/preview/@ember/application/index.d.ts   | 159 ++++++
 .../preview/@ember/application/instance.d.ts  |   7 +
 .../application/test/application-instance.ts  |  44 ++
 .../@ember/application/test/application.ts    |  43 ++
 .../@ember/application/test/deprecations.ts   |  17 +
 .../preview/@ember/application/test/index.ts  |  28 +
 .../preview/@ember/application/tsconfig.json  |   3 +
 types/preview/@ember/application/types.d.ts   |  27 +
 .../@ember/array/-private/enumerable.d.ts     | 179 ++++++
 .../array/-private/mutable-enumerable.d.ts    |  28 +
 .../@ember/array/-private/native-array.d.ts   |  23 +
 types/preview/@ember/array/index.d.ts         |  79 +++
 types/preview/@ember/array/mutable.d.ts       |  75 +++
 types/preview/@ember/array/proxy.d.ts         |  31 ++
 types/preview/@ember/array/test/array-ext.ts  |  23 +
 .../preview/@ember/array/test/array-proxy.ts  |  57 ++
 types/preview/@ember/array/test/array.ts      |  65 +++
 types/preview/@ember/array/test/lib/assert.ts |   2 +
 types/preview/@ember/array/tsconfig.json      |   3 +
 .../array/types/prototype-extensions.d.ts     |   5 +
 .../-private/class-names-support.d.ts         |  25 +
 .../@ember/component/-private/core-view.d.ts  |  12 +
 .../-private/glimmer-interfaces.d.ts          |  44 ++
 .../@ember/component/-private/view-mixin.d.ts |  57 ++
 types/preview/@ember/component/helper.d.ts    | 198 +++++++
 types/preview/@ember/component/index.d.ts     | 131 +++++
 .../@ember/component/template-only.d.ts       |  46 ++
 .../@ember/component/test/built-ins.ts        |   4 +
 .../@ember/component/test/component.ts        | 157 ++++++
 types/preview/@ember/component/test/helper.ts | 128 +++++
 .../@ember/component/test/lib/assert.ts       |   2 +
 .../@ember/component/test/template-only.ts    |  28 +
 types/preview/@ember/component/tsconfig.json  |   3 +
 types/preview/@ember/controller/index.d.ts    |  47 ++
 types/preview/@ember/controller/test/main.ts  |  14 +
 .../preview/@ember/controller/test/octane.ts  |  36 ++
 types/preview/@ember/controller/tsconfig.json |   3 +
 .../@ember/debug/container-debug-adapter.d.ts |  11 +
 types/preview/@ember/debug/data-adapter.d.ts  |  62 +++
 .../@ember/debug/ember__debug-tests.ts        | 237 ++++++++
 types/preview/@ember/debug/index.d.ts         | 100 ++++
 types/preview/@ember/debug/tsconfig.json      |   3 +
 types/preview/@ember/destroyable/index.d.ts   |  29 +
 .../@ember/destroyable/test/lib/assert.ts     |   2 +
 types/preview/@ember/destroyable/test/main.ts |  91 +++
 .../preview/@ember/destroyable/tsconfig.json  |   3 +
 .../-private/container-proxy-mixin.d.ts       |  15 +
 .../engine/-private/registry-proxy-mixin.d.ts |  52 ++
 .../engine/-private/types/initializer.d.ts    |   6 +
 types/preview/@ember/engine/index.d.ts        |  65 +++
 types/preview/@ember/engine/instance.d.ts     |  22 +
 .../@ember/engine/test/engine-instance.ts     |  26 +
 types/preview/@ember/engine/test/engine.ts    |  43 ++
 types/preview/@ember/engine/tsconfig.json     |   3 +
 .../@ember/error/ember__error-tests.ts        |   7 +
 types/preview/@ember/error/index.d.ts         |  12 +
 types/preview/@ember/error/tsconfig.json      |   3 +
 .../@ember/helper/ember__helper-tests.ts      |   7 +
 types/preview/@ember/helper/index.d.ts        |  55 ++
 types/preview/@ember/helper/tsconfig.json     |   3 +
 .../@ember/modifier/ember__modifier-tests.ts  |   8 +
 types/preview/@ember/modifier/index.d.ts      |  39 ++
 types/preview/@ember/modifier/tsconfig.json   |   3 +
 .../object/-private/action-handler.d.ts       |  28 +
 .../preview/@ember/object/-private/types.d.ts |  61 ++
 types/preview/@ember/object/compat.d.ts       |   7 +
 types/preview/@ember/object/computed.d.ts     | 261 +++++++++
 types/preview/@ember/object/core.d.ts         |  82 +++
 types/preview/@ember/object/evented.d.ts      |  60 ++
 types/preview/@ember/object/events.d.ts       |  49 ++
 types/preview/@ember/object/index.d.ts        | 116 ++++
 types/preview/@ember/object/internals.d.ts    |  15 +
 types/preview/@ember/object/mixin.d.ts        |  17 +
 types/preview/@ember/object/observable.d.ts   |  78 +++
 types/preview/@ember/object/observers.d.ts    |  32 ++
 .../@ember/object/promise-proxy-mixin.d.ts    |  35 ++
 types/preview/@ember/object/proxy.d.ts        |  25 +
 .../@ember/object/test/access-modifier.ts     |  29 +
 types/preview/@ember/object/test/compat.ts    |  12 +
 types/preview/@ember/object/test/computed.ts  | 231 ++++++++
 types/preview/@ember/object/test/core.ts      | 218 ++++++++
 .../@ember/object/test/create-negative.ts     |  11 +
 types/preview/@ember/object/test/create.ts    |  54 ++
 types/preview/@ember/object/test/event.ts     |  92 +++
 types/preview/@ember/object/test/extend.ts    |  61 ++
 types/preview/@ember/object/test/get-set.ts   |  14 +
 types/preview/@ember/object/test/internals.ts |  10 +
 .../preview/@ember/object/test/lib/assert.ts  |   2 +
 types/preview/@ember/object/test/object.ts    | 102 ++++
 .../preview/@ember/object/test/observable.ts  | 102 ++++
 types/preview/@ember/object/test/octane.ts    | 331 +++++++++++
 types/preview/@ember/object/test/proxy.ts     | 103 ++++
 types/preview/@ember/object/test/reopen.ts    |  75 +++
 types/preview/@ember/object/tsconfig.json     |   3 +
 .../@ember/owner/ember__owner-tests.ts        | 135 +++++
 types/preview/@ember/owner/index.d.ts         | 104 ++++
 types/preview/@ember/owner/tsconfig.json      |   3 +
 .../polyfills/ember__polyfills-tests.ts       |  23 +
 types/preview/@ember/polyfills/index.d.ts     |  29 +
 types/preview/@ember/polyfills/tsconfig.json  |   3 +
 types/preview/@ember/polyfills/types.d.ts     |   4 +
 .../-private/route-info-with-attributes.d.ts  |   1 +
 .../@ember/routing/-private/route-info.d.ts   |   1 +
 .../@ember/routing/-private/router-dsl.d.ts   |  18 +
 .../@ember/routing/-private/transition.d.ts   |   1 +
 .../preview/@ember/routing/auto-location.d.ts |   6 +
 .../preview/@ember/routing/hash-location.d.ts |   8 +
 .../@ember/routing/history-location.d.ts      |   7 +
 types/preview/@ember/routing/index.d.ts       |  26 +
 .../preview/@ember/routing/none-location.d.ts |   9 +
 types/preview/@ember/routing/route-info.d.ts  |  72 +++
 types/preview/@ember/routing/route.d.ts       | 525 ++++++++++++++++++
 .../@ember/routing/router-service.d.ts        | 360 ++++++++++++
 types/preview/@ember/routing/router.d.ts      |  43 ++
 .../preview/@ember/routing/test/built-ins.ts  |   3 +
 .../preview/@ember/routing/test/lib/assert.ts |   2 +
 types/preview/@ember/routing/test/route.ts    | 227 ++++++++
 .../@ember/routing/test/router-service.ts     | 120 ++++
 types/preview/@ember/routing/test/router.ts   |  81 +++
 types/preview/@ember/routing/transition.d.ts  | 124 +++++
 types/preview/@ember/routing/tsconfig.json    |   3 +
 types/preview/@ember/routing/types.d.ts       |  13 +
 .../@ember/runloop/-private/backburner.d.ts   |  41 ++
 .../@ember/runloop/-private/types.d.ts        |   1 +
 .../@ember/runloop/ember__runloop-tests.ts    | 279 ++++++++++
 types/preview/@ember/runloop/index.d.ts       | 179 ++++++
 types/preview/@ember/runloop/tsconfig.json    |   3 +
 types/preview/@ember/runloop/types.d.ts       |   3 +
 types/preview/@ember/service/index.d.ts       |  32 ++
 types/preview/@ember/service/test/main.ts     |  58 ++
 types/preview/@ember/service/test/octane.ts   |  34 ++
 types/preview/@ember/service/tsconfig.json    |   3 +
 .../@ember/template/-private/handlebars.d.ts  |   5 +
 .../@ember/template/ember__template-tests.ts  |  15 +
 types/preview/@ember/template/index.d.ts      |  11 +
 types/preview/@ember/template/tsconfig.json   |   3 +
 types/preview/@ember/test/adapter.d.ts        |  20 +
 .../preview/@ember/test/ember__test-tests.ts  |  42 ++
 types/preview/@ember/test/index.d.ts          |  55 ++
 types/preview/@ember/test/tsconfig.json       |   3 +
 .../preview/@ember/utils/-private/types.d.ts  |  36 ++
 .../@ember/utils/ember__utils-tests.ts        | 145 +++++
 types/preview/@ember/utils/index.d.ts         |  49 ++
 types/preview/@ember/utils/tsconfig.json      |   3 +
 types/preview/ember/-private/type-utils.d.ts  |  52 ++
 types/preview/ember/index.d.ts                | 401 +++++++++++++
 types/preview/ember/test/access-modifier.ts   |  42 ++
 .../ember/test/application-instance.ts        |  29 +
 types/preview/ember/test/application.ts       |  43 ++
 types/preview/ember/test/array-ext.ts         |  21 +
 types/preview/ember/test/array-proxy.ts       |  26 +
 types/preview/ember/test/array.ts             |  50 ++
 types/preview/ember/test/component.ts         | 124 +++++
 types/preview/ember/test/computed.ts          | 192 +++++++
 types/preview/ember/test/controller.ts        |  11 +
 types/preview/ember/test/core-object.ts       | 218 ++++++++
 types/preview/ember/test/create-negative.ts   |  14 +
 types/preview/ember/test/create.ts            |  55 ++
 types/preview/ember/test/data-adapter.ts      |  59 ++
 types/preview/ember/test/debug.ts             |  99 ++++
 .../preview/ember/test/ember-module-tests.ts  | 295 ++++++++++
 types/preview/ember/test/ember-tests.ts       | 190 +++++++
 types/preview/ember/test/engine-instance.ts   |  27 +
 types/preview/ember/test/engine.ts            |  43 ++
 types/preview/ember/test/error.ts             |   5 +
 types/preview/ember/test/event.ts             |  60 ++
 types/preview/ember/test/extend.ts            |  61 ++
 types/preview/ember/test/helper.ts            |  45 ++
 types/preview/ember/test/inject.ts            |  60 ++
 types/preview/ember/test/lib/assert.ts        |   2 +
 types/preview/ember/test/mixin.ts             |  57 ++
 types/preview/ember/test/object.ts            |  84 +++
 types/preview/ember/test/observable.ts        | 116 ++++
 .../ember/test/private/computed-tests.ts      |  92 +++
 .../ember/test/private/observable-tests.ts    | 200 +++++++
 types/preview/ember/test/reopen.ts            |  64 +++
 types/preview/ember/test/route.ts             |  97 ++++
 types/preview/ember/test/router.ts            |  49 ++
 types/preview/ember/test/run.ts               | 220 ++++++++
 types/preview/ember/test/string.ts            |  51 ++
 .../test/techniques/properties-from-this.ts   |  71 +++
 types/preview/ember/test/test.ts              |  32 ++
 types/preview/ember/test/transition.ts        |  29 +
 types/preview/ember/test/utils.ts             | 146 +++++
 types/preview/ember/test/view-utils.ts        |   7 +
 types/preview/ember/tsconfig.json             |   3 +
 types/preview/tsconfig.json                   |   6 +
 yarn.lock                                     | 339 ++++++++++-
 193 files changed, 11981 insertions(+), 7 deletions(-)
 create mode 100644 types/preview/@ember/application/-private/event-dispatcher.d.ts
 create mode 100644 types/preview/@ember/application/-private/registry.d.ts
 create mode 100644 types/preview/@ember/application/deprecations.d.ts
 create mode 100644 types/preview/@ember/application/index.d.ts
 create mode 100644 types/preview/@ember/application/instance.d.ts
 create mode 100644 types/preview/@ember/application/test/application-instance.ts
 create mode 100755 types/preview/@ember/application/test/application.ts
 create mode 100644 types/preview/@ember/application/test/deprecations.ts
 create mode 100644 types/preview/@ember/application/test/index.ts
 create mode 100644 types/preview/@ember/application/tsconfig.json
 create mode 100644 types/preview/@ember/application/types.d.ts
 create mode 100644 types/preview/@ember/array/-private/enumerable.d.ts
 create mode 100644 types/preview/@ember/array/-private/mutable-enumerable.d.ts
 create mode 100644 types/preview/@ember/array/-private/native-array.d.ts
 create mode 100644 types/preview/@ember/array/index.d.ts
 create mode 100644 types/preview/@ember/array/mutable.d.ts
 create mode 100644 types/preview/@ember/array/proxy.d.ts
 create mode 100755 types/preview/@ember/array/test/array-ext.ts
 create mode 100644 types/preview/@ember/array/test/array-proxy.ts
 create mode 100755 types/preview/@ember/array/test/array.ts
 create mode 100755 types/preview/@ember/array/test/lib/assert.ts
 create mode 100644 types/preview/@ember/array/tsconfig.json
 create mode 100644 types/preview/@ember/array/types/prototype-extensions.d.ts
 create mode 100644 types/preview/@ember/component/-private/class-names-support.d.ts
 create mode 100644 types/preview/@ember/component/-private/core-view.d.ts
 create mode 100644 types/preview/@ember/component/-private/glimmer-interfaces.d.ts
 create mode 100644 types/preview/@ember/component/-private/view-mixin.d.ts
 create mode 100644 types/preview/@ember/component/helper.d.ts
 create mode 100644 types/preview/@ember/component/index.d.ts
 create mode 100644 types/preview/@ember/component/template-only.d.ts
 create mode 100644 types/preview/@ember/component/test/built-ins.ts
 create mode 100644 types/preview/@ember/component/test/component.ts
 create mode 100644 types/preview/@ember/component/test/helper.ts
 create mode 100755 types/preview/@ember/component/test/lib/assert.ts
 create mode 100644 types/preview/@ember/component/test/template-only.ts
 create mode 100644 types/preview/@ember/component/tsconfig.json
 create mode 100644 types/preview/@ember/controller/index.d.ts
 create mode 100644 types/preview/@ember/controller/test/main.ts
 create mode 100644 types/preview/@ember/controller/test/octane.ts
 create mode 100644 types/preview/@ember/controller/tsconfig.json
 create mode 100644 types/preview/@ember/debug/container-debug-adapter.d.ts
 create mode 100644 types/preview/@ember/debug/data-adapter.d.ts
 create mode 100644 types/preview/@ember/debug/ember__debug-tests.ts
 create mode 100644 types/preview/@ember/debug/index.d.ts
 create mode 100644 types/preview/@ember/debug/tsconfig.json
 create mode 100644 types/preview/@ember/destroyable/index.d.ts
 create mode 100644 types/preview/@ember/destroyable/test/lib/assert.ts
 create mode 100644 types/preview/@ember/destroyable/test/main.ts
 create mode 100644 types/preview/@ember/destroyable/tsconfig.json
 create mode 100644 types/preview/@ember/engine/-private/container-proxy-mixin.d.ts
 create mode 100644 types/preview/@ember/engine/-private/registry-proxy-mixin.d.ts
 create mode 100644 types/preview/@ember/engine/-private/types/initializer.d.ts
 create mode 100644 types/preview/@ember/engine/index.d.ts
 create mode 100644 types/preview/@ember/engine/instance.d.ts
 create mode 100644 types/preview/@ember/engine/test/engine-instance.ts
 create mode 100755 types/preview/@ember/engine/test/engine.ts
 create mode 100644 types/preview/@ember/engine/tsconfig.json
 create mode 100644 types/preview/@ember/error/ember__error-tests.ts
 create mode 100644 types/preview/@ember/error/index.d.ts
 create mode 100644 types/preview/@ember/error/tsconfig.json
 create mode 100644 types/preview/@ember/helper/ember__helper-tests.ts
 create mode 100644 types/preview/@ember/helper/index.d.ts
 create mode 100644 types/preview/@ember/helper/tsconfig.json
 create mode 100644 types/preview/@ember/modifier/ember__modifier-tests.ts
 create mode 100644 types/preview/@ember/modifier/index.d.ts
 create mode 100644 types/preview/@ember/modifier/tsconfig.json
 create mode 100644 types/preview/@ember/object/-private/action-handler.d.ts
 create mode 100644 types/preview/@ember/object/-private/types.d.ts
 create mode 100644 types/preview/@ember/object/compat.d.ts
 create mode 100644 types/preview/@ember/object/computed.d.ts
 create mode 100644 types/preview/@ember/object/core.d.ts
 create mode 100644 types/preview/@ember/object/evented.d.ts
 create mode 100644 types/preview/@ember/object/events.d.ts
 create mode 100644 types/preview/@ember/object/index.d.ts
 create mode 100644 types/preview/@ember/object/internals.d.ts
 create mode 100644 types/preview/@ember/object/mixin.d.ts
 create mode 100644 types/preview/@ember/object/observable.d.ts
 create mode 100644 types/preview/@ember/object/observers.d.ts
 create mode 100644 types/preview/@ember/object/promise-proxy-mixin.d.ts
 create mode 100644 types/preview/@ember/object/proxy.d.ts
 create mode 100644 types/preview/@ember/object/test/access-modifier.ts
 create mode 100644 types/preview/@ember/object/test/compat.ts
 create mode 100644 types/preview/@ember/object/test/computed.ts
 create mode 100644 types/preview/@ember/object/test/core.ts
 create mode 100644 types/preview/@ember/object/test/create-negative.ts
 create mode 100644 types/preview/@ember/object/test/create.ts
 create mode 100644 types/preview/@ember/object/test/event.ts
 create mode 100644 types/preview/@ember/object/test/extend.ts
 create mode 100644 types/preview/@ember/object/test/get-set.ts
 create mode 100644 types/preview/@ember/object/test/internals.ts
 create mode 100644 types/preview/@ember/object/test/lib/assert.ts
 create mode 100644 types/preview/@ember/object/test/object.ts
 create mode 100644 types/preview/@ember/object/test/observable.ts
 create mode 100644 types/preview/@ember/object/test/octane.ts
 create mode 100644 types/preview/@ember/object/test/proxy.ts
 create mode 100644 types/preview/@ember/object/test/reopen.ts
 create mode 100644 types/preview/@ember/object/tsconfig.json
 create mode 100644 types/preview/@ember/owner/ember__owner-tests.ts
 create mode 100644 types/preview/@ember/owner/index.d.ts
 create mode 100644 types/preview/@ember/owner/tsconfig.json
 create mode 100644 types/preview/@ember/polyfills/ember__polyfills-tests.ts
 create mode 100644 types/preview/@ember/polyfills/index.d.ts
 create mode 100644 types/preview/@ember/polyfills/tsconfig.json
 create mode 100644 types/preview/@ember/polyfills/types.d.ts
 create mode 100644 types/preview/@ember/routing/-private/route-info-with-attributes.d.ts
 create mode 100644 types/preview/@ember/routing/-private/route-info.d.ts
 create mode 100644 types/preview/@ember/routing/-private/router-dsl.d.ts
 create mode 100644 types/preview/@ember/routing/-private/transition.d.ts
 create mode 100644 types/preview/@ember/routing/auto-location.d.ts
 create mode 100644 types/preview/@ember/routing/hash-location.d.ts
 create mode 100644 types/preview/@ember/routing/history-location.d.ts
 create mode 100644 types/preview/@ember/routing/index.d.ts
 create mode 100644 types/preview/@ember/routing/none-location.d.ts
 create mode 100644 types/preview/@ember/routing/route-info.d.ts
 create mode 100644 types/preview/@ember/routing/route.d.ts
 create mode 100644 types/preview/@ember/routing/router-service.d.ts
 create mode 100644 types/preview/@ember/routing/router.d.ts
 create mode 100644 types/preview/@ember/routing/test/built-ins.ts
 create mode 100755 types/preview/@ember/routing/test/lib/assert.ts
 create mode 100755 types/preview/@ember/routing/test/route.ts
 create mode 100644 types/preview/@ember/routing/test/router-service.ts
 create mode 100755 types/preview/@ember/routing/test/router.ts
 create mode 100644 types/preview/@ember/routing/transition.d.ts
 create mode 100644 types/preview/@ember/routing/tsconfig.json
 create mode 100644 types/preview/@ember/routing/types.d.ts
 create mode 100644 types/preview/@ember/runloop/-private/backburner.d.ts
 create mode 100644 types/preview/@ember/runloop/-private/types.d.ts
 create mode 100644 types/preview/@ember/runloop/ember__runloop-tests.ts
 create mode 100644 types/preview/@ember/runloop/index.d.ts
 create mode 100644 types/preview/@ember/runloop/tsconfig.json
 create mode 100644 types/preview/@ember/runloop/types.d.ts
 create mode 100644 types/preview/@ember/service/index.d.ts
 create mode 100644 types/preview/@ember/service/test/main.ts
 create mode 100644 types/preview/@ember/service/test/octane.ts
 create mode 100644 types/preview/@ember/service/tsconfig.json
 create mode 100644 types/preview/@ember/template/-private/handlebars.d.ts
 create mode 100644 types/preview/@ember/template/ember__template-tests.ts
 create mode 100644 types/preview/@ember/template/index.d.ts
 create mode 100644 types/preview/@ember/template/tsconfig.json
 create mode 100644 types/preview/@ember/test/adapter.d.ts
 create mode 100644 types/preview/@ember/test/ember__test-tests.ts
 create mode 100644 types/preview/@ember/test/index.d.ts
 create mode 100644 types/preview/@ember/test/tsconfig.json
 create mode 100644 types/preview/@ember/utils/-private/types.d.ts
 create mode 100644 types/preview/@ember/utils/ember__utils-tests.ts
 create mode 100644 types/preview/@ember/utils/index.d.ts
 create mode 100644 types/preview/@ember/utils/tsconfig.json
 create mode 100644 types/preview/ember/-private/type-utils.d.ts
 create mode 100755 types/preview/ember/index.d.ts
 create mode 100644 types/preview/ember/test/access-modifier.ts
 create mode 100644 types/preview/ember/test/application-instance.ts
 create mode 100755 types/preview/ember/test/application.ts
 create mode 100755 types/preview/ember/test/array-ext.ts
 create mode 100644 types/preview/ember/test/array-proxy.ts
 create mode 100755 types/preview/ember/test/array.ts
 create mode 100755 types/preview/ember/test/component.ts
 create mode 100755 types/preview/ember/test/computed.ts
 create mode 100755 types/preview/ember/test/controller.ts
 create mode 100644 types/preview/ember/test/core-object.ts
 create mode 100644 types/preview/ember/test/create-negative.ts
 create mode 100755 types/preview/ember/test/create.ts
 create mode 100644 types/preview/ember/test/data-adapter.ts
 create mode 100644 types/preview/ember/test/debug.ts
 create mode 100644 types/preview/ember/test/ember-module-tests.ts
 create mode 100755 types/preview/ember/test/ember-tests.ts
 create mode 100644 types/preview/ember/test/engine-instance.ts
 create mode 100755 types/preview/ember/test/engine.ts
 create mode 100644 types/preview/ember/test/error.ts
 create mode 100755 types/preview/ember/test/event.ts
 create mode 100755 types/preview/ember/test/extend.ts
 create mode 100755 types/preview/ember/test/helper.ts
 create mode 100755 types/preview/ember/test/inject.ts
 create mode 100755 types/preview/ember/test/lib/assert.ts
 create mode 100755 types/preview/ember/test/mixin.ts
 create mode 100755 types/preview/ember/test/object.ts
 create mode 100755 types/preview/ember/test/observable.ts
 create mode 100644 types/preview/ember/test/private/computed-tests.ts
 create mode 100644 types/preview/ember/test/private/observable-tests.ts
 create mode 100755 types/preview/ember/test/reopen.ts
 create mode 100755 types/preview/ember/test/route.ts
 create mode 100755 types/preview/ember/test/router.ts
 create mode 100755 types/preview/ember/test/run.ts
 create mode 100644 types/preview/ember/test/string.ts
 create mode 100644 types/preview/ember/test/techniques/properties-from-this.ts
 create mode 100755 types/preview/ember/test/test.ts
 create mode 100755 types/preview/ember/test/transition.ts
 create mode 100755 types/preview/ember/test/utils.ts
 create mode 100644 types/preview/ember/test/view-utils.ts
 create mode 100755 types/preview/ember/tsconfig.json
 create mode 100644 types/preview/tsconfig.json

diff --git a/.eslintrc.js b/.eslintrc.js
index 921dc164dd6..07cabcb5d36 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -65,6 +65,27 @@ module.exports = {
         'prefer-rest-params': 'off',
       },
     },
+    {
+      files: ['types/preview/**/*.ts'],
+
+      extends: ['plugin:@typescript-eslint/recommended'],
+
+      parserOptions: {
+        sourceType: 'module',
+        project: './types/preview/tsconfig.json',
+        tsconfigRootDir: __dirname,
+      },
+
+      rules: {
+        'import/export': 'off',
+        '@typescript-eslint/ban-ts-comment': 'off',
+        '@typescript-eslint/no-empty-interface': 'off',
+        'import/no-unresolved': 'off',
+        '@typescript-eslint/no-this-alias': 'off',
+        '@typescript-eslint/consistent-type-imports': 'error',
+        '@typescript-eslint/no-empty-function': 'off',
+      },
+    },
     {
       // TODO: files: ['packages/**/*.[jt]s'],
       files: ['packages/**/*.js'],
diff --git a/package.json b/package.json
index af8309ccb97..21640d79066 100644
--- a/package.json
+++ b/package.json
@@ -80,6 +80,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 +94,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,6 +156,9 @@
     "testem-failure-only-reporter": "^1.0.0",
     "typescript": "~4.6.4"
   },
+  "peerDependencies": {
+    "@glimmer/component": "^1.1.2"
+  },
   "engines": {
     "node": ">= 12.*"
   },
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..3df6d612ad7
--- /dev/null
+++ b/types/preview/@ember/application/-private/event-dispatcher.d.ts
@@ -0,0 +1,16 @@
+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..dc5ca32d531
--- /dev/null
+++ b/types/preview/@ember/application/-private/registry.d.ts
@@ -0,0 +1,9 @@
+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..0ed913f11b6
--- /dev/null
+++ b/types/preview/@ember/application/deprecations.d.ts
@@ -0,0 +1,23 @@
+import { AnyFn } from 'ember/-private/type-utils';
+
+// tslint:disable-next-line:strict-export-declare-modifiers
+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..16b359ce356
--- /dev/null
+++ b/types/preview/@ember/application/index.d.ts
@@ -0,0 +1,159 @@
+// Type definitions for non-npm package @ember/application 4.0
+// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Fapplication
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+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 { Resolver } from '@ember/engine';
+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..db5f37fcd5f
--- /dev/null
+++ b/types/preview/@ember/application/instance.d.ts
@@ -0,0 +1,7 @@
+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/test/application-instance.ts b/types/preview/@ember/application/test/application-instance.ts
new file mode 100644
index 00000000000..32748ca0d96
--- /dev/null
+++ b/types/preview/@ember/application/test/application-instance.ts
@@ -0,0 +1,44 @@
+import ApplicationInstance from '@ember/application/instance';
+import hbs from 'htmlbars-inline-precompile';
+
+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,
+});
+// @ts-expect-error
+appInstance.register('templates:foo/bar', hbs`<h1>Hello World</h1>`, {
+  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/types/preview/@ember/application/test/application.ts b/types/preview/@ember/application/test/application.ts
new file mode 100755
index 00000000000..8654afe83e4
--- /dev/null
+++ b/types/preview/@ember/application/test/application.ts
@@ -0,0 +1,43 @@
+import Application from '@ember/application';
+import EmberObject from '@ember/object';
+
+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();
+
+const App3Instance1 = App3.buildInstance(); // $ExpectType ApplicationInstance
+
+const App3Instance2 = App3.buildInstance({ foo: 'bar' }); // $ExpectType ApplicationInstance
diff --git a/types/preview/@ember/application/test/deprecations.ts b/types/preview/@ember/application/test/deprecations.ts
new file mode 100644
index 00000000000..e9bb19ed390
--- /dev/null
+++ b/types/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/types/preview/@ember/application/test/index.ts b/types/preview/@ember/application/test/index.ts
new file mode 100644
index 00000000000..521a4b6936d
--- /dev/null
+++ b/types/preview/@ember/application/test/index.ts
@@ -0,0 +1,28 @@
+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';
+
+// $ExpectType Owner | undefined
+getOwner({});
+
+// Confirm that random subclasses work as expected.
+declare class MyService extends Service {
+    withStuff: true;
+}
+declare let myService: MyService;
+// $ExpectType Owner
+getOwner(myService);
+
+// @ts-expect-error
+getOwner();
+
+declare let baseOwner: Owner;
+setOwner({}, baseOwner);
+
+declare let engine: EngineInstance;
+setOwner({}, engine);
+
+declare let application: ApplicationInstance;
+setOwner({}, application);
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..f03863c4d29
--- /dev/null
+++ b/types/preview/@ember/application/types.d.ts
@@ -0,0 +1,27 @@
+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..ca22d5a29fc
--- /dev/null
+++ b/types/preview/@ember/array/-private/enumerable.d.ts
@@ -0,0 +1,179 @@
+import ComputedProperty from '@ember/object/computed';
+import Mixin from '@ember/object/mixin';
+import NativeArray from '@ember/array/-private/native-array';
+import EmberArray from '@ember/array';
+import {
+  AnyFn,
+  MethodNamesOf,
+  MethodParams,
+  MethodReturns,
+  MethodsOf,
+} from 'ember/-private/type-utils';
+
+/**
+ * This mixin defines the common interface implemented by enumerable objects
+ * in Ember. Most of these methods follow the standard Array iteration
+ * API defined up to JavaScript 1.8 (excluding language-specific features that
+ * cannot be emulated in older versions of JavaScript).
+ */
+interface Enumerable<T> {
+  /**
+   * 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;
+  /**
+   * Iterates through the enumerable, calling the passed function on each
+   * item. This method corresponds to the `forEach()` method defined in
+   * JavaScript 1.6.
+   */
+  forEach: T[]['forEach'];
+  /**
+   * Alias for `mapBy`
+   */
+  getEach<K extends keyof T>(key: K): Array<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: T[]['map'];
+  /**
+   * 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): Array<T[K]>;
+  mapBy(key: string): 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: T[]['filter'];
+  /**
+   * 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(
+    callbackfn: (value: T, index: number, array: T[]) => unknown,
+    thisArg?: any
+  ): 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: T[]['find'];
+  /**
+   * 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: T[]['every'];
+  /**
+   * 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(callback: (value: T, index: number, array: T[]) => boolean, 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 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>;
+  /**
+   * 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 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>;
+  /**
+   * Returns `true` if the passed object can be found in the enumerable.
+   */
+  includes(searchElement: T, fromIndex?: number): boolean;
+  /**
+   * 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.
+   */
+  '[]': ComputedProperty<this>;
+}
+
+declare const Enumerable: Mixin<Enumerable<unknown>>;
+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..c2786508b29
--- /dev/null
+++ b/types/preview/@ember/array/-private/mutable-enumerable.d.ts
@@ -0,0 +1,28 @@
+import Mixin from '@ember/object/mixin';
+import Enumerable from '@ember/array/-private/enumerable';
+
+/**
+ * This mixin defines the API for modifying generic enumerables. These methods
+ * can be applied to an object regardless of whether it is ordered or
+ * unordered.
+ */
+interface MutableEnumerable<T> extends Enumerable<T> {
+    /**
+     * __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: Enumerable<T>): this;
+    /**
+     * __Required.__ You must implement this method to apply this mixin.
+     */
+    removeObject(object: T): T;
+    /**
+     * Removes each object in the passed enumerable from the receiver.
+     */
+    removeObjects(objects: Enumerable<T>): this;
+}
+declare const MutableEnumerable: Mixin<MutableEnumerable<unknown>>;
+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..c44ffbc1887
--- /dev/null
+++ b/types/preview/@ember/array/-private/native-array.d.ts
@@ -0,0 +1,23 @@
+import MutableArray from '@ember/array/mutable';
+import Observable from '@ember/object/observable';
+import Mixin from '@ember/object/mixin';
+
+// Get an alias to the global Array type to use in inner scope below.
+type GlobalArray<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 GlobalArray<T>, MutableArray<T>, Observable {
+    /**
+     * __Required.__ You must implement this method to apply this mixin.
+     */
+    length: number;
+}
+
+declare const NativeArray: Mixin<NativeArray<unknown>>;
+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..10b58c75dda
--- /dev/null
+++ b/types/preview/@ember/array/index.d.ts
@@ -0,0 +1,79 @@
+// Type definitions for non-npm package @ember/array 4.0
+// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Farray
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+import ComputedProperty from "@ember/object/computed";
+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<T> {
+    /**
+     * __Required.__ You must implement this method to apply this mixin.
+     */
+    length: number | ComputedProperty<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`.
+     */
+    // tslint:disable-next-line:array-type
+    objectsAt(indexes: number[]): Array<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): 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;
+    /**
+     * Returns a special object that can be used to observe individual properties
+     * on the array. Just get an equivalent property on this object and it will
+     * return an enumerable that maps automatically to the named key on the
+     * member objects.
+     */
+    '@each': ComputedProperty<T>;
+}
+// Ember.Array rather than Array because the `array-type` lint rule doesn't realize the global is shadowed
+// tslint:disable-next-line:array-type
+declare const Array: Mixin<Array<unknown>>;
+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..505408a66be
--- /dev/null
+++ b/types/preview/@ember/array/mutable.d.ts
@@ -0,0 +1,75 @@
+import Mixin from "@ember/object/mixin";
+import MutableEnumerable from "@ember/array/-private/mutable-enumerable";
+import EmberArray from '@ember/array';
+import Enumerable from "@ember/array/-private/enumerable";
+
+/**
+ * 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<T> {
+    /**
+     * __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: Enumerable<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: Enumerable<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: EmberArray<T>): this;
+}
+
+declare const MutableArray: Mixin<MutableArray<unknown>>;
+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..590f65fc2e7
--- /dev/null
+++ b/types/preview/@ember/array/proxy.d.ts
@@ -0,0 +1,31 @@
+import type MutableArray from '@ember/array/mutable';
+import EmberObject from '@ember/object';
+
+interface EmberArrayLike<T> {
+  length: number;
+  objectAt(idx: number): T | undefined;
+}
+
+/**
+ * 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[] | EmberArrayLike<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/test/array-ext.ts b/types/preview/@ember/array/test/array-ext.ts
new file mode 100755
index 00000000000..d4fa40cf36c
--- /dev/null
+++ b/types/preview/@ember/array/test/array-ext.ts
@@ -0,0 +1,23 @@
+import { assertType } from './lib/assert';
+import EmberObject from '@ember/object';
+import ArrayPrototypeExtensions from '@ember/array/types/prototype-extensions';
+
+declare global {
+    interface Array<T> extends ArrayPrototypeExtensions<T> {}
+}
+
+class Person extends EmberObject {
+    declare name: string;
+}
+
+const person = Person.create({ name: 'Joe' });
+const array = [person];
+
+assertType<number>(array.get('length'));
+assertType<Person | undefined>(array.get('firstObject'));
+assertType<string[]>(array.mapBy('name'));
+assertType<string[]>(array.map(p => p.get('name')));
+assertType<Person[]>(array.sortBy('name'));
+assertType<Person[]>(array.uniq());
+assertType<Person[]>(array.uniqBy('name'));
+assertType<Person[]>(array.uniqBy(p => p.get('name')));
diff --git a/types/preview/@ember/array/test/array-proxy.ts b/types/preview/@ember/array/test/array-proxy.ts
new file mode 100644
index 00000000000..397f08183f7
--- /dev/null
+++ b/types/preview/@ember/array/test/array-proxy.ts
@@ -0,0 +1,57 @@
+import { assertType } from './lib/assert';
+import ArrayProxy from '@ember/array/proxy';
+import EmberArray, { A } from '@ember/array';
+import EmberObject from '@ember/object';
+
+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(idx: number): string | undefined {
+        return this.get('content').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>;
+assertType<number | undefined>(x.get('firstObject'));
+assertType<boolean>(x.isNew);
+
+// Custom EmberArray
+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/types/preview/@ember/array/test/array.ts b/types/preview/@ember/array/test/array.ts
new file mode 100755
index 00000000000..f035b6fdaa5
--- /dev/null
+++ b/types/preview/@ember/array/test/array.ts
@@ -0,0 +1,65 @@
+import { assertType } from './lib/assert';
+import EmberObject from '@ember/object';
+import EmberArray, { A } from '@ember/array';
+import MutableArray from '@ember/array/mutable';
+
+type Person = typeof Person.prototype;
+const Person = EmberObject.extend({
+    name: '',
+    isHappy: false,
+});
+
+const people = A([Person.create({ name: 'Yehuda', isHappy: true }), Person.create({ name: 'Majd', isHappy: false })]);
+
+assertType<number>(people.get('length'));
+assertType<Person>(people.get('lastObject'));
+assertType<Person>(people.get('firstObject'));
+assertType<boolean>(people.isAny('isHappy'));
+assertType<boolean>(people.isAny('isHappy', false));
+// @ts-expect-error
+assertType<boolean>(people.isAny('isHappy', "false"));
+
+assertType<Person | undefined>(people.objectAt(0));
+assertType<EmberArray<Person | undefined>>(people.objectsAt([1, 2, 3]));
+
+const persons1: Person[] = people.filterBy('isHappy');
+const persons2: MutableArray<Person> = people.filterBy('isHappy');
+const persons3: Person[] = people.rejectBy('isHappy');
+const persons4: MutableArray<Person> = people.rejectBy('isHappy');
+const persons5: Person[] = people.filter(person => person.get('name') === 'Yehuda');
+const persons6: MutableArray<Person> = people.filter(person => person.get('name') === 'Yehuda');
+
+assertType<typeof people>(people.get('[]'));
+assertType<Person>(people.get('[]').get('firstObject'));
+
+assertType<boolean[]>(people.mapBy('isHappy'));
+assertType<unknown[]>(people.mapBy('name.length'));
+
+const last = people.get('lastObject'); // $ExpectType ({ name: string; isHappy: boolean; } & EmberObject & { name: string; isHappy: boolean; }) | undefined
+if (last) {
+    assertType<string>(last.get('name'));
+}
+
+const first = people.get('lastObject');
+if (first) {
+    assertType<boolean>(first.get('isHappy'));
+}
+
+const letters: EmberArray<string> = A(['a', 'b', 'c']);
+const codes: number[] = letters.map((item, index, enumerable) => {
+    assertType<string>(item);
+    assertType<number>(index);
+    return item.charCodeAt(0);
+});
+
+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/types/preview/@ember/array/test/lib/assert.ts b/types/preview/@ember/array/test/lib/assert.ts
new file mode 100755
index 00000000000..dad227ab5e9
--- /dev/null
+++ b/types/preview/@ember/array/test/lib/assert.ts
@@ -0,0 +1,2 @@
+/** Static assertion that `value` has type `T` */
+export declare function assertType<T>(value: T): T;
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/array/types/prototype-extensions.d.ts b/types/preview/@ember/array/types/prototype-extensions.d.ts
new file mode 100644
index 00000000000..4609906857a
--- /dev/null
+++ b/types/preview/@ember/array/types/prototype-extensions.d.ts
@@ -0,0 +1,5 @@
+// import Ember from 'ember';
+import Observable from '@ember/object/observable';
+import MutableArray from '@ember/array/mutable';
+
+export default interface ArrayPrototypeExtensions<T> extends MutableArray<T>, Observable {}
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..59fabab2fda
--- /dev/null
+++ b/types/preview/@ember/component/-private/class-names-support.d.ts
@@ -0,0 +1,25 @@
+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[];
+}
+declare const ClassNamesSupport: Mixin<ClassNamesSupport>;
+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..6a98d1716fb
--- /dev/null
+++ b/types/preview/@ember/component/-private/core-view.d.ts
@@ -0,0 +1,12 @@
+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..1b27d8f716f
--- /dev/null
+++ b/types/preview/@ember/component/-private/glimmer-interfaces.d.ts
@@ -0,0 +1,44 @@
+// 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
+// tslint:disable-next-line:strict-export-declare-modifiers
+declare 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/view-mixin.d.ts b/types/preview/@ember/component/-private/view-mixin.d.ts
new file mode 100644
index 00000000000..72b78927dad
--- /dev/null
+++ b/types/preview/@ember/component/-private/view-mixin.d.ts
@@ -0,0 +1,57 @@
+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;
+}
+declare const ViewMixin: Mixin<ViewMixin>;
+
+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..28a8cf37ec8
--- /dev/null
+++ b/types/preview/@ember/component/helper.d.ts
@@ -0,0 +1,198 @@
+import EmberObject from '@ember/object';
+import { Opaque } from 'ember/-private/type-utils';
+
+// --- Type utilities for signatures --- //
+// Type-only "symbol" to use with `EmptyObject` below, so that it is *not*
+// equivalent to an empty interface.
+declare 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;
+
+/**
+ * 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;
+}
+
+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.
+declare const BadType: unique symbol;
+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:
+export interface ExpandSignature<T> {
+    Args: unknown extends T // Is this the default (i.e. unspecified) signature?
+        ? MissingSignatureArgs // Then return our special "missing signature" type
+        : keyof T extends 'Args' | 'Return' // Is this a `Signature`?
+        ? ArgsFor<T> // Then use `Signature` args
+        : LegacyArgsFor<T>; // Otherwise fall back to classic `Args`.
+    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`.
+type NamedArgs<S> = unknown extends S ? Record<string, unknown> : ExpandSignature<S>['Args']['Named'];
+type PositionalArgs<S> = unknown extends S ? unknown[] : ExpandSignature<S>['Args']['Positional'];
+
+type Return<S> = GetOrElse<S, '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 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.
+// tslint:disable-next-line:no-unnecessary-generics
+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..069e9d2c923
--- /dev/null
+++ b/types/preview/@ember/component/index.d.ts
@@ -0,0 +1,131 @@
+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 './-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.
+// tslint:disable-next-line:no-unnecessary-generics
+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..6f652be7b20
--- /dev/null
+++ b/types/preview/@ember/component/template-only.d.ts
@@ -0,0 +1,46 @@
+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.
+// tslint:disable-next-line:no-unnecessary-generics
+export default function templateOnly<S>(moduleName?: string): TemplateOnlyComponent<S>;
diff --git a/types/preview/@ember/component/test/built-ins.ts b/types/preview/@ember/component/test/built-ins.ts
new file mode 100644
index 00000000000..ec95d1b50a6
--- /dev/null
+++ b/types/preview/@ember/component/test/built-ins.ts
@@ -0,0 +1,4 @@
+import { Input, Textarea } from '@ember/component';
+
+Input; // $ExpectType Input
+Textarea; // $ExpectType Textarea
diff --git a/types/preview/@ember/component/test/component.ts b/types/preview/@ember/component/test/component.ts
new file mode 100644
index 00000000000..64596a83fa6
--- /dev/null
+++ b/types/preview/@ember/component/test/component.ts
@@ -0,0 +1,157 @@
+import Component from '@ember/component';
+import Object, { computed, get } from '@ember/object';
+import hbs from 'htmlbars-inline-precompile';
+import { assertType } from './lib/assert';
+
+Component.extend({
+    layout: hbs`
+        <div>
+          {{yield}}
+        </div>
+    `,
+});
+
+Component.extend({
+    layout: 'my-layout',
+});
+
+const MyComponent = Component.extend();
+assertType<string | string[]>(get(MyComponent, 'positionalParams'));
+
+const component1 = Component.extend({
+    actions: {
+        hello(name: string) {
+            console.log('Hello', name);
+        },
+    },
+});
+
+Component.extend({
+    name: '',
+    hello(name: string) {
+        this.set('name', name);
+    },
+});
+
+Component.extend({
+    tagName: 'em',
+});
+
+Component.extend({
+    classNames: ['my-class', 'my-other-class'],
+});
+
+Component.extend({
+    classNameBindings: ['propertyA', 'propertyB'],
+    propertyA: 'from-a',
+    propertyB: computed(function () {
+        if (!this.get('propertyA')) {
+            return 'from-b';
+        }
+    }),
+});
+
+Component.extend({
+    classNameBindings: ['hovered'],
+    hovered: true,
+});
+
+Component.extend({
+    classNameBindings: ['messages.empty'],
+    messages: Object.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(() => {
+        if ('someLogic') {
+            return true;
+        } else {
+            return false;
+        }
+    }),
+});
+
+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, // $ExpectType string
+            age, // $ExpectType number
+        } = this;
+
+        return `${name} is ${age} years old`;
+    }
+}
diff --git a/types/preview/@ember/component/test/helper.ts b/types/preview/@ember/component/test/helper.ts
new file mode 100644
index 00000000000..301a167ffb2
--- /dev/null
+++ b/types/preview/@ember/component/test/helper.ts
@@ -0,0 +1,128 @@
+import Helper, { ExpandSignature, helper } from '@ember/component/helper';
+
+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() {
+        clearInterval(this.timer);
+    }
+}
+
+interface DemoSig {
+    Args: {
+        Named: {
+            name: string;
+            age: number;
+        };
+        Positional: [i18nizer: (s: string) => string];
+    };
+    Return: string;
+}
+
+function testMissingSignature({ Args, Return }: ExpandSignature<unknown>) {
+    // $ExpectType BadType<"This helper is missing a signature">
+    Args.Named;
+
+    // $ExpectType unknown[]
+    Args.Positional;
+
+    // $ExpectType unknown
+    Return;
+}
+
+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`));
+    }
+}
+
+// $ExpectType FunctionBasedHelper<{ Args: { Positional: [number, number]; Named: EmptyObject; }; Return: number; }>
+const inferenceOnPositional = helper(function add([a, b]: [number, number]) {
+    return a + b;
+});
+
+const coolHelper = helper(([], named) => {
+    // $ExpectType EmptyObject
+    named;
+});
+
+// $ExpectType FunctionBasedHelper<{ Args: { Positional: DefaultPositional; Named: { cool: boolean; }; }; Return: 123 | "neat"; }>
+const typeInferenceOnNamed = helper(([], { cool }: { cool: boolean }) => {
+    // $ExpectType boolean
+    cool;
+
+    return cool ? 123 : 'neat';
+});
+
+// $ExpectType FunctionBasedHelper<{ Args: { Positional: [string]; Named: { delim?: string; }; }; Return: string; }>
+const dasherizeHelper = helper(function dasherize([str]: [string], { delim = '-' }: { delim?: string }) {
+    return str.split(/[\s\n\_\.]+/g).join(delim);
+});
+
+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`));
+
+// @ts-expect-error
+const badReturnSig = helper<DemoSig>(([i18nizer], { name, age }) => 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 {}
+
+// $ExpectType abstract new <T>() => FunctionBasedHelperInstance<{ Args: { Positional: [T]; Named: EmptyObject; }; Return: [T, T]; }>
+const pair = helper(<T>([item]: [T]): [T, T] => [item, item]);
diff --git a/types/preview/@ember/component/test/lib/assert.ts b/types/preview/@ember/component/test/lib/assert.ts
new file mode 100755
index 00000000000..dad227ab5e9
--- /dev/null
+++ b/types/preview/@ember/component/test/lib/assert.ts
@@ -0,0 +1,2 @@
+/** Static assertion that `value` has type `T` */
+export declare function assertType<T>(value: T): T;
diff --git a/types/preview/@ember/component/test/template-only.ts b/types/preview/@ember/component/test/template-only.ts
new file mode 100644
index 00000000000..ce494a181a8
--- /dev/null
+++ b/types/preview/@ember/component/test/template-only.ts
@@ -0,0 +1,28 @@
+import templateOnly, { TemplateOnlyComponent, TOC } from '@ember/component/template-only';
+
+const to = templateOnly(); // $ExpectType TemplateOnlyComponent<unknown>
+
+to.toString(); // $ExpectType string
+
+// @ts-expect-error
+new TemplateOnlyComponent();
+
+interface MySig {
+    Element: HTMLAnchorElement;
+    Args: {
+        name: string;
+        age: number;
+    };
+    Blocks: {
+        default: [(newName: string) => void];
+    };
+}
+
+// $ExpectType TemplateOnlyComponent<MySig>
+const toc: TOC<MySig> = templateOnly();
+
+// $ExpectType TemplateOnlyComponent<MySig>
+const tocInferred = templateOnly<MySig>();
+
+// $ExpectType TemplateOnlyComponent<MySig>
+const longToc: TemplateOnlyComponent<MySig> = templateOnly();
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..da29c40835e
--- /dev/null
+++ b/types/preview/@ember/controller/index.d.ts
@@ -0,0 +1,47 @@
+import ActionHandler from '@ember/object/-private/action-handler';
+import Mixin from '@ember/object/mixin';
+import EmberObject from '@ember/object';
+import ComputedProperty 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<ControllerMixin>;
+
+export default class Controller extends EmberObject {}
+export default interface Controller extends ControllerMixin {}
+
+export function inject(): ComputedProperty<Controller>;
+export function inject<K extends keyof Registry>(name: K): ComputedProperty<Registry[K]>;
+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.
+// tslint:disable-next-line no-empty-interface
+export interface Registry {}
diff --git a/types/preview/@ember/controller/test/main.ts b/types/preview/@ember/controller/test/main.ts
new file mode 100644
index 00000000000..e34d763e167
--- /dev/null
+++ b/types/preview/@ember/controller/test/main.ts
@@ -0,0 +1,14 @@
+import Controller, { inject } from '@ember/controller';
+
+Controller.extend({
+    queryParams: ['category'],
+    category: null,
+    isExpanded: false,
+
+    first: inject(),
+    second: inject('second'),
+
+    toggleBody() {
+        this.toggleProperty('isExpanded');
+    },
+});
diff --git a/types/preview/@ember/controller/test/octane.ts b/types/preview/@ember/controller/test/octane.ts
new file mode 100644
index 00000000000..1ce829a275b
--- /dev/null
+++ b/types/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/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..3e03e0923fd
--- /dev/null
+++ b/types/preview/@ember/debug/container-debug-adapter.d.ts
@@ -0,0 +1,11 @@
+import Resolver from 'ember-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..9ed2f3c7515
--- /dev/null
+++ b/types/preview/@ember/debug/data-adapter.d.ts
@@ -0,0 +1,62 @@
+import ContainerDebugAdapter from "@ember/debug/container-debug-adapter";
+import EmberObject from "@ember/object";
+
+declare 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/ember__debug-tests.ts b/types/preview/@ember/debug/ember__debug-tests.ts
new file mode 100644
index 00000000000..9df7cf532de
--- /dev/null
+++ b/types/preview/@ember/debug/ember__debug-tests.ts
@@ -0,0 +1,237 @@
+import {
+    runInDebug,
+    warn,
+    debug,
+    assert,
+    registerWarnHandler,
+    registerDeprecationHandler,
+    deprecate,
+} from '@ember/debug';
+
+/**
+ * @ember/debug tests
+ */
+// @ts-expect-error
+runInDebug();
+runInDebug(() => console.log('Should not show up in prod')); // $ExpectType void
+
+// Log a warning if we have more than 3 tomsters
+const tomsterCount = 2;
+// @ts-expect-error
+warn('Too many tomsters!');
+warn('Too many tomsters!', { id: 'some-warning' }); // $ExpectType void
+// @ts-expect-error
+warn('Too many tomsters!', tomsterCount <= 3);
+warn('Too many tomsters!', tomsterCount <= 3, { id: 'some-warning' }); // $ExpectType void
+warn('Too many tomsters!', tomsterCount <= 3, { // $ExpectType void
+    id: 'ember-debug.too-many-tomsters'
+});
+
+// @ts-expect-error
+debug();
+debug('Too many tomsters!'); // $ExpectType void
+// @ts-expect-error
+debug('Too many tomsters!', 'foo');
+
+// Test for truthiness
+const str: unknown = 'hello';
+assert('Must pass a string', typeof str === 'string'); // $ExpectType void
+str; // $ExpectType string
+
+const anObject = {};
+assert('Must pass an object', anObject); // $ExpectType void
+
+// Test with null and undefined
+assert('Can handle falsiness', null); // $ExpectType void
+assert('Can handle falsiness', undefined); // $ExpectType void
+
+// Fail unconditionally
+assert('This code path should never be run'); // $ExpectType never
+
+// Require first argument
+// @ts-expect-error
+assert();
+
+// next is not called, so no warnings get the default behavior
+// @ts-expect-error
+registerWarnHandler();
+registerWarnHandler(() => {}); // $ExpectType void
+registerWarnHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; } | undefined
+    next; // $ExpectType (message: string, options?: { id: string; } | undefined) => void
+});
+registerWarnHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; } | undefined
+    // @ts-expect-error
+    next();
+});
+registerWarnHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; } | undefined
+    next(message); // $ExpectType void
+});
+registerWarnHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; } | undefined
+    next(message, options); // $ExpectType void
+});
+
+// next is not called, so no warnings get the default behavior
+// @ts-expect-error
+registerDeprecationHandler();
+registerDeprecationHandler(() => {}); // $ExpectType void
+registerDeprecationHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; until: string; } | undefined
+    next; // $ExpectType (message: string, options?: { id: string; until: string; } | undefined) => void
+});
+registerDeprecationHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; until: string; } | undefined
+    // @ts-expect-error
+    next();
+});
+registerDeprecationHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; until: string; } | undefined
+    next(message); // $ExpectType void
+});
+registerDeprecationHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; until: string; } | undefined
+    next(message, options); // $ExpectType void
+});
+
+// @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' });
+deprecate('a valid deprecation without `url`', true, { // $ExpectType void
+  id: 'some.deprecation',
+  until: 'v4.0.0',
+  for: 'some.namespace',
+  since: {
+    available: 'some.early.version',
+    enabled: 'some.version',
+  },
+});
+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',
+  },
+});
+deprecate('a valid deprecation with `url`', true, { // $ExpectType void
+  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',
+  },
+});
+deprecate('a valid deprecation with `for`', true, { // $ExpectType void
+  id: 'some.deprecation',
+  until: 'v4.0.0',
+  for: 'some.namespace',
+  since: {
+    available: 'some.earlier.version',
+    enabled: 'some.version',
+  },
+});
+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',
+  },
+});
+deprecate('a valid deprecation with `since`', true, { // $ExpectType void
+  id: 'some.deprecation',
+  until: 'v4.0.0',
+  for: 'some.namespace',
+  since: {
+    available: 'some.version',
+  },
+});
+deprecate('a valid deprecation with `since`', true, { // $ExpectType void
+  id: 'some.deprecation',
+  until: 'v4.0.0',
+  for: 'some.namespace',
+  since: {
+    available: 'some.version',
+    enabled: 'some.version',
+  },
+});
+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',
+  },
+});
diff --git a/types/preview/@ember/debug/index.d.ts b/types/preview/@ember/debug/index.d.ts
new file mode 100644
index 00000000000..0500927bc3b
--- /dev/null
+++ b/types/preview/@ember/debug/index.d.ts
@@ -0,0 +1,100 @@
+// Type definitions for non-npm package @ember/debug 4.0
+// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Fdebug
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+/**
+ * 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..855508cbbcf
--- /dev/null
+++ b/types/preview/@ember/destroyable/index.d.ts
@@ -0,0 +1,29 @@
+// Type definitions for non-npm package @ember/destroyable 4.0
+// Project: https://api.emberjs.com/ember/3.22/modules/@ember%2Fdestroyable
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+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/test/lib/assert.ts b/types/preview/@ember/destroyable/test/lib/assert.ts
new file mode 100644
index 00000000000..dad227ab5e9
--- /dev/null
+++ b/types/preview/@ember/destroyable/test/lib/assert.ts
@@ -0,0 +1,2 @@
+/** Static assertion that `value` has type `T` */
+export declare function assertType<T>(value: T): T;
diff --git a/types/preview/@ember/destroyable/test/main.ts b/types/preview/@ember/destroyable/test/main.ts
new file mode 100644
index 00000000000..4c5e3619045
--- /dev/null
+++ b/types/preview/@ember/destroyable/test/main.ts
@@ -0,0 +1,91 @@
+import {
+    assertDestroyablesDestroyed,
+    associateDestroyableChild,
+    destroy,
+    enableDestroyableTracking,
+    isDestroyed,
+    isDestroying,
+    registerDestructor,
+    unregisterDestructor
+} from '@ember/destroyable';
+
+import { assertType } from './lib/assert';
+
+// @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();
+
+assertType<boolean>(isDestroyed(c));
+assertType<boolean>(isDestroyed(p));
+
+destroy(p);
+
+assertType<boolean>(isDestroying(c));
+assertType<boolean>(isDestroying(p));
+
+assertType<boolean>(isDestroyed(c));
+assertType<boolean>(isDestroyed(p));
+
+// @ts-expect-error
+assertDestroyablesDestroyed(true);
+// @ts-expect-error
+assertDestroyablesDestroyed({});
+// @ts-expect-error
+assertDestroyablesDestroyed('foo');
+// @ts-expect-error
+assertDestroyablesDestroyed(1);
+assertDestroyablesDestroyed();
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..27463373dc1
--- /dev/null
+++ b/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts
@@ -0,0 +1,15 @@
+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(): {};
+}
+declare const ContainerProxyMixin: Mixin<ContainerProxyMixin>;
+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..f0718b2a83d
--- /dev/null
+++ b/types/preview/@ember/engine/-private/registry-proxy-mixin.d.ts
@@ -0,0 +1,52 @@
+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;
+}
+declare const RegistryProxyMixin: Mixin<RegistryProxyMixin>;
+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..515c89f5194
--- /dev/null
+++ b/types/preview/@ember/engine/-private/types/initializer.d.ts
@@ -0,0 +1,6 @@
+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..130449d87de
--- /dev/null
+++ b/types/preview/@ember/engine/index.d.ts
@@ -0,0 +1,65 @@
+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 { Factory, FullName } from '@ember/owner';
+
+export type KnownForTypeResult<Type extends string> = {
+  [fullName in `${Type}:${string}`]: boolean | undefined;
+};
+
+/**
+ * A `Resolver` 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 {
+  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;
+}
+
+/**
+ * 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..84c65b47581
--- /dev/null
+++ b/types/preview/@ember/engine/instance.d.ts
@@ -0,0 +1,22 @@
+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/test/engine-instance.ts b/types/preview/@ember/engine/test/engine-instance.ts
new file mode 100644
index 00000000000..2663ba996ff
--- /dev/null
+++ b/types/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/types/preview/@ember/engine/test/engine.ts b/types/preview/@ember/engine/test/engine.ts
new file mode 100755
index 00000000000..cf01e987b7e
--- /dev/null
+++ b/types/preview/@ember/engine/test/engine.ts
@@ -0,0 +1,43 @@
+import Engine from '@ember/engine';
+import EmberObject from '@ember/object';
+
+const BaseEngine = Engine.extend({
+    modulePrefix: 'my-engine',
+});
+
+class Obj extends EmberObject.extend({ 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');
+    },
+});
+
+const Engine1 = BaseEngine.create({
+    rootElement: '#engine-one',
+    customEvents: {
+        paste: 'paste',
+    },
+});
+
+const Engine2 = BaseEngine.create({
+    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/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/ember__error-tests.ts b/types/preview/@ember/error/ember__error-tests.ts
new file mode 100644
index 00000000000..503d16ee5af
--- /dev/null
+++ b/types/preview/@ember/error/ember__error-tests.ts
@@ -0,0 +1,7 @@
+import Error from '@ember/error';
+
+new Error('Fuuuuuuuu'); // $ExpectType EmberError
+
+// allows to extend from EmberError
+class AjaxError extends Error {
+}
diff --git a/types/preview/@ember/error/index.d.ts b/types/preview/@ember/error/index.d.ts
new file mode 100644
index 00000000000..e1a44683d6f
--- /dev/null
+++ b/types/preview/@ember/error/index.d.ts
@@ -0,0 +1,12 @@
+// Type definitions for non-npm package @ember/error 4.0
+// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Ferror
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+/**
+ * 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/ember__helper-tests.ts b/types/preview/@ember/helper/ember__helper-tests.ts
new file mode 100644
index 00000000000..56b0f5743f8
--- /dev/null
+++ b/types/preview/@ember/helper/ember__helper-tests.ts
@@ -0,0 +1,7 @@
+import { array, concat, fn, get, hash } from '@ember/helper';
+
+array; // $ExpectType ArrayHelper
+concat; // $ExpectType ConcatHelper
+fn; // $ExpectType FnHelper
+get; // $ExpectType GetHelper
+hash; // $ExpectType HashHelper
diff --git a/types/preview/@ember/helper/index.d.ts b/types/preview/@ember/helper/index.d.ts
new file mode 100644
index 00000000000..7081b026074
--- /dev/null
+++ b/types/preview/@ember/helper/index.d.ts
@@ -0,0 +1,55 @@
+// Type definitions for non-npm package @ember/helper 4.0
+// Project: https://github.com/emberjs/ember.js
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+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/ember__modifier-tests.ts b/types/preview/@ember/modifier/ember__modifier-tests.ts
new file mode 100644
index 00000000000..3dc6865fb40
--- /dev/null
+++ b/types/preview/@ember/modifier/ember__modifier-tests.ts
@@ -0,0 +1,8 @@
+import { setModifierManager, capabilities, on } from '@ember/modifier';
+import Owner from '@ember/owner';
+
+declare let owner: Owner;
+
+on; // $ExpectType OnModifier
+setModifierManager((owner) => {}, {}); // $ExpectType {}
+capabilities('3.24'); // $ExpectType unknown
diff --git a/types/preview/@ember/modifier/index.d.ts b/types/preview/@ember/modifier/index.d.ts
new file mode 100644
index 00000000000..6d197ae5ee6
--- /dev/null
+++ b/types/preview/@ember/modifier/index.d.ts
@@ -0,0 +1,39 @@
+// Type definitions for non-npm package @ember/modifier 4.0
+// Project: https://github.com/emberjs/ember.js
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+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..dae8f951509
--- /dev/null
+++ b/types/preview/@ember/object/-private/action-handler.d.ts
@@ -0,0 +1,28 @@
+import type Mixin from '../mixin';
+
+interface ActionsHash {
+  [index: string]: (...params: any[]) => any;
+}
+
+/**
+ * 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;
+}
+declare const ActionHandler: Mixin<ActionHandler>;
+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..5945629ca89
--- /dev/null
+++ b/types/preview/@ember/object/-private/types.d.ts
@@ -0,0 +1,61 @@
+import type Mixin from '../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..291097ab67a
--- /dev/null
+++ b/types/preview/@ember/object/compat.d.ts
@@ -0,0 +1,7 @@
+/**
+ * `@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..c283b1bf86e
--- /dev/null
+++ b/types/preview/@ember/object/computed.d.ts
@@ -0,0 +1,261 @@
+/**
+ * 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..c8dbc893d7a
--- /dev/null
+++ b/types/preview/@ember/object/core.d.ts
@@ -0,0 +1,82 @@
+import type { EmberClassConstructor, Objectify } from './-private/types';
+import type Mixin from './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>(
+    ...initialValues: Array<Mixin | Record<string, unknown>>
+  ): 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;
+}
diff --git a/types/preview/@ember/object/evented.d.ts b/types/preview/@ember/object/evented.d.ts
new file mode 100644
index 00000000000..d888571eeed
--- /dev/null
+++ b/types/preview/@ember/object/evented.d.ts
@@ -0,0 +1,60 @@
+import Mixin from '@ember/object/mixin';
+import { AnyFn, EmberMethod, MethodNamesOf, MethodParams, MethodsOf } 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[]): any;
+    /**
+     * 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;
+}
+declare const Evented: Mixin<Evented>;
+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..04fd9b029ca
--- /dev/null
+++ b/types/preview/@ember/object/events.d.ts
@@ -0,0 +1,49 @@
+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..09348748992
--- /dev/null
+++ b/types/preview/@ember/object/index.d.ts
@@ -0,0 +1,116 @@
+import CoreObject from './core';
+import type Observable from './observable';
+import type ComputedProperty from './computed';
+import type { BasicComputedProperty } from './computed';
+import type { AnyFunction } from './-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.
+ */
+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>(obj: T, key: K, value: T[K]): T[K];
+
+/**
+ * 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' {
+  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..bb9ccc5be99
--- /dev/null
+++ b/types/preview/@ember/object/internals.d.ts
@@ -0,0 +1,15 @@
+/**
+ * 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..4ddb16700f7
--- /dev/null
+++ b/types/preview/@ember/object/mixin.d.ts
@@ -0,0 +1,17 @@
+declare 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..bffceba42cb
--- /dev/null
+++ b/types/preview/@ember/object/observable.d.ts
@@ -0,0 +1,78 @@
+import { ObserverMethod } from './-private/types';
+import Mixin from './mixin';
+import CoreObject from './core';
+
+/**
+ * This mixin provides properties and property observing functionality, core features of the Ember object model.
+ */
+interface Observable {
+  /**
+   * Retrieves the value of a property from the object.
+   */
+  get<K extends keyof this>(key: K): this[K];
+  /**
+   * 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>;
+  /**
+   * 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;
+  /**
+   * 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>;
+  /**
+   * 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;
+}
+declare const Observable: Mixin<Observable, CoreObject>;
+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..f1decdb96fe
--- /dev/null
+++ b/types/preview/@ember/object/observers.d.ts
@@ -0,0 +1,32 @@
+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..c23f8e75494
--- /dev/null
+++ b/types/preview/@ember/object/promise-proxy-mixin.d.ts
@@ -0,0 +1,35 @@
+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>;
+}
+declare const PromiseProxyMixin: Mixin<PromiseProxyMixin<any>>;
+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..266b34d3c81
--- /dev/null
+++ b/types/preview/@ember/object/proxy.d.ts
@@ -0,0 +1,25 @@
+import EmberObject from './index';
+
+/**
+ * `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/test/access-modifier.ts b/types/preview/@ember/object/test/access-modifier.ts
new file mode 100644
index 00000000000..3551a20dd36
--- /dev/null
+++ b/types/preview/@ember/object/test/access-modifier.ts
@@ -0,0 +1,29 @@
+import { assertType } from './lib/assert';
+import EmberObject from '@ember/object';
+
+class Foo extends EmberObject {
+    hello() {
+        return 'world';
+    }
+    protected bar() {
+        return 'bar';
+    }
+    private baz() {
+        return 'baz';
+    }
+}
+const f = new Foo();
+assertType<string>(f.hello());
+// @ts-expect-error
+assertType<string>(f.bar());
+// @ts-expect-error
+assertType<string>(f.baz());
+
+// TODO: enable after TS 3.0 https://github.com/typed-ember/ember-cli-typescript/issues/291
+// class Foo2 extends EmberObject.extend({
+//     bar: ''
+// }) {
+//     hello() { return 'world'; }
+//     protected bar() { return 'bar'; } // @ts-expect-error
+//     private baz() { return 'baz'; }
+// }
diff --git a/types/preview/@ember/object/test/compat.ts b/types/preview/@ember/object/test/compat.ts
new file mode 100644
index 00000000000..f661c37529a
--- /dev/null
+++ b/types/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/types/preview/@ember/object/test/computed.ts b/types/preview/@ember/object/test/computed.ts
new file mode 100644
index 00000000000..fa99c5ede92
--- /dev/null
+++ b/types/preview/@ember/object/test/computed.ts
@@ -0,0 +1,231 @@
+import EmberObject, { computed } from '@ember/object';
+import ComputedProperty, {
+    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 { assertType } from './lib/assert';
+
+const Person = EmberObject.extend({
+    firstName: '',
+    lastName: '',
+    age: 0,
+
+    noArgs: computed<string>(() => 'test'),
+
+    fullName: computed<string>('firstName', 'lastName', function () {
+        return `${this.get('firstName')} ${this.get('lastName')}`;
+    }),
+
+    fullNameReadonly: computed<string>('fullName', function () {
+        return this.get('fullName');
+    }).readOnly(),
+
+    fullNameWritable: computed<string>('firstName', 'lastName', {
+        get() {
+            return this.get('fullName');
+        },
+        set(key, value) {
+            const [first, last] = value.split(' ');
+            this.set('firstName', first);
+            this.set('lastName', last);
+            return value;
+        },
+    }),
+
+    fullNameGetOnly: computed<string>('fullName', {
+        get() {
+            return this.get('fullName');
+        },
+    }),
+
+    fullNameSetOnly: computed<string>('firstName', 'lastName', {
+        set(key, value) {
+            const [first, last] = value.split(' ');
+            this.set('firstName', first);
+            this.set('lastName', last);
+            return value;
+        },
+    }),
+
+    combinators: computed<string>(function () {
+        return this.get('firstName');
+    })
+        .property('firstName')
+        .meta({ foo: 'bar' })
+        .volatile()
+        .readOnly(),
+
+    explicitlyDeclared: alias('fullName') as ComputedProperty<string>,
+});
+
+const person = Person.create({
+    firstName: 'Fred',
+    lastName: 'Smith',
+    age: 29,
+});
+
+assertType<string>(person.firstName);
+assertType<number>(person.age);
+assertType<ComputedProperty<string>>(person.noArgs);
+assertType<ComputedProperty<string>>(person.fullName);
+assertType<ComputedProperty<string>>(person.fullNameReadonly);
+assertType<ComputedProperty<string>>(person.fullNameWritable);
+assertType<ComputedProperty<string>>(person.fullNameGetOnly);
+assertType<ComputedProperty<string>>(person.fullNameSetOnly);
+assertType<ComputedProperty<string>>(person.combinators);
+assertType<ComputedProperty<string>>(person.explicitlyDeclared);
+
+assertType<string>(person.get('firstName'));
+assertType<number>(person.get('age'));
+assertType<string>(person.get('noArgs'));
+assertType<string>(person.get('fullName'));
+assertType<string>(person.get('fullNameReadonly'));
+assertType<string>(person.get('fullNameWritable'));
+assertType<string>(person.get('fullNameGetOnly'));
+assertType<string>(person.get('fullNameSetOnly'));
+assertType<string>(person.get('combinators'));
+assertType<string>(person.get('explicitlyDeclared'));
+
+assertType<{ firstName: string; fullName: string; age: number }>(person.getProperties('firstName', 'fullName', 'age'));
+
+const person2 = Person.create({
+    fullName: 'Fred Smith',
+});
+
+assertType<string>(person2.get('firstName'));
+assertType<string>(person2.get('fullName'));
+
+const person3 = Person.extend({
+    firstName: 'Fred',
+    fullName: 'Fred Smith',
+}).create();
+
+assertType<string>(person3.get('firstName'));
+assertType<string>(person3.get('fullName'));
+
+const person4 = Person.extend({
+    firstName: computed(() => 'Fred'),
+    fullName: computed(() => 'Fred Smith'),
+}).create();
+
+assertType<string>(person4.get('firstName'));
+assertType<string>(person4.get('fullName'));
+
+// computed property macros
+const objectWithComputedProperties = EmberObject.extend({
+    alias: alias('foo'),
+    and: and('foo', 'bar', 'baz', 'qux'),
+    bool: bool('foo'),
+    collect: collect('foo', 'bar', 'baz', 'qux'),
+    deprecatingAlias: deprecatingAlias('foo', {
+        id: 'hamster.deprecate-banana',
+        until: '3.0.0',
+    }),
+    empty: empty('foo'),
+    equalNumber: equal('foo', 1),
+    equalString: equal('foo', 'bar'),
+    equalObject: equal('foo', {}),
+    filter1: filter('foo', item => item === 'bar'),
+    filter2: filter('foo', ['bar', 'baz'], item => item === 'bar'),
+    filterBy1: filterBy('foo', 'bar'),
+    filterBy2: filterBy('foo', 'bar', false),
+    gt: gt('foo', 3),
+    gte: gte('foo', 3),
+    intersect: intersect('foo', 'bar', 'baz', 'qux'),
+    lt: lt('foo', 3),
+    lte: lte('foo', 3),
+    map: map('foo', (item, index) => item),
+    mapBy: mapBy('foo', 'bar'),
+    match: match('foo', /^tom.ter$/),
+    max: max('foo'),
+    min: min('foo'),
+    none: none('foo'),
+    not: not('foo'),
+    notEmpty: notEmpty('foo'),
+    oneWay: oneWay('foo'),
+    or: or('foo', 'bar', 'baz', 'qux'),
+    readOnly: readOnly('foo'),
+    reads: reads('foo'),
+    setDiff: setDiff('foo', 'bar'),
+    sort1: sort('foo', 'bar'),
+    sort2: sort('foo', (itemA, itemB) => {
+      return `${itemA}`.length - `${itemB}`.length;
+    }),
+    sort3: sort('foo', ['bar', 'baz'], (itemA, itemB) => {
+      return `${itemA}`.length - `${itemB}`.length;
+    }),
+
+    sum: sum('foo'),
+    union: union('foo', 'bar', 'baz', 'qux'),
+    uniq: uniq('foo'),
+    uniqBy: uniqBy('foo', 'bar'),
+}).create();
+
+assertType<unknown>(objectWithComputedProperties.get('alias'));
+assertType<unknown>(objectWithComputedProperties.get('and'));
+assertType<boolean>(objectWithComputedProperties.get('bool'));
+assertType<unknown[]>(objectWithComputedProperties.get('collect'));
+assertType<unknown>(objectWithComputedProperties.get('deprecatingAlias'));
+assertType<boolean>(objectWithComputedProperties.get('empty'));
+assertType<boolean>(objectWithComputedProperties.get('equalNumber'));
+assertType<boolean>(objectWithComputedProperties.get('equalString'));
+assertType<boolean>(objectWithComputedProperties.get('equalObject'));
+assertType<unknown[]>(objectWithComputedProperties.get('filter1'));
+assertType<unknown[]>(objectWithComputedProperties.get('filter2'));
+assertType<unknown[]>(objectWithComputedProperties.get('filterBy1'));
+assertType<unknown[]>(objectWithComputedProperties.get('filterBy2'));
+assertType<boolean>(objectWithComputedProperties.get('gt'));
+assertType<boolean>(objectWithComputedProperties.get('gte'));
+assertType<unknown[]>(objectWithComputedProperties.get('intersect'));
+assertType<boolean>(objectWithComputedProperties.get('lt'));
+assertType<boolean>(objectWithComputedProperties.get('lte'));
+assertType<unknown[]>(objectWithComputedProperties.get('map'));
+assertType<unknown[]>(objectWithComputedProperties.get('mapBy'));
+assertType<boolean>(objectWithComputedProperties.get('match'));
+assertType<number>(objectWithComputedProperties.get('max'));
+assertType<number>(objectWithComputedProperties.get('min'));
+assertType<boolean>(objectWithComputedProperties.get('none'));
+assertType<boolean>(objectWithComputedProperties.get('not'));
+assertType<boolean>(objectWithComputedProperties.get('notEmpty'));
+assertType<unknown>(objectWithComputedProperties.get('oneWay'));
+assertType<unknown>(objectWithComputedProperties.get('or'));
+assertType<unknown>(objectWithComputedProperties.get('readOnly'));
+assertType<unknown>(objectWithComputedProperties.get('reads'));
+assertType<unknown[]>(objectWithComputedProperties.get('setDiff'));
+assertType<unknown[]>(objectWithComputedProperties.get('sort1'));
+assertType<unknown[]>(objectWithComputedProperties.get('sort2'));
+assertType<unknown[]>(objectWithComputedProperties.get('sort3'));
+assertType<number>(objectWithComputedProperties.get('sum'));
+assertType<unknown[]>(objectWithComputedProperties.get('union'));
+assertType<unknown[]>(objectWithComputedProperties.get('uniq'));
+assertType<unknown[]>(objectWithComputedProperties.get('uniqBy'));
diff --git a/types/preview/@ember/object/test/core.ts b/types/preview/@ember/object/test/core.ts
new file mode 100644
index 00000000000..650e2c22066
--- /dev/null
+++ b/types/preview/@ember/object/test/core.ts
@@ -0,0 +1,218 @@
+import { assertType } from './lib/assert';
+import CoreObject from '@ember/object/core';
+
+/** Newable tests */
+const co1 = new CoreObject();
+
+// TODO: Enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+// co1.concatenatedProperties; // $ExpectType string[]
+co1.isDestroyed; // $ExpectType boolean
+co1.isDestroying; // $ExpectType boolean
+co1.destroy(); // $ExpectType CoreObject
+co1.toString(); // $ExpectType string
+
+/** .create tests */
+const co2 = CoreObject.create();
+// TODO: Enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+// co2.concatenatedProperties; // $ExpectType string[]
+co2.isDestroyed; // $ExpectType boolean
+co2.isDestroying; // $ExpectType boolean
+co2.destroy(); // $ExpectType CoreObject
+co2.toString(); // $ExpectType string
+
+/** .create tests w/ initial instance data passed in */
+const co3 = CoreObject.create({ foo: '123', bar: 456 });
+
+co3.foo; // $ExpectType string
+co3.bar; // $ExpectType number
+
+/** .extend with a zero-argument .create()  */
+const co4 = CoreObject.extend({
+    foo: '123',
+    bar: 456,
+    baz(): [string, number] {
+        return [this.foo, this.bar];
+    },
+}).create();
+
+co4.foo; // $ExpectType string
+co4.bar; // $ExpectType number
+co4.baz; // $ExpectType () => [string, number]
+
+/** .extend with inconsistent arguments passed into .create()  */
+const class05 = CoreObject.extend({
+    foo: '123' as string | boolean,
+    bar: 456,
+    baz() {
+        return [this.foo, this.bar];
+    },
+});
+// @ts-expect-error
+const c05 = class05.create({ foo: 99 });
+const c05b = class05.create({ foo: true });
+const c05c = class05.create({ foo: 'abc' });
+// @ts-expect-error
+assertType<string>(c05b.foo);
+// @ts-expect-error
+assertType<boolean>(c05c.foo);
+
+/** two .extend arguments with a zero-argument .create() */
+const co6 = CoreObject.extend(
+    {
+        foo: '123',
+        bar: 456,
+        baz() {
+            return [this.foo, this.bar];
+        },
+        func1() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.foo; // $ExpectType string
+            // this does not include stuff from later extend args
+            // @ts-expect-error
+            this.bee;
+        },
+    },
+    {
+        foo: 99,
+        bee: 'honey',
+        func2() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+            this.foo;
+            // this includes stuff from earlier extend-args
+            this.bar; // $ExpectType number
+        },
+    },
+).create();
+
+// TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+// assertType<string>(co6.foo); // @ts-expect-error
+assertType<number>(co6.bar); // $ExpectType number
+assertType<() => Array<string | number>>(co6.baz); // $ExpectType () => (string | number)[]
+
+/** three .extend arguments with a zero-argument .create() */
+const co7 = CoreObject.extend(
+    {
+        foo: '123',
+        bar: 456,
+        baz() {
+            return [this.foo, this.bar];
+        },
+        func1() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.foo; // $ExpectType string
+            // this does not include stuff from later extend args
+            // @ts-expect-error
+            this.bee;
+        },
+    },
+    {
+        foo: 99,
+        bee: 'honey',
+        func2() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+            this.foo;
+            // this includes stuff from earlier extend-args
+            this.bar; // $ExpectType number
+        },
+    },
+    {
+        foo: '99',
+        money: 'in the banana stand',
+        func3() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.money; // $ExpectType string
+            // this includes stuff from earlier extend-args
+            this.bee; // $ExpectType string
+            this.bar; // $ExpectType number
+        },
+    },
+).create();
+// TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+// assertType<number>(co7.foo); // @ts-expect-error
+assertType<number>(co7.bar); // $ExpectType number
+assertType<string>(co7.money); // $ExpectType string
+assertType<() => Array<string | number>>(co7.baz); // $ExpectType () => (string | number)[]
+
+/** four .extend arguments with a zero-argument .create() */
+const co8 = CoreObject.extend(
+    {
+        foo: '123',
+        bar: 456,
+        baz() {
+            return [this.foo, this.bar];
+        },
+        func1() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.foo; // $ExpectType string
+            // this does not include stuff from later extend args
+            // @ts-expect-error
+            this.bee;
+        },
+    },
+    {
+        foo: 99,
+        bee: 'honey',
+        func2() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+            this.foo;
+            // this includes stuff from earlier extend-args
+            this.bar; // $ExpectType number
+            // this does not include stuff from later extend args
+            // @ts-expect-error
+            this.money;
+        },
+    },
+    {
+        foo: '99',
+        money: 'in the banana stand',
+        func3() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.money; // $ExpectType string
+            // this includes stuff from earlier extend-args
+            this.bee; // $ExpectType string
+            this.bar; // $ExpectType number
+            // this does not include stuff from later extend args
+            // @ts-expect-error
+            this.neighborhood;
+        },
+    },
+    {
+        foo: '99',
+        neighborhood: 'sudden valley',
+        func4() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.neighborhood; // $ExpectType string
+            // this includes stuff from earlier extend-args
+            this.bee; // $ExpectType string
+            this.bar; // $ExpectType number
+            this.money; // $ExpectType string
+        },
+    },
+).create();
+
+// TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+// assertType<number>(co8.foo); // @ts-expect-error
+assertType<number>(co8.bar); // $ExpectType number
+assertType<string>(co8.money); // $ExpectType string
+assertType<() => Array<string | number>>(co8.baz); // $ExpectType () => (string | number)[]
diff --git a/types/preview/@ember/object/test/create-negative.ts b/types/preview/@ember/object/test/create-negative.ts
new file mode 100644
index 00000000000..e1e01ff9a13
--- /dev/null
+++ b/types/preview/@ember/object/test/create-negative.ts
@@ -0,0 +1,11 @@
+import { assertType } from './lib/assert';
+import { PersonWithNumberName, Person } from './create';
+
+// @ts-expect-error
+Person.create({ firstName: 99 });
+// @ts-expect-error
+Person.create({}, { firstName: 99 });
+// @ts-expect-error
+Person.create({}, {}, { firstName: 99 });
+
+const p4 = new PersonWithNumberName();
diff --git a/types/preview/@ember/object/test/create.ts b/types/preview/@ember/object/test/create.ts
new file mode 100644
index 00000000000..a508679fa12
--- /dev/null
+++ b/types/preview/@ember/object/test/create.ts
@@ -0,0 +1,54 @@
+import { assertType } from './lib/assert';
+import EmberObject, { computed } from '@ember/object';
+import ComputedProperty from '@ember/object/computed';
+
+/**
+ * Zero-argument case
+ */
+const o = EmberObject.create();
+// create returns an object
+assertType<object>(o);
+// object returned by create type-checks as an instance of Ember.Object
+assertType<boolean>(o.isDestroyed); // from instance
+assertType<boolean>(o.isDestroying); // from instance
+assertType<(key: keyof EmberObject) => any>(o.get); // from prototype
+
+/**
+ * One-argument case
+ */
+const o1 = EmberObject.create({ x: 9, y: 'hello', z: false });
+assertType<number>(o1.x);
+assertType<string>(o1.y);
+o1.y; // $ExpectType string
+o1.z; // $ExpectType boolean
+
+const obj = EmberObject.create({ a: 1 }, { b: 2 }, { c: 3 });
+assertType<number>(obj.b);
+assertType<number>(obj.a);
+assertType<number>(obj.c);
+
+export class Person extends EmberObject {
+    fullName = computed('firstName', 'lastName', function () {
+        return [this.firstName + this.lastName].join(' ');
+    });
+    declare firstName: string;
+    declare lastName: string;
+    declare age: number;
+}
+const p = new Person();
+
+assertType<string>(p.firstName);
+assertType<ComputedProperty<string>>(p.fullName);
+assertType<string>(p.get('fullName'));
+
+const p2 = Person.create({ firstName: 'string' });
+const p2b = Person.create({}, { firstName: 'string' });
+const p2c = Person.create({}, {}, { firstName: 'string' });
+
+export class PersonWithNumberName extends Person.extend({
+    fullName: 6,
+}) {}
+
+const p4 = new PersonWithNumberName();
+assertType<string>(p4.firstName);
+assertType<number>(p4.fullName);
diff --git a/types/preview/@ember/object/test/event.ts b/types/preview/@ember/object/test/event.ts
new file mode 100644
index 00000000000..386735b5098
--- /dev/null
+++ b/types/preview/@ember/object/test/event.ts
@@ -0,0 +1,92 @@
+import EmberObject, { observer } 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() {
+    const Person = EmberObject.extend(Evented, {
+        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() {}
+
+    EmberObject.extend({
+        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/types/preview/@ember/object/test/extend.ts b/types/preview/@ember/object/test/extend.ts
new file mode 100644
index 00000000000..c70d2e24b18
--- /dev/null
+++ b/types/preview/@ember/object/test/extend.ts
@@ -0,0 +1,61 @@
+import EmberObject from '@ember/object';
+import { assertType } from './lib/assert';
+
+const Person = EmberObject.extend({
+    firstName: '',
+    lastName: '',
+
+    getFullName() {
+        return `${this.firstName} ${this.lastName}`;
+    },
+    getFullName2(): string {
+        return `${this.get('firstName')} ${this.get('lastName')}`;
+    },
+});
+
+assertType<string>(Person.prototype.firstName);
+assertType<() => string>(Person.prototype.getFullName);
+
+const person = Person.create({
+    firstName: 'Joe',
+    lastName: 'Blow',
+    extra: 42,
+});
+
+assertType<string>(person.getFullName());
+assertType<number>(person.extra);
+
+class ES6Person 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')}`;
+    }
+}
+
+assertType<string>(ES6Person.prototype.firstName);
+assertType<string>(ES6Person.prototype.fullName);
+
+const es6Person = ES6Person.create({
+    firstName: 'Joe',
+    lastName: 'Blow',
+    extra: 42,
+});
+
+assertType<string>(es6Person.fullName);
+assertType<number>(es6Person.extra);
+
+class PersonWithStatics extends EmberObject {
+    static isPerson = true;
+}
+const PersonWithStatics2 = PersonWithStatics.extend({});
+class PersonWithStatics3 extends PersonWithStatics {}
+class PersonWithStatics4 extends PersonWithStatics2 {}
+assertType<boolean>(PersonWithStatics.isPerson);
+assertType<boolean>(PersonWithStatics2.isPerson);
+assertType<boolean>(PersonWithStatics3.isPerson);
+assertType<boolean>(PersonWithStatics4.isPerson);
diff --git a/types/preview/@ember/object/test/get-set.ts b/types/preview/@ember/object/test/get-set.ts
new file mode 100644
index 00000000000..86c801e7b63
--- /dev/null
+++ b/types/preview/@ember/object/test/get-set.ts
@@ -0,0 +1,14 @@
+import { get, set } from '@ember/object';
+
+const basicPojo = { greeting: 'hello' };
+
+get(basicPojo, 'greeting'); // $ExpectType string
+get(basicPojo, 'salutation'); // $ExpectType unknown
+set(basicPojo, 'greeting', 'ahoy'); // $ExpectType string
+// @ts-expect-error
+set(basicPojo, 'salutation', 'heyo');
+
+declare let whoKnows: unknown;
+get(whoKnows, 'any-string'); // $ExpectType unknown
+// @ts-expect-error
+set(whoKnows, 'any-string', 123);
diff --git a/types/preview/@ember/object/test/internals.ts b/types/preview/@ember/object/test/internals.ts
new file mode 100644
index 00000000000..fcfb55c2bcb
--- /dev/null
+++ b/types/preview/@ember/object/test/internals.ts
@@ -0,0 +1,10 @@
+import { guidFor } from '@ember/object/internals';
+
+// $ExpectType string
+const strGuid = guidFor('a string');
+// $ExpectType string
+const numGuid = guidFor(123);
+// $ExpectType string
+const objGuid = guidFor({ hello: 'world' });
+// $ExpectType string
+const arrGuid = guidFor([1, 2, 3]);
diff --git a/types/preview/@ember/object/test/lib/assert.ts b/types/preview/@ember/object/test/lib/assert.ts
new file mode 100644
index 00000000000..dad227ab5e9
--- /dev/null
+++ b/types/preview/@ember/object/test/lib/assert.ts
@@ -0,0 +1,2 @@
+/** Static assertion that `value` has type `T` */
+export declare function assertType<T>(value: T): T;
diff --git a/types/preview/@ember/object/test/object.ts b/types/preview/@ember/object/test/object.ts
new file mode 100644
index 00000000000..703ab737616
--- /dev/null
+++ b/types/preview/@ember/object/test/object.ts
@@ -0,0 +1,102 @@
+import EmberObject, { computed, notifyPropertyChange } from '@ember/object';
+
+const LifetimeHooks = EmberObject.extend({
+    resource: undefined as {} | undefined,
+
+    init() {
+        this._super();
+        this.resource = {};
+    },
+
+    willDestroy() {
+        this.resource = undefined;
+        this._super();
+    },
+});
+
+class MyObject30 extends EmberObject {
+    constructor() {
+        super();
+    }
+}
+
+class MyObject31 extends EmberObject {
+    constructor(properties: object) {
+        super(properties);
+    }
+}
+
+class Foo extends EmberObject {
+    a = computed({
+        get() {
+            return '';
+        },
+        set(key: string, newVal: string) {
+            return '';
+        },
+    });
+    b = 5;
+    c = computed({
+        get() {
+            return '';
+        },
+        set(key: string, newVal: string | number) {
+            return '';
+        }
+    });
+    baz() {
+        const x = this.a; // $ExpectType ComputedProperty<string, string>
+        const y = this.b; // $ExpectType number
+        const z = this.c; // $ExpectType ComputedProperty<string, string | number>
+        this.b = 10;
+        this.get('b').toFixed(4); // $ExpectType string
+        this.set('a', 'abc').split(','); // $ExpectType string[]
+        this.set('b', 10).toFixed(4); // $ExpectType string
+        this.get('c').split(','); // $ExpectType string[]
+        this.set('c', '10').split(','); // $ExpectType string[]
+        this.set('c', 10);
+        // @ts-expect-error
+        this.set('c', 10).split(',');
+
+        this.setProperties({ b: 11 });
+        // this.setProperties({ b: '11' }); // @ts-expect-error
+        this.setProperties({
+            a: 'def',
+            b: 11,
+        });
+    }
+    bar() {
+        notifyPropertyChange(this, 'name');
+        // @ts-expect-error
+        notifyPropertyChange(this);
+        // @ts-expect-error
+        notifyPropertyChange('name');
+        // @ts-expect-error
+        notifyPropertyChange(this, 'name', 'bar');
+    }
+}
+
+// TODO: enable after TS 3.0 https://github.com/typed-ember/ember-cli-typescript/issues/291
+// class Foo extends EmberObject.extend({
+//     a: computed({
+//         get() { return ''; },
+//         set(key: string, newVal: string) { return ''; }
+//     })
+// }) {
+//     b = 5;
+//     baz() {
+//         const y = this.b; // $ExpectType number
+//         const z = this.a; // $ExpectType ComputedProperty<string, string>
+//         this.b = 10;
+//         this.get('b').toFixed(4); // $ExpectType string
+//         this.set('a', 'abc').split(','); // $ExpectType string[]
+//         this.set('b', 10).toFixed(4); // $ExpectType string
+
+//         this.setProperties({ b: 11 });
+//         // this.setProperties({ b: '11' }); // @ts-expect-error
+//         this.setProperties({
+//             a: 'def',
+//             b: 11
+//         });
+//     }
+// }
diff --git a/types/preview/@ember/object/test/observable.ts b/types/preview/@ember/object/test/observable.ts
new file mode 100644
index 00000000000..9d82e8de043
--- /dev/null
+++ b/types/preview/@ember/object/test/observable.ts
@@ -0,0 +1,102 @@
+import { assertType } from './lib/assert';
+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');
+
+const person = EmberObject.create({
+    name: 'Fred',
+    age: 29,
+    capitalized: computed<string>(function () {
+        return this.get('name').toUpperCase();
+    }),
+});
+
+const pojo = { name: 'Fred', age: 29 };
+
+function testGet() {
+    assertType<string>(get(person, 'name'));
+    assertType<number>(get(person, 'age'));
+    assertType<string>(get(person, 'capitalized'));
+    assertType<string>(person.get('name'));
+    assertType<number>(person.get('age'));
+    assertType<string>(person.get('capitalized'));
+    assertType<string>(get(pojo, 'name'));
+}
+
+function testGetProperties() {
+    assertType<{ name: string }>(getProperties(person, 'name'));
+    assertType<{ name: string; age: number }>(getProperties(person, 'name', 'age'));
+    assertType<{ name: string; age: number }>(getProperties(person, ['name', 'age']));
+    assertType<{ name: string; age: number; capitalized: string }>(getProperties(person, 'name', 'age', 'capitalized'));
+    assertType<{ name: string }>(person.getProperties('name'));
+    assertType<{ name: string; age: number }>(person.getProperties('name', 'age'));
+    assertType<{ name: string; age: number }>(person.getProperties(['name', 'age']));
+    assertType<{ name: string; age: number; capitalized: string }>(person.getProperties('name', 'age', 'capitalized'));
+    assertType<{ name: string; age: number }>(getProperties(pojo, 'name', 'age'));
+}
+
+function testSet() {
+    assertType<string>(set(person, 'name', 'Joe'));
+    assertType<number>(set(person, 'age', 35));
+    assertType<string>(set(person, 'capitalized', 'JOE'));
+    assertType<string>(person.set('name', 'Joe'));
+    assertType<number>(person.set('age', 35));
+    assertType<string>(person.set('capitalized', 'JOE'));
+    assertType<string>(set(pojo, 'name', 'Joe'));
+}
+
+function testSetProperties() {
+    assertType<{ name: string }>(setProperties(person, { name: 'Joe' }));
+    assertType<{ name: string; age: number }>(setProperties(person, { name: 'Joe', age: 35 }));
+    assertType<{ name: string; capitalized: string }>(setProperties(person, { name: 'Joe', capitalized: 'JOE' }));
+    assertType<{ name: string }>(person.setProperties({ name: 'Joe' }));
+    assertType<{ name: string; age: number }>(person.setProperties({ name: 'Joe', age: 35 }));
+    assertType<{ name: string; capitalized: string }>(person.setProperties({ name: 'Joe', capitalized: 'JOE' }));
+    assertType<{ name: string; age: number }>(setProperties(pojo, { name: 'Joe', age: 35 }));
+}
+
+function testDynamic() {
+    const obj: any = {};
+    const dynamicKey: string = 'dummy'; // tslint:disable-line:no-inferrable-types
+
+    assertType<any>(get(obj, 'dummy'));
+    assertType<any>(get(obj, dynamicKey));
+    assertType<{ dummy: any }>(getProperties(obj, 'dummy'));
+    assertType<{ dummy: any }>(getProperties(obj, ['dummy']));
+    assertType<object>(getProperties(obj, dynamicKey));
+    assertType<object>(getProperties(obj, [dynamicKey]));
+    assertType<string>(set(obj, 'dummy', 'value'));
+    assertType<string>(set(obj, dynamicKey, 'value'));
+    assertType<{ dummy: string }>(setProperties(obj, { dummy: 'value ' }));
+    assertType<object>(setProperties(obj, { [dynamicKey]: 'value' }));
+}
diff --git a/types/preview/@ember/object/test/octane.ts b/types/preview/@ember/object/test/octane.ts
new file mode 100644
index 00000000000..adc1526aff8
--- /dev/null
+++ b/types/preview/@ember/object/test/octane.ts
@@ -0,0 +1,331 @@
+import { action, computed, default as EmberObject } from '@ember/object';
+import {
+  alias,
+  and,
+  bool,
+  collect,
+  deprecatingAlias,
+  empty,
+  equal,
+  filter,
+  filterBy,
+  gt,
+  gte,
+  intersect,
+  lt,
+  lte,
+  map,
+  mapBy,
+  match,
+  max,
+  min,
+  none,
+  not,
+  notEmpty,
+  oneWay,
+  or,
+  readOnly,
+  reads,
+  setDiff,
+  sort,
+  sum,
+  union,
+  uniq,
+  uniqBy,
+} from '@ember/object/computed';
+
+function customMacro(message: string) {
+  return computed(() => {
+    return [message, message];
+  });
+}
+
+// Native class syntax
+class Foo extends EmberObject {
+  declare firstName: string;
+  declare lastName: string;
+
+  // @ts-expect-error -- action only works on methods
+  @action
+  bar!: string;
+
+  @computed('firstName', 'lastName')
+  get fullName() {
+    return `${this.firstName} ${this.lastName}`;
+  }
+
+  // @ts-expect-error -- we require this to be with a getter.
+  @computed('firstName', 'lastName')
+  declare badFullName: string;
+
+  @computed('fullName', function (this: Foo) {
+    return this.fullName.toUpperCase();
+  })
+  declare bigFullName: string;
+
+  @customMacro('hi')
+  declare hiTwice: string[];
+
+  @action
+  foo() {
+    /* no op demo */
+  }
+}
+
+// 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: any;
+  @collect() declare collectTest1: any;
+  @collect('firstName') declare collectTest2: any;
+
+  // @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: any[];
+  // @ts-expect-error
+  @filterBy() declare filterByTest2: any[];
+  // @ts-expect-error
+  @filterBy('firstName') declare filterByTest3: any[];
+  @filterBy('firstName', 'id') declare filterByTest4: any[];
+
+  // @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: any;
+  @union() declare unionTest2: any;
+  @union('firstName') declare unionTest3: any;
+  @union('firstName', 'lastName') declare unionTest4: any;
+
+  // @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/types/preview/@ember/object/test/proxy.ts b/types/preview/@ember/object/test/proxy.ts
new file mode 100644
index 00000000000..14a8a386570
--- /dev/null
+++ b/types/preview/@ember/object/test/proxy.ts
@@ -0,0 +1,103 @@
+import Ember from 'ember';
+import ObjectProxy from '@ember/object/proxy';
+
+interface Book {
+    title: string;
+    subtitle: string;
+    chapters: Array<{ title: string }>;
+}
+
+class DefaultProxy extends ObjectProxy {}
+DefaultProxy.create().content; // $ExpectType 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();
+book.content; // $ExpectType Book | undefined
+
+// @ts-expect-error
+book.get('unknownProperty');
+book.get('title'); // $ExpectType string | undefined
+book.get('altTitle'); // $ExpectType string
+book.getTitle(); // $ExpectType string | undefined
+
+// @ts-expect-error
+book.getProperties('title', 'unknownProperty');
+book.getProperties('title', 'subtitle'); // $ExpectType Pick<Partial<UnwrapComputedPropertyGetters<Book>>, "title" | "subtitle">
+book.getPropertiesTitleSubtitle(); // $ExpectType Pick<Partial<UnwrapComputedPropertyGetters<Book>>, "title" | "subtitle">
+// tslint:disable-next-line
+book.getProperties(['subtitle', 'chapters']); // $ExpectType Pick<Partial<UnwrapComputedPropertyGetters<Book>>, "subtitle" | "chapters"> || Pick<Partial<UnwrapComputedPropertyGetters<Book>>, "chapters" | "subtitle">
+// @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';
+
+    fullName = Ember.computed('firstName', 'lastName', {
+        get() {
+          return `${this.firstName} ${this.lastName}`;
+        },
+
+        set(key, value: string) {
+          const [firstName, lastName] = value.split(' ');
+
+          Ember.set(this, 'firstName', firstName);
+          Ember.set(this, 'lastName', lastName);
+
+          return value;
+        }
+    });
+}
+
+class PersonProxy extends ObjectProxy<Person> { }
+
+const person = PersonProxy.create();
+
+person.get('firstName'); // $ExpectType string | undefined
+person.get('fullName'); // $ExpectType string | undefined
+person.set('fullName', 'John Doe'); // $ExpectType string
+// @ts-expect-error
+person.set('fullName', 1);
+// @ts-expect-error
+person.set('invalid', true);
+person.setProperties({ fullName: 'John Doe' }); // $ExpectType Pick<UnwrapComputedPropertySetters<PersonProxy & Person>, "fullName">
+person.setProperties({ fullName: 'John Doe' }).fullName; // $ExpectType string
+// @ts-expect-error
+person.setProperties({ fullName: 1 });
+// @ts-expect-error
+person.setProperties({ fullName: 'John Doe', invalid: true });
diff --git a/types/preview/@ember/object/test/reopen.ts b/types/preview/@ember/object/test/reopen.ts
new file mode 100644
index 00000000000..10a2e9e1845
--- /dev/null
+++ b/types/preview/@ember/object/test/reopen.ts
@@ -0,0 +1,75 @@
+import { assertType } from './lib/assert';
+import EmberObject from '@ember/object';
+import Mixin from '@ember/object/mixin';
+
+type Person = typeof Person.prototype;
+const Person = EmberObject.extend({
+    name: '',
+    sayHello() {
+        alert(`Hello. My name is ${this.get('name')}`);
+    },
+});
+
+assertType<Person>(Person.reopen());
+
+assertType<string>(Person.create().name);
+// tslint:disable-next-line no-void-expression
+assertType<void>(Person.create().sayHello());
+
+const Person2 = Person.reopenClass({
+    species: 'Homo sapiens',
+
+    createPerson(name: string): Person {
+        return Person.create({ name });
+    },
+});
+
+assertType<string>(Person2.create().name);
+// tslint:disable-next-line no-void-expression
+assertType<void>(Person2.create().sayHello());
+assertType<string>(Person2.species);
+
+const tom = Person2.create({
+    name: 'Tom Dale',
+});
+
+// @ts-expect-error
+const badTom = Person2.create({ name: 99 });
+
+const yehuda = Person2.createPerson('Yehuda Katz');
+
+tom.sayHello(); // "Hello. My name is Tom Dale"
+yehuda.sayHello(); // "Hello. My name is Yehuda Katz"
+alert(Person2.species); // "Homo sapiens"
+
+const Person3 = Person2.reopen({
+    goodbyeMessage: 'goodbye',
+
+    sayGoodbye() {
+        alert(`${this.get('goodbyeMessage')}, ${this.get('name')}`);
+    },
+});
+
+const person3 = Person3.create();
+person3.get('name');
+person3.get('goodbyeMessage');
+person3.sayHello();
+person3.sayGoodbye();
+
+interface AutoResizeMixin {
+    resizable: true;
+}
+declare const AutoResizeMixin: Mixin<AutoResizeMixin>;
+
+const ResizableTextArea = EmberObject.reopen(AutoResizeMixin, {
+    scaling: 1.0,
+});
+const text = ResizableTextArea.create();
+// TODO fix upstream
+// assertType<boolean>(text.resizable);
+assertType<number>(text.scaling);
+
+const Reopened = EmberObject.reopenClass({ a: 1 }, { b: 2 }, { c: 3 });
+assertType<number>(Reopened.a);
+assertType<number>(Reopened.b);
+assertType<number>(Reopened.c);
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/ember__owner-tests.ts b/types/preview/@ember/owner/ember__owner-tests.ts
new file mode 100644
index 00000000000..27b57933cca
--- /dev/null
+++ b/types/preview/@ember/owner/ember__owner-tests.ts
@@ -0,0 +1,135 @@
+import Owner, { Factory, FactoryManager, FullName, RegisterOptions } from '@ember/owner';
+
+// Just a class we can construct in the Factory and FactoryManager tests
+declare class ConstructThis {
+    hasProps: boolean;
+}
+
+// ----- RegisterOptions ----- //
+declare let regOptionsA: RegisterOptions;
+regOptionsA.instantiate; // $ExpectType boolean | undefined
+regOptionsA.singleton; // $ExpectType 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>;
+aFactoryManager.class; // $ExpectType Factory<ConstructThis>
+aFactoryManager.create({}); // $ExpectType ConstructThis
+aFactoryManager.create({ hasProps: true }); // $ExpectType ConstructThis
+aFactoryManager.create({ hasProps: false }); // $ExpectType ConstructThis
+// @ts-expect-error
+aFactoryManager.create({ otherStuff: 'nope' });
+// @ts-expect-error
+aFactoryManager.create({ hasProps: true, otherStuff: 'nope' });
+aFactoryManager.create(goodPojo); // $ExpectType 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();
+owner.lookup('type:name'); // $ExpectType unknown
+// @ts-expect-error
+owner.lookup('non-namespace-string');
+owner.lookup('namespace@type:name'); // $ExpectType unknown
+
+owner.register('type:name', aFactory); // $ExpectType void
+owner.register('type:name', aFactory, {}); // $ExpectType void
+owner.register('type:name', aFactory, { instantiate: true }); // $ExpectType void
+owner.register('type:name', aFactory, { instantiate: false }); // $ExpectType void
+owner.register('type:name', aFactory, { singleton: true }); // $ExpectType void
+owner.register('type:name', aFactory, { singleton: false }); // $ExpectType void
+owner.register('type:name', aFactory, { instantiate: true, singleton: true }); // $ExpectType void
+owner.register('type:name', aFactory, { instantiate: true, singleton: false }); // $ExpectType void
+owner.register('type:name', aFactory, { instantiate: false, singleton: true }); // $ExpectType void
+owner.register('type:name', aFactory, { instantiate: false, singleton: false }); // $ExpectType void
+// @ts-expect-error
+owner.register('non-namespace-string', aFactory);
+owner.register('namespace@type:name', aFactory); // $ExpectType void
+
+owner.factoryFor('type:name'); // $ExpectType FactoryManager<unknown> | undefined
+owner.factoryFor('type:name')?.class; // $ExpectType Factory<unknown> | undefined
+owner.factoryFor('type:name')?.create(); // $ExpectType unknown
+owner.factoryFor('type:name')?.create({}); // $ExpectType unknown
+owner.factoryFor('type:name')?.create({ anythingGoes: true }); // $ExpectType unknown
+// @ts-expect-error
+owner.factoryFor('non-namespace-string');
+owner.factoryFor('namespace@type:name'); // $ExpectType 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';
+owner.lookup(aTypedName); // $ExpectType unknown
+
+// 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';
+owner.lookup(aConstName); // $ExpectType unknown
+
+// ----- 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;
+    },
+};
+
+pojoFactory.create(); // $ExpectType { hasProps: boolean; }
diff --git a/types/preview/@ember/owner/index.d.ts b/types/preview/@ember/owner/index.d.ts
new file mode 100644
index 00000000000..db9b3dbb28a
--- /dev/null
+++ b/types/preview/@ember/owner/index.d.ts
@@ -0,0 +1,104 @@
+// Type definitions for non-npm package @ember/owner 4.0
+// Project: https://emberjs.com/api/ember/4.0/
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+/**
+ * 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/ember__polyfills-tests.ts b/types/preview/@ember/polyfills/ember__polyfills-tests.ts
new file mode 100644
index 00000000000..859ca779645
--- /dev/null
+++ b/types/preview/@ember/polyfills/ember__polyfills-tests.ts
@@ -0,0 +1,23 @@
+import { assign } from '@ember/polyfills';
+
+(() => {
+    /* assign */
+    assign({}, { a: 'b' });
+    assign({}, { a: 'b' }).a; // $ExpectType string
+    assign({ a: 6 }, { a: 'b' }).a; // $ExpectType string
+    assign({ a: 6 }, {}).a; // $ExpectType number
+    // @ts-expect-error
+    assign({ b: 6 }, {}).a;
+    assign({}, { b: 6 }, {}).b; // $ExpectType number
+    assign({ a: 'hello' }, { b: 6 }, {}).a; // $ExpectType string
+    assign({ a: 'hello' }, { b: 6 }, { a: true }).a; // $ExpectType boolean
+    // @ts-expect-error
+    assign({ a: 'hello' }, '', { a: true }).a;
+    assign({ d: ['gobias industries'] }, { a: 'hello' }, { b: 6 }, { a: true }).d; // $ExpectType string[]
+    // @ts-expect-error
+    assign({}, { a: 0 }, { b: 1 }, { c: 2 }, { d: 3 }).a;
+
+    // matches Object.assign
+    assign({}, null); // $ExpectType never
+    assign({}, undefined); // $ExpectType never
+})();
diff --git a/types/preview/@ember/polyfills/index.d.ts b/types/preview/@ember/polyfills/index.d.ts
new file mode 100644
index 00000000000..487bc2cf648
--- /dev/null
+++ b/types/preview/@ember/polyfills/index.d.ts
@@ -0,0 +1,29 @@
+// Type definitions for non-npm package @ember/polyfills 4.0
+// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Fpolyfills
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+import type { Mix, Mix3, Mix4 } from './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..d1c8cf23063
--- /dev/null
+++ b/types/preview/@ember/polyfills/types.d.ts
@@ -0,0 +1,4 @@
+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/route-info-with-attributes.d.ts b/types/preview/@ember/routing/-private/route-info-with-attributes.d.ts
new file mode 100644
index 00000000000..4977630e2ef
--- /dev/null
+++ b/types/preview/@ember/routing/-private/route-info-with-attributes.d.ts
@@ -0,0 +1 @@
+export { RouteInfoWithAttributes as default } from '../route-info';
diff --git a/types/preview/@ember/routing/-private/route-info.d.ts b/types/preview/@ember/routing/-private/route-info.d.ts
new file mode 100644
index 00000000000..8c186376518
--- /dev/null
+++ b/types/preview/@ember/routing/-private/route-info.d.ts
@@ -0,0 +1 @@
+export { default as default } from '../route-info';
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..86c6b086494
--- /dev/null
+++ b/types/preview/@ember/routing/-private/router-dsl.d.ts
@@ -0,0 +1,18 @@
+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/-private/transition.d.ts b/types/preview/@ember/routing/-private/transition.d.ts
new file mode 100644
index 00000000000..b825aaed5a7
--- /dev/null
+++ b/types/preview/@ember/routing/-private/transition.d.ts
@@ -0,0 +1 @@
+export { default as default } from '../transition';
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..86be671620b
--- /dev/null
+++ b/types/preview/@ember/routing/auto-location.d.ts
@@ -0,0 +1,6 @@
+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..a045285fbc6
--- /dev/null
+++ b/types/preview/@ember/routing/hash-location.d.ts
@@ -0,0 +1,8 @@
+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..8921fdb15e2
--- /dev/null
+++ b/types/preview/@ember/routing/history-location.d.ts
@@ -0,0 +1,7 @@
+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..923ca316b6b
--- /dev/null
+++ b/types/preview/@ember/routing/index.d.ts
@@ -0,0 +1,26 @@
+// Type definitions for non-npm package @ember/routing 4.0
+// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Frouting
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+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..22934d7cece
--- /dev/null
+++ b/types/preview/@ember/routing/none-location.d.ts
@@ -0,0 +1,9 @@
+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..2261063b669
--- /dev/null
+++ b/types/preview/@ember/routing/route-info.d.ts
@@ -0,0 +1,72 @@
+// 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..07c4c5c9156
--- /dev/null
+++ b/types/preview/@ember/routing/route.d.ts
@@ -0,0 +1,525 @@
+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 { RenderOptions, RouteQueryParam } from '@ember/routing/types';
+import Controller from '@ember/controller';
+
+// tslint:disable-next-line:strict-export-declare-modifiers
+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..827d40dbb92
--- /dev/null
+++ b/types/preview/@ember/routing/router-service.d.ts
@@ -0,0 +1,360 @@
+import RouteInfo, { RouteInfoWithAttributes } from '@ember/routing/route-info';
+import Transition from '@ember/routing/transition';
+import Service from '@ember/service';
+
+// tslint:disable-next-line:strict-export-declare-modifiers
+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..ca70289b2b7
--- /dev/null
+++ b/types/preview/@ember/routing/router.d.ts
@@ -0,0 +1,43 @@
+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";
+import RouterService from "@ember/routing/router-service";
+
+/**
+ * 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.extend(Evented) {
+    /**
+     * 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;
+    transitionTo(name: string, ...models: any[]): Transition;
+    transitionTo(name: string, options: {}): Transition;
+}
+
+declare module '@ember/service' {
+    interface Registry {
+        'router': RouterService;
+    }
+}
diff --git a/types/preview/@ember/routing/test/built-ins.ts b/types/preview/@ember/routing/test/built-ins.ts
new file mode 100644
index 00000000000..40db98e07cf
--- /dev/null
+++ b/types/preview/@ember/routing/test/built-ins.ts
@@ -0,0 +1,3 @@
+import { LinkTo } from '@ember/routing';
+
+LinkTo; // $ExpectType LinkTo
diff --git a/types/preview/@ember/routing/test/lib/assert.ts b/types/preview/@ember/routing/test/lib/assert.ts
new file mode 100755
index 00000000000..dad227ab5e9
--- /dev/null
+++ b/types/preview/@ember/routing/test/lib/assert.ts
@@ -0,0 +1,2 @@
+/** Static assertion that `value` has type `T` */
+export declare function assertType<T>(value: T): T;
diff --git a/types/preview/@ember/routing/test/route.ts b/types/preview/@ember/routing/test/route.ts
new file mode 100755
index 00000000000..42c53d4e73b
--- /dev/null
+++ b/types/preview/@ember/routing/test/route.ts
@@ -0,0 +1,227 @@
+import Route from '@ember/routing/route';
+import Array from '@ember/array';
+import EmberObject from '@ember/object';
+import Controller from '@ember/controller';
+import Transition from '@ember/routing/transition';
+import RouteInfo, { RouteInfoWithAttributes } from '@ember/routing/route-info';
+
+class Post extends EmberObject {}
+
+interface Posts extends Array<Post> {}
+
+Route.extend({
+    beforeModel(transition: Transition) {
+        this.transitionTo('someOtherRoute');
+    },
+});
+
+Route.extend({
+    afterModel(posts: Posts, transition: Transition) {
+        if (posts.firstObject) {
+            this.transitionTo('post.show', posts.firstObject);
+        }
+    },
+});
+
+Route.extend({
+    model() {
+        return this.modelFor('post');
+    },
+});
+
+Route.extend({
+    queryParams: {
+        memberQp: { refreshModel: true },
+    },
+});
+
+Route.extend({
+    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() {
+        // $ExpectType Transition<unknown>
+        this.transitionTo('somewhere', { queryParams: { neat: true } });
+    }
+
+    transitionToJustQP() {
+        // $ExpectType Transition<unknown>
+        this.transitionTo({ queryParams: { neat: 'true' } });
+    }
+
+    transitionToNonsense() {
+        // @ts-expect-error
+        this.transitionTo({ cannotDoModelHere: true });
+    }
+
+    transitionToBadQP() {
+        // @ts-expect-error
+        this.transitionTo({ queryParams: 12 });
+    }
+
+    transitionToId() {
+        // $ExpectType Transition<unknown>
+        this.transitionTo('blog-post', 1);
+    }
+
+    transitionToIdWithQP() {
+        // $ExpectType Transition<unknown>
+        this.transitionTo('blog-post', 1, { queryParams: { includeComments: true } });
+    }
+
+    transitionToIds() {
+        // $ExpectType Transition<unknown>
+        this.transitionTo('blog-comment', 1, '13');
+    }
+
+    transitionToIdsWithQP() {
+        // $ExpectType Transition<unknown>
+        this.transitionTo('blog-comment', 1, '13', { queryParams: { includePost: true } });
+    }
+
+    buildRouteInfoMetadata() {
+        return { foo: 'bar' };
+    }
+}
+
+class ApplicationController extends Controller {}
+declare module '@ember/controller' {
+    interface Registry {
+        application: ApplicationController;
+    }
+}
+
+Route.extend({
+    setupController(controller: Controller, model: {}, transition: Transition) {
+        this._super(controller, model);
+        this.controllerFor('application').set('model', model);
+        transition.abort();
+    },
+});
+
+const route = Route.create();
+route.controllerFor('whatever'); // $ExpectType Controller
+route.paramsFor('whatever'); // $ExpectType 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' };
+    }
+}
+
+// $ExpectType RouteParams
+type ImplicitParams = WithImplicitParams extends Route<any, infer T> ? T : never;
+
+// back-compat for existing users of these
+// NOTE: we will *not* migrate the private import locations when moving to
+// publish from Ember itself.
+import PrivateTransition from '@ember/routing/-private/transition';
+declare let publicTransition: Transition;
+declare let oldPrivateTransition: PrivateTransition;
+publicTransition = oldPrivateTransition;
+oldPrivateTransition = publicTransition;
+
+import PrivateRouteInfo from '@ember/routing/-private/route-info';
+declare let publicRouteInfo: RouteInfo;
+declare let privateRouteInfo: PrivateRouteInfo;
+publicRouteInfo = privateRouteInfo;
+privateRouteInfo = publicRouteInfo;
+
+import PrivateRouteInfoWithAttributes from '@ember/routing/-private/route-info-with-attributes';
+declare let publicRouteInfoWithAttributes: RouteInfoWithAttributes;
+declare let privateRouteInfoWithAttributes: PrivateRouteInfoWithAttributes;
+publicRouteInfoWithAttributes = privateRouteInfoWithAttributes;
+privateRouteInfoWithAttributes = publicRouteInfoWithAttributes;
diff --git a/types/preview/@ember/routing/test/router-service.ts b/types/preview/@ember/routing/test/router-service.ts
new file mode 100644
index 00000000000..10875f86b1d
--- /dev/null
+++ b/types/preview/@ember/routing/test/router-service.ts
@@ -0,0 +1,120 @@
+import RouterService from '@ember/routing/router-service';
+
+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 = () => {};
+
+// $ExpectType RouterService
+router.on('routeWillChange', routeWillChangeHandler);
+
+// $ExpectType boolean
+router.has('routeWillChange');
+
+// $ExpectType RouterService
+router.off('routeWillChange', routeWillChangeHandler);
+
+// $ExpectType RouterService
+router.one('routeWillChange', routeWillChangeHandler);
+
+// $ExpectType void
+router.trigger('routeWillChange', 'boo');
+
+const transition = router.transitionTo('someRoute');
+
+// $ExpectType Transition<unknown>
+transition.abort();
+
+// $ExpectType Promise<unknown>
+transition.catch();
+transition.catch(err => console.log(err), 'label');
+
+// $ExpectType Promise<unknown>
+transition.finally();
+transition.finally(() => console.log('finally!'));
+transition.finally(() => console.log('finally!'), 'label');
+
+// $ExpectType Promise<unknown>
+transition.followRedirects();
+
+// $ExpectType Transition<unknown>
+transition.method();
+transition.method('replace');
+
+// $ExpectType Transition<unknown>
+transition.retry();
+
+// $ExpectType Promise<unknown>
+transition.then();
+transition.then(
+    result => console.log(result),
+    err => console.log(err),
+    'label',
+);
+
+// $ExpectType void
+transition.trigger(false, 'error');
+
+// $ExpectType void
+transition.send(false, 'error');
+
+transition.data = { some: 'data' };
+
+// $ExpectType RouteInfoWithAttributes | null
+transition.from;
+// @ts-expect-error
+transition.from = 'from';
+
+// $ExpectType Promise<unknown>
+transition.promise;
+// @ts-expect-error
+transition.promise = 'promise';
+
+// $ExpectType RouteInfo | RouteInfoWithAttributes
+transition.to;
+// @ts-expect-error
+transition.to = 'to';
+
+// $ExpectType unknown
+transition.to.metadata;
+// @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.
+// $ExpectType Transition<unknown>
+router.transitionTo('someRoute', { queryParams: { shouldWork: true } });
+// $ExpectType Transition<unknown>
+router.transitionTo({ queryParams: { areSupported: true } });
+// @ts-expect-error
+router.transitionTo({ queryParams: 'potato' });
+// $ExpectType Transition<unknown>
+router.transitionTo('someRoute', 1);
+// $ExpectType Transition<unknown>
+router.transitionTo('someRoute', 1, { queryParams: { areSupported: true } });
+// $ExpectType Transition<unknown>
+router.transitionTo('someRoute', 1, '13');
+// $ExpectType Transition<unknown>
+router.transitionTo('someRoute', 1, '13', { queryParams: { areSupported: true } });
+
+router.recognize('foo/bar'); // $ExpectType RouteInfo
+
+router.recognizeAndLoad('foo/bar'); // $ExpectType RouteInfoWithAttributes
+
+router.rootURL; // $ExpectType string
+// @ts-expect-error
+router.rootURL = 'foo';
+
+router.refresh(); // $ExpectType Transition<unknown>
+router.refresh('my-route'); // $ExpectType Transition<unknown>
diff --git a/types/preview/@ember/routing/test/router.ts b/types/preview/@ember/routing/test/router.ts
new file mode 100755
index 00000000000..0ef27748380
--- /dev/null
+++ b/types/preview/@ember/routing/test/router.ts
@@ -0,0 +1,81 @@
+import Router from '@ember/routing/router';
+import Service, { inject as service } from '@ember/service';
+import EmberObject, { get } from '@ember/object';
+
+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' });
+});
+
+const RouterServiceConsumer = Service.extend({
+    router: service('router'),
+    currentRouteName() {
+        const x: string = get(this, 'router').currentRouteName;
+    },
+    currentURL() {
+        const x: string = get(this, 'router').currentURL;
+    },
+    rootURL() {
+        const x: string = get(this, 'router').rootURL;
+    },
+    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;
+                to.child; // $ExpectType RouteInfo | null
+                to.localName; // $ExpectType string
+                to.name; // $ExpectType string
+                to.paramNames; // $ExpectType string[]
+                to.params.foo; // $ExpectType string | undefined
+                to.parent; // $ExpectType RouteInfo | null
+                to.queryParams.foo; // $ExpectType string | undefined
+                to.find(info => info.name === 'foo'); // $ExpectType RouteInfo | undefined
+            })
+            .on('routeDidChange', transition => {
+                const from = transition.from;
+                if (from) {
+                    from.child; // $ExpectType RouteInfo | null
+                    from.localName; // $ExpectType string
+                    from.name; // $ExpectType string
+                    from.paramNames; // $ExpectType string[]
+                    from.params.foo; // $ExpectType string | undefined
+                    from.parent; // $ExpectType RouteInfo | null
+                    from.queryParams.foo; // $ExpectType string | undefined
+                    from.find(info => info.name === 'foo'); // $ExpectType RouteInfo | undefined
+                }
+            });
+    },
+});
diff --git a/types/preview/@ember/routing/transition.d.ts b/types/preview/@ember/routing/transition.d.ts
new file mode 100644
index 00000000000..b623b76b634
--- /dev/null
+++ b/types/preview/@ember/routing/transition.d.ts
@@ -0,0 +1,124 @@
+import RouteInfo, { RouteInfoWithAttributes } from './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..251a295fcc4
--- /dev/null
+++ b/types/preview/@ember/routing/types.d.ts
@@ -0,0 +1,13 @@
+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..676a3b36ada
--- /dev/null
+++ b/types/preview/@ember/runloop/-private/backburner.d.ts
@@ -0,0 +1,41 @@
+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..48384ec84bb
--- /dev/null
+++ b/types/preview/@ember/runloop/-private/types.d.ts
@@ -0,0 +1 @@
+export type EmberRunQueues = 'sync' | 'actions' | 'routerTransitions' | 'render' | 'afterRender' | 'destroy';
diff --git a/types/preview/@ember/runloop/ember__runloop-tests.ts b/types/preview/@ember/runloop/ember__runloop-tests.ts
new file mode 100644
index 00000000000..5192db4bcae
--- /dev/null
+++ b/types/preview/@ember/runloop/ember__runloop-tests.ts
@@ -0,0 +1,279 @@
+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 from '@ember/object';
+import { 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(() => { // $ExpectType number
+        // 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();
+        });
+    }
+}
+
+function testBind() {
+    EmberObject.extend({
+        init() {
+            const bound = bind(this, this.setupEditor);
+            bound();
+        },
+
+        editor: null as string | 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);
+
+    EmberObject.extend({
+        searchValue: 'test',
+        fetchResults(value: string) {},
+
+        actions: {
+            handleTyping() {
+                // the fetchResults function is passed into the component from its parent
+                debounce(this, this.get('fetchResults'), this.get('searchValue'), 250);
+            }
+        }
+    });
+}
+
+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
+    });
+}
+
+function testOnce() {
+    EmberObject.extend({
+        init() {
+            once(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/types/preview/@ember/runloop/index.d.ts b/types/preview/@ember/runloop/index.d.ts
new file mode 100644
index 00000000000..7265638796a
--- /dev/null
+++ b/types/preview/@ember/runloop/index.d.ts
@@ -0,0 +1,179 @@
+// Type definitions for non-npm package @ember/runloop 4.0
+// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Frunloop
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+import { EmberMethod, EmberMethodParams, AnyFn, EmberMethodReturn } from "ember/-private/type-utils";
+import { EmberRunQueues } from './-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;
+
+/**
+ * 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..2aeaa44726a
--- /dev/null
+++ b/types/preview/@ember/runloop/types.d.ts
@@ -0,0 +1,3 @@
+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..798774107b8
--- /dev/null
+++ b/types/preview/@ember/service/index.d.ts
@@ -0,0 +1,32 @@
+// Type definitions for non-npm package @ember/service 4.0
+// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Fservice
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+import EmberObject from '@ember/object';
+import ComputedProperty 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(): ComputedProperty<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): ComputedProperty<Registry[K]>; // @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(): ComputedProperty<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): ComputedProperty<Registry[K]>; // @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.
+// tslint:disable-next-line no-empty-interface strict-export-declare-modifiers
+interface Registry {}
diff --git a/types/preview/@ember/service/test/main.ts b/types/preview/@ember/service/test/main.ts
new file mode 100644
index 00000000000..3fca6a674aa
--- /dev/null
+++ b/types/preview/@ember/service/test/main.ts
@@ -0,0 +1,58 @@
+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 '';
+    },
+});
+
+class ThirdSvc extends Service.extend({
+    foo: 'bar',
+    third() {
+        return '';
+    },
+}) {}
+
+declare module '@ember/service' {
+    interface Registry {
+        first: FirstSvc;
+        second: InstanceType<typeof SecondSvc>;
+        third: ThirdSvc;
+    }
+}
+
+const ServiceTriplet = EmberObject.extend({
+    sFirst: inject('first'),
+    sSecond: inject('second'),
+    sThird: inject('third'),
+    unknownService: inject(),
+});
+
+const obj = ServiceTriplet.create();
+
+obj.get('sFirst'); // $ExpectType FirstSvc
+obj.get('sSecond').second(); // $ExpectType ""
+obj.get('sThird'); // $ExpectType ThirdSvc
+obj.get('unknownService'); // $ExpectType Service
+
+const ServiceTripletService = EmberObject.extend({
+    sFirst: service('first'),
+    sSecond: service('second'),
+    sThird: service('third'),
+    unknownService: service(),
+});
+
+const objService = ServiceTripletService.create();
+
+objService.get('sFirst'); // $ExpectType FirstSvc
+objService.get('sSecond').second(); // $ExpectType ""
+objService.get('sThird'); // $ExpectType ThirdSvc
+objService.get('unknownService'); // $ExpectType Service
diff --git a/types/preview/@ember/service/test/octane.ts b/types/preview/@ember/service/test/octane.ts
new file mode 100644
index 00000000000..e176dece15b
--- /dev/null
+++ b/types/preview/@ember/service/test/octane.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/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/template/-private/handlebars.d.ts b/types/preview/@ember/template/-private/handlebars.d.ts
new file mode 100644
index 00000000000..ac9a7eb6fb3
--- /dev/null
+++ b/types/preview/@ember/template/-private/handlebars.d.ts
@@ -0,0 +1,5 @@
+export class SafeString {
+  constructor(str: string);
+  toString(): string;
+  toHTML(): string;
+}
diff --git a/types/preview/@ember/template/ember__template-tests.ts b/types/preview/@ember/template/ember__template-tests.ts
new file mode 100644
index 00000000000..4ed95f22c74
--- /dev/null
+++ b/types/preview/@ember/template/ember__template-tests.ts
@@ -0,0 +1,15 @@
+import { SafeString } from '@ember/template/-private/handlebars';
+import { htmlSafe, isHTMLSafe } from '@ember/template';
+
+const handlebarsSafeString: SafeString = htmlSafe('lorem ipsum...');
+htmlSafe('lorem ipsum...'); // $ExpectType SafeString
+// @ts-expect-error
+const regularString: string = htmlSafe('lorem ipsum...');
+
+function isSafeTest(a: string | SafeString) {
+    if (isHTMLSafe(a)) {
+        a = a.toString();
+    }
+
+    a.toLowerCase();
+}
diff --git a/types/preview/@ember/template/index.d.ts b/types/preview/@ember/template/index.d.ts
new file mode 100644
index 00000000000..40a7f0c2408
--- /dev/null
+++ b/types/preview/@ember/template/index.d.ts
@@ -0,0 +1,11 @@
+// Type definitions for non-npm package @ember/template 4.0
+// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Ftemplate
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+import { SafeString } from './-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..b991607531e
--- /dev/null
+++ b/types/preview/@ember/test/adapter.d.ts
@@ -0,0 +1,20 @@
+/**
+ * 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/ember__test-tests.ts b/types/preview/@ember/test/ember__test-tests.ts
new file mode 100644
index 00000000000..5833196292c
--- /dev/null
+++ b/types/preview/@ember/test/ember__test-tests.ts
@@ -0,0 +1,42 @@
+import { registerWaiter, registerHelper, registerAsyncHelper } from '@ember/test';
+import TestAdapter from '@ember/test/adapter';
+
+const pending = 0;
+registerWaiter(() => pending !== 0);
+
+declare const MyDb: {
+    hasPendingTransactions(): boolean;
+};
+
+registerWaiter(MyDb, MyDb.hasPendingTransactions);
+// @ts-expect-error
+registerWaiter();
+
+registerHelper('boot', app => {
+    app.advanceReadiness(); // $ExpectType void
+    app.deferReadiness(); // $ExpectType void
+    app.register('foo', class {}); // $ExpectType void
+    // @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/types/preview/@ember/test/index.d.ts b/types/preview/@ember/test/index.d.ts
new file mode 100644
index 00000000000..d3a6c468f7a
--- /dev/null
+++ b/types/preview/@ember/test/index.d.ts
@@ -0,0 +1,55 @@
+// Type definitions for non-npm package @ember/test 4.0
+// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Ftest
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+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..a09307c2c40
--- /dev/null
+++ b/types/preview/@ember/utils/-private/types.d.ts
@@ -0,0 +1,36 @@
+import type { AnyFn } from 'ember/-private/type-utils';
+
+// 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: 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/ember__utils-tests.ts b/types/preview/@ember/utils/ember__utils-tests.ts
new file mode 100644
index 00000000000..5c9c0787704
--- /dev/null
+++ b/types/preview/@ember/utils/ember__utils-tests.ts
@@ -0,0 +1,145 @@
+/* eslint-disable no-new-wrappers */ // we have to test the new-wrappers!
+
+import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@ember/utils';
+
+(function () {
+  /** isNone */
+  const maybeUndefined: string | undefined = 'not actually undefined';
+  if (isNone(maybeUndefined)) {
+    return;
+  }
+  const anotherString = maybeUndefined + 'another string';
+  isNone(); // $ExpectType boolean
+  isNone(null); // $ExpectType boolean
+  isNone(undefined); // $ExpectType boolean
+  isNone(''); // $ExpectType boolean
+  isNone([]); // $ExpectType boolean
+  isNone(function () {}); // $ExpectType boolean
+})();
+
+(function () {
+  /** isPresent */
+  isPresent(); // $ExpectType boolean
+  isPresent(null); // $ExpectType boolean
+  isPresent(undefined); // $ExpectType boolean
+  isPresent(''); // $ExpectType boolean
+  isPresent('  '); // $ExpectType boolean
+  isPresent('\n\t'); // $ExpectType boolean
+  isPresent([]); // $ExpectType boolean
+  isPresent({ length: 0 }); // $ExpectType boolean
+  isPresent(false); // $ExpectType boolean
+  isPresent(true); // $ExpectType boolean
+  isPresent('string'); // $ExpectType boolean
+  isPresent(0); // $ExpectType boolean
+  isPresent(function () {}); // $ExpectType boolean
+  isPresent({}); // $ExpectType boolean
+  isPresent(false); // $ExpectType boolean
+  isPresent('\n\t Hello'); // $ExpectType boolean
+  isPresent([1, 2, 3]); // $ExpectType boolean
+})();
+
+(function () {
+  /** typeOf */
+  typeOf(null); // $ExpectType "null"
+  typeOf(undefined); // $ExpectType "undefined"
+  typeOf('michael'); // $ExpectType "string"
+  // tslint:disable-next-line:no-construct
+  typeOf(new String('michael')); // $ExpectType "string"
+  typeOf(101); // $ExpectType "number"
+  // tslint:disable-next-line:no-construct
+  typeOf(new Number(101)); // $ExpectType "number"
+  typeOf(true); // $ExpectType "boolean"
+  // tslint:disable-next-line:no-construct
+  typeOf(new Boolean(true)); // $ExpectType "boolean"
+  typeOf(() => 4); // $ExpectType "function"
+  typeOf([1, 2, 90]); // $ExpectType "array"
+  typeOf(/abc/); // $ExpectType "regexp"
+  typeOf(new Date()); // $ExpectType "date"
+  typeOf(new FileList()); // $ExpectType "filelist"
+  // typeOf(EmberObject.extend());   // $ExpectType "class"
+  // typeOf(EmberObject.create());   // $ExpectType "instance"
+  typeOf(new Error('teamocil')); // $ExpectType "error"
+  typeOf({ justAPojo: true }); // $ExpectType "object"
+
+  typeOf();
+  typeOf(null);
+  typeOf(undefined);
+  typeOf('michael');
+  // tslint:disable-next-line:no-construct
+  typeOf(new String('michael'));
+  typeOf(101);
+  // tslint:disable-next-line:no-construct
+  typeOf(new Number(101));
+  typeOf(true);
+  // tslint:disable-next-line:no-construct
+  typeOf(new Boolean(true));
+  typeOf(() => 4);
+  typeOf([1, 2, 90]);
+  typeOf(/abc/);
+  typeOf(new Date());
+  typeOf(FileList);
+  typeOf(new Error('teamocil'));
+})();
+
+(function () {
+  /** isEqual */
+  isEqual('foo', 'bar'); // $ExpectType boolean
+  isEqual(14, 37); // $ExpectType boolean
+  isEqual(14, '1'); // $ExpectType boolean
+  isEqual(
+    () => 4,
+    () => 37
+  ); // $ExpectType boolean
+  // @ts-expect-error
+  isEqual(14);
+  // @ts-expect-error
+  isEqual();
+})();
+
+(function () {
+  /** compare */
+  compare('foo', 'bar'); // $ExpectType number
+  compare(14, 37); // $ExpectType number
+  compare(class {}, class {}); // $ExpectType number
+  compare([], class {}); // $ExpectType number
+  compare([], undefined); // $ExpectType number
+  compare({}, () => 4); // $ExpectType number
+  // @ts-expect-error
+  compare(14);
+  // @ts-expect-error
+  compare();
+})();
+
+(function () {
+  /** isBlank */
+
+  isBlank(); // $ExpectType boolean
+  isBlank(null); // $ExpectType boolean
+  isBlank(undefined); // $ExpectType boolean
+  isBlank(''); // $ExpectType boolean
+  isBlank([]); // $ExpectType boolean
+  isBlank('\n\t'); // $ExpectType boolean
+  isBlank('  '); // $ExpectType boolean
+  isBlank({}); // $ExpectType boolean
+  isBlank('\n\t Hello'); // $ExpectType boolean
+  isBlank('Hello world'); // $ExpectType boolean
+  isBlank([1, 2, 3]); // $ExpectType boolean
+})();
+
+(function () {
+  /** isEmpty */
+
+  isEmpty(); // $ExpectType boolean
+  isEmpty(null); // $ExpectType boolean
+  isEmpty(undefined); // $ExpectType boolean
+  isEmpty(''); // $ExpectType boolean
+  isEmpty([]); // $ExpectType boolean
+  isEmpty({ size: 0 }); // $ExpectType boolean
+  isEmpty({}); // $ExpectType boolean
+  isEmpty('Adam Hawkins'); // $ExpectType boolean
+  isEmpty([0, 1, 2]); // $ExpectType boolean
+  isEmpty('\n\t'); // $ExpectType boolean
+  isEmpty('  '); // $ExpectType boolean
+  isEmpty({ size: 1 }); // $ExpectType boolean
+  isEmpty({ size: () => 0 }); // $ExpectType boolean
+})();
diff --git a/types/preview/@ember/utils/index.d.ts b/types/preview/@ember/utils/index.d.ts
new file mode 100644
index 00000000000..353be5f0e34
--- /dev/null
+++ b/types/preview/@ember/utils/index.d.ts
@@ -0,0 +1,49 @@
+// Type definitions for non-npm package @ember/utils 4.0
+// Project: https://api.emberjs.com/ember/3.16/modules/@ember%2Futils
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 Dan Freeman <https://github.com/dfreeman>
+//                 James C. Davis <https://github.com/jamescdavis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+import type { TypeOf } from './-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';
+export function typeOf(item: unknown): string;
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..a40275e657b
--- /dev/null
+++ b/types/preview/ember/-private/type-utils.d.ts
@@ -0,0 +1,52 @@
+// 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).
+declare 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..1d5ba10445c
--- /dev/null
+++ b/types/preview/ember/index.d.ts
@@ -0,0 +1,401 @@
+// Type definitions for Ember.js 4.0
+// Project: https://emberjs.com/, https://github.com/emberjs/ember
+// Definitions by: Chris Krycho <https://github.com/chriskrycho>
+//                 James C. Davis <https://github.com/jamescdavis>
+//                 Dan Freeman <https://github.com/dfreeman>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.4
+
+// Capitalization is intentional: this makes it much easier to re-export RSVP on
+// the Ember namespace.
+import Rsvp from 'rsvp';
+
+import { TemplateFactory } from 'htmlbars-inline-precompile';
+
+import { Registry as ServiceRegistry } from '@ember/service';
+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';
+// tslint:disable-next-line:no-duplicate-imports
+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 EmberObjectMixinNs from '@ember/object/mixin';
+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 _ContainerProxyMixin from '@ember/engine/-private/container-proxy-mixin';
+import _RegistryProxyMixin from '@ember/engine/-private/registry-proxy-mixin';
+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';
+// tslint:disable-next-line:no-duplicate-imports
+import * as EmberControllerNs from '@ember/controller';
+// tslint:disable-next-line:no-duplicate-imports
+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';
+import type EmberArrayProtoExtensions from '@ember/array/types/prototype-extensions';
+// @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 EmberRoutingTransition from '@ember/routing/transition';
+import EmberRoutingRouterService from '@ember/routing/router-service';
+import EmberRoutingHashLocation from '@ember/routing/hash-location';
+import EmberRoutingAutoLocation from '@ember/routing/auto-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';
+
+export namespace Ember {
+  const A: typeof EmberArrayNs.A;
+  const isArray: typeof EmberArrayNs.isArray;
+  type Enumerable<T> = EmberEnumerable<T>;
+  const Enumerable: typeof EmberEnumerable;
+  class ArrayProxy<T> extends EmberArrayProxy<T> {}
+  type Array<T> = EmberArray<T>;
+  const Array: typeof EmberArrayNs.default;
+  type MutableArray<T> = EmberMutableArray<T>;
+  const MutableArray: typeof EmberMutableArray;
+  type NativeArray<T> = EmberNativeArray<T>;
+  const NativeArray: typeof EmberNativeArray;
+  type MutableEnumerable<T> = EmberMutableEnumerable<T>;
+  const MutableEnumerable: typeof EmberMutableEnumerable;
+  class Router extends EmberRoutingRouter {}
+  class Route extends EmberRoutingRoute {}
+  const ActionHandler: typeof EmberActionHandler;
+  class Controller extends EmberControllerNs.default {}
+  class Component extends EmberComponent {}
+  class Helper extends EmberHelper {}
+
+  class HashLocation extends EmberRoutingHashLocation {}
+  class NoneLocation extends EmberRoutingNoneLocation {}
+  class HistoryLocation extends EmberRoutingHistoryLocation {}
+  const deprecateFunc: typeof EmberApplicationDeprecateNs.deprecateFunc;
+  const deprecate: typeof EmberApplicationDeprecateNs.deprecate;
+  const getOwner: typeof EmberApplicationNs.getOwner;
+  const setOwner: typeof EmberApplicationNs.setOwner;
+  class EventDispatcher extends EmberEventDispatcher {}
+  class Registry extends EmberRegistry {}
+  interface ArrayPrototypeExtensions<T> extends EmberArrayProtoExtensions<T> {}
+
+  /**
+   * Implements some standard methods for comparing objects. Add this mixin to
+   * any class you create that can compare its instances.
+   */
+  interface Comparable {
+    compare(a: unknown, b: unknown): number;
+  }
+  const Comparable: EmberMixin<Comparable>;
+  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 {}
+
+  // TODO: replace with a proper ES6 reexport once we remove declare module 'ember' {}
+  class Object extends EmberObjectNs.default {}
+  class ObjectProxy extends EmberObjectProxyNs.default {}
+  const Observable: typeof EmberObservable;
+  const PromiseProxyMixin: typeof EmberObjectPromiseProxyNs.default;
+  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;
+
+  class Mixin<T, Base = EmberObjectNs.default> extends EmberMixin<T, Base> {}
+
+  /**
+   * 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<ViewTargetActionSupport>;
+  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(): ComputedProperty<Controller>;
+    function controller<K extends keyof ControllerRegistry>(
+      name: K
+    ): ComputedProperty<ControllerRegistry[K]>;
+    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;
+  // TODO: replace with an es6 reexport when declare module 'ember' is removed
+  /**
+   * 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/test/access-modifier.ts b/types/preview/ember/test/access-modifier.ts
new file mode 100644
index 00000000000..3b3a27f6641
--- /dev/null
+++ b/types/preview/ember/test/access-modifier.ts
@@ -0,0 +1,42 @@
+/**
+ * Tests to ensure that access modifier keywords are appropriately
+ * respected and supported
+ */
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+
+class Foo extends Ember.Object {
+    hello() {
+        return 'world';
+    }
+    protected bar() {
+        return 'bar';
+    }
+    private baz() {
+        return 'baz';
+    }
+}
+const f = new Foo();
+assertType<string>(f.hello());
+// protected property should not be visible from outside of Foo
+// @ts-expect-error
+assertType<string>(f.bar());
+// private property should not be visible from outside of Foo
+// @ts-expect-error
+assertType<string>(f.baz());
+
+class Foo2 extends Ember.Object.extend({
+    bar: '',
+}) {
+    hello() {
+        return 'world';
+    }
+    // Cannot override with a mis-matched property type
+    // @ts-expect-error
+    protected bar() {
+        return 'bar';
+    }
+    private baz() {
+        return 'baz';
+    }
+}
diff --git a/types/preview/ember/test/application-instance.ts b/types/preview/ember/test/application-instance.ts
new file mode 100644
index 00000000000..e151828fa60
--- /dev/null
+++ b/types/preview/ember/test/application-instance.ts
@@ -0,0 +1,29 @@
+import ApplicationInstance from '@ember/application/instance';
+import hbs from 'htmlbars-inline-precompile';
+
+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('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/types/preview/ember/test/application.ts b/types/preview/ember/test/application.ts
new file mode 100755
index 00000000000..fcc65a70009
--- /dev/null
+++ b/types/preview/ember/test/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/types/preview/ember/test/array-ext.ts b/types/preview/ember/test/array-ext.ts
new file mode 100755
index 00000000000..50698a70292
--- /dev/null
+++ b/types/preview/ember/test/array-ext.ts
@@ -0,0 +1,21 @@
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+
+declare global {
+    interface Array<T> extends Ember.ArrayPrototypeExtensions<T> {}
+}
+
+class Person extends Ember.Object {
+    declare name: string;
+}
+
+const person = Person.create({ name: 'Joe' });
+const array = [person];
+
+assertType<number>(array.get('length'));
+assertType<Person | undefined>(array.get('firstObject'));
+assertType<string[]>(array.mapBy('name'));
+assertType<string[]>(array.map(p => p.get('name')));
+assertType<Person[]>(array.sortBy('name'));
+assertType<Person[]>(array.uniq());
+assertType<Person[]>(array.uniqBy('name'));
diff --git a/types/preview/ember/test/array-proxy.ts b/types/preview/ember/test/array-proxy.ts
new file mode 100644
index 00000000000..53b6ec7e0a9
--- /dev/null
+++ b/types/preview/ember/test/array-proxy.ts
@@ -0,0 +1,26 @@
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+
+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(idx: number): string {
+        return this.get('content').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>;
+assertType<number | undefined>(x.get('firstObject'));
+assertType<boolean>(x.isNew);
diff --git a/types/preview/ember/test/array.ts b/types/preview/ember/test/array.ts
new file mode 100755
index 00000000000..f4cbaae2d83
--- /dev/null
+++ b/types/preview/ember/test/array.ts
@@ -0,0 +1,50 @@
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+
+type Person = typeof Person.prototype;
+const Person = Ember.Object.extend({
+    name: '',
+    isHappy: false,
+});
+
+const people = Ember.A([
+    Person.create({ name: 'Yehuda', isHappy: true }),
+    Person.create({ name: 'Majd', isHappy: false }),
+]);
+
+assertType<number>(people.get('length'));
+assertType<Person>(people.get('lastObject'));
+assertType<boolean>(people.isAny('isHappy'));
+// @ts-expect-error
+assertType<boolean>(people.isAny('isHappy', 'false'));
+assertType<boolean>(people.isAny('isHappy', false));
+assertType<Ember.Enumerable<Person>>(people.filterBy('isHappy'));
+assertType<Ember.Enumerable<Person>>(people.rejectBy('isHappy'));
+assertType<Ember.Enumerable<Person>>(people.filter(person => person.get('name') === 'Yehuda'));
+assertType<typeof people>(people.get('[]'));
+assertType<Person>(people.get('[]').get('firstObject'));
+
+assertType<Ember.Array<boolean>>(people.mapBy('isHappy'));
+assertType<unknown[]>(people.mapBy('name.length'));
+
+const last = people.get('lastObject');
+if (last) {
+    assertType<string>(last.get('name'));
+}
+
+const first = people.get('lastObject');
+if (first) {
+    assertType<boolean>(first.get('isHappy'));
+}
+
+const letters: Ember.Enumerable<string> = Ember.A(['a', 'b', 'c']);
+const codes: number[] = letters.map((item, index, enumerable) => {
+    assertType<string>(item);
+    assertType<number>(index);
+    return item.charCodeAt(0);
+});
+
+const value = '1,2,3';
+const filters = Ember.A(value.split(','));
+filters.push('4');
+filters.sort();
diff --git a/types/preview/ember/test/component.ts b/types/preview/ember/test/component.ts
new file mode 100755
index 00000000000..925a2e7b451
--- /dev/null
+++ b/types/preview/ember/test/component.ts
@@ -0,0 +1,124 @@
+import Ember from 'ember';
+import Component from '@ember/component';
+import Object, { computed } from '@ember/object';
+import hbs from 'htmlbars-inline-precompile';
+import { assertType } from './lib/assert';
+
+Component.extend({
+    layout: hbs`
+        <div>
+          {{yield}}
+        </div>
+    `,
+});
+
+Component.extend({
+    layout: 'my-layout',
+});
+
+const MyComponent = Component.extend();
+assertType<string | string[]>(Ember.get(MyComponent, 'positionalParams'));
+
+const component1 = Component.extend({
+    actions: {
+        hello(name: string) {
+            console.log('Hello', name);
+        },
+    },
+});
+
+Component.extend({
+    name: '',
+    hello(name: string) {
+        this.set('name', name);
+    },
+});
+
+Component.extend({
+    tagName: 'em',
+});
+
+Component.extend({
+    classNames: ['my-class', 'my-other-class'],
+});
+
+Component.extend({
+    classNameBindings: ['propertyA', 'propertyB'],
+    propertyA: 'from-a',
+    propertyB: computed(function () {
+        if (!this.get('propertyA')) {
+            return 'from-b';
+        }
+    }),
+});
+
+Component.extend({
+    classNameBindings: ['hovered'],
+    hovered: true,
+});
+
+Component.extend({
+    classNameBindings: ['messages.empty'],
+    messages: Object.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(() => {
+        if ('someLogic') {
+            return true;
+        } else {
+            return false;
+        }
+    }),
+});
+
+Component.extend({
+    tagName: 'form',
+    attributeBindings: ['novalidate'],
+    novalidate: null,
+});
+
+Component.extend({
+    click(event: object) {
+        // will be called when an instance's
+        // rendered element is clicked
+    },
+});
diff --git a/types/preview/ember/test/computed.ts b/types/preview/ember/test/computed.ts
new file mode 100755
index 00000000000..8d5ff6f0eec
--- /dev/null
+++ b/types/preview/ember/test/computed.ts
@@ -0,0 +1,192 @@
+import Ember from 'ember';
+import Component from '@ember/component';
+import Computed, { alias, or } from '@ember/object/computed';
+import { assertType } from './lib/assert';
+
+const Person = Ember.Object.extend({
+    firstName: '',
+    lastName: '',
+    age: 0,
+
+    noArgs: Ember.computed<string>(() => 'test'),
+
+    fullName: Ember.computed<string>('firstName', 'lastName', function () {
+        return `${this.get('firstName')} ${this.get('lastName')}`;
+    }),
+
+    fullNameReadonly: Ember.computed<string>('fullName', function () {
+        return this.get('fullName');
+    }).readOnly(),
+
+    fullNameWritable: Ember.computed<string>('firstName', 'lastName', {
+        get() {
+            return this.get('fullName');
+        },
+        set(key, value) {
+            const [first, last] = value.split(' ');
+            this.set('firstName', first);
+            this.set('lastName', last);
+            return value;
+        },
+    }),
+
+    fullNameGetOnly: Ember.computed<string>('fullName', {
+        get() {
+            return this.get('fullName');
+        },
+    }),
+
+    fullNameSetOnly: Ember.computed<string>('firstName', 'lastName', {
+        set(key, value) {
+            const [first, last] = value.split(' ');
+            this.set('firstName', first);
+            this.set('lastName', last);
+            return value;
+        },
+    }),
+
+    combinators: Ember.computed<string>(function () {
+        return this.get('firstName');
+    })
+        .property('firstName')
+        .meta({ foo: 'bar' })
+        .volatile()
+        .readOnly(),
+
+    explicitlyDeclared: alias('fullName') as Computed<string>,
+});
+
+const person = Person.create({
+    firstName: 'Fred',
+    lastName: 'Smith',
+    age: 29,
+});
+
+assertType<string>(person.firstName);
+assertType<number>(person.age);
+assertType<Ember.ComputedProperty<string>>(person.noArgs);
+assertType<Ember.ComputedProperty<string>>(person.fullName);
+assertType<Ember.ComputedProperty<string>>(person.fullNameReadonly);
+assertType<Ember.ComputedProperty<string>>(person.fullNameWritable);
+assertType<Ember.ComputedProperty<string>>(person.fullNameGetOnly);
+assertType<Ember.ComputedProperty<string>>(person.fullNameSetOnly);
+assertType<Ember.ComputedProperty<string>>(person.combinators);
+assertType<Ember.ComputedProperty<string>>(person.explicitlyDeclared);
+
+assertType<string>(person.get('firstName'));
+assertType<number>(person.get('age'));
+assertType<string>(person.get('noArgs'));
+assertType<string>(person.get('fullName'));
+assertType<string>(person.get('fullNameReadonly'));
+assertType<string>(person.get('fullNameWritable'));
+assertType<string>(person.get('fullNameGetOnly'));
+assertType<string>(person.get('fullNameSetOnly'));
+assertType<string>(person.get('combinators'));
+assertType<string>(person.get('explicitlyDeclared'));
+
+assertType<{ firstName: string; fullName: string; age: number }>(person.getProperties('firstName', 'fullName', 'age'));
+
+const person2 = Person.create({
+    fullName: 'Fred Smith',
+});
+
+assertType<string>(person2.get('firstName'));
+assertType<string>(person2.get('fullName'));
+
+const person3 = Person.extend({
+    firstName: 'Fred',
+    fullName: 'Fred Smith',
+}).create();
+
+assertType<string>(person3.get('firstName'));
+assertType<string>(person3.get('fullName'));
+
+const person4 = Person.extend({
+    firstName: Ember.computed(() => 'Fred'),
+    fullName: Ember.computed(() => 'Fred Smith'),
+}).create();
+
+assertType<string>(person4.get('firstName'));
+assertType<string>(person4.get('fullName'));
+
+// computed property macros
+const objectWithComputedProperties = Ember.Object.extend({
+    alias: Ember.computed.alias('foo'),
+    and: Ember.computed.and('foo', 'bar', 'baz', 'qux'),
+    bool: Ember.computed.bool('foo'),
+    collect: Ember.computed.collect('foo', 'bar', 'baz', 'qux'),
+    deprecatingAlias: Ember.computed.deprecatingAlias('foo', {
+        id: 'hamster.deprecate-banana',
+        until: '3.0.0',
+    }),
+    empty: Ember.computed.empty('foo'),
+    equalNumber: Ember.computed.equal('foo', 1),
+    equalString: Ember.computed.equal('foo', 'bar'),
+    equalObject: Ember.computed.equal('foo', {}),
+    filter: Ember.computed.filter('foo', item => item === 'bar'),
+    filterBy1: Ember.computed.filterBy('foo', 'bar'),
+    filterBy2: Ember.computed.filterBy('foo', 'bar', false),
+    gt: Ember.computed.gt('foo', 3),
+    gte: Ember.computed.gte('foo', 3),
+    intersect: Ember.computed.intersect('foo', 'bar', 'baz', 'qux'),
+    lt: Ember.computed.lt('foo', 3),
+    lte: Ember.computed.lte('foo', 3),
+    map: Ember.computed.map('foo', (item, index) => item),
+    mapBy: Ember.computed.mapBy('foo', 'bar'),
+    match: Ember.computed.match('foo', /^tom.ter$/),
+    max: Ember.computed.max('foo'),
+    min: Ember.computed.min('foo'),
+    none: Ember.computed.none('foo'),
+    not: Ember.computed.not('foo'),
+    notEmpty: Ember.computed.notEmpty('foo'),
+    oneWay: Ember.computed.oneWay('foo'),
+    or: Ember.computed.or('foo', 'bar', 'baz', 'qux'),
+    readOnly: Ember.computed.readOnly('foo'),
+    reads: Ember.computed.reads('foo'),
+    setDiff: Ember.computed.setDiff('foo', 'bar'),
+    sort1: Ember.computed.sort('foo', 'bar'),
+    sort2: Ember.computed.sort('foo', (itemA, itemB) => {
+        return `${itemA}`.length - `${itemB}`.length;
+    }),
+    sum: Ember.computed.sum('foo'),
+    union: Ember.computed.union('foo', 'bar', 'baz', 'qux'),
+    uniq: Ember.computed.uniq('foo'),
+    uniqBy: Ember.computed.uniqBy('foo', 'bar'),
+}).create();
+
+assertType<unknown>(objectWithComputedProperties.get('alias'));
+assertType<unknown>(objectWithComputedProperties.get('and'));
+assertType<boolean>(objectWithComputedProperties.get('bool'));
+assertType<unknown[]>(objectWithComputedProperties.get('collect'));
+assertType<unknown>(objectWithComputedProperties.get('deprecatingAlias'));
+assertType<boolean>(objectWithComputedProperties.get('empty'));
+assertType<boolean>(objectWithComputedProperties.get('equalNumber'));
+assertType<boolean>(objectWithComputedProperties.get('equalString'));
+assertType<boolean>(objectWithComputedProperties.get('equalObject'));
+assertType<unknown[]>(objectWithComputedProperties.get('filter'));
+assertType<unknown[]>(objectWithComputedProperties.get('filterBy1'));
+assertType<unknown[]>(objectWithComputedProperties.get('filterBy2'));
+assertType<boolean>(objectWithComputedProperties.get('gt'));
+assertType<boolean>(objectWithComputedProperties.get('gte'));
+assertType<unknown[]>(objectWithComputedProperties.get('intersect'));
+assertType<boolean>(objectWithComputedProperties.get('lt'));
+assertType<boolean>(objectWithComputedProperties.get('lte'));
+assertType<unknown[]>(objectWithComputedProperties.get('map'));
+assertType<unknown[]>(objectWithComputedProperties.get('mapBy'));
+assertType<boolean>(objectWithComputedProperties.get('match'));
+assertType<number>(objectWithComputedProperties.get('max'));
+assertType<number>(objectWithComputedProperties.get('min'));
+assertType<boolean>(objectWithComputedProperties.get('none'));
+assertType<boolean>(objectWithComputedProperties.get('not'));
+assertType<boolean>(objectWithComputedProperties.get('notEmpty'));
+assertType<unknown>(objectWithComputedProperties.get('oneWay'));
+assertType<unknown>(objectWithComputedProperties.get('or'));
+assertType<unknown>(objectWithComputedProperties.get('readOnly'));
+assertType<unknown>(objectWithComputedProperties.get('reads'));
+assertType<unknown[]>(objectWithComputedProperties.get('setDiff'));
+assertType<unknown[]>(objectWithComputedProperties.get('sort1'));
+assertType<unknown[]>(objectWithComputedProperties.get('sort2'));
+assertType<number>(objectWithComputedProperties.get('sum'));
+assertType<unknown[]>(objectWithComputedProperties.get('union'));
+assertType<unknown[]>(objectWithComputedProperties.get('uniq'));
+assertType<unknown[]>(objectWithComputedProperties.get('uniqBy'));
diff --git a/types/preview/ember/test/controller.ts b/types/preview/ember/test/controller.ts
new file mode 100755
index 00000000000..208babb8fd1
--- /dev/null
+++ b/types/preview/ember/test/controller.ts
@@ -0,0 +1,11 @@
+import Controller from '@ember/controller';
+
+Controller.extend({
+    queryParams: ['category'],
+    category: null,
+    isExpanded: false,
+
+    toggleBody() {
+        this.toggleProperty('isExpanded');
+    },
+});
diff --git a/types/preview/ember/test/core-object.ts b/types/preview/ember/test/core-object.ts
new file mode 100644
index 00000000000..df469143166
--- /dev/null
+++ b/types/preview/ember/test/core-object.ts
@@ -0,0 +1,218 @@
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+
+/** Newable tests */
+const co1 = new Ember.CoreObject();
+
+// TODO: Enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+// co1.concatenatedProperties; // $ExpectType string[]
+co1.isDestroyed; // $ExpectType boolean
+co1.isDestroying; // $ExpectType boolean
+co1.destroy(); // $ExpectType CoreObject
+co1.toString(); // $ExpectType string
+
+/** .create tests */
+const co2 = Ember.CoreObject.create();
+// TODO: Enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+// co2.concatenatedProperties; // $ExpectType string[]
+co2.isDestroyed; // $ExpectType boolean
+co2.isDestroying; // $ExpectType boolean
+co2.destroy(); // $ExpectType CoreObject
+co2.toString(); // $ExpectType string
+
+/** .create tests w/ initial instance data passed in */
+const co3 = Ember.CoreObject.create({ foo: '123', bar: 456 });
+
+co3.foo; // $ExpectType string
+co3.bar; // $ExpectType number
+
+/** .extend with a zero-argument .create()  */
+const co4 = Ember.CoreObject.extend({
+    foo: '123',
+    bar: 456,
+    baz(): [string, number] {
+        return [this.foo, this.bar];
+    },
+}).create();
+
+co4.foo; // $ExpectType string
+co4.bar; // $ExpectType number
+co4.baz; // $ExpectType () => [string, number]
+
+/** .extend with inconsistent arguments passed into .create()  */
+const class05 = Ember.CoreObject.extend({
+    foo: '123' as string | boolean,
+    bar: 456,
+    baz() {
+        return [this.foo, this.bar];
+    },
+});
+// @ts-expect-error
+const c05 = class05.create({ foo: 99 });
+const c05b = class05.create({ foo: true });
+const c05c = class05.create({ foo: 'abc' });
+// @ts-expect-error
+assertType<string>(c05b.foo);
+// @ts-expect-error
+assertType<boolean>(c05c.foo);
+
+/** two .extend arguments with a zero-argument .create() */
+const co6 = Ember.CoreObject.extend(
+    {
+        foo: '123',
+        bar: 456,
+        baz() {
+            return [this.foo, this.bar];
+        },
+        func1() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.foo; // $ExpectType string
+            // this does not include stuff from later extend args
+            // @ts-expect-error
+            this.bee;
+        },
+    },
+    {
+        foo: 99,
+        bee: 'honey',
+        func2() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+            this.foo;
+            // this includes stuff from earlier extend-args
+            this.bar; // $ExpectType number
+        },
+    },
+).create();
+
+// TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+// assertType<string>(co6.foo); // @ts-expect-error
+assertType<number>(co6.bar); // $ExpectType number
+assertType<() => Array<string | number>>(co6.baz); // $ExpectType () => (string | number)[]
+
+/** three .extend arguments with a zero-argument .create() */
+const co7 = Ember.CoreObject.extend(
+    {
+        foo: '123',
+        bar: 456,
+        baz() {
+            return [this.foo, this.bar];
+        },
+        func1() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.foo; // $ExpectType string
+            // this does not include stuff from later extend args
+            // @ts-expect-error
+            this.bee;
+        },
+    },
+    {
+        foo: 99,
+        bee: 'honey',
+        func2() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+            this.foo;
+            // this includes stuff from earlier extend-args
+            this.bar; // $ExpectType number
+        },
+    },
+    {
+        foo: '99',
+        money: 'in the banana stand',
+        func3() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.money; // $ExpectType string
+            // this includes stuff from earlier extend-args
+            this.bee; // $ExpectType string
+            this.bar; // $ExpectType number
+        },
+    },
+).create();
+// TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+// assertType<number>(co7.foo); // @ts-expect-error
+assertType<number>(co7.bar); // $ExpectType number
+assertType<string>(co7.money); // $ExpectType string
+assertType<() => Array<string | number>>(co7.baz); // $ExpectType () => (string | number)[]
+
+/** four .extend arguments with a zero-argument .create() */
+const co8 = Ember.CoreObject.extend(
+    {
+        foo: '123',
+        bar: 456,
+        baz() {
+            return [this.foo, this.bar];
+        },
+        func1() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.foo; // $ExpectType string
+            // this does not include stuff from later extend args
+            // @ts-expect-error
+            this.bee;
+        },
+    },
+    {
+        foo: 99,
+        bee: 'honey',
+        func2() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+            this.foo;
+            // this includes stuff from earlier extend-args
+            this.bar; // $ExpectType number
+            // this does not include stuff from later extend args
+            // @ts-expect-error
+            this.money;
+        },
+    },
+    {
+        foo: '99',
+        money: 'in the banana stand',
+        func3() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.money; // $ExpectType string
+            // this includes stuff from earlier extend-args
+            this.bee; // $ExpectType string
+            this.bar; // $ExpectType number
+            // this does not include stuff from later extend args
+            // @ts-expect-error
+            this.neighborhood;
+        },
+    },
+    {
+        foo: '99',
+        neighborhood: 'sudden valley',
+        func4() {
+            // this includes stuff from CoreObject
+            this.init; // $ExpectType () => void
+            // this includes stuff from this extend-arg
+            this.neighborhood; // $ExpectType string
+            // this includes stuff from earlier extend-args
+            this.bee; // $ExpectType string
+            this.bar; // $ExpectType number
+            this.money; // $ExpectType string
+        },
+    },
+).create();
+
+// TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+// assertType<number>(co8.foo); // @ts-expect-error
+assertType<number>(co8.bar); // $ExpectType number
+assertType<string>(co8.money); // $ExpectType string
+assertType<() => Array<string | number>>(co8.baz); // $ExpectType () => (string | number)[]
diff --git a/types/preview/ember/test/create-negative.ts b/types/preview/ember/test/create-negative.ts
new file mode 100644
index 00000000000..ff86313e31a
--- /dev/null
+++ b/types/preview/ember/test/create-negative.ts
@@ -0,0 +1,14 @@
+import { assertType } from './lib/assert';
+import Ember from 'ember';
+import { PersonWithNumberName, Person } from './create';
+
+// @ts-expect-error
+Person.create({ firstName: 99 });
+// @ts-expect-error
+Person.create({}, { firstName: 99 });
+// @ts-expect-error
+Person.create({}, {}, { firstName: 99 });
+
+const p4 = new PersonWithNumberName();
+
+// assertType<Ember.ComputedProperty<string, string>>(p4.fullName); // @ts-expect-error
diff --git a/types/preview/ember/test/create.ts b/types/preview/ember/test/create.ts
new file mode 100755
index 00000000000..2412309691f
--- /dev/null
+++ b/types/preview/ember/test/create.ts
@@ -0,0 +1,55 @@
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+import { UnwrapComputedPropertyGetter } from "@ember/object/-private/types";
+
+/**
+ * Zero-argument case
+ */
+const o = Ember.Object.create();
+// create returns an object
+assertType<object>(o);
+// object returned by create type-checks as an instance of Ember.Object
+assertType<boolean>(o.isDestroyed); // from instance
+assertType<boolean>(o.isDestroying); // from instance
+assertType<<K extends keyof Ember.Object>(key: K) => UnwrapComputedPropertyGetter<Ember.Object[K]>>(o.get); // from prototype
+
+/**
+ * One-argument case
+ */
+const o1 = Ember.Object.create({ x: 9, y: 'hello', z: false });
+assertType<number>(o1.x);
+assertType<string>(o1.y);
+o1.y; // $ExpectType string
+o1.z; // $ExpectType boolean
+
+const obj = Ember.Object.create({ a: 1 }, { b: 2 }, { c: 3 });
+assertType<number>(obj.b);
+assertType<number>(obj.a);
+assertType<number>(obj.c);
+
+export class Person extends Ember.Object.extend({
+    fullName: Ember.computed('firstName', 'lastName', function () {
+        return [this.firstName + this.lastName].join(' ');
+    }),
+}) {
+    declare firstName: string;
+    declare lastName: string;
+    declare age: number;
+}
+const p = new Person();
+
+assertType<string>(p.firstName);
+assertType<Ember.ComputedProperty<string>>(p.fullName);
+assertType<string>(p.get('fullName'));
+
+const p2 = Person.create({ firstName: 'string' });
+const p2b = Person.create({}, { firstName: 'string' });
+const p2c = Person.create({}, {}, { firstName: 'string' });
+
+export class PersonWithNumberName extends Person.extend({
+    fullName: 6,
+}) {}
+
+const p4 = new PersonWithNumberName();
+assertType<string>(p4.firstName);
+assertType<number>(p4.fullName);
diff --git a/types/preview/ember/test/data-adapter.ts b/types/preview/ember/test/data-adapter.ts
new file mode 100644
index 00000000000..a77e6b66a14
--- /dev/null
+++ b/types/preview/ember/test/data-adapter.ts
@@ -0,0 +1,59 @@
+import Ember from 'ember';
+
+const da = Ember.DataAdapter.create();
+
+const filters = da.getFilters();
+filters.includes({ name: 'foo', desc: 'bar' }); // $ExpectType boolean
+// @ts-expect-error
+filters.includes({});
+
+filters[0].name; // $ExpectType string
+filters[0].desc; // $ExpectType string
+
+// $ExpectType () => void
+da.watchModelTypes(
+    function added(wrappedTypes) {
+        wrappedTypes;
+        wrappedTypes[0].release; // $ExpectType () => void
+        wrappedTypes[0].type.columns[0].desc; // $ExpectType string
+        wrappedTypes[0].type.columns[0].name; // $ExpectType string
+        wrappedTypes[0].type.count; // $ExpectType number
+        wrappedTypes[0].type.name; // $ExpectType string
+    },
+    function updated(wrappedTypes) {
+        wrappedTypes;
+        wrappedTypes[0].release; // $ExpectType () => void
+        wrappedTypes[0].type.columns[0].desc; // $ExpectType string
+        wrappedTypes[0].type.columns[0].name; // $ExpectType string
+        wrappedTypes[0].type.count; // $ExpectType number
+        wrappedTypes[0].type.name; // $ExpectType string
+    },
+);
+// @ts-expect-error
+da.watchModelTypes(() => {});
+
+// $ExpectType () => void
+da.watchRecords(
+    'house',
+    function added(records) {
+        records[0].object; // $ExpectType object
+        records[0].columnValues; // $ExpectType object
+    },
+    function updated(records) {
+        records[0].object; // $ExpectType object
+        records[0].columnValues; // $ExpectType object
+    },
+    function removed(idx, count) {
+        idx; // $ExpectType number
+        count; // $ExpectType number
+    },
+);
+// @ts-expect-error
+da.watchRecords(() => {});
+
+da.acceptsModelName; // $ExpectType boolean
+da.containerDebugAdapter; // $ExpectType ContainerDebugAdapter
+
+const ca: Ember.ContainerDebugAdapter = da.containerDebugAdapter;
+ca.canCatalogEntriesByType('controller'); // $ExpectType boolean
+ca.catalogEntriesByType('controller'); // $ExpectType string[]
diff --git a/types/preview/ember/test/debug.ts b/types/preview/ember/test/debug.ts
new file mode 100644
index 00000000000..5220e793301
--- /dev/null
+++ b/types/preview/ember/test/debug.ts
@@ -0,0 +1,99 @@
+import Ember from 'ember';
+
+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();
+runInDebug(() => console.log('Should not show up in prod')); // $ExpectType void
+
+// Log a warning if we have more than 3 tomsters
+const tomsterCount = 2;
+// @ts-expect-error
+warn('Too many tomsters!');
+warn('Too many tomsters!', { id: 'some-warning' }); // $ExpectType void
+// @ts-expect-error
+warn('Too many tomsters!', tomsterCount <= 3);
+warn('Too many tomsters!', tomsterCount <= 3, { id: 'some-warning' }); // $ExpectType void
+// $ExpectType void
+warn('Too many tomsters!', tomsterCount <= 3, {
+    id: 'ember-debug.too-many-tomsters',
+});
+
+// @ts-expect-error
+debug();
+debug('Too many tomsters!'); // $ExpectType void
+// @ts-expect-error
+debug('Too many tomsters!', 'foo');
+
+// next is not called, so no warnings get the default behavior
+// @ts-expect-error
+registerWarnHandler();
+registerWarnHandler(() => {}); // $ExpectType void
+registerWarnHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; } | undefined
+    next; // $ExpectType (message: string, options?: { id: string; } | undefined) => void
+});
+registerWarnHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; } | undefined
+    // @ts-expect-error
+    next();
+});
+registerWarnHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; } | undefined
+    next(message); // $ExpectType void
+});
+registerWarnHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; } | undefined
+    next(message, options); // $ExpectType void
+});
+
+// next is not called, so no warnings get the default behavior
+// @ts-expect-error
+registerDeprecationHandler();
+registerDeprecationHandler(() => {}); // $ExpectType void
+registerDeprecationHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; until: string; } | undefined
+    next; // $ExpectType (message: string, options?: { id: string; until: string; } | undefined) => void
+});
+registerDeprecationHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; until: string; } | undefined
+    // @ts-expect-error
+    next();
+});
+registerDeprecationHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; until: string; } | undefined
+    next(message); // $ExpectType void
+});
+registerDeprecationHandler((message, options, next) => { // $ExpectType void
+    message; // $ExpectType string
+    options; // $ExpectType { id: string; until: string; } | undefined
+    next(message, options); // $ExpectType void
+});
+
+// Test for truthiness
+const str: unknown = 'hello';
+assert('Must pass a string', typeof str === 'string');
+str; // $ExpectType string
+
+// Fail unconditionally
+// This has to be last because `assert never` will raise TS's checks for
+// unreachable code.
+assert('This code path should never be run'); // $ExpectType never
diff --git a/types/preview/ember/test/ember-module-tests.ts b/types/preview/ember/test/ember-module-tests.ts
new file mode 100644
index 00000000000..63e49dc2c40
--- /dev/null
+++ b/types/preview/ember/test/ember-module-tests.ts
@@ -0,0 +1,295 @@
+import Ember from 'ember';
+
+const top = (<T>(x?: T): T => x!)();
+type Top = typeof top;
+declare function expectTypeNativeArrayTop(x: Ember.NativeArray<Top>): void;
+// A
+expectTypeNativeArrayTop(Ember.A());
+Ember.A([1, 2]); // $ExpectType 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 });
+o1.a; // $ExpectType number
+o1.b; // $ExpectType number
+// @ts-expect-error
+o1.c;
+// Ember.bind // @ts-expect-error
+// cacheFor
+Ember.cacheFor({ a: 123 }, 'a'); // $ExpectType number | undefined
+// @ts-expect-error
+Ember.cacheFor({ a: 123 }, 'x');
+// compare
+Ember.compare('31', '114'); // $ExpectType 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
+Ember.get({ z: 23 }, 'z'); // $ExpectType number
+Ember.get({ z: 23 }, 'zz'); // $ExpectType unknown
+// getEngineParent
+Ember.getEngineParent(new Ember.EngineInstance()); // $ExpectType EngineInstance
+// getOwner
+Ember.getOwner(new Ember.Component()); // $ExpectType Owner
+// getProperties
+Ember.getProperties({ z: 23 }, 'z').z; // $ExpectType number
+Ember.getProperties({ z: 23 }, 'z', 'z').z; // $ExpectType number
+// @ts-expect-error
+Ember.getProperties({ z: 23 }, 'z', 'a').z;
+Ember.getProperties({ z: 23 }, ['z', 'z']).z; // $ExpectType number
+// @ts-expect-error
+Ember.getProperties({ z: 23 }, ['z', 'a']).z;
+
+// guidFor
+Ember.guidFor({}); // $ExpectType string
+Ember.guidFor(''); // $ExpectType string
+// isArray
+Ember.isArray(''); // $ExpectType boolean
+Ember.isArray([]); // $ExpectType boolean
+// isBlank
+Ember.isBlank(''); // $ExpectType boolean
+Ember.isBlank([]); // $ExpectType boolean
+// isEmpty
+Ember.isEmpty(''); // $ExpectType boolean
+Ember.isEmpty([]); // $ExpectType boolean
+// isEqual
+Ember.isEqual('', 'foo'); // $ExpectType boolean
+Ember.isEqual([], ''); // $ExpectType boolean
+// isNone
+Ember.isNone(''); // $ExpectType boolean
+Ember.isNone([]); // $ExpectType boolean
+// isPresent
+Ember.isPresent(''); // $ExpectType boolean
+Ember.isPresent([]); // $ExpectType boolean
+// observer
+const o2 = Ember.Object.extend({
+    name: 'foo',
+    age: 3,
+    nameWatcher: Ember.observer('name', () => {}),
+    nameWatcher2: Ember.observer('name', 'fullName', () => {}),
+});
+// on
+const o3 = Ember.Object.extend({
+    name: 'foo',
+    nameWatcher: Ember.on('init', () => {}),
+    nameWatcher2: Ember.on('destroy', () => {}),
+});
+// 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
+Ember.sendEvent(o2, 'clicked', [1, 2]); // $ExpectType boolean
+// set
+Ember.set(o2.create(), 'name', 'bar'); // $ExpectType string
+Ember.set(o2.create(), 'age', 4); // $ExpectType number
+// @ts-expect-error
+Ember.set(o2.create(), 'nam', 'bar');
+// setOwner
+declare let app: Ember.ApplicationInstance;
+Ember.setOwner(o2.create(), app);
+// setProperties
+Ember.setProperties(o2.create(), { name: 'bar' }).name; // $ExpectType string
+// trySet
+Ember.trySet(o2, 'nam', ''); // $ExpectType any
+// typeOf
+Ember.typeOf(''); // $ExpectType "string"
+Ember.typeOf(Ember.A()); // $ExpectType "array"
+// warn
+// @ts-expect-error
+Ember.warn('be caseful!');
+Ember.warn('be caseful!', { id: 'some-warning' });
+// VERSION
+Ember.VERSION; // $ExpectType 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
+new Ember.Application(); // $ExpectType Application
+Ember.Application.create(); // $ExpectType Application
+// Ember.ApplicationInstance
+new Ember.ApplicationInstance(); // $ExpectType ApplicationInstance
+Ember.ApplicationInstance.create(); // $ExpectType ApplicationInstance
+// TODO: Ember.ApplicationInstance.BootOptions
+// Ember.Array
+const a1: Ember.Array<string> = [];
+// @ts-expect-error
+const a2: Ember.Array<string> = {};
+// Ember.ArrayProxy
+new Ember.ArrayProxy<number>([3, 3, 2]); // $ExpectType 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();
+// Ember.ComputedProperty
+const cp: Ember.ComputedProperty<string, string> = Ember.computed('foo', {
+    get(): string {
+        return '';
+    },
+    set(_key: string, newVal: string): string {
+        return '';
+    },
+});
+// Ember.ContainerDebugAdapter
+const cda = new Ember.ContainerDebugAdapter(); // $ExpectType ContainerDebugAdapter
+// Ember.Controller
+const con = new Ember.Controller(); // $ExpectType Controller
+// Ember.CoreObject
+const co = new Ember.CoreObject(); // $ExpectType CoreObject
+// Ember.DataAdapter
+const da = new Ember.DataAdapter(); // $ExpectType 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
+const oe1 = Ember.Object.extend(Ember.Evented).create();
+oe1.trigger('foo');
+oe1.on('bar', () => {});
+oe1.on('bar', { foo() {} }, () => {});
+// Ember.HashLocation
+const hl = new Ember.HashLocation(); // $ExpectType HashLocation
+// Ember.Helper
+const h1 = Ember.Helper.extend({
+    compute() {
+        this.recompute();
+        return '';
+    },
+});
+// Ember.HistoryLocation
+const hil = new Ember.HistoryLocation(); // $ExpectType HistoryLocation
+// Ember.Mixin
+Ember.Object.extend(Ember.Mixin.create({ foo: 'bar' }), {
+    baz() {
+        this.foo; // $ExpectType string
+    },
+});
+// Ember.MutableArray
+const ma1: Ember.MutableArray<string> = ['money', 'in', 'the', 'bananna', 'stand'];
+ma1.addObject('!'); // $ExpectType string
+// @ts-expect-error
+ma1.filterBy('');
+ma1.firstObject; // $ExpectType string | undefined
+ma1.lastObject; // $ExpectType string | undefined
+const ma2: Ember.MutableArray<{ name: string }> = [{ name: 'chris' }, { name: 'dan' }, { name: 'james' }];
+ma2.filterBy('name', 'chris'); // $ExpectType NativeArray<{ name: string; }>
+// Ember.MutableEnumerable
+const me1: Ember.MutableEnumerable<string | null | undefined> = ['foo', undefined, null];
+me1.compact(); // $ExpectType NativeArray<string>
+// Ember.Namespace
+const myNs = Ember.Namespace.extend({});
+// Ember.NativeArray
+const na: Ember.NativeArray<number> = Ember.A([2, 3, 4]);
+na; // $ExpectType NativeArray<number>
+na.clear(); // $ExpectType NativeArray<number>
+// Ember.NoneLocation
+new Ember.NoneLocation(); // $ExpectType NoneLocation
+// Ember.Object
+new Ember.Object();
+// Ember.ObjectProxy
+new Ember.ObjectProxy(); // $ExpectType ObjectProxy
+// Ember.Observable
+Ember.Object.extend(Ember.Observable, {});
+// Ember.PromiseProxyMixin
+Ember.Object.extend(Ember.PromiseProxyMixin, {
+    foo() {
+        this.reason; // $ExpectType unknown
+        this.isPending; // $ExpectType 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
+Ember.String.htmlSafe('foo'); // $ExpectType SafeString
+// isHTMLSafe
+Ember.String.isHTMLSafe('foo'); // $ExpectType boolean
+// Ember.Test
+Ember.Test.checkWaiters(); // $ExpectType 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/types/preview/ember/test/ember-tests.ts b/types/preview/ember/test/ember-tests.ts
new file mode 100755
index 00000000000..493d98f9c82
--- /dev/null
+++ b/types/preview/ember/test/ember-tests.ts
@@ -0,0 +1,190 @@
+import Ember from 'ember';
+import { AnyFn } from 'ember/-private/type-utils';
+import { assertType } from './lib/assert';
+
+let App: any;
+
+App = Ember.Application.create();
+App.president = Ember.Object.create({
+  name: 'Barack Obama',
+});
+App.country = Ember.Object.create({
+  presidentNameBinding: 'MyApp.president.name',
+});
+App.country.get('presidentName');
+App.president = Ember.Object.create({
+  firstName: 'Barack',
+  lastName: 'Obama',
+  fullName: Ember.computed(function () {
+    return `${this.get('firstName')} ${this.get('lastName')}`;
+  }),
+});
+App.president.get('fullName');
+
+declare class MyPerson extends Ember.Object {
+  static createMan(): MyPerson;
+}
+MyPerson.createMan();
+
+const Person1 = Ember.Object.extend({
+  say: (thing: string) => {
+    alert(thing);
+  },
+});
+
+declare class MyPerson2 extends Ember.Object {
+  helloWorld(): void;
+}
+MyPerson2.create().helloWorld();
+
+const tom = Person1.create({
+  name: 'Tom Dale',
+  helloWorld() {
+    this.say('Hi my name is ' + this.get('name'));
+  },
+});
+tom.helloWorld();
+
+const PersonReopened = Person1.reopen({ isPerson: true });
+PersonReopened.create().get('isPerson');
+
+App.todosController = Ember.Object.create({
+  todos: [Ember.Object.create({ isDone: false })],
+  remaining: Ember.computed('todos.@each.isDone', function () {
+    const todos = this.get('todos');
+    return todos.filterProperty('isDone', false).get('length');
+  }),
+});
+
+const todos = App.todosController.get('todos');
+let todo = todos.objectAt(0);
+todo.set('isDone', true);
+App.todosController.get('remaining');
+todo = Ember.Object.create({ isDone: false });
+todos.pushObject(todo);
+App.todosController.get('remaining');
+
+App.wife = Ember.Object.create({
+  householdIncome: 80000,
+});
+App.husband = Ember.Object.create({
+  householdIncomeBinding: 'App.wife.householdIncome',
+});
+App.husband.get('householdIncome');
+App.husband.set('householdIncome', 90000);
+App.wife.get('householdIncome');
+
+App.user = Ember.Object.create({
+  fullName: 'Kara Gates',
+});
+App.user.set('fullName', 'Krang Gates');
+App.userView.set('userName', 'Truckasaurus Gates');
+App.user.get('fullName');
+
+App = Ember.Application.create({
+  rootElement: '#sidebar',
+});
+
+App.userController = Ember.Object.create({
+  content: Ember.Object.create({
+    firstName: 'Albert',
+    lastName: 'Hofmann',
+    posts: 25,
+    hobbies: 'Riding bicycles',
+  }),
+});
+
+Ember.Handlebars.registerHelper(
+  'highlight',
+  (property: string, options: any) =>
+    new Ember.Handlebars.SafeString('<span class="highlight">' + 'some value' + '</span>')
+);
+
+const coolView = App.CoolView.create();
+
+const Person2 = Ember.Object.extend({
+  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()]);
+arr.setEach('name', 'unknown'); // $ExpectType void
+arr.setEach('name', undefined); // $ExpectType void
+arr.getEach('name'); // $ExpectType (string | undefined)[]
+// @ts-expect-error
+arr.setEach('age', 123);
+// @ts-expect-error
+arr.getEach('age');
+
+const Person3 = Ember.Object.extend({
+  name: '',
+  isHappy: false,
+});
+const people2 = Ember.A([
+  Person3.create({ name: 'Yehuda', isHappy: true }),
+  Person3.create({ name: 'Majd', isHappy: false }),
+]);
+const isHappy = (person: typeof Person3.prototype): boolean => {
+  return !!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
+    assertType<string>(value);
+  },
+  (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
+Ember.String.htmlSafe('hello'); // $ExpectType SafeString
diff --git a/types/preview/ember/test/engine-instance.ts b/types/preview/ember/test/engine-instance.ts
new file mode 100644
index 00000000000..e3f8c0b3aae
--- /dev/null
+++ b/types/preview/ember/test/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/types/preview/ember/test/engine.ts b/types/preview/ember/test/engine.ts
new file mode 100755
index 00000000000..094cbfcc82d
--- /dev/null
+++ b/types/preview/ember/test/engine.ts
@@ -0,0 +1,43 @@
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+
+const BaseEngine = Ember.Engine.extend({
+    modulePrefix: 'my-engine',
+});
+
+class Obj extends Ember.Object.extend({ 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');
+    },
+});
+
+const Engine1 = BaseEngine.create({
+    rootElement: '#engine-one',
+    customEvents: {
+        paste: 'paste',
+    },
+});
+
+const Engine2 = BaseEngine.create({
+    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/types/preview/ember/test/error.ts b/types/preview/ember/test/error.ts
new file mode 100644
index 00000000000..3e8de002ad9
--- /dev/null
+++ b/types/preview/ember/test/error.ts
@@ -0,0 +1,5 @@
+import { assertType } from './lib/assert';
+
+import Ember from 'ember';
+
+assertType<typeof Ember.Error>(Ember.Error);
diff --git a/types/preview/ember/test/event.ts b/types/preview/ember/test/event.ts
new file mode 100755
index 00000000000..ab53935c8f5
--- /dev/null
+++ b/types/preview/ember/test/event.ts
@@ -0,0 +1,60 @@
+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() {
+    const Person = Ember.Object.extend(Ember.Evented, {
+        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() {
+    Ember.Component.extend({
+        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/types/preview/ember/test/extend.ts b/types/preview/ember/test/extend.ts
new file mode 100755
index 00000000000..61dd852accb
--- /dev/null
+++ b/types/preview/ember/test/extend.ts
@@ -0,0 +1,61 @@
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+
+const Person = Ember.Object.extend({
+    firstName: '',
+    lastName: '',
+
+    getFullName() {
+        return `${this.firstName} ${this.lastName}`;
+    },
+    getFullName2(): string {
+        return `${this.get('firstName')} ${this.get('lastName')}`;
+    },
+});
+
+assertType<string>(Person.prototype.firstName);
+assertType<() => string>(Person.prototype.getFullName);
+
+const person = Person.create({
+    firstName: 'Joe',
+    lastName: 'Blow',
+    extra: 42,
+});
+
+assertType<string>(person.getFullName());
+assertType<number>(person.extra);
+
+class ES6Person 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')}`;
+    }
+}
+
+assertType<string>(ES6Person.prototype.firstName);
+assertType<string>(ES6Person.prototype.fullName);
+
+const es6Person = ES6Person.create({
+    firstName: 'Joe',
+    lastName: 'Blow',
+    extra: 42,
+});
+
+assertType<string>(es6Person.fullName);
+assertType<number>(es6Person.extra);
+
+class PersonWithStatics extends Ember.Object {
+    static isPerson = true;
+}
+const PersonWithStatics2 = PersonWithStatics.extend({});
+class PersonWithStatics3 extends PersonWithStatics {}
+class PersonWithStatics4 extends PersonWithStatics2 {}
+assertType<boolean>(PersonWithStatics.isPerson);
+assertType<boolean>(PersonWithStatics2.isPerson);
+assertType<boolean>(PersonWithStatics3.isPerson);
+assertType<boolean>(PersonWithStatics4.isPerson);
diff --git a/types/preview/ember/test/helper.ts b/types/preview/ember/test/helper.ts
new file mode 100755
index 00000000000..433ddbd0637
--- /dev/null
+++ b/types/preview/ember/test/helper.ts
@@ -0,0 +1,45 @@
+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;
+    }
+}
+
+const CurrentUserEmailHelper = Ember.Helper.extend({
+    session: Ember.inject.service('session'),
+    onNewUser: Ember.observer('session.currentUser', function (this: Ember.Helper) {
+        this.recompute();
+    }),
+    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/types/preview/ember/test/inject.ts b/types/preview/ember/test/inject.ts
new file mode 100755
index 00000000000..961923c03ba
--- /dev/null
+++ b/types/preview/ember/test/inject.ts
@@ -0,0 +1,60 @@
+import Ember from 'ember';
+
+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 {
+        application: ApplicationController;
+    }
+}
+
+class LoginRoute extends Ember.Route {
+    auth = Ember.inject.service('auth');
+    application = Ember.inject.controller('application');
+
+    didTransition() {
+        if (!this.get('auth').get('isAuthenticated')) {
+            this.get('application').transitionToLogin();
+        }
+    }
+
+    anyOldMethod() {
+        this.get('application').set('string', 'must be a string');
+        this.controllerFor('application'); // $ExpectType Controller
+    }
+}
+
+// New module injection style.
+import Controller, { inject as controller } from '@ember/controller';
+import Service, { inject as service } from '@ember/service';
+import { assertType } from './lib/assert';
+
+class ComponentInjection extends Ember.Component {
+    applicationController = controller('application');
+    auth = service('auth');
+    router = service('router');
+    misc = service();
+
+    testem() {
+        assertType<Ember.Service>(this.get('misc'));
+        const url = this.get('router').urlFor('some-route', 1, 2, 3, { queryParams: { seriously: 'yes' } });
+        assertType<string>(url);
+        if (!this.get('auth').isAuthenticated) {
+            this.get('applicationController').transitionToLogin();
+        }
+    }
+}
diff --git a/types/preview/ember/test/lib/assert.ts b/types/preview/ember/test/lib/assert.ts
new file mode 100755
index 00000000000..dad227ab5e9
--- /dev/null
+++ b/types/preview/ember/test/lib/assert.ts
@@ -0,0 +1,2 @@
+/** Static assertion that `value` has type `T` */
+export declare function assertType<T>(value: T): T;
diff --git a/types/preview/ember/test/mixin.ts b/types/preview/ember/test/mixin.ts
new file mode 100755
index 00000000000..ccb71d14ef1
--- /dev/null
+++ b/types/preview/ember/test/mixin.ts
@@ -0,0 +1,57 @@
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+
+interface EditableMixin {
+    edit(): void;
+    isEditing: boolean;
+}
+
+const EditableMixin = Ember.Mixin.create<EditableMixin, Ember.Route>({
+    edit() {
+        this.get('controller');
+        console.log('starting to edit');
+        this.set('isEditing', true);
+    },
+    isEditing: false,
+});
+
+const EditableComment = 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();
+assertType<boolean>(comment.isEditing);
+assertType<number>(comment.postId);
+
+const LiteralMixins = Ember.Object.extend({ a: 1 }, { b: 2 }, { c: 3 });
+const obj = LiteralMixins.create();
+assertType<number>(obj.a);
+assertType<number>(obj.b);
+assertType<number>(obj.c);
+
+/* Test composition of mixins */
+const EditableAndCancelableMixin = Ember.Mixin.create(EditableMixin, {
+    cancelled: false,
+});
+
+const EditableAndCancelableComment = Ember.Route.extend(EditableAndCancelableMixin);
+
+const editableAndCancelable = EditableAndCancelableComment.create();
+assertType<boolean>(editableAndCancelable.isEditing);
+assertType<boolean>(editableAndCancelable.cancelled);
diff --git a/types/preview/ember/test/object.ts b/types/preview/ember/test/object.ts
new file mode 100755
index 00000000000..9deb3df638d
--- /dev/null
+++ b/types/preview/ember/test/object.ts
@@ -0,0 +1,84 @@
+import Ember from 'ember';
+
+const LifetimeHooks = Ember.Object.extend({
+    resource: undefined as {} | 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.extend({
+    a: Ember.computed({
+        get() {
+            return '';
+        },
+        set(key: string, newVal: string) {
+            return '';
+        },
+    }),
+}) {
+    b = 5;
+    baz() {
+        const y = this.b; // $ExpectType number
+        const z = this.a; // $ExpectType ComputedProperty<string, string>
+        this.b = 10;
+        this.get('b').toFixed(4); // $ExpectType string
+        this.set('a', 'abc').split(','); // $ExpectType string[]
+        this.set('b', 10).toFixed(4); // $ExpectType 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!: string;
+
+    changeName(name: string) {
+        const a: string = this.set('name', name);
+        // @ts-expect-error
+        const b: number = this.set('name', name);
+        const x: string = Ember.set(this, 'name', name);
+        // @ts-expect-error
+        const y: number = Ember.set(this, 'name', name);
+        this.setProperties({
+            name,
+        });
+        Ember.setProperties(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/types/preview/ember/test/observable.ts b/types/preview/ember/test/observable.ts
new file mode 100755
index 00000000000..b8c339b4aed
--- /dev/null
+++ b/types/preview/ember/test/observable.ts
@@ -0,0 +1,116 @@
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+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>();
+
+const person = Ember.Object.create({
+  name: 'Fred',
+  age: 29,
+  capitalized: Ember.computed<string>(function () {
+    return this.get('name').toUpperCase();
+  }),
+});
+
+const pojo = { name: 'Fred', age: 29 };
+
+function testGet() {
+  assertType<string>(Ember.get(person, 'name'));
+  assertType<number>(Ember.get(person, 'age'));
+  assertType<string>(Ember.get(person, 'capitalized'));
+  assertType<string>(person.get('name'));
+  assertType<number>(person.get('age'));
+  assertType<string>(person.get('capitalized'));
+  assertType<string>(Ember.get(pojo, 'name'));
+}
+
+function testGetProperties() {
+  assertType<{ name: string }>(Ember.getProperties(person, 'name'));
+  assertType<{ name: string; age: number }>(Ember.getProperties(person, 'name', 'age'));
+  assertType<{ name: string; age: number }>(Ember.getProperties(person, ['name', 'age']));
+  assertType<{ name: string; age: number; capitalized: string }>(
+    Ember.getProperties(person, 'name', 'age', 'capitalized')
+  );
+  assertType<{ name: string }>(person.getProperties('name'));
+  assertType<{ name: string; age: number }>(person.getProperties('name', 'age'));
+  assertType<{ name: string; age: number }>(person.getProperties(['name', 'age']));
+  assertType<{ name: string; age: number; capitalized: string }>(
+    person.getProperties('name', 'age', 'capitalized')
+  );
+  assertType<{ name: string; age: number }>(Ember.getProperties(pojo, 'name', 'age'));
+}
+
+function testSet() {
+  assertType<string>(Ember.set(person, 'name', 'Joe'));
+  assertType<number>(Ember.set(person, 'age', 35));
+  assertType<string>(Ember.set(person, 'capitalized', 'JOE'));
+  assertType<string>(person.set('name', 'Joe'));
+  assertType<number>(person.set('age', 35));
+  assertType<string>(person.set('capitalized', 'JOE'));
+  assertType<string>(Ember.set(pojo, 'name', 'Joe'));
+}
+
+function testSetProperties() {
+  assertType<{ name: string }>(Ember.setProperties(person, { name: 'Joe' }));
+  assertType<{ name: string; age: number }>(Ember.setProperties(person, { name: 'Joe', age: 35 }));
+  assertType<{ name: string; capitalized: string }>(
+    Ember.setProperties(person, { name: 'Joe', capitalized: 'JOE' })
+  );
+  assertType<{ name: string }>(person.setProperties({ name: 'Joe' }));
+  assertType<{ name: string; age: number }>(person.setProperties({ name: 'Joe', age: 35 }));
+  assertType<{ name: string; capitalized: string }>(
+    person.setProperties({ name: 'Joe', capitalized: 'JOE' })
+  );
+  assertType<{ name: string; age: number }>(Ember.setProperties(pojo, { name: 'Joe', age: 35 }));
+}
+
+function testDynamic() {
+  const obj: Record<string, string> = {};
+  const dynamicKey: string = 'dummy'; // tslint:disable-line:no-inferrable-types
+
+  assertType<string | undefined>(Ember.get(obj, 'dummy'));
+  assertType<string | undefined>(Ember.get(obj, dynamicKey));
+  assertType<{ dummy: string | undefined }>(Ember.getProperties(obj, 'dummy'));
+  assertType<{ dummy: string | undefined }>(Ember.getProperties(obj, ['dummy']));
+  assertType<Record<string, string>>(Ember.getProperties(obj, dynamicKey));
+  assertType<Record<string, string>>(Ember.getProperties(obj, [dynamicKey]));
+  assertType<string | undefined>(Ember.set(obj, 'dummy', 'value'));
+  assertType<string | undefined>(Ember.set(obj, dynamicKey, 'value'));
+  assertType<{ dummy: string | undefined }>(Ember.setProperties(obj, { dummy: 'value ' }));
+  assertType<Record<string, string>>(Ember.setProperties(obj, { [dynamicKey]: 'value' }));
+}
diff --git a/types/preview/ember/test/private/computed-tests.ts b/types/preview/ember/test/private/computed-tests.ts
new file mode 100644
index 00000000000..c0c83772383
--- /dev/null
+++ b/types/preview/ember/test/private/computed-tests.ts
@@ -0,0 +1,92 @@
+import Ember from 'ember';
+import {
+    UnwrapComputedPropertySetters,
+    UnwrapComputedPropertyGetters,
+    UnwrapComputedPropertySetter,
+    UnwrapComputedPropertyGetter,
+} from '@ember/object/-private/types';
+import { assertType } from '../lib/assert';
+
+class Example1 extends Ember.Object.extend({
+    firstName: '',
+    lastName: '',
+    allNames: Ember.computed('fullName', function () {
+        return [this.fullName];
+    }) as Ember.ComputedProperty<string[]>,
+    fullName: Ember.computed('firstName', 'lastName', function () {
+        // tslint:disable-next-line:no-unnecessary-type-assertion
+        return `${this.firstName} ${this.lastName}` as string;
+    }),
+}) {}
+
+declare const unwrappedGetters1: UnwrapComputedPropertyGetters<Example1>;
+unwrappedGetters1.firstName; // $ExpectType string
+unwrappedGetters1.lastName; // $ExpectType string
+unwrappedGetters1.fullName; // $ExpectType string
+unwrappedGetters1.allNames; // $ExpectType string[]
+
+declare const unwrappedSetters1: UnwrapComputedPropertySetters<Example1>;
+unwrappedSetters1.firstName; // $ExpectType string
+unwrappedSetters1.lastName; // $ExpectType string
+unwrappedSetters1.fullName; // $ExpectType string
+unwrappedSetters1.allNames; // $ExpectType string[]
+
+class Example2 extends Ember.Object.extend({
+    allNames: Ember.computed('fullName', function () {
+        return [this.fullName + ''];
+    }),
+    fullName: Ember.computed('firstName', 'lastName', function () {
+        // tslint:disable-next-line:no-unnecessary-type-assertion
+        return `${this.firstName} ${this.lastName}` as string;
+    }),
+}) {
+    firstName = '';
+    lastName = '';
+    foo() {
+        this.fullName; // $ExpectType ComputedProperty<string, string>
+        this.allNames; // $ExpectType ComputedProperty<string[], string[]>
+        this.firstName; // $ExpectType string
+        this.lastName; // $ExpectType string
+
+        this.get('fullName').split(','); // $ExpectType string[]
+        this.get('allNames')[0]; // $ExpectType string
+        this.get('firstName').split(','); // $ExpectType string[]
+        this.get('lastName').split(','); // $ExpectType string[]
+    }
+}
+const ex2 = new Example2();
+
+declare const unwrappedGetters2: UnwrapComputedPropertyGetters<typeof ex2>;
+assertType<string>(unwrappedGetters2.firstName); // $ExpectType string
+assertType<string>(unwrappedGetters2.lastName); // $ExpectType string
+assertType<string>(unwrappedGetters2.fullName); // $ExpectType string
+assertType<string[]>(unwrappedGetters2.allNames); // $ExpectType string[]
+
+declare const unwrappedSetters2: UnwrapComputedPropertySetters<typeof ex2>;
+assertType<string>(unwrappedSetters2.firstName); // $ExpectType string
+assertType<string>(unwrappedSetters2.lastName); // $ExpectType string
+assertType<string>(unwrappedSetters2.fullName); // $ExpectType string
+assertType<string[]>(unwrappedSetters2.allNames); // $ExpectType string[]
+
+ex2.fullName; // $ExpectType ComputedProperty<string, string>
+ex2.allNames; // $ExpectType ComputedProperty<string[], string[]>
+ex2.firstName; // $ExpectType string
+
+type UnwStringSet = UnwrapComputedPropertySetter<string>; // $ExpectType string
+type UnwStringGet = UnwrapComputedPropertyGetter<string>; // $ExpectType string
+// $ExpectType string
+type UnwCpStringSet1 = UnwrapComputedPropertySetter<Ember.ComputedProperty<string>>;
+// $ExpectType string
+type UnwCpStringGet1 = UnwrapComputedPropertyGetter<Ember.ComputedProperty<string>>;
+// $ExpectType string
+type UnwCpStringSet2 = UnwrapComputedPropertySetter<Ember.ComputedProperty<string, string>>;
+// $ExpectType string
+type UnwCpStringGet2 = UnwrapComputedPropertyGetter<Ember.ComputedProperty<string, string>>;
+// $ExpectType string
+type UnwCpStringSet3 = UnwrapComputedPropertySetter<Ember.ComputedProperty<number, string>>;
+// $ExpectType number
+type UnwCpStringGet3 = UnwrapComputedPropertyGetter<Ember.ComputedProperty<number, string>>;
+// $ExpectType number
+type UnwCpStringSet4 = UnwrapComputedPropertySetter<Ember.ComputedProperty<string, number>>;
+// $ExpectType string
+type UnwCpStringGet4 = UnwrapComputedPropertyGetter<Ember.ComputedProperty<string, number>>;
diff --git a/types/preview/ember/test/private/observable-tests.ts b/types/preview/ember/test/private/observable-tests.ts
new file mode 100644
index 00000000000..ed4a2371a9a
--- /dev/null
+++ b/types/preview/ember/test/private/observable-tests.ts
@@ -0,0 +1,200 @@
+// tslint-disable-next-line
+import { assertType } from '../lib/assert';
+import Ember from 'ember';
+import { ExtractPropertyNamesOfType } from '@ember/object/-private/types';
+import Observable from '@ember/object/observable';
+
+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) => {
+      assertType<DemoObservable>(sender);
+      assertType<'foo'>(key);
+      assertType<string>(value);
+      assertType<number>(rev);
+    });
+    this.removeObserver('foo', lambda);
+    Ember.addObserver(this, 'foo', lambda);
+    Ember.removeObserver(this, 'foo', lambda);
+  }
+
+  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<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
+ */
+assertType<string>(o.get('foo')); // $ExpectType string
+assertType<[boolean, boolean]>(o.get('bar')); // $ExpectType [boolean, boolean]
+assertType<number | undefined>(o.get('baz')); // $ExpectType number | undefined
+
+/**
+ * incrementProperty, decrementProperty
+ */
+assertType<number>(o.incrementProperty('baz')); // $ExpectType number
+assertType<number>(o.decrementProperty('baz')); // $ExpectType number
+assertType<number>(o.incrementProperty('baz', 3)); // $ExpectType number
+assertType<number>(o.decrementProperty('baz', 12)); // $ExpectType number
+// non-numeric property case
+// @ts-expect-error
+assertType<number>(o.incrementProperty('bar'));
+// @ts-expect-error
+assertType<number>(o.decrementProperty('bar'));
+// empty case
+// @ts-expect-error
+assertType<number>(o.incrementProperty());
+// @ts-expect-error
+assertType<number>(o.decrementProperty());
+
+/**
+ * toggleProperty
+ */
+o.toggleProperty('isFoo'); // $ExpectType boolean
+// @ts-expect-error
+o.toggleProperty();
+
+/**
+ * getProperties
+ */
+// ('foo', 'bar')
+assertType<{ foo: string; bar: [boolean, boolean] }>(o.getProperties('foo', 'bar')); // $ExpectType { foo: string; bar: [boolean, boolean]; }
+// ['foo', 'bar']
+assertType<{ foo: string; bar: [boolean, boolean] }>(o.getProperties(['foo', 'bar'])); // $ExpectType { foo: string; bar: [boolean, boolean]; }
+// empty cases
+assertType<{}>(o.getProperties()); // $ExpectType {}
+assertType<{}>(o.getProperties([])); // $ExpectType {}
+// property that doesn't exist
+// @ts-expect-error
+o.getProperties('jeanShorts', 'foo');
+// @ts-expect-error
+o.getProperties(['foo', 'jeanShorts']);
+
+/**
+ * set
+ */
+assertType<string>(o.set('foo', 'abc')); // $ExpectType string
+assertType<[boolean, boolean]>(o.set('bar', [false, false])); // $ExpectType [boolean, boolean]
+assertType<number | undefined>(o.set('baz', undefined)); // $ExpectType number | undefined
+assertType<number | undefined>(o.set('baz', 10)); // $ExpectType number | undefined
+// property that doesn't exist
+// @ts-expect-error
+o.set('jeanShorts', 10);
+
+/**
+ * setProperties
+ */
+assertType<{ foo: string; bar: [boolean, boolean] }>(
+  o.setProperties({ foo: 'abc', bar: [true, true] })
+); // $ExpectType { foo: string; bar: [boolean, boolean]; }
+// empty case
+assertType<{}>(o.setProperties({})); // $ExpectType {}
+// property that doesn't exist
+// @ts-expect-error
+o.setProperties({ jeanShorts: 'under the pants' });
+
+/**
+ * notifyPropertyChange
+ */
+assertType<DemoObservable>(o.notifyPropertyChange('foo')); // $ExpectType DemoObservable
+// @ts-expect-error
+assertType<Observable>(o.notifyPropertyChange('jeanShorts'));
diff --git a/types/preview/ember/test/reopen.ts b/types/preview/ember/test/reopen.ts
new file mode 100755
index 00000000000..08300aec1ca
--- /dev/null
+++ b/types/preview/ember/test/reopen.ts
@@ -0,0 +1,64 @@
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+
+type Person = typeof Person.prototype;
+const Person = Ember.Object.extend({
+    name: '',
+    sayHello() {
+        alert(`Hello. My name is ${this.get('name')}`);
+    },
+});
+
+assertType<Person>(Person.reopen());
+
+assertType<string>(Person.create().name);
+Person.create().sayHello(); // $ExpectType void
+
+const Person2 = Person.reopenClass({
+    species: 'Homo sapiens',
+
+    createPerson(name: string): Person {
+        return Person.create({ name });
+    },
+});
+
+assertType<string>(Person2.create().name);
+Person2.create().sayHello(); // $ExpectType void
+assertType<string>(Person2.species);
+
+const tom = Person2.create({
+    name: 'Tom Dale',
+});
+
+// @ts-expect-error
+const badTom = Person2.create({ name: 99 });
+
+const yehuda = Person2.createPerson('Yehuda Katz');
+
+tom.sayHello(); // "Hello. My name is Tom Dale"
+yehuda.sayHello(); // "Hello. My name is Yehuda Katz"
+alert(Person2.species); // "Homo sapiens"
+
+const Person3 = Person2.reopen({
+    goodbyeMessage: 'goodbye',
+
+    sayGoodbye() {
+        alert(`${this.get('goodbyeMessage')}, ${this.get('name')}`);
+    },
+});
+
+const person3 = Person3.create();
+person3.get('name');
+person3.get('goodbyeMessage');
+person3.sayHello();
+person3.sayGoodbye();
+
+interface AutoResizeMixin {
+    resizable: true;
+}
+const AutoResizeMixin = Ember.Mixin.create({ resizable: true });
+
+const Reopened = Ember.Object.reopenClass({ a: 1 }, { b: 2 }, { c: 3 });
+assertType<number>(Reopened.a);
+assertType<number>(Reopened.b);
+assertType<number>(Reopened.c);
diff --git a/types/preview/ember/test/route.ts b/types/preview/ember/test/route.ts
new file mode 100755
index 00000000000..28f127888b4
--- /dev/null
+++ b/types/preview/ember/test/route.ts
@@ -0,0 +1,97 @@
+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> {}
+
+Route.extend({
+    beforeModel(transition: Transition) {
+        this.transitionTo('someOtherRoute');
+    },
+});
+
+Route.extend({
+    afterModel(posts: Posts, transition: Transition) {
+        if (posts.firstObject) {
+            this.transitionTo('post.show', posts.firstObject);
+        }
+    },
+});
+
+Ember.Route.extend({
+    model() {
+        return this.modelFor('post');
+    },
+});
+
+Route.extend({
+    queryParams: {
+        memberQp: { refreshModel: true },
+    },
+});
+
+Route.extend({
+    resetController(controller: Ember.Controller, isExiting: boolean, transition: boolean) {
+        if (isExiting) {
+            //   controller.set('page', 1);
+        }
+    },
+});
+
+Route.extend({
+    setupController(controller: Ember.Controller, model: {}) {
+        this._super(controller, model);
+        this.controllerFor('application').set('model', model);
+    },
+});
+
+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')";
+    }
+}
diff --git a/types/preview/ember/test/router.ts b/types/preview/ember/test/router.ts
new file mode 100755
index 00000000000..105a8d75264
--- /dev/null
+++ b/types/preview/ember/test/router.ts
@@ -0,0 +1,49 @@
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+
+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' });
+});
+
+const RouterServiceConsumer = Ember.Service.extend({
+    router: Ember.inject.service('router'),
+    currentRouteName() {
+        const x: string = Ember.get(this, 'router').currentRouteName;
+    },
+    currentURL() {
+        const x: string = Ember.get(this, 'router').currentURL;
+    },
+    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/types/preview/ember/test/run.ts b/types/preview/ember/test/run.ts
new file mode 100755
index 00000000000..bba22edd2c7
--- /dev/null
+++ b/types/preview/ember/test/run.ts
@@ -0,0 +1,220 @@
+import Ember from 'ember';
+import RSVP from 'rsvp';
+import { assertType } from './lib/assert';
+
+function testRun() {
+    const r = Ember.run(() => {
+        // code to be executed within a RunLoop
+        return 123;
+    });
+    assertType<number>(r);
+
+    function destroyApp(application: Ember.Application) {
+        Ember.run(application, 'destroy');
+        Ember.run(application, function () {
+            this.destroy();
+        });
+    }
+}
+
+function testBind() {
+    Ember.Component.extend({
+        init() {
+            const bound = Ember.run.bind(this, this.setupEditor);
+            bound();
+        },
+
+        editor: null as string | 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);
+
+    Ember.Component.extend({
+        searchValue: 'test',
+        fetchResults(value: string) {},
+
+        actions: {
+            handleTyping() {
+                // the fetchResults function is passed into the component from its parent
+                Ember.run.debounce(this, this.get('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
+    });
+}
+
+function testOnce() {
+    Ember.Component.extend({
+        init() {
+            Ember.run.once(this, 'processFullName');
+        },
+
+        processFullName() {},
+    });
+}
+
+function testSchedule() {
+    Ember.Component.extend({
+        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/types/preview/ember/test/string.ts b/types/preview/ember/test/string.ts
new file mode 100644
index 00000000000..c05f68f1a3d
--- /dev/null
+++ b/types/preview/ember/test/string.ts
@@ -0,0 +1,51 @@
+import Ember from 'ember';
+import { SafeString } from '@ember/template/-private/handlebars';
+
+const { dasherize, camelize, capitalize, classify, decamelize, htmlSafe, underscore, w } = Ember.String;
+
+// @ts-expect-error
+dasherize();
+dasherize('blue man group'); // $ExpectType string
+// @ts-expect-error
+dasherize('', '');
+
+// @ts-expect-error
+camelize();
+camelize('blue man group'); // $ExpectType string
+// @ts-expect-error
+camelize('', '');
+
+// @ts-expect-error
+decamelize();
+decamelize('blue man group'); // $ExpectType string
+// @ts-expect-error
+decamelize('', '');
+
+// @ts-expect-error
+underscore();
+underscore('blue man group'); // $ExpectType string
+// @ts-expect-error
+underscore('', '');
+
+// @ts-expect-error
+w();
+w('blue man group'); // $ExpectType string[]
+// @ts-expect-error
+w('', '');
+
+// @ts-expect-error
+classify();
+classify('blue man group'); // $ExpectType string
+// @ts-expect-error
+classify('', '');
+
+// @ts-expect-error
+capitalize();
+capitalize('blue man group'); // $ExpectType string
+// @ts-expect-error
+capitalize('', '');
+
+const handlebarsSafeString: SafeString = Ember.String.htmlSafe('lorem ipsum...');
+Ember.String.htmlSafe('lorem ipsum...'); // $ExpectType SafeString
+// @ts-expect-error
+const regularString: string = Ember.String.htmlSafe('lorem ipsum...');
diff --git a/types/preview/ember/test/techniques/properties-from-this.ts b/types/preview/ember/test/techniques/properties-from-this.ts
new file mode 100644
index 00000000000..78b5b96dd1d
--- /dev/null
+++ b/types/preview/ember/test/techniques/properties-from-this.ts
@@ -0,0 +1,71 @@
+/**
+ * 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
+ */
+
+class BoxedProperty<Get, Set = Get> {
+    declare private [GetType]: Get;
+    declare private [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();
+
+f.get('a'); // $ExpectType number
+// @ts-expect-error
+f.set('a');
+// @ts-expect-error
+f.set('a', '1');
+f.set('a', 1); // $ExpectType number
+
+f.get('b'); // $ExpectType [boolean, boolean]
+// @ts-expect-error
+f.set('b', 1);
+// @ts-expect-error
+f.set('b', []);
+// @ts-expect-error
+f.set('b', [true]);
+f.set('b', [false, true]); // $ExpectType [boolean, boolean]
+// @ts-expect-error
+f.set('b', [false, true, false]);
+
+f.get('c'); // $ExpectType string
+f.set('c', '1'); // $ExpectType string
+
+f.get('cpA'); // $ExpectType string
+// @ts-expect-error
+f.set('cpA', ['newValue']);
+f.set('cpA', 'newValue'); // $ExpectType string
diff --git a/types/preview/ember/test/test.ts b/types/preview/ember/test/test.ts
new file mode 100755
index 00000000000..d3eecc5a2b5
--- /dev/null
+++ b/types/preview/ember/test/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/types/preview/ember/test/transition.ts b/types/preview/ember/test/transition.ts
new file mode 100755
index 00000000000..53eb4397764
--- /dev/null
+++ b/types/preview/ember/test/transition.ts
@@ -0,0 +1,29 @@
+import Ember from 'ember';
+import Transition from '@ember/routing/transition';
+
+Ember.Route.extend({
+    beforeModel(transition: Transition) {
+        if (new Date() > new Date('January 1, 1980')) {
+            alert('Sorry, you need a time machine to enter this route.');
+            transition.abort();
+        }
+    },
+});
+
+Ember.Controller.extend({
+    previousTransition: null as Transition | null,
+
+    actions: {
+        login() {
+            // Log the user in, then reattempt previous transition if it exists.
+            const previousTransition = this.get('previousTransition');
+            if (previousTransition) {
+                this.set('previousTransition', null);
+                previousTransition.retry();
+            } else {
+                // Default back to homepage
+                this.transitionToRoute('index');
+            }
+        },
+    },
+});
diff --git a/types/preview/ember/test/utils.ts b/types/preview/ember/test/utils.ts
new file mode 100755
index 00000000000..ef0504eba30
--- /dev/null
+++ b/types/preview/ember/test/utils.ts
@@ -0,0 +1,146 @@
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+
+function testTypeOf() {
+    Ember.typeOf(); // $ExpectType "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';
+    Ember.isNone(); // $ExpectType boolean
+}
+
+function testIsBlank() {
+    Ember.isBlank(); // $ExpectType boolean
+    Ember.isBlank(''); // $ExpectType boolean
+    // @ts-expect-error
+    Ember.isBlank('', '');
+}
+
+function testIsEmpty() {
+    Ember.isEmpty(); // $ExpectType boolean
+    Ember.isEmpty(''); // $ExpectType boolean
+    // @ts-expect-error
+    Ember.isEmpty('', '');
+}
+
+function testIsPresent() {
+    Ember.isPresent(); // $ExpectType boolean
+    Ember.isPresent(''); // $ExpectType boolean
+    // @ts-expect-error
+    Ember.isPresent('', '');
+}
+
+function testIsNone() {
+    Ember.isNone(); // $ExpectType boolean
+    Ember.isNone(''); // $ExpectType boolean
+    // @ts-expect-error
+    Ember.isNone('', '');
+}
+
+function testAssign() {
+    assertType<{ first: string; middle: string; last: string }>(
+        Ember.assign({ first: 'Tom' }, { middle: 'M' }, { last: 'Dale' }),
+    );
+}
+
+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,
+    );
+    assertType<string>(newMethod('first', 123));
+    assertType<string>(oldMethod('first', 123));
+}
+
+function testDefineProperty() {
+    const 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 () {
+            return `${this.firstName} ${this.lastName}`;
+        }),
+    );
+}
+
+// For use in IIFE below.
+declare const fileList: FileList;
+
+(() => {
+    /** typeOf */
+    Ember.typeOf(); // $ExpectType "undefined"
+    Ember.typeOf(null); // $ExpectType "null"
+    Ember.typeOf(undefined); // $ExpectType "undefined"
+    Ember.typeOf('michael'); // $ExpectType "string"
+    // tslint:disable-next-line:no-construct
+    Ember.typeOf(new String('michael')); // $ExpectType "string"
+    Ember.typeOf(101); // $ExpectType "number"
+    // tslint:disable-next-line:no-construct
+    Ember.typeOf(new Number(101)); // $ExpectType "number"
+    Ember.typeOf(true); // $ExpectType "boolean"
+    // tslint:disable-next-line:no-construct
+    Ember.typeOf(new Boolean(true)); // $ExpectType "boolean"
+    Ember.typeOf(() => 4); // $ExpectType "function"
+    Ember.typeOf([1, 2, 90]); // $ExpectType "array"
+    Ember.typeOf(/abc/); // $ExpectType "regexp"
+    Ember.typeOf(new Date()); // $ExpectType "date"
+    Ember.typeOf(fileList); // $ExpectType "filelist"
+    Ember.typeOf(Ember.Object.extend()); // $ExpectType "class"
+    Ember.typeOf(Ember.Object.create()); // $ExpectType "instance"
+    Ember.typeOf(new Error('teamocil')); // $ExpectType "error"
+    Ember.typeOf(new Date() as RegExp | Date); // "regexp" | "date"
+    Ember.typeOf({ randomObject: true }); // $ExpectType "object"
+})();
+
+(() => {
+    /* assign */
+    Ember.assign({}, { a: 'b' });
+    Ember.assign({}, { a: 'b' }).a; // $ExpectType string
+    Ember.assign({ a: 6 }, { a: 'b' }).a; // $ExpectType string
+    Ember.assign({ a: 6 }, {}).a; // $ExpectType number
+    // @ts-expect-error
+    Ember.assign({ b: 6 }, {}).a;
+    Ember.assign({}, { b: 6 }, {}).b; // $ExpectType number
+    Ember.assign({ a: 'hello' }, { b: 6 }, {}).a; // $ExpectType string
+    Ember.assign({ a: 'hello' }, { b: 6 }, { a: true }).a; // $ExpectType boolean
+    // @ts-expect-error
+    Ember.assign({ a: 'hello' }, '', { a: true }).a;
+    Ember.assign({ d: ['gobias industries'] }, { a: 'hello' }, { b: 6 }, { a: true }).d; // $ExpectType string[]
+})();
diff --git a/types/preview/ember/test/view-utils.ts b/types/preview/ember/test/view-utils.ts
new file mode 100644
index 00000000000..a45f4f3ce59
--- /dev/null
+++ b/types/preview/ember/test/view-utils.ts
@@ -0,0 +1,7 @@
+import Ember from 'ember';
+import { assertType } from './lib/assert';
+
+const {
+    ViewUtils: { isSimpleClick },
+} = Ember;
+assertType<boolean>(isSimpleClick(new Event('wat')));
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/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==

From 414a7638c4081a3e38ce80996907b59e29c27ce9 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Thu, 25 Aug 2022 17:19:31 -0600
Subject: [PATCH 02/39] Begin iterating on object and application preview types

---
 .eslintrc.js                                  |   5 +-
 package.json                                  |   5 +-
 tsconfig.json                                 |   2 +-
 .../preview/@ember/application/instance.d.ts  |   2 +-
 .../application/test/application-instance.ts  |   5 +-
 .../@ember/application/test/application.ts    |  36 +-
 .../-private/container-proxy-mixin.d.ts       |  12 +-
 types/preview/@ember/engine/instance.d.ts     |  24 +-
 types/preview/@ember/object/core.d.ts         |   1 +
 types/preview/@ember/object/observable.d.ts   |   5 +
 types/preview/@ember/runloop/index.d.ts       | 113 +++---
 .../@ember/utils/ember__utils-tests.ts        | 111 +++---
 types/preview/ember/index.d.ts                |  71 ++--
 types/preview/ember/test/run.ts               | 336 +++++++++---------
 types/preview/ember/test/string.ts            |   3 +-
 types/preview/ember/test/transition.ts        |  28 +-
 types/preview/ember/test/utils.ts             | 210 +++++------
 17 files changed, 470 insertions(+), 499 deletions(-)

diff --git a/.eslintrc.js b/.eslintrc.js
index 07cabcb5d36..25aece7add1 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -78,12 +78,15 @@ module.exports = {
 
       rules: {
         'import/export': 'off',
+        'disable-features/disable-async-await': 'off',
         '@typescript-eslint/ban-ts-comment': 'off',
+        '@typescript-eslint/ban-types': 'off',
         '@typescript-eslint/no-empty-interface': 'off',
         'import/no-unresolved': 'off',
         '@typescript-eslint/no-this-alias': 'off',
-        '@typescript-eslint/consistent-type-imports': 'error',
+        '@typescript-eslint/consistent-type-imports': 'off',
         '@typescript-eslint/no-empty-function': 'off',
+        'no-console': 'off',
       },
     },
     {
diff --git a/package.json b/package.json
index 21640d79066..771014a287e 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,7 @@
     "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": "tsc --noEmit && tsc --noEmit --project types/preview",
     "lint:fix": "npm-run-all lint:*:fix",
     "test": "node bin/run-tests.js",
     "test:blueprints:js": "mocha node-tests/blueprints/**/*-test.js",
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/types/preview/@ember/application/instance.d.ts b/types/preview/@ember/application/instance.d.ts
index db5f37fcd5f..74215a39a46 100644
--- a/types/preview/@ember/application/instance.d.ts
+++ b/types/preview/@ember/application/instance.d.ts
@@ -1,4 +1,4 @@
-import EngineInstance from "@ember/engine/instance";
+import EngineInstance from '@ember/engine/instance';
 
 /**
  * The `ApplicationInstance` encapsulates all of the stateful aspects of a
diff --git a/types/preview/@ember/application/test/application-instance.ts b/types/preview/@ember/application/test/application-instance.ts
index 32748ca0d96..07bbf776dee 100644
--- a/types/preview/@ember/application/test/application-instance.ts
+++ b/types/preview/@ember/application/test/application-instance.ts
@@ -1,5 +1,6 @@
 import ApplicationInstance from '@ember/application/instance';
-import hbs from 'htmlbars-inline-precompile';
+
+declare function hbs(strings: TemplateStringsArray): object;
 
 const appInstance = ApplicationInstance.create();
 appInstance.register('some:injection', class Foo {});
@@ -23,8 +24,8 @@ appInstance.register('templates:foo/bar', hbs`<h1>Hello World</h1>`, {
   singleton: true,
   instantiate: true,
 });
-// @ts-expect-error
 appInstance.register('templates:foo/bar', hbs`<h1>Hello World</h1>`, {
+  // @ts-expect-error
   singleton: 'true',
   instantiate: true,
 });
diff --git a/types/preview/@ember/application/test/application.ts b/types/preview/@ember/application/test/application.ts
index 8654afe83e4..e3bb601c492 100755
--- a/types/preview/@ember/application/test/application.ts
+++ b/types/preview/@ember/application/test/application.ts
@@ -2,38 +2,38 @@ import Application from '@ember/application';
 import EmberObject from '@ember/object';
 
 const BaseApp = Application.extend({
-    modulePrefix: 'my-app',
+  modulePrefix: 'my-app',
 });
 
 class Obj extends EmberObject.extend({ foo: 'bar' }) {}
 
 BaseApp.initializer({
-    name: 'my-initializer',
-    initialize(app) {
-        app.register('foo:bar', Obj);
-    },
+  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');
-    },
+  name: 'my-instance-initializer',
+  initialize(app) {
+    (app.lookup('foo:bar') as Obj).get('foo');
+  },
 });
 
 const App1 = BaseApp.create({
-    rootElement: '#app-one',
-    customEvents: {
-        paste: 'paste',
-    },
+  rootElement: '#app-one',
+  customEvents: {
+    paste: 'paste',
+  },
 });
 
 const App2 = BaseApp.create({
-    rootElement: '#app-two',
-    customEvents: {
-        mouseenter: null,
-        mouseleave: null,
-    },
+  rootElement: '#app-two',
+  customEvents: {
+    mouseenter: null,
+    mouseleave: null,
+  },
 });
 
 const App3 = BaseApp.create();
diff --git a/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts b/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts
index 27463373dc1..d281c67be69 100644
--- a/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts
+++ b/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts
@@ -5,11 +5,11 @@ 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(): {};
+  /**
+   * Returns an object that can be used to provide an owner to a
+   * manually created instance.
+   */
+  ownerInjection(): {};
 }
-declare const ContainerProxyMixin: Mixin<ContainerProxyMixin>;
+declare const ContainerProxyMixin: Mixin;
 export default ContainerProxyMixin;
diff --git a/types/preview/@ember/engine/instance.d.ts b/types/preview/@ember/engine/instance.d.ts
index 84c65b47581..482e66b6caa 100644
--- a/types/preview/@ember/engine/instance.d.ts
+++ b/types/preview/@ember/engine/instance.d.ts
@@ -1,22 +1,22 @@
-import ContainerProxyMixin from "@ember/engine/-private/container-proxy-mixin";
-import RegistryProxyMixin from "@ember/engine/-private/registry-proxy-mixin";
-import EmberObject from "@ember/object";
+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;
+  /**
+   * 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>;
+  /**
+   *  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/object/core.d.ts b/types/preview/@ember/object/core.d.ts
index c8dbc893d7a..58d719ad6cc 100644
--- a/types/preview/@ember/object/core.d.ts
+++ b/types/preview/@ember/object/core.d.ts
@@ -59,6 +59,7 @@ export default class CoreObject {
   toString(): string;
 
   static create<Class extends typeof CoreObject>(
+    this: Class,
     ...initialValues: Array<Mixin | Record<string, unknown>>
   ): InstanceType<Class>;
 
diff --git a/types/preview/@ember/object/observable.d.ts b/types/preview/@ember/object/observable.d.ts
index bffceba42cb..d0bbc08f1ff 100644
--- a/types/preview/@ember/object/observable.d.ts
+++ b/types/preview/@ember/object/observable.d.ts
@@ -10,17 +10,21 @@ interface Observable {
    * 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
@@ -28,6 +32,7 @@ interface Observable {
    */
   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.
    *
diff --git a/types/preview/@ember/runloop/index.d.ts b/types/preview/@ember/runloop/index.d.ts
index 7265638796a..25cd870cf0d 100644
--- a/types/preview/@ember/runloop/index.d.ts
+++ b/types/preview/@ember/runloop/index.d.ts
@@ -6,9 +6,14 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // Minimum TypeScript Version: 4.4
 
-import { EmberMethod, EmberMethodParams, AnyFn, EmberMethodReturn } from "ember/-private/type-utils";
+import {
+  EmberMethod,
+  EmberMethodParams,
+  AnyFn,
+  EmberMethodReturn,
+} from 'ember/-private/type-utils';
 import { EmberRunQueues } from './-private/types';
-import { EmberRunTimer } from "@ember/runloop/types";
+import { EmberRunTimer } from '@ember/runloop/types';
 import '@ember/runloop/-private/backburner';
 
 /**
@@ -17,7 +22,11 @@ import '@ember/runloop/-private/backburner';
  * 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>;
+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
@@ -26,9 +35,9 @@ export function run<T, M extends EmberMethod<T>>(target: T, method: M, ...args:
  */
 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>
+  target: T,
+  method: M,
+  ...args: EmberMethodParams<T, M>
 ): EmberMethodReturn<T, M> | undefined;
 
 /**
@@ -42,9 +51,9 @@ export function join<T, M extends EmberMethod<T>>(
 // `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[]
+  target: T,
+  method: M,
+  ...args: any[]
 ): (...args: any[]) => EmberMethodReturn<T, M>;
 
 /**
@@ -68,15 +77,15 @@ export function end(): void;
  * automatically.
  */
 export function schedule<T, M extends EmberMethod<T>>(
-   queue: EmberRunQueues,
-   target: T,
-   method: M,
-   ...args: EmberMethodParams<T, M>
+  queue: EmberRunQueues,
+  target: T,
+  method: M,
+  ...args: EmberMethodParams<T, M>
 ): EmberRunTimer;
 export function schedule<M extends AnyFn>(
-   queue: EmberRunQueues,
-   method: M,
-   ...args: Parameters<M>
+  queue: EmberRunQueues,
+  method: M,
+  ...args: Parameters<M>
 ): EmberRunTimer;
 
 /**
@@ -86,12 +95,7 @@ export function schedule<M extends AnyFn>(
  */
 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,
-    ]
+  ...args: [target: T, method: M, ...args: EmberMethodParams<T, M>, wait: number]
 ): EmberRunTimer;
 
 /**
@@ -99,9 +103,9 @@ export function later<T, M extends EmberMethod<T>>(
  * to calling `scheduleOnce` with the "actions" queue.
  */
 export function once<T, M extends EmberMethod<T>>(
-   target: T,
-   method: M,
-   ...args: EmberMethodParams<T, M>
+  target: T,
+  method: M,
+  ...args: EmberMethodParams<T, M>
 ): EmberRunTimer;
 
 /**
@@ -110,10 +114,10 @@ export function once<T, M extends EmberMethod<T>>(
  * no effect (past the initial call).
  */
 export function scheduleOnce<T, M extends EmberMethod<T>>(
-   queue: EmberRunQueues,
-   target: T,
-   method: M,
-   ...args: EmberMethodParams<T, M>
+  queue: EmberRunQueues,
+  target: T,
+  method: M,
+  ...args: EmberMethodParams<T, M>
 ): EmberRunTimer;
 
 /**
@@ -122,14 +126,11 @@ export function scheduleOnce<T, M extends EmberMethod<T>>(
  * `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>
+  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()`,
@@ -144,36 +145,28 @@ export function cancel(timer?: EmberRunTimer): boolean;
  * 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(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
-    ]
+  ...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(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
-    ]
+  ...args: [
+    target: T,
+    method: M,
+    ...methodArgs: EmberMethodParams<T, M>,
+    spacing: number,
+    immediate?: boolean
+  ]
 ): EmberRunTimer;
diff --git a/types/preview/@ember/utils/ember__utils-tests.ts b/types/preview/@ember/utils/ember__utils-tests.ts
index 5c9c0787704..b9be7a5b34d 100644
--- a/types/preview/@ember/utils/ember__utils-tests.ts
+++ b/types/preview/@ember/utils/ember__utils-tests.ts
@@ -1,4 +1,5 @@
 /* eslint-disable no-new-wrappers */ // we have to test the new-wrappers!
+import { expectTypeOf } from 'expect-type';
 
 import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@ember/utils';
 
@@ -9,33 +10,33 @@ import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@
     return;
   }
   const anotherString = maybeUndefined + 'another string';
-  isNone(); // $ExpectType boolean
-  isNone(null); // $ExpectType boolean
-  isNone(undefined); // $ExpectType boolean
-  isNone(''); // $ExpectType boolean
-  isNone([]); // $ExpectType boolean
-  isNone(function () {}); // $ExpectType boolean
+  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 */
-  isPresent(); // $ExpectType boolean
-  isPresent(null); // $ExpectType boolean
-  isPresent(undefined); // $ExpectType boolean
-  isPresent(''); // $ExpectType boolean
-  isPresent('  '); // $ExpectType boolean
-  isPresent('\n\t'); // $ExpectType boolean
-  isPresent([]); // $ExpectType boolean
-  isPresent({ length: 0 }); // $ExpectType boolean
-  isPresent(false); // $ExpectType boolean
-  isPresent(true); // $ExpectType boolean
-  isPresent('string'); // $ExpectType boolean
-  isPresent(0); // $ExpectType boolean
-  isPresent(function () {}); // $ExpectType boolean
-  isPresent({}); // $ExpectType boolean
-  isPresent(false); // $ExpectType boolean
-  isPresent('\n\t Hello'); // $ExpectType boolean
-  isPresent([1, 2, 3]); // $ExpectType boolean
+  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 () {
@@ -83,13 +84,15 @@ import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@
 
 (function () {
   /** isEqual */
-  isEqual('foo', 'bar'); // $ExpectType boolean
-  isEqual(14, 37); // $ExpectType boolean
-  isEqual(14, '1'); // $ExpectType boolean
-  isEqual(
-    () => 4,
-    () => 37
-  ); // $ExpectType boolean
+  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
@@ -113,33 +116,33 @@ import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@
 (function () {
   /** isBlank */
 
-  isBlank(); // $ExpectType boolean
-  isBlank(null); // $ExpectType boolean
-  isBlank(undefined); // $ExpectType boolean
-  isBlank(''); // $ExpectType boolean
-  isBlank([]); // $ExpectType boolean
-  isBlank('\n\t'); // $ExpectType boolean
-  isBlank('  '); // $ExpectType boolean
-  isBlank({}); // $ExpectType boolean
-  isBlank('\n\t Hello'); // $ExpectType boolean
-  isBlank('Hello world'); // $ExpectType boolean
-  isBlank([1, 2, 3]); // $ExpectType boolean
+  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 */
 
-  isEmpty(); // $ExpectType boolean
-  isEmpty(null); // $ExpectType boolean
-  isEmpty(undefined); // $ExpectType boolean
-  isEmpty(''); // $ExpectType boolean
-  isEmpty([]); // $ExpectType boolean
-  isEmpty({ size: 0 }); // $ExpectType boolean
-  isEmpty({}); // $ExpectType boolean
-  isEmpty('Adam Hawkins'); // $ExpectType boolean
-  isEmpty([0, 1, 2]); // $ExpectType boolean
-  isEmpty('\n\t'); // $ExpectType boolean
-  isEmpty('  '); // $ExpectType boolean
-  isEmpty({ size: 1 }); // $ExpectType boolean
-  isEmpty({ size: () => 0 }); // $ExpectType boolean
+  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/types/preview/ember/index.d.ts b/types/preview/ember/index.d.ts
index 1d5ba10445c..7fa5d54e922 100755
--- a/types/preview/ember/index.d.ts
+++ b/types/preview/ember/index.d.ts
@@ -10,9 +10,6 @@
 // the Ember namespace.
 import Rsvp from 'rsvp';
 
-import { TemplateFactory } from 'htmlbars-inline-precompile';
-
-import { Registry as ServiceRegistry } from '@ember/service';
 import type { Registry as ControllerRegistry } from '@ember/controller';
 import type * as EmberStringNs from '@ember/string';
 import type * as EmberTemplateNs from '@ember/template';
@@ -24,7 +21,6 @@ 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 EmberObjectMixinNs from '@ember/object/mixin';
 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';
@@ -38,8 +34,6 @@ import EmberDataAdapter from '@ember/debug/data-adapter';
 // @ember/engine
 import * as EmberEngineNs from '@ember/engine';
 import * as EmberEngineInstanceNs from '@ember/engine/instance';
-import _ContainerProxyMixin from '@ember/engine/-private/container-proxy-mixin';
-import _RegistryProxyMixin from '@ember/engine/-private/registry-proxy-mixin';
 import EmberCoreObject from '@ember/object/core';
 import * as EmberApplicationNs from '@ember/application';
 import * as EmberApplicationInstanceNs from '@ember/application/instance';
@@ -68,10 +62,7 @@ import EmberHelper from '@ember/component/helper';
 // @ember/routing
 import EmberRoutingRouter from '@ember/routing/router';
 import EmberRoutingRoute from '@ember/routing/route';
-import EmberRoutingTransition from '@ember/routing/transition';
-import EmberRoutingRouterService from '@ember/routing/router-service';
 import EmberRoutingHashLocation from '@ember/routing/hash-location';
-import EmberRoutingAutoLocation from '@ember/routing/auto-location';
 import EmberRoutingHistoryLocation from '@ember/routing/history-location';
 import EmberRoutingNoneLocation from '@ember/routing/none-location';
 // @ember/application
@@ -81,45 +72,45 @@ import EmberRegistry from '@ember/application/-private/registry';
 import EmberTestAdapter from '@ember/test/adapter';
 
 export namespace Ember {
-  const A: typeof EmberArrayNs.A;
-  const isArray: typeof EmberArrayNs.isArray;
-  type Enumerable<T> = EmberEnumerable<T>;
-  const Enumerable: typeof EmberEnumerable;
-  class ArrayProxy<T> extends EmberArrayProxy<T> {}
-  type Array<T> = EmberArray<T>;
-  const Array: typeof EmberArrayNs.default;
-  type MutableArray<T> = EmberMutableArray<T>;
-  const MutableArray: typeof EmberMutableArray;
-  type NativeArray<T> = EmberNativeArray<T>;
-  const NativeArray: typeof EmberNativeArray;
-  type MutableEnumerable<T> = EmberMutableEnumerable<T>;
-  const MutableEnumerable: typeof EmberMutableEnumerable;
-  class Router extends EmberRoutingRouter {}
-  class Route extends EmberRoutingRoute {}
-  const ActionHandler: typeof EmberActionHandler;
-  class Controller extends EmberControllerNs.default {}
-  class Component extends EmberComponent {}
-  class Helper extends EmberHelper {}
+  export const A: typeof EmberArrayNs.A;
+  export const isArray: typeof EmberArrayNs.isArray;
+  export type Enumerable<T> = EmberEnumerable<T>;
+  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<T> = EmberMutableEnumerable<T>;
+  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 {}
 
-  class HashLocation extends EmberRoutingHashLocation {}
-  class NoneLocation extends EmberRoutingNoneLocation {}
-  class HistoryLocation extends EmberRoutingHistoryLocation {}
-  const deprecateFunc: typeof EmberApplicationDeprecateNs.deprecateFunc;
-  const deprecate: typeof EmberApplicationDeprecateNs.deprecate;
-  const getOwner: typeof EmberApplicationNs.getOwner;
-  const setOwner: typeof EmberApplicationNs.setOwner;
-  class EventDispatcher extends EmberEventDispatcher {}
-  class Registry extends EmberRegistry {}
-  interface ArrayPrototypeExtensions<T> extends EmberArrayProtoExtensions<T> {}
+  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 {}
+  export interface ArrayPrototypeExtensions<T> extends EmberArrayProtoExtensions<T> {}
 
   /**
    * Implements some standard methods for comparing objects. Add this mixin to
    * any class you create that can compare its instances.
    */
-  interface Comparable {
+  export interface Comparable {
     compare(a: unknown, b: unknown): number;
   }
-  const Comparable: EmberMixin<Comparable>;
+  const Comparable: EmberMixin;
   class ComputedProperty extends EmberObjectComputedNs.default {}
   /**
    * A container used to instantiate and cache objects.
diff --git a/types/preview/ember/test/run.ts b/types/preview/ember/test/run.ts
index bba22edd2c7..aa86a35ddc2 100755
--- a/types/preview/ember/test/run.ts
+++ b/types/preview/ember/test/run.ts
@@ -1,220 +1,214 @@
 import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
 import RSVP from 'rsvp';
-import { assertType } from './lib/assert';
 
 function testRun() {
-    const r = Ember.run(() => {
-        // code to be executed within a RunLoop
-        return 123;
+  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();
     });
-    assertType<number>(r);
-
-    function destroyApp(application: Ember.Application) {
-        Ember.run(application, 'destroy');
-        Ember.run(application, function () {
-            this.destroy();
-        });
-    }
+  }
 }
 
-function testBind() {
-    Ember.Component.extend({
-        init() {
-            const bound = Ember.run.bind(this, this.setupEditor);
-            bound();
-        },
+class TestBind extends Ember.Component {
+  init() {
+    const bound = Ember.run.bind(this, this.setupEditor);
+    bound();
+  }
 
-        editor: null as string | null,
+  editor: string | null = null;
 
-        setupEditor(editor: string) {
-            this.set('editor', editor);
-        },
-    });
+  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);
+  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() {}
+  function runIt() {}
 
-    const myContext = { name: 'debounce' };
+  const myContext = { name: 'debounce' };
 
-    Ember.run.debounce(runIt, 150);
-    Ember.run.debounce(myContext, runIt, 150);
-    Ember.run.debounce(myContext, runIt, 150, true);
+  Ember.run.debounce(runIt, 150);
+  Ember.run.debounce(myContext, runIt, 150);
+  Ember.run.debounce(myContext, runIt, 150, true);
 
-    Ember.Component.extend({
-        searchValue: 'test',
-        fetchResults(value: string) {},
+  class TestDebounce extends Ember.Component {
+    searchValue = 'test';
+    declare fetchResults: (value: string) => void;
 
-        actions: {
-            handleTyping() {
-                // the fetchResults function is passed into the component from its parent
-                Ember.run.debounce(this, this.get('fetchResults'), this.get('searchValue'), 250);
-            },
-        },
-    });
+    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();
+  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.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.
-        });
+  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);
-    });
+  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,
-    );
+  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
-    });
+  const myContext = {};
+  Ember.run.next(myContext, () => {
+    // code to be executed in the next run loop,
+    // which will be scheduled after the current one
+  });
 }
 
-function testOnce() {
-    Ember.Component.extend({
-        init() {
-            Ember.run.once(this, 'processFullName');
-        },
+class TestOnce extends Ember.Component {
+  init() {
+    Ember.run.once(this, 'processFullName');
+  }
 
-        processFullName() {},
-    });
+  processFullName() {}
 }
 
-function testSchedule() {
-    Ember.Component.extend({
-        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');
-            });
-        },
-    });
+{
+  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
-    });
+  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 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() {}
+  function runIt() {}
 
-    const myContext = { name: 'throttle' };
+  const myContext = { name: 'throttle' };
 
-    Ember.run.throttle(runIt, 150);
-    Ember.run.throttle(myContext, runIt, 150);
+  Ember.run.throttle(runIt, 150);
+  Ember.run.throttle(myContext, runIt, 150);
 }
diff --git a/types/preview/ember/test/string.ts b/types/preview/ember/test/string.ts
index c05f68f1a3d..d494d78a94e 100644
--- a/types/preview/ember/test/string.ts
+++ b/types/preview/ember/test/string.ts
@@ -1,7 +1,8 @@
 import Ember from 'ember';
 import { SafeString } from '@ember/template/-private/handlebars';
 
-const { dasherize, camelize, capitalize, classify, decamelize, htmlSafe, underscore, w } = Ember.String;
+const { dasherize, camelize, capitalize, classify, decamelize, htmlSafe, underscore, w } =
+  Ember.String;
 
 // @ts-expect-error
 dasherize();
diff --git a/types/preview/ember/test/transition.ts b/types/preview/ember/test/transition.ts
index 53eb4397764..303fe28ecdb 100755
--- a/types/preview/ember/test/transition.ts
+++ b/types/preview/ember/test/transition.ts
@@ -1,29 +1,5 @@
 import Ember from 'ember';
 import Transition from '@ember/routing/transition';
+import { expectTypeOf } from 'expect-type';
 
-Ember.Route.extend({
-    beforeModel(transition: Transition) {
-        if (new Date() > new Date('January 1, 1980')) {
-            alert('Sorry, you need a time machine to enter this route.');
-            transition.abort();
-        }
-    },
-});
-
-Ember.Controller.extend({
-    previousTransition: null as Transition | null,
-
-    actions: {
-        login() {
-            // Log the user in, then reattempt previous transition if it exists.
-            const previousTransition = this.get('previousTransition');
-            if (previousTransition) {
-                this.set('previousTransition', null);
-                previousTransition.retry();
-            } else {
-                // Default back to homepage
-                this.transitionToRoute('index');
-            }
-        },
-    },
-});
+expectTypeOf<Parameters<Ember.Route['beforeModel']>[0]>().toEqualTypeOf<Transition>();
diff --git a/types/preview/ember/test/utils.ts b/types/preview/ember/test/utils.ts
index ef0504eba30..91796516054 100755
--- a/types/preview/ember/test/utils.ts
+++ b/types/preview/ember/test/utils.ts
@@ -1,146 +1,148 @@
 import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
 import { assertType } from './lib/assert';
 
 function testTypeOf() {
-    Ember.typeOf(); // $ExpectType "undefined"
-    const str: string = Ember.typeOf({});
+  Ember.typeOf(); // $ExpectType "undefined"
+  const str: string = Ember.typeOf({});
 }
 
 function testIsNoneType() {
-    const maybeUndefined: string | undefined = 'not actually undefined';
-    if (Ember.isNone(maybeUndefined)) {
-        return;
-    }
+  const maybeUndefined: string | undefined = 'not actually undefined';
+  if (Ember.isNone(maybeUndefined)) {
+    return;
+  }
 
-    const anotherString = maybeUndefined + 'another string';
-    Ember.isNone(); // $ExpectType boolean
+  const anotherString = maybeUndefined + 'another string';
+  Ember.isNone(); // $ExpectType boolean
 }
 
 function testIsBlank() {
-    Ember.isBlank(); // $ExpectType boolean
-    Ember.isBlank(''); // $ExpectType boolean
-    // @ts-expect-error
-    Ember.isBlank('', '');
+  Ember.isBlank(); // $ExpectType boolean
+  Ember.isBlank(''); // $ExpectType boolean
+  // @ts-expect-error
+  Ember.isBlank('', '');
 }
 
 function testIsEmpty() {
-    Ember.isEmpty(); // $ExpectType boolean
-    Ember.isEmpty(''); // $ExpectType boolean
-    // @ts-expect-error
-    Ember.isEmpty('', '');
+  Ember.isEmpty(); // $ExpectType boolean
+  Ember.isEmpty(''); // $ExpectType boolean
+  // @ts-expect-error
+  Ember.isEmpty('', '');
 }
 
 function testIsPresent() {
-    Ember.isPresent(); // $ExpectType boolean
-    Ember.isPresent(''); // $ExpectType boolean
-    // @ts-expect-error
-    Ember.isPresent('', '');
+  Ember.isPresent(); // $ExpectType boolean
+  Ember.isPresent(''); // $ExpectType boolean
+  // @ts-expect-error
+  Ember.isPresent('', '');
 }
 
 function testIsNone() {
-    Ember.isNone(); // $ExpectType boolean
-    Ember.isNone(''); // $ExpectType boolean
-    // @ts-expect-error
-    Ember.isNone('', '');
+  Ember.isNone(); // $ExpectType boolean
+  Ember.isNone(''); // $ExpectType boolean
+  // @ts-expect-error
+  Ember.isNone('', '');
 }
 
 function testAssign() {
-    assertType<{ first: string; middle: string; last: string }>(
-        Ember.assign({ first: 'Tom' }, { middle: 'M' }, { last: 'Dale' }),
-    );
+  assertType<{ first: string; middle: string; last: string }>(
+    Ember.assign({ first: 'Tom' }, { middle: 'M' }, { last: 'Dale' })
+  );
 }
 
 function testOnError() {
-    Ember.onerror = error => {
-        fetch('/report-error', {
-            method: 'POST',
-            body: JSON.stringify({
-                stack: error.stack,
-                otherInformation: 'whatever app state you want to provide',
-            })
-        });
-    };
+  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,
-    );
-    assertType<string>(newMethod('first', 123));
-    assertType<string>(oldMethod('first', 123));
+  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() {
-    const 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 () {
-            return `${this.firstName} ${this.lastName}`;
-        }),
-    );
+  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 */
-    Ember.typeOf(); // $ExpectType "undefined"
-    Ember.typeOf(null); // $ExpectType "null"
-    Ember.typeOf(undefined); // $ExpectType "undefined"
-    Ember.typeOf('michael'); // $ExpectType "string"
-    // tslint:disable-next-line:no-construct
-    Ember.typeOf(new String('michael')); // $ExpectType "string"
-    Ember.typeOf(101); // $ExpectType "number"
-    // tslint:disable-next-line:no-construct
-    Ember.typeOf(new Number(101)); // $ExpectType "number"
-    Ember.typeOf(true); // $ExpectType "boolean"
-    // tslint:disable-next-line:no-construct
-    Ember.typeOf(new Boolean(true)); // $ExpectType "boolean"
-    Ember.typeOf(() => 4); // $ExpectType "function"
-    Ember.typeOf([1, 2, 90]); // $ExpectType "array"
-    Ember.typeOf(/abc/); // $ExpectType "regexp"
-    Ember.typeOf(new Date()); // $ExpectType "date"
-    Ember.typeOf(fileList); // $ExpectType "filelist"
-    Ember.typeOf(Ember.Object.extend()); // $ExpectType "class"
-    Ember.typeOf(Ember.Object.create()); // $ExpectType "instance"
-    Ember.typeOf(new Error('teamocil')); // $ExpectType "error"
-    Ember.typeOf(new Date() as RegExp | Date); // "regexp" | "date"
-    Ember.typeOf({ randomObject: true }); // $ExpectType "object"
+  /** typeOf */
+  Ember.typeOf(); // $ExpectType "undefined"
+  Ember.typeOf(null); // $ExpectType "null"
+  Ember.typeOf(undefined); // $ExpectType "undefined"
+  Ember.typeOf('michael'); // $ExpectType "string"
+  // tslint:disable-next-line:no-construct
+  Ember.typeOf(new String('michael')); // $ExpectType "string"
+  Ember.typeOf(101); // $ExpectType "number"
+  // tslint:disable-next-line:no-construct
+  Ember.typeOf(new Number(101)); // $ExpectType "number"
+  Ember.typeOf(true); // $ExpectType "boolean"
+  // tslint:disable-next-line:no-construct
+  Ember.typeOf(new Boolean(true)); // $ExpectType "boolean"
+  Ember.typeOf(() => 4); // $ExpectType "function"
+  Ember.typeOf([1, 2, 90]); // $ExpectType "array"
+  Ember.typeOf(/abc/); // $ExpectType "regexp"
+  Ember.typeOf(new Date()); // $ExpectType "date"
+  Ember.typeOf(fileList); // $ExpectType "filelist"
+  Ember.typeOf(Ember.Object.extend()); // $ExpectType "class"
+  Ember.typeOf(Ember.Object.create()); // $ExpectType "instance"
+  Ember.typeOf(new Error('teamocil')); // $ExpectType "error"
+  Ember.typeOf(new Date() as RegExp | Date); // "regexp" | "date"
+  Ember.typeOf({ randomObject: true }); // $ExpectType "object"
 })();
 
 (() => {
-    /* assign */
-    Ember.assign({}, { a: 'b' });
-    Ember.assign({}, { a: 'b' }).a; // $ExpectType string
-    Ember.assign({ a: 6 }, { a: 'b' }).a; // $ExpectType string
-    Ember.assign({ a: 6 }, {}).a; // $ExpectType number
-    // @ts-expect-error
-    Ember.assign({ b: 6 }, {}).a;
-    Ember.assign({}, { b: 6 }, {}).b; // $ExpectType number
-    Ember.assign({ a: 'hello' }, { b: 6 }, {}).a; // $ExpectType string
-    Ember.assign({ a: 'hello' }, { b: 6 }, { a: true }).a; // $ExpectType boolean
-    // @ts-expect-error
-    Ember.assign({ a: 'hello' }, '', { a: true }).a;
-    Ember.assign({ d: ['gobias industries'] }, { a: 'hello' }, { b: 6 }, { a: true }).d; // $ExpectType string[]
+  /* assign */
+  Ember.assign({}, { a: 'b' });
+  Ember.assign({}, { a: 'b' }).a; // $ExpectType string
+  Ember.assign({ a: 6 }, { a: 'b' }).a; // $ExpectType string
+  Ember.assign({ a: 6 }, {}).a; // $ExpectType number
+  // @ts-expect-error
+  Ember.assign({ b: 6 }, {}).a;
+  Ember.assign({}, { b: 6 }, {}).b; // $ExpectType number
+  Ember.assign({ a: 'hello' }, { b: 6 }, {}).a; // $ExpectType string
+  Ember.assign({ a: 'hello' }, { b: 6 }, { a: true }).a; // $ExpectType boolean
+  // @ts-expect-error
+  Ember.assign({ a: 'hello' }, '', { a: true }).a;
+  Ember.assign({ d: ['gobias industries'] }, { a: 'hello' }, { b: 6 }, { a: true }).d; // $ExpectType string[]
 })();

From 14acfd7ee471e21680daa643526621172b0c1b39 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Fri, 26 Aug 2022 13:49:55 -0600
Subject: [PATCH 03/39] Fix many errors in types preview

- Improve the way we do a minimal representation of the Ember Object
  primitives and utilities.
- Introduce our own copy of `@ember/string`.
- Start workk on many of the tests for `Ember` namespace re-exports.
- Stop distinguishing between Octane and everything else: we only care
  about Octane anyway in our public *TS* API, per RFC 0800.
---
 .../@ember/array/-private/enumerable.d.ts     |  13 +-
 .../array/-private/mutable-enumerable.d.ts    |  34 +-
 types/preview/@ember/object/core.d.ts         |   6 +-
 types/preview/@ember/object/test/computed.ts  | 585 +++++++++++-------
 types/preview/@ember/object/test/core.ts      | 268 ++++----
 types/preview/@ember/object/test/octane.ts    | 331 ----------
 types/preview/@ember/routing/test/router.ts   | 146 ++---
 .../@ember/string/ember__string-tests.ts      |  52 ++
 types/preview/@ember/string/index.d.ts        |   7 +
 types/preview/@ember/string/tsconfig.json     |   3 +
 types/preview/ember/index.d.ts                |  10 +-
 types/preview/ember/test/computed.ts          | 258 +++-----
 types/preview/ember/test/helper.ts            |  37 +-
 types/preview/ember/test/mixin.ts             |  63 +-
 types/preview/ember/test/object.ts            | 136 ++--
 types/preview/ember/test/observable.ts        |  42 +-
 .../ember/test/private/computed-tests.ts      | 110 +---
 types/preview/ember/test/reopen.ts            |  67 +-
 types/preview/ember/test/route.ts             | 125 ++--
 types/preview/ember/test/router.ts            |  83 +--
 20 files changed, 1072 insertions(+), 1304 deletions(-)
 delete mode 100644 types/preview/@ember/object/test/octane.ts
 create mode 100644 types/preview/@ember/string/ember__string-tests.ts
 create mode 100644 types/preview/@ember/string/index.d.ts
 create mode 100644 types/preview/@ember/string/tsconfig.json

diff --git a/types/preview/@ember/array/-private/enumerable.d.ts b/types/preview/@ember/array/-private/enumerable.d.ts
index ca22d5a29fc..eb33abcf7df 100644
--- a/types/preview/@ember/array/-private/enumerable.d.ts
+++ b/types/preview/@ember/array/-private/enumerable.d.ts
@@ -1,14 +1,7 @@
 import ComputedProperty from '@ember/object/computed';
 import Mixin from '@ember/object/mixin';
 import NativeArray from '@ember/array/-private/native-array';
-import EmberArray from '@ember/array';
-import {
-  AnyFn,
-  MethodNamesOf,
-  MethodParams,
-  MethodReturns,
-  MethodsOf,
-} from 'ember/-private/type-utils';
+import { MethodNamesOf, MethodParams, MethodReturns } from 'ember/-private/type-utils';
 
 /**
  * This mixin defines the common interface implemented by enumerable objects
@@ -172,8 +165,8 @@ interface Enumerable<T> {
    * this property, it will return this. If you set this property to a new
    * array, it will replace the current content.
    */
-  '[]': ComputedProperty<this>;
+  '[]': ComputedProperty;
 }
 
-declare const Enumerable: Mixin<Enumerable<unknown>>;
+declare 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
index c2786508b29..b6785f8fe33 100644
--- a/types/preview/@ember/array/-private/mutable-enumerable.d.ts
+++ b/types/preview/@ember/array/-private/mutable-enumerable.d.ts
@@ -7,22 +7,22 @@ import Enumerable from '@ember/array/-private/enumerable';
  * unordered.
  */
 interface MutableEnumerable<T> extends Enumerable<T> {
-    /**
-     * __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: Enumerable<T>): this;
-    /**
-     * __Required.__ You must implement this method to apply this mixin.
-     */
-    removeObject(object: T): T;
-    /**
-     * Removes each object in the passed enumerable from the receiver.
-     */
-    removeObjects(objects: Enumerable<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: Enumerable<T>): this;
+  /**
+   * __Required.__ You must implement this method to apply this mixin.
+   */
+  removeObject(object: T): T;
+  /**
+   * Removes each object in the passed enumerable from the receiver.
+   */
+  removeObjects(objects: Enumerable<T>): this;
 }
-declare const MutableEnumerable: Mixin<MutableEnumerable<unknown>>;
+declare const MutableEnumerable: Mixin;
 export default MutableEnumerable;
diff --git a/types/preview/@ember/object/core.d.ts b/types/preview/@ember/object/core.d.ts
index 58d719ad6cc..f9ecbbb256a 100644
--- a/types/preview/@ember/object/core.d.ts
+++ b/types/preview/@ember/object/core.d.ts
@@ -60,7 +60,7 @@ export default class CoreObject {
 
   static create<Class extends typeof CoreObject>(
     this: Class,
-    ...initialValues: Array<Mixin | Record<string, unknown>>
+    ...initialValues: Array<Mixin | MembersOf<Class>>
   ): InstanceType<Class>;
 
   static extend<Statics, Instance>(
@@ -81,3 +81,7 @@ export default class CoreObject {
   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/test/computed.ts b/types/preview/@ember/object/test/computed.ts
index fa99c5ede92..cbb90910b6d 100644
--- a/types/preview/@ember/object/test/computed.ts
+++ b/types/preview/@ember/object/test/computed.ts
@@ -1,231 +1,396 @@
 import EmberObject, { computed } from '@ember/object';
-import ComputedProperty, {
-    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,
+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 { assertType } from './lib/assert';
-
-const Person = EmberObject.extend({
-    firstName: '',
-    lastName: '',
-    age: 0,
-
-    noArgs: computed<string>(() => 'test'),
-
-    fullName: computed<string>('firstName', 'lastName', function () {
-        return `${this.get('firstName')} ${this.get('lastName')}`;
-    }),
-
-    fullNameReadonly: computed<string>('fullName', function () {
-        return this.get('fullName');
-    }).readOnly(),
-
-    fullNameWritable: computed<string>('firstName', 'lastName', {
-        get() {
-            return this.get('fullName');
-        },
-        set(key, value) {
-            const [first, last] = value.split(' ');
-            this.set('firstName', first);
-            this.set('lastName', last);
-            return value;
-        },
-    }),
-
-    fullNameGetOnly: computed<string>('fullName', {
-        get() {
-            return this.get('fullName');
-        },
-    }),
-
-    fullNameSetOnly: computed<string>('firstName', 'lastName', {
-        set(key, value) {
-            const [first, last] = value.split(' ');
-            this.set('firstName', first);
-            this.set('lastName', last);
-            return value;
-        },
-    }),
-
-    combinators: computed<string>(function () {
-        return this.get('firstName');
-    })
-        .property('firstName')
-        .meta({ foo: 'bar' })
-        .volatile()
-        .readOnly(),
-
-    explicitlyDeclared: alias('fullName') as ComputedProperty<string>,
-});
+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,
+  firstName: 'Fred',
+  lastName: 'Smith',
+  age: 29,
 });
 
-assertType<string>(person.firstName);
-assertType<number>(person.age);
-assertType<ComputedProperty<string>>(person.noArgs);
-assertType<ComputedProperty<string>>(person.fullName);
-assertType<ComputedProperty<string>>(person.fullNameReadonly);
-assertType<ComputedProperty<string>>(person.fullNameWritable);
-assertType<ComputedProperty<string>>(person.fullNameGetOnly);
-assertType<ComputedProperty<string>>(person.fullNameSetOnly);
-assertType<ComputedProperty<string>>(person.combinators);
-assertType<ComputedProperty<string>>(person.explicitlyDeclared);
-
-assertType<string>(person.get('firstName'));
-assertType<number>(person.get('age'));
-assertType<string>(person.get('noArgs'));
-assertType<string>(person.get('fullName'));
-assertType<string>(person.get('fullNameReadonly'));
-assertType<string>(person.get('fullNameWritable'));
-assertType<string>(person.get('fullNameGetOnly'));
-assertType<string>(person.get('fullNameSetOnly'));
-assertType<string>(person.get('combinators'));
-assertType<string>(person.get('explicitlyDeclared'));
-
-assertType<{ firstName: string; fullName: string; age: number }>(person.getProperties('firstName', 'fullName', 'age'));
+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',
+  fullName: 'Fred Smith',
 });
 
-assertType<string>(person2.get('firstName'));
-assertType<string>(person2.get('fullName'));
+expectTypeOf(person2.get('firstName')).toEqualTypeOf<string>();
+expectTypeOf(person2.get('fullName')).toEqualTypeOf<string>();
 
 const person3 = Person.extend({
-    firstName: 'Fred',
-    fullName: 'Fred Smith',
+  firstName: 'Fred',
+  fullName: 'Fred Smith',
 }).create();
 
-assertType<string>(person3.get('firstName'));
-assertType<string>(person3.get('fullName'));
+expectTypeOf(person3.get('firstName')).toEqualTypeOf<string>();
+expectTypeOf(person3.get('fullName')).toEqualTypeOf<string>();
 
 const person4 = Person.extend({
-    firstName: computed(() => 'Fred'),
-    fullName: computed(() => 'Fred Smith'),
+  firstName: computed(() => 'Fred'),
+  fullName: computed(() => 'Fred Smith'),
 }).create();
 
-assertType<string>(person4.get('firstName'));
-assertType<string>(person4.get('fullName'));
+expectTypeOf(person4.get('firstName')).toEqualTypeOf<string>();
+expectTypeOf(person4.get('fullName')).toEqualTypeOf<string>();
 
 // computed property macros
-const objectWithComputedProperties = EmberObject.extend({
-    alias: alias('foo'),
-    and: and('foo', 'bar', 'baz', 'qux'),
-    bool: bool('foo'),
-    collect: collect('foo', 'bar', 'baz', 'qux'),
-    deprecatingAlias: deprecatingAlias('foo', {
-        id: 'hamster.deprecate-banana',
-        until: '3.0.0',
-    }),
-    empty: empty('foo'),
-    equalNumber: equal('foo', 1),
-    equalString: equal('foo', 'bar'),
-    equalObject: equal('foo', {}),
-    filter1: filter('foo', item => item === 'bar'),
-    filter2: filter('foo', ['bar', 'baz'], item => item === 'bar'),
-    filterBy1: filterBy('foo', 'bar'),
-    filterBy2: filterBy('foo', 'bar', false),
-    gt: gt('foo', 3),
-    gte: gte('foo', 3),
-    intersect: intersect('foo', 'bar', 'baz', 'qux'),
-    lt: lt('foo', 3),
-    lte: lte('foo', 3),
-    map: map('foo', (item, index) => item),
-    mapBy: mapBy('foo', 'bar'),
-    match: match('foo', /^tom.ter$/),
-    max: max('foo'),
-    min: min('foo'),
-    none: none('foo'),
-    not: not('foo'),
-    notEmpty: notEmpty('foo'),
-    oneWay: oneWay('foo'),
-    or: or('foo', 'bar', 'baz', 'qux'),
-    readOnly: readOnly('foo'),
-    reads: reads('foo'),
-    setDiff: setDiff('foo', 'bar'),
-    sort1: sort('foo', 'bar'),
-    sort2: sort('foo', (itemA, itemB) => {
-      return `${itemA}`.length - `${itemB}`.length;
-    }),
-    sort3: sort('foo', ['bar', 'baz'], (itemA, itemB) => {
-      return `${itemA}`.length - `${itemB}`.length;
-    }),
-
-    sum: sum('foo'),
-    union: union('foo', 'bar', 'baz', 'qux'),
-    uniq: uniq('foo'),
-    uniqBy: uniqBy('foo', 'bar'),
-}).create();
+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;
 
-assertType<unknown>(objectWithComputedProperties.get('alias'));
-assertType<unknown>(objectWithComputedProperties.get('and'));
-assertType<boolean>(objectWithComputedProperties.get('bool'));
-assertType<unknown[]>(objectWithComputedProperties.get('collect'));
-assertType<unknown>(objectWithComputedProperties.get('deprecatingAlias'));
-assertType<boolean>(objectWithComputedProperties.get('empty'));
-assertType<boolean>(objectWithComputedProperties.get('equalNumber'));
-assertType<boolean>(objectWithComputedProperties.get('equalString'));
-assertType<boolean>(objectWithComputedProperties.get('equalObject'));
-assertType<unknown[]>(objectWithComputedProperties.get('filter1'));
-assertType<unknown[]>(objectWithComputedProperties.get('filter2'));
-assertType<unknown[]>(objectWithComputedProperties.get('filterBy1'));
-assertType<unknown[]>(objectWithComputedProperties.get('filterBy2'));
-assertType<boolean>(objectWithComputedProperties.get('gt'));
-assertType<boolean>(objectWithComputedProperties.get('gte'));
-assertType<unknown[]>(objectWithComputedProperties.get('intersect'));
-assertType<boolean>(objectWithComputedProperties.get('lt'));
-assertType<boolean>(objectWithComputedProperties.get('lte'));
-assertType<unknown[]>(objectWithComputedProperties.get('map'));
-assertType<unknown[]>(objectWithComputedProperties.get('mapBy'));
-assertType<boolean>(objectWithComputedProperties.get('match'));
-assertType<number>(objectWithComputedProperties.get('max'));
-assertType<number>(objectWithComputedProperties.get('min'));
-assertType<boolean>(objectWithComputedProperties.get('none'));
-assertType<boolean>(objectWithComputedProperties.get('not'));
-assertType<boolean>(objectWithComputedProperties.get('notEmpty'));
-assertType<unknown>(objectWithComputedProperties.get('oneWay'));
-assertType<unknown>(objectWithComputedProperties.get('or'));
-assertType<unknown>(objectWithComputedProperties.get('readOnly'));
-assertType<unknown>(objectWithComputedProperties.get('reads'));
-assertType<unknown[]>(objectWithComputedProperties.get('setDiff'));
-assertType<unknown[]>(objectWithComputedProperties.get('sort1'));
-assertType<unknown[]>(objectWithComputedProperties.get('sort2'));
-assertType<unknown[]>(objectWithComputedProperties.get('sort3'));
-assertType<number>(objectWithComputedProperties.get('sum'));
-assertType<unknown[]>(objectWithComputedProperties.get('union'));
-assertType<unknown[]>(objectWithComputedProperties.get('uniq'));
-assertType<unknown[]>(objectWithComputedProperties.get('uniqBy'));
+  // @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/types/preview/@ember/object/test/core.ts b/types/preview/@ember/object/test/core.ts
index 650e2c22066..ce913dcf889 100644
--- a/types/preview/@ember/object/test/core.ts
+++ b/types/preview/@ember/object/test/core.ts
@@ -28,11 +28,11 @@ co3.bar; // $ExpectType number
 
 /** .extend with a zero-argument .create()  */
 const co4 = CoreObject.extend({
-    foo: '123',
-    bar: 456,
-    baz(): [string, number] {
-        return [this.foo, this.bar];
-    },
+  foo: '123',
+  bar: 456,
+  baz(): [string, number] {
+    return [this.foo, this.bar];
+  },
 }).create();
 
 co4.foo; // $ExpectType string
@@ -41,11 +41,11 @@ co4.baz; // $ExpectType () => [string, number]
 
 /** .extend with inconsistent arguments passed into .create()  */
 const class05 = CoreObject.extend({
-    foo: '123' as string | boolean,
-    bar: 456,
-    baz() {
-        return [this.foo, this.bar];
-    },
+  foo: '123' as string | boolean,
+  bar: 456,
+  baz() {
+    return [this.foo, this.bar];
+  },
 });
 // @ts-expect-error
 const c05 = class05.create({ foo: 99 });
@@ -58,35 +58,35 @@ assertType<boolean>(c05c.foo);
 
 /** two .extend arguments with a zero-argument .create() */
 const co6 = CoreObject.extend(
-    {
-        foo: '123',
-        bar: 456,
-        baz() {
-            return [this.foo, this.bar];
-        },
-        func1() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            this.foo; // $ExpectType string
-            // this does not include stuff from later extend args
-            // @ts-expect-error
-            this.bee;
-        },
+  {
+    foo: '123',
+    bar: 456,
+    baz() {
+      return [this.foo, this.bar];
     },
-    {
-        foo: 99,
-        bee: 'honey',
-        func2() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-            this.foo;
-            // this includes stuff from earlier extend-args
-            this.bar; // $ExpectType number
-        },
+    func1() {
+      // this includes stuff from CoreObject
+      this.init; // $ExpectType () => void
+      // this includes stuff from this extend-arg
+      this.foo; // $ExpectType string
+      // this does not include stuff from later extend args
+      // @ts-expect-error
+      this.bee;
     },
+  },
+  {
+    foo: 99,
+    bee: 'honey',
+    func2() {
+      // this includes stuff from CoreObject
+      this.init; // $ExpectType () => void
+      // this includes stuff from this extend-arg
+      // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+      this.foo;
+      // this includes stuff from earlier extend-args
+      this.bar; // $ExpectType number
+    },
+  }
 ).create();
 
 // TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
@@ -96,48 +96,48 @@ assertType<() => Array<string | number>>(co6.baz); // $ExpectType () => (string
 
 /** three .extend arguments with a zero-argument .create() */
 const co7 = CoreObject.extend(
-    {
-        foo: '123',
-        bar: 456,
-        baz() {
-            return [this.foo, this.bar];
-        },
-        func1() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            this.foo; // $ExpectType string
-            // this does not include stuff from later extend args
-            // @ts-expect-error
-            this.bee;
-        },
+  {
+    foo: '123',
+    bar: 456,
+    baz() {
+      return [this.foo, this.bar];
+    },
+    func1() {
+      // this includes stuff from CoreObject
+      this.init; // $ExpectType () => void
+      // this includes stuff from this extend-arg
+      this.foo; // $ExpectType string
+      // this does not include stuff from later extend args
+      // @ts-expect-error
+      this.bee;
     },
-    {
-        foo: 99,
-        bee: 'honey',
-        func2() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-            this.foo;
-            // this includes stuff from earlier extend-args
-            this.bar; // $ExpectType number
-        },
+  },
+  {
+    foo: 99,
+    bee: 'honey',
+    func2() {
+      // this includes stuff from CoreObject
+      this.init; // $ExpectType () => void
+      // this includes stuff from this extend-arg
+      // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+      this.foo;
+      // this includes stuff from earlier extend-args
+      this.bar; // $ExpectType number
     },
-    {
-        foo: '99',
-        money: 'in the banana stand',
-        func3() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            this.money; // $ExpectType string
-            // this includes stuff from earlier extend-args
-            this.bee; // $ExpectType string
-            this.bar; // $ExpectType number
-        },
+  },
+  {
+    foo: '99',
+    money: 'in the banana stand',
+    func3() {
+      // this includes stuff from CoreObject
+      this.init; // $ExpectType () => void
+      // this includes stuff from this extend-arg
+      this.money; // $ExpectType string
+      // this includes stuff from earlier extend-args
+      this.bee; // $ExpectType string
+      this.bar; // $ExpectType number
     },
+  }
 ).create();
 // TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
 // assertType<number>(co7.foo); // @ts-expect-error
@@ -147,68 +147,68 @@ assertType<() => Array<string | number>>(co7.baz); // $ExpectType () => (string
 
 /** four .extend arguments with a zero-argument .create() */
 const co8 = CoreObject.extend(
-    {
-        foo: '123',
-        bar: 456,
-        baz() {
-            return [this.foo, this.bar];
-        },
-        func1() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            this.foo; // $ExpectType string
-            // this does not include stuff from later extend args
-            // @ts-expect-error
-            this.bee;
-        },
+  {
+    foo: '123',
+    bar: 456,
+    baz() {
+      return [this.foo, this.bar];
+    },
+    func1() {
+      // this includes stuff from CoreObject
+      this.init; // $ExpectType () => void
+      // this includes stuff from this extend-arg
+      this.foo; // $ExpectType string
+      // this does not include stuff from later extend args
+      // @ts-expect-error
+      this.bee;
     },
-    {
-        foo: 99,
-        bee: 'honey',
-        func2() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-            this.foo;
-            // this includes stuff from earlier extend-args
-            this.bar; // $ExpectType number
-            // this does not include stuff from later extend args
-            // @ts-expect-error
-            this.money;
-        },
+  },
+  {
+    foo: 99,
+    bee: 'honey',
+    func2() {
+      // this includes stuff from CoreObject
+      this.init; // $ExpectType () => void
+      // this includes stuff from this extend-arg
+      // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
+      this.foo;
+      // this includes stuff from earlier extend-args
+      this.bar; // $ExpectType number
+      // this does not include stuff from later extend args
+      // @ts-expect-error
+      this.money;
     },
-    {
-        foo: '99',
-        money: 'in the banana stand',
-        func3() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            this.money; // $ExpectType string
-            // this includes stuff from earlier extend-args
-            this.bee; // $ExpectType string
-            this.bar; // $ExpectType number
-            // this does not include stuff from later extend args
-            // @ts-expect-error
-            this.neighborhood;
-        },
+  },
+  {
+    foo: '99',
+    money: 'in the banana stand',
+    func3() {
+      // this includes stuff from CoreObject
+      this.init; // $ExpectType () => void
+      // this includes stuff from this extend-arg
+      this.money; // $ExpectType string
+      // this includes stuff from earlier extend-args
+      this.bee; // $ExpectType string
+      this.bar; // $ExpectType number
+      // this does not include stuff from later extend args
+      // @ts-expect-error
+      this.neighborhood;
     },
-    {
-        foo: '99',
-        neighborhood: 'sudden valley',
-        func4() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            this.neighborhood; // $ExpectType string
-            // this includes stuff from earlier extend-args
-            this.bee; // $ExpectType string
-            this.bar; // $ExpectType number
-            this.money; // $ExpectType string
-        },
+  },
+  {
+    foo: '99',
+    neighborhood: 'sudden valley',
+    func4() {
+      // this includes stuff from CoreObject
+      this.init; // $ExpectType () => void
+      // this includes stuff from this extend-arg
+      this.neighborhood; // $ExpectType string
+      // this includes stuff from earlier extend-args
+      this.bee; // $ExpectType string
+      this.bar; // $ExpectType number
+      this.money; // $ExpectType string
     },
+  }
 ).create();
 
 // TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
diff --git a/types/preview/@ember/object/test/octane.ts b/types/preview/@ember/object/test/octane.ts
deleted file mode 100644
index adc1526aff8..00000000000
--- a/types/preview/@ember/object/test/octane.ts
+++ /dev/null
@@ -1,331 +0,0 @@
-import { action, computed, default as EmberObject } from '@ember/object';
-import {
-  alias,
-  and,
-  bool,
-  collect,
-  deprecatingAlias,
-  empty,
-  equal,
-  filter,
-  filterBy,
-  gt,
-  gte,
-  intersect,
-  lt,
-  lte,
-  map,
-  mapBy,
-  match,
-  max,
-  min,
-  none,
-  not,
-  notEmpty,
-  oneWay,
-  or,
-  readOnly,
-  reads,
-  setDiff,
-  sort,
-  sum,
-  union,
-  uniq,
-  uniqBy,
-} from '@ember/object/computed';
-
-function customMacro(message: string) {
-  return computed(() => {
-    return [message, message];
-  });
-}
-
-// Native class syntax
-class Foo extends EmberObject {
-  declare firstName: string;
-  declare lastName: string;
-
-  // @ts-expect-error -- action only works on methods
-  @action
-  bar!: string;
-
-  @computed('firstName', 'lastName')
-  get fullName() {
-    return `${this.firstName} ${this.lastName}`;
-  }
-
-  // @ts-expect-error -- we require this to be with a getter.
-  @computed('firstName', 'lastName')
-  declare badFullName: string;
-
-  @computed('fullName', function (this: Foo) {
-    return this.fullName.toUpperCase();
-  })
-  declare bigFullName: string;
-
-  @customMacro('hi')
-  declare hiTwice: string[];
-
-  @action
-  foo() {
-    /* no op demo */
-  }
-}
-
-// 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: any;
-  @collect() declare collectTest1: any;
-  @collect('firstName') declare collectTest2: any;
-
-  // @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: any[];
-  // @ts-expect-error
-  @filterBy() declare filterByTest2: any[];
-  // @ts-expect-error
-  @filterBy('firstName') declare filterByTest3: any[];
-  @filterBy('firstName', 'id') declare filterByTest4: any[];
-
-  // @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: any;
-  @union() declare unionTest2: any;
-  @union('firstName') declare unionTest3: any;
-  @union('firstName', 'lastName') declare unionTest4: any;
-
-  // @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/types/preview/@ember/routing/test/router.ts b/types/preview/@ember/routing/test/router.ts
index 0ef27748380..fab3ba98b8b 100755
--- a/types/preview/@ember/routing/test/router.ts
+++ b/types/preview/@ember/routing/test/router.ts
@@ -1,81 +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('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('new');
+    this.route('post', { path: '/post/:post_id', resetNamespace: true });
+    this.route('comments', { resetNamespace: true }, function () {
+      this.route('new');
     });
-    this.route('not-found', { path: '/*path' });
-    this.mount('my-engine');
-    this.mount('my-engine', { as: 'some-other-engine', path: '/some-other-engine' });
+  });
+  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' });
 });
 
-const RouterServiceConsumer = Service.extend({
-    router: service('router'),
-    currentRouteName() {
-        const x: string = get(this, 'router').currentRouteName;
-    },
-    currentURL() {
-        const x: string = get(this, 'router').currentURL;
-    },
-    rootURL() {
-        const x: string = get(this, 'router').rootURL;
-    },
-    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;
-                to.child; // $ExpectType RouteInfo | null
-                to.localName; // $ExpectType string
-                to.name; // $ExpectType string
-                to.paramNames; // $ExpectType string[]
-                to.params.foo; // $ExpectType string | undefined
-                to.parent; // $ExpectType RouteInfo | null
-                to.queryParams.foo; // $ExpectType string | undefined
-                to.find(info => info.name === 'foo'); // $ExpectType RouteInfo | undefined
-            })
-            .on('routeDidChange', transition => {
-                const from = transition.from;
-                if (from) {
-                    from.child; // $ExpectType RouteInfo | null
-                    from.localName; // $ExpectType string
-                    from.name; // $ExpectType string
-                    from.paramNames; // $ExpectType string[]
-                    from.params.foo; // $ExpectType string | undefined
-                    from.parent; // $ExpectType RouteInfo | null
-                    from.queryParams.foo; // $ExpectType string | undefined
-                    from.find(info => info.name === 'foo'); // $ExpectType RouteInfo | undefined
-                }
-            });
-    },
-});
+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/types/preview/@ember/string/ember__string-tests.ts b/types/preview/@ember/string/ember__string-tests.ts
new file mode 100644
index 00000000000..bd5f513b4c2
--- /dev/null
+++ b/types/preview/@ember/string/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/types/preview/@ember/string/index.d.ts b/types/preview/@ember/string/index.d.ts
new file mode 100644
index 00000000000..6a6f95b8ed5
--- /dev/null
+++ b/types/preview/@ember/string/index.d.ts
@@ -0,0 +1,7 @@
+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/index.d.ts b/types/preview/ember/index.d.ts
index 7fa5d54e922..a3210233f40 100755
--- a/types/preview/ember/index.d.ts
+++ b/types/preview/ember/index.d.ts
@@ -147,7 +147,7 @@ export namespace Ember {
 
   const Evented: typeof EmberObjectEventedNs.default;
 
-  class Mixin<T, Base = EmberObjectNs.default> extends EmberMixin<T, Base> {}
+  class Mixin extends EmberMixin {}
 
   /**
    * A Namespace is an object usually used to contain other objects or methods
@@ -162,7 +162,7 @@ export namespace Ember {
     target: unknown;
     actionContext: unknown;
   }
-  const ViewTargetActionSupport: Mixin<ViewTargetActionSupport>;
+  const ViewTargetActionSupport: Mixin;
   const ViewUtils: {
     isSimpleClick(event: Event): boolean;
   };
@@ -242,10 +242,8 @@ export namespace Ember {
      * Creates a property that lazily looks up another controller in the container.
      * Can only be used when defining another controller.
      */
-    function controller(): ComputedProperty<Controller>;
-    function controller<K extends keyof ControllerRegistry>(
-      name: K
-    ): ComputedProperty<ControllerRegistry[K]>;
+    function controller(): Controller;
+    function controller<K extends keyof ControllerRegistry>(name: K): ControllerRegistry[K];
     const service: typeof EmberServiceNs.inject;
   }
   namespace ENV {
diff --git a/types/preview/ember/test/computed.ts b/types/preview/ember/test/computed.ts
index 8d5ff6f0eec..24cbba4eaf0 100755
--- a/types/preview/ember/test/computed.ts
+++ b/types/preview/ember/test/computed.ts
@@ -1,192 +1,100 @@
 import Ember from 'ember';
-import Component from '@ember/component';
-import Computed, { alias, or } from '@ember/object/computed';
-import { assertType } from './lib/assert';
-
-const Person = Ember.Object.extend({
-    firstName: '',
-    lastName: '',
-    age: 0,
-
-    noArgs: Ember.computed<string>(() => 'test'),
-
-    fullName: Ember.computed<string>('firstName', 'lastName', function () {
-        return `${this.get('firstName')} ${this.get('lastName')}`;
-    }),
-
-    fullNameReadonly: Ember.computed<string>('fullName', function () {
-        return this.get('fullName');
-    }).readOnly(),
-
-    fullNameWritable: Ember.computed<string>('firstName', 'lastName', {
-        get() {
-            return this.get('fullName');
-        },
-        set(key, value) {
-            const [first, last] = value.split(' ');
-            this.set('firstName', first);
-            this.set('lastName', last);
-            return value;
-        },
-    }),
-
-    fullNameGetOnly: Ember.computed<string>('fullName', {
-        get() {
-            return this.get('fullName');
-        },
-    }),
-
-    fullNameSetOnly: Ember.computed<string>('firstName', 'lastName', {
-        set(key, value) {
-            const [first, last] = value.split(' ');
-            this.set('firstName', first);
-            this.set('lastName', last);
-            return value;
-        },
-    }),
-
-    combinators: Ember.computed<string>(function () {
-        return this.get('firstName');
-    })
-        .property('firstName')
-        .meta({ foo: 'bar' })
-        .volatile()
-        .readOnly(),
-
-    explicitlyDeclared: alias('fullName') as Computed<string>,
-});
+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,
+  firstName: 'Fred',
+  lastName: 'Smith',
+  age: 29,
 });
 
-assertType<string>(person.firstName);
-assertType<number>(person.age);
-assertType<Ember.ComputedProperty<string>>(person.noArgs);
-assertType<Ember.ComputedProperty<string>>(person.fullName);
-assertType<Ember.ComputedProperty<string>>(person.fullNameReadonly);
-assertType<Ember.ComputedProperty<string>>(person.fullNameWritable);
-assertType<Ember.ComputedProperty<string>>(person.fullNameGetOnly);
-assertType<Ember.ComputedProperty<string>>(person.fullNameSetOnly);
-assertType<Ember.ComputedProperty<string>>(person.combinators);
-assertType<Ember.ComputedProperty<string>>(person.explicitlyDeclared);
-
-assertType<string>(person.get('firstName'));
-assertType<number>(person.get('age'));
-assertType<string>(person.get('noArgs'));
-assertType<string>(person.get('fullName'));
-assertType<string>(person.get('fullNameReadonly'));
-assertType<string>(person.get('fullNameWritable'));
-assertType<string>(person.get('fullNameGetOnly'));
-assertType<string>(person.get('fullNameSetOnly'));
-assertType<string>(person.get('combinators'));
-assertType<string>(person.get('explicitlyDeclared'));
-
-assertType<{ firstName: string; fullName: string; age: number }>(person.getProperties('firstName', 'fullName', 'age'));
+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',
+  fullName: 'Fred Smith',
 });
 
-assertType<string>(person2.get('firstName'));
-assertType<string>(person2.get('fullName'));
+expectTypeOf(person2.get('firstName')).toEqualTypeOf<string>();
+expectTypeOf(person2.get('fullName')).toEqualTypeOf<string>();
 
 const person3 = Person.extend({
-    firstName: 'Fred',
-    fullName: 'Fred Smith',
+  firstName: 'Fred',
+  fullName: 'Fred Smith',
 }).create();
 
-assertType<string>(person3.get('firstName'));
-assertType<string>(person3.get('fullName'));
+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();
-
-assertType<string>(person4.get('firstName'));
-assertType<string>(person4.get('fullName'));
-
-// computed property macros
-const objectWithComputedProperties = Ember.Object.extend({
-    alias: Ember.computed.alias('foo'),
-    and: Ember.computed.and('foo', 'bar', 'baz', 'qux'),
-    bool: Ember.computed.bool('foo'),
-    collect: Ember.computed.collect('foo', 'bar', 'baz', 'qux'),
-    deprecatingAlias: Ember.computed.deprecatingAlias('foo', {
-        id: 'hamster.deprecate-banana',
-        until: '3.0.0',
-    }),
-    empty: Ember.computed.empty('foo'),
-    equalNumber: Ember.computed.equal('foo', 1),
-    equalString: Ember.computed.equal('foo', 'bar'),
-    equalObject: Ember.computed.equal('foo', {}),
-    filter: Ember.computed.filter('foo', item => item === 'bar'),
-    filterBy1: Ember.computed.filterBy('foo', 'bar'),
-    filterBy2: Ember.computed.filterBy('foo', 'bar', false),
-    gt: Ember.computed.gt('foo', 3),
-    gte: Ember.computed.gte('foo', 3),
-    intersect: Ember.computed.intersect('foo', 'bar', 'baz', 'qux'),
-    lt: Ember.computed.lt('foo', 3),
-    lte: Ember.computed.lte('foo', 3),
-    map: Ember.computed.map('foo', (item, index) => item),
-    mapBy: Ember.computed.mapBy('foo', 'bar'),
-    match: Ember.computed.match('foo', /^tom.ter$/),
-    max: Ember.computed.max('foo'),
-    min: Ember.computed.min('foo'),
-    none: Ember.computed.none('foo'),
-    not: Ember.computed.not('foo'),
-    notEmpty: Ember.computed.notEmpty('foo'),
-    oneWay: Ember.computed.oneWay('foo'),
-    or: Ember.computed.or('foo', 'bar', 'baz', 'qux'),
-    readOnly: Ember.computed.readOnly('foo'),
-    reads: Ember.computed.reads('foo'),
-    setDiff: Ember.computed.setDiff('foo', 'bar'),
-    sort1: Ember.computed.sort('foo', 'bar'),
-    sort2: Ember.computed.sort('foo', (itemA, itemB) => {
-        return `${itemA}`.length - `${itemB}`.length;
-    }),
-    sum: Ember.computed.sum('foo'),
-    union: Ember.computed.union('foo', 'bar', 'baz', 'qux'),
-    uniq: Ember.computed.uniq('foo'),
-    uniqBy: Ember.computed.uniqBy('foo', 'bar'),
+  firstName: Ember.computed(() => 'Fred'),
+  fullName: Ember.computed(() => 'Fred Smith'),
 }).create();
 
-assertType<unknown>(objectWithComputedProperties.get('alias'));
-assertType<unknown>(objectWithComputedProperties.get('and'));
-assertType<boolean>(objectWithComputedProperties.get('bool'));
-assertType<unknown[]>(objectWithComputedProperties.get('collect'));
-assertType<unknown>(objectWithComputedProperties.get('deprecatingAlias'));
-assertType<boolean>(objectWithComputedProperties.get('empty'));
-assertType<boolean>(objectWithComputedProperties.get('equalNumber'));
-assertType<boolean>(objectWithComputedProperties.get('equalString'));
-assertType<boolean>(objectWithComputedProperties.get('equalObject'));
-assertType<unknown[]>(objectWithComputedProperties.get('filter'));
-assertType<unknown[]>(objectWithComputedProperties.get('filterBy1'));
-assertType<unknown[]>(objectWithComputedProperties.get('filterBy2'));
-assertType<boolean>(objectWithComputedProperties.get('gt'));
-assertType<boolean>(objectWithComputedProperties.get('gte'));
-assertType<unknown[]>(objectWithComputedProperties.get('intersect'));
-assertType<boolean>(objectWithComputedProperties.get('lt'));
-assertType<boolean>(objectWithComputedProperties.get('lte'));
-assertType<unknown[]>(objectWithComputedProperties.get('map'));
-assertType<unknown[]>(objectWithComputedProperties.get('mapBy'));
-assertType<boolean>(objectWithComputedProperties.get('match'));
-assertType<number>(objectWithComputedProperties.get('max'));
-assertType<number>(objectWithComputedProperties.get('min'));
-assertType<boolean>(objectWithComputedProperties.get('none'));
-assertType<boolean>(objectWithComputedProperties.get('not'));
-assertType<boolean>(objectWithComputedProperties.get('notEmpty'));
-assertType<unknown>(objectWithComputedProperties.get('oneWay'));
-assertType<unknown>(objectWithComputedProperties.get('or'));
-assertType<unknown>(objectWithComputedProperties.get('readOnly'));
-assertType<unknown>(objectWithComputedProperties.get('reads'));
-assertType<unknown[]>(objectWithComputedProperties.get('setDiff'));
-assertType<unknown[]>(objectWithComputedProperties.get('sort1'));
-assertType<unknown[]>(objectWithComputedProperties.get('sort2'));
-assertType<number>(objectWithComputedProperties.get('sum'));
-assertType<unknown[]>(objectWithComputedProperties.get('union'));
-assertType<unknown[]>(objectWithComputedProperties.get('uniq'));
-assertType<unknown[]>(objectWithComputedProperties.get('uniqBy'));
+expectTypeOf(person4.get('firstName')).toEqualTypeOf<string>();
+expectTypeOf(person4.get('fullName')).toEqualTypeOf<string>();
diff --git a/types/preview/ember/test/helper.ts b/types/preview/ember/test/helper.ts
index 433ddbd0637..2cfc4141a60 100755
--- a/types/preview/ember/test/helper.ts
+++ b/types/preview/ember/test/helper.ts
@@ -1,45 +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}`;
+  const cents = params[0];
+  const currency = hash.currency;
+  return `${currency}${cents * 0.01}`;
 });
 
 class User extends Ember.Object {
-    declare email: string;
+  declare email: string;
 }
 
 class SessionService extends Ember.Service {
-    declare currentUser: User;
+  declare currentUser: User;
 }
 
 declare module '@ember/service' {
-    interface Registry {
-        session: SessionService;
-    }
+  interface Registry {
+    session: SessionService;
+  }
 }
 
-const CurrentUserEmailHelper = Ember.Helper.extend({
-    session: Ember.inject.service('session'),
-    onNewUser: Ember.observer('session.currentUser', function (this: Ember.Helper) {
-        this.recompute();
-    }),
-    compute(): string {
-        return this.get('session').get('currentUser').get('email');
-    },
-});
+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';
+  return 'my type of help';
 }
 
 export default helper(typedHelp);
 
 function arrayNumHelp(/*params, hash*/) {
-    return [1, 2, 3];
+  return [1, 2, 3];
 }
 
 helper(arrayNumHelp);
diff --git a/types/preview/ember/test/mixin.ts b/types/preview/ember/test/mixin.ts
index ccb71d14ef1..1fb85c78d9d 100755
--- a/types/preview/ember/test/mixin.ts
+++ b/types/preview/ember/test/mixin.ts
@@ -1,36 +1,37 @@
 import Ember from 'ember';
 import { assertType } from './lib/assert';
 
-interface EditableMixin {
-    edit(): void;
-    isEditing: boolean;
+interface EditableMixin extends Ember.Mixin {
+  edit(): void;
+  isEditing: boolean;
 }
 
-const EditableMixin = Ember.Mixin.create<EditableMixin, Ember.Route>({
-    edit() {
-        this.get('controller');
-        console.log('starting to edit');
-        this.set('isEditing', true);
-    },
-    isEditing: false,
+const EditableMixin = Ember.Mixin.create({
+  edit(this: EditableMixin & Ember.Object) {
+    this.get('controller');
+    console.log('starting to edit');
+    this.set('isEditing', true);
+  },
+  isEditing: false,
 });
 
-const EditableComment = Ember.Route.extend(EditableMixin, {
-    postId: 0,
+interface EditableComment extends EditableMixin {}
+class EditableComment extends Ember.Route.extend(EditableMixin) {
+  postId = 0;
 
-    canEdit() {
-        return !this.isEditing;
-    },
+  canEdit() {
+    return !this.isEditing;
+  }
 
-    tryEdit() {
-        if (this.canEdit()) {
-            this.edit();
-        }
-    },
-});
+  tryEdit() {
+    if (this.canEdit()) {
+      this.edit();
+    }
+  }
+}
 
 const comment = EditableComment.create({
-    postId: 42,
+  postId: 42,
 });
 
 comment.edit();
@@ -39,18 +40,26 @@ comment.tryEdit();
 assertType<boolean>(comment.isEditing);
 assertType<number>(comment.postId);
 
+// 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();
-assertType<number>(obj.a);
-assertType<number>(obj.b);
-assertType<number>(obj.c);
+// @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,
+  cancelled: false,
 });
 
-const EditableAndCancelableComment = Ember.Route.extend(EditableAndCancelableMixin);
+interface EditableAndCancelableComment extends EditableAndCancelableMixin {}
+class EditableAndCancelableComment extends Ember.Route.extend(EditableAndCancelableMixin) {}
 
 const editableAndCancelable = EditableAndCancelableComment.create();
 assertType<boolean>(editableAndCancelable.isEditing);
diff --git a/types/preview/ember/test/object.ts b/types/preview/ember/test/object.ts
index 9deb3df638d..98a8cd909b7 100755
--- a/types/preview/ember/test/object.ts
+++ b/types/preview/ember/test/object.ts
@@ -1,84 +1,88 @@
 import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
 
-const LifetimeHooks = Ember.Object.extend({
-    resource: undefined as {} | undefined,
+class LifetimeHooks extends Ember.Object {
+  resource: {} | undefined;
 
-    init() {
-        this._super();
-        this.resource = {};
-    },
+  init() {
+    this._super();
+    this.resource = {};
+  }
 
-    willDestroy() {
-        this.resource = undefined;
-        this._super();
-    },
-});
+  willDestroy() {
+    this.resource = undefined;
+    this._super();
+  }
+}
 
 class MyObject30 extends Ember.Object {
-    constructor() {
-        super();
-    }
+  constructor() {
+    super();
+  }
 }
 
 class MyObject31 extends Ember.Object {
-    constructor(properties: object) {
-        super(properties);
-    }
+  constructor(properties: object) {
+    super(properties);
+  }
 }
 
-class Foo extends Ember.Object.extend({
-    a: Ember.computed({
-        get() {
-            return '';
-        },
-        set(key: string, newVal: string) {
-            return '';
-        },
-    }),
-}) {
-    b = 5;
-    baz() {
-        const y = this.b; // $ExpectType number
-        const z = this.a; // $ExpectType ComputedProperty<string, string>
-        this.b = 10;
-        this.get('b').toFixed(4); // $ExpectType string
-        this.set('a', 'abc').split(','); // $ExpectType string[]
-        this.set('b', 10).toFixed(4); // $ExpectType string
+class Foo extends Ember.Object {
+  @Ember.computed()
+  get a() {
+    return '';
+  }
+
+  set a(newVal: string) {
+    /* no-op */
+  }
+
+  b = 5;
+
+  baz() {
+    const y = this.b; // $ExpectType number
+    const z = this.a; // $ExpectType ComputedProperty<string, string>
+    this.b = 10;
+    this.get('b').toFixed(4); // $ExpectType string
+    this.set('a', 'abc').split(','); // $ExpectType string[]
+    this.set('b', 10).toFixed(4); // $ExpectType string
 
-        this.setProperties({ b: 11 });
-        // this.setProperties({ b: '11' }); // @ts-expect-error
-        this.setProperties({
-            a: 'def',
-            b: 11,
-        });
-    }
+    this.setProperties({ b: 11 });
+    // this.setProperties({ b: '11' }); // @ts-expect-error
+    this.setProperties({
+      a: 'def',
+      b: 11,
+    });
+  }
 }
 
 export class Foo2 extends Ember.Object {
-    name!: string;
+  name = '';
 
-    changeName(name: string) {
-        const a: string = this.set('name', name);
-        // @ts-expect-error
-        const b: number = this.set('name', name);
-        const x: string = Ember.set(this, 'name', name);
-        // @ts-expect-error
-        const y: number = Ember.set(this, 'name', name);
-        this.setProperties({
-            name,
-        });
-        Ember.setProperties(this, {
-            name,
-        });
-    }
+  changeName(name: string) {
+    expectTypeOf(this.set('name', name)).toEqualTypeOf<string>();
+    // This is checking for assignability; `expectTypeOf` doesn't work correctly
+    // here because TS isn't resolving `this['name']` eagerly, and so it is not
+    // (currently) possible for the type utility to match it.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const x: string = Ember.set(this, 'name', name);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const y: string = Ember.get(this, 'name');
+    this.setProperties({
+      name,
+    });
+    Ember.setProperties(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');
-    }
+  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/types/preview/ember/test/observable.ts b/types/preview/ember/test/observable.ts
index b8c339b4aed..afb5aadf508 100755
--- a/types/preview/ember/test/observable.ts
+++ b/types/preview/ember/test/observable.ts
@@ -39,24 +39,30 @@ myComponent.addObserver('foo', null, () => {});
 myComponent.set('foo', 'baz');
 expectTypeOf(myComponent.get('foo')).toEqualTypeOf<string>();
 
-const person = Ember.Object.create({
+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,
-  capitalized: Ember.computed<string>(function () {
-    return this.get('name').toUpperCase();
-  }),
 });
 
 const pojo = { name: 'Fred', age: 29 };
 
 function testGet() {
-  assertType<string>(Ember.get(person, 'name'));
-  assertType<number>(Ember.get(person, 'age'));
-  assertType<string>(Ember.get(person, 'capitalized'));
-  assertType<string>(person.get('name'));
-  assertType<number>(person.get('age'));
-  assertType<string>(person.get('capitalized'));
-  assertType<string>(Ember.get(pojo, 'name'));
+  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() {
@@ -101,14 +107,14 @@ function testSetProperties() {
 
 function testDynamic() {
   const obj: Record<string, string> = {};
-  const dynamicKey: string = 'dummy'; // tslint:disable-line:no-inferrable-types
+  const dynamicKey = 'dummy' as string;
 
-  assertType<string | undefined>(Ember.get(obj, 'dummy'));
-  assertType<string | undefined>(Ember.get(obj, dynamicKey));
-  assertType<{ dummy: string | undefined }>(Ember.getProperties(obj, 'dummy'));
-  assertType<{ dummy: string | undefined }>(Ember.getProperties(obj, ['dummy']));
-  assertType<Record<string, string>>(Ember.getProperties(obj, dynamicKey));
-  assertType<Record<string, string>>(Ember.getProperties(obj, [dynamicKey]));
+  expectTypeOf(Ember.get(obj, 'dummy')).toEqualTypeOf<string | undefined>();
+  expectTypeOf(Ember.get(obj, dynamicKey)).toEqualTypeOf<string | undefined>();
+  expectTypeOf(Ember.getProperties(obj, 'dummy')).toEqualTypeOf<{ dummy: string | undefined }>();
+  expectTypeOf(Ember.getProperties(obj, ['dummy'])).toEqualTypeOf<{ dummy: string | undefined }>();
+  expectTypeOf(Ember.getProperties(obj, dynamicKey)).toEqualTypeOf<Record<string, string>>();
+  expectTypeOf(Ember.getProperties(obj, [dynamicKey])).toEqualTypeOf<Record<string, string>>();
   assertType<string | undefined>(Ember.set(obj, 'dummy', 'value'));
   assertType<string | undefined>(Ember.set(obj, dynamicKey, 'value'));
   assertType<{ dummy: string | undefined }>(Ember.setProperties(obj, { dummy: 'value ' }));
diff --git a/types/preview/ember/test/private/computed-tests.ts b/types/preview/ember/test/private/computed-tests.ts
index c0c83772383..a3f61025ac2 100644
--- a/types/preview/ember/test/private/computed-tests.ts
+++ b/types/preview/ember/test/private/computed-tests.ts
@@ -1,92 +1,30 @@
 import Ember from 'ember';
-import {
-    UnwrapComputedPropertySetters,
-    UnwrapComputedPropertyGetters,
-    UnwrapComputedPropertySetter,
-    UnwrapComputedPropertyGetter,
-} from '@ember/object/-private/types';
-import { assertType } from '../lib/assert';
 
-class Example1 extends Ember.Object.extend({
-    firstName: '',
-    lastName: '',
-    allNames: Ember.computed('fullName', function () {
-        return [this.fullName];
-    }) as Ember.ComputedProperty<string[]>,
-    fullName: Ember.computed('firstName', 'lastName', function () {
-        // tslint:disable-next-line:no-unnecessary-type-assertion
-        return `${this.firstName} ${this.lastName}` as string;
-    }),
-}) {}
+class Example1 extends Ember.Object {
+  firstName = '';
+  lastName = '';
 
-declare const unwrappedGetters1: UnwrapComputedPropertyGetters<Example1>;
-unwrappedGetters1.firstName; // $ExpectType string
-unwrappedGetters1.lastName; // $ExpectType string
-unwrappedGetters1.fullName; // $ExpectType string
-unwrappedGetters1.allNames; // $ExpectType string[]
+  @Ember.computed('fullName')
+  get allNames() {
+    return [this.fullName];
+  }
 
-declare const unwrappedSetters1: UnwrapComputedPropertySetters<Example1>;
-unwrappedSetters1.firstName; // $ExpectType string
-unwrappedSetters1.lastName; // $ExpectType string
-unwrappedSetters1.fullName; // $ExpectType string
-unwrappedSetters1.allNames; // $ExpectType string[]
-
-class Example2 extends Ember.Object.extend({
-    allNames: Ember.computed('fullName', function () {
-        return [this.fullName + ''];
-    }),
-    fullName: Ember.computed('firstName', 'lastName', function () {
-        // tslint:disable-next-line:no-unnecessary-type-assertion
-        return `${this.firstName} ${this.lastName}` as string;
-    }),
-}) {
-    firstName = '';
-    lastName = '';
-    foo() {
-        this.fullName; // $ExpectType ComputedProperty<string, string>
-        this.allNames; // $ExpectType ComputedProperty<string[], string[]>
-        this.firstName; // $ExpectType string
-        this.lastName; // $ExpectType string
-
-        this.get('fullName').split(','); // $ExpectType string[]
-        this.get('allNames')[0]; // $ExpectType string
-        this.get('firstName').split(','); // $ExpectType string[]
-        this.get('lastName').split(','); // $ExpectType string[]
-    }
+  @Ember.computed('firstName', 'lastName')
+  get fullName() {
+    return `${this.firstName} ${this.lastName}`;
+  }
 }
-const ex2 = new Example2();
-
-declare const unwrappedGetters2: UnwrapComputedPropertyGetters<typeof ex2>;
-assertType<string>(unwrappedGetters2.firstName); // $ExpectType string
-assertType<string>(unwrappedGetters2.lastName); // $ExpectType string
-assertType<string>(unwrappedGetters2.fullName); // $ExpectType string
-assertType<string[]>(unwrappedGetters2.allNames); // $ExpectType string[]
 
-declare const unwrappedSetters2: UnwrapComputedPropertySetters<typeof ex2>;
-assertType<string>(unwrappedSetters2.firstName); // $ExpectType string
-assertType<string>(unwrappedSetters2.lastName); // $ExpectType string
-assertType<string>(unwrappedSetters2.fullName); // $ExpectType string
-assertType<string[]>(unwrappedSetters2.allNames); // $ExpectType string[]
-
-ex2.fullName; // $ExpectType ComputedProperty<string, string>
-ex2.allNames; // $ExpectType ComputedProperty<string[], string[]>
-ex2.firstName; // $ExpectType string
-
-type UnwStringSet = UnwrapComputedPropertySetter<string>; // $ExpectType string
-type UnwStringGet = UnwrapComputedPropertyGetter<string>; // $ExpectType string
-// $ExpectType string
-type UnwCpStringSet1 = UnwrapComputedPropertySetter<Ember.ComputedProperty<string>>;
-// $ExpectType string
-type UnwCpStringGet1 = UnwrapComputedPropertyGetter<Ember.ComputedProperty<string>>;
-// $ExpectType string
-type UnwCpStringSet2 = UnwrapComputedPropertySetter<Ember.ComputedProperty<string, string>>;
-// $ExpectType string
-type UnwCpStringGet2 = UnwrapComputedPropertyGetter<Ember.ComputedProperty<string, string>>;
-// $ExpectType string
-type UnwCpStringSet3 = UnwrapComputedPropertySetter<Ember.ComputedProperty<number, string>>;
-// $ExpectType number
-type UnwCpStringGet3 = UnwrapComputedPropertyGetter<Ember.ComputedProperty<number, string>>;
-// $ExpectType number
-type UnwCpStringSet4 = UnwrapComputedPropertySetter<Ember.ComputedProperty<string, number>>;
-// $ExpectType string
-type UnwCpStringGet4 = UnwrapComputedPropertyGetter<Ember.ComputedProperty<string, number>>;
+class Example2 extends Example1 {
+  foo() {
+    this.fullName; // $ExpectType ComputedProperty<string, string>
+    this.allNames; // $ExpectType ComputedProperty<string[], string[]>
+    this.firstName; // $ExpectType string
+    this.lastName; // $ExpectType string
+
+    this.get('fullName').split(','); // $ExpectType string[]
+    this.get('allNames')[0]; // $ExpectType string
+    this.get('firstName').split(','); // $ExpectType string[]
+    this.get('lastName').split(','); // $ExpectType string[]
+  }
+}
diff --git a/types/preview/ember/test/reopen.ts b/types/preview/ember/test/reopen.ts
index 08300aec1ca..2df9f538d16 100755
--- a/types/preview/ember/test/reopen.ts
+++ b/types/preview/ember/test/reopen.ts
@@ -1,64 +1,79 @@
 import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
 import { assertType } from './lib/assert';
 
-type Person = typeof Person.prototype;
-const Person = Ember.Object.extend({
-    name: '',
-    sayHello() {
-        alert(`Hello. My name is ${this.get('name')}`);
-    },
-});
+class Person extends Ember.Object {
+  name = '';
+
+  sayHello() {
+    alert(`Hello. My name is ${this.get('name')}`);
+  }
+}
 
-assertType<Person>(Person.reopen());
+expectTypeOf(Person.reopen()).toMatchTypeOf<typeof Person>();
 
-assertType<string>(Person.create().name);
-Person.create().sayHello(); // $ExpectType void
+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',
+  species: 'Homo sapiens',
 
-    createPerson(name: string): Person {
-        return Person.create({ name });
-    },
+  createPerson(name: string): Person {
+    return Person.create({ name });
+  },
 });
 
-assertType<string>(Person2.create().name);
-Person2.create().sayHello(); // $ExpectType void
-assertType<string>(Person2.species);
+// 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',
+  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',
+  goodbyeMessage: 'goodbye',
 
-    sayGoodbye() {
-        alert(`${this.get('goodbyeMessage')}, ${this.get('name')}`);
-    },
+  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;
+  resizable: true;
 }
 const AutoResizeMixin = Ember.Mixin.create({ resizable: true });
 
+// And the same here.
 const Reopened = Ember.Object.reopenClass({ a: 1 }, { b: 2 }, { c: 3 });
-assertType<number>(Reopened.a);
-assertType<number>(Reopened.b);
-assertType<number>(Reopened.c);
+// @ts-expect-error
+Reopened.a;
+// @ts-expect-error
+Reopened.b;
+// @ts-expect-error
+Reopened.c;
diff --git a/types/preview/ember/test/route.ts b/types/preview/ember/test/route.ts
index 28f127888b4..e532cfbbc05 100755
--- a/types/preview/ember/test/route.ts
+++ b/types/preview/ember/test/route.ts
@@ -8,90 +8,79 @@ import Transition from '@ember/routing/transition';
 Ember.Transition;
 
 interface Post extends Ember.Object {
-    title: string;
+  title: string;
 }
 
 interface Posts extends Array<Post> {}
 
-Route.extend({
-    beforeModel(transition: Transition) {
-        this.transitionTo('someOtherRoute');
-    },
-});
+class Test extends Route {
+  queryParams = {
+    memberQp: { refreshModel: true },
+  };
 
-Route.extend({
-    afterModel(posts: Posts, transition: Transition) {
-        if (posts.firstObject) {
-            this.transitionTo('post.show', posts.firstObject);
-        }
-    },
-});
+  beforeModel(transition: Transition) {
+    this.transitionTo('someOtherRoute');
+  }
 
-Ember.Route.extend({
-    model() {
-        return this.modelFor('post');
-    },
-});
+  model() {
+    return this.modelFor('post');
+  }
 
-Route.extend({
-    queryParams: {
-        memberQp: { refreshModel: true },
-    },
-});
-
-Route.extend({
-    resetController(controller: Ember.Controller, isExiting: boolean, transition: boolean) {
-        if (isExiting) {
-            //   controller.set('page', 1);
-        }
-    },
-});
+  afterModel(posts: Posts, transition: Transition) {
+    if (posts.firstObject) {
+      this.transitionTo('post.show', posts.firstObject);
+    }
+  }
 
-Route.extend({
-    setupController(controller: Ember.Controller, model: {}) {
-        this._super(controller, model);
-        this.controllerFor('application').set('model', model);
-    },
-});
+  setupController(controller: Ember.Controller, model: {}) {
+    this._super(controller, model);
+    this.controllerFor('application').set('model', model);
+  }
 
-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, {});
+  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;
-    }
+  beforeModel(transition: Transition): void | Promise<unknown> {
+    return;
+  }
 
-    afterModel(resolvedModel: unknown, transition: Transition): void {
-        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')";
-    }
+  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')";
-    }
+  afterModel(resolvedModel: unknown, transition: Transition): void {
+    // @ts-expect-error
+    return "returning anything else is nonsensical (if 'legal')";
+  }
 }
diff --git a/types/preview/ember/test/router.ts b/types/preview/ember/test/router.ts
index 105a8d75264..2519b2af204 100755
--- a/types/preview/ember/test/router.ts
+++ b/types/preview/ember/test/router.ts
@@ -1,49 +1,52 @@
+import RouterService from '@ember/routing/router-service';
 import Ember from 'ember';
-import { assertType } from './lib/assert';
+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('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('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' });
+  });
+  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' });
 });
 
-const RouterServiceConsumer = Ember.Service.extend({
-    router: Ember.inject.service('router'),
-    currentRouteName() {
-        const x: string = Ember.get(this, 'router').currentRouteName;
-    },
-    currentURL() {
-        const x: string = Ember.get(this, 'router').currentURL;
-    },
-    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' } });
-    },
-});
+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' } });
+  }
+}

From 061f2b3ee7601df64f72ce0f0f84f77afd015dd0 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Sun, 28 Aug 2022 20:43:39 -0600
Subject: [PATCH 04/39] Rework preview type tests for `@ember/object/core`

---
 types/preview/@ember/object/test/core.ts | 199 +++--------------------
 1 file changed, 19 insertions(+), 180 deletions(-)

diff --git a/types/preview/@ember/object/test/core.ts b/types/preview/@ember/object/test/core.ts
index ce913dcf889..2030d672887 100644
--- a/types/preview/@ember/object/test/core.ts
+++ b/types/preview/@ember/object/test/core.ts
@@ -1,5 +1,5 @@
-import { assertType } from './lib/assert';
 import CoreObject from '@ember/object/core';
+import { expectTypeOf } from 'expect-type';
 
 /** Newable tests */
 const co1 = new CoreObject();
@@ -21,198 +21,37 @@ co2.destroy(); // $ExpectType CoreObject
 co2.toString(); // $ExpectType string
 
 /** .create tests w/ initial instance data passed in */
-const co3 = CoreObject.create({ foo: '123', bar: 456 });
+declare class CO3 extends CoreObject {
+  foo: string;
+  bar: number;
+}
+const co3 = CO3.create({ foo: '123', bar: 456 });
 
 co3.foo; // $ExpectType string
 co3.bar; // $ExpectType number
 
 /** .extend with a zero-argument .create()  */
-const co4 = CoreObject.extend({
-  foo: '123',
-  bar: 456,
+class CO4 extends CO3 {
   baz(): [string, number] {
     return [this.foo, this.bar];
-  },
-}).create();
+  }
+}
+const co4 = CO4.create();
 
 co4.foo; // $ExpectType string
 co4.bar; // $ExpectType number
 co4.baz; // $ExpectType () => [string, number]
 
 /** .extend with inconsistent arguments passed into .create()  */
-const class05 = CoreObject.extend({
-  foo: '123' as string | boolean,
-  bar: 456,
+class CO5 extends CoreObject {
+  foo: string | boolean = 'hello';
+  bar = 123;
   baz() {
     return [this.foo, this.bar];
-  },
-});
-// @ts-expect-error
-const c05 = class05.create({ foo: 99 });
-const c05b = class05.create({ foo: true });
-const c05c = class05.create({ foo: 'abc' });
-// @ts-expect-error
-assertType<string>(c05b.foo);
-// @ts-expect-error
-assertType<boolean>(c05c.foo);
-
-/** two .extend arguments with a zero-argument .create() */
-const co6 = CoreObject.extend(
-  {
-    foo: '123',
-    bar: 456,
-    baz() {
-      return [this.foo, this.bar];
-    },
-    func1() {
-      // this includes stuff from CoreObject
-      this.init; // $ExpectType () => void
-      // this includes stuff from this extend-arg
-      this.foo; // $ExpectType string
-      // this does not include stuff from later extend args
-      // @ts-expect-error
-      this.bee;
-    },
-  },
-  {
-    foo: 99,
-    bee: 'honey',
-    func2() {
-      // this includes stuff from CoreObject
-      this.init; // $ExpectType () => void
-      // this includes stuff from this extend-arg
-      // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-      this.foo;
-      // this includes stuff from earlier extend-args
-      this.bar; // $ExpectType number
-    },
-  }
-).create();
-
-// TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-// assertType<string>(co6.foo); // @ts-expect-error
-assertType<number>(co6.bar); // $ExpectType number
-assertType<() => Array<string | number>>(co6.baz); // $ExpectType () => (string | number)[]
-
-/** three .extend arguments with a zero-argument .create() */
-const co7 = CoreObject.extend(
-  {
-    foo: '123',
-    bar: 456,
-    baz() {
-      return [this.foo, this.bar];
-    },
-    func1() {
-      // this includes stuff from CoreObject
-      this.init; // $ExpectType () => void
-      // this includes stuff from this extend-arg
-      this.foo; // $ExpectType string
-      // this does not include stuff from later extend args
-      // @ts-expect-error
-      this.bee;
-    },
-  },
-  {
-    foo: 99,
-    bee: 'honey',
-    func2() {
-      // this includes stuff from CoreObject
-      this.init; // $ExpectType () => void
-      // this includes stuff from this extend-arg
-      // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-      this.foo;
-      // this includes stuff from earlier extend-args
-      this.bar; // $ExpectType number
-    },
-  },
-  {
-    foo: '99',
-    money: 'in the banana stand',
-    func3() {
-      // this includes stuff from CoreObject
-      this.init; // $ExpectType () => void
-      // this includes stuff from this extend-arg
-      this.money; // $ExpectType string
-      // this includes stuff from earlier extend-args
-      this.bee; // $ExpectType string
-      this.bar; // $ExpectType number
-    },
-  }
-).create();
-// TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-// assertType<number>(co7.foo); // @ts-expect-error
-assertType<number>(co7.bar); // $ExpectType number
-assertType<string>(co7.money); // $ExpectType string
-assertType<() => Array<string | number>>(co7.baz); // $ExpectType () => (string | number)[]
-
-/** four .extend arguments with a zero-argument .create() */
-const co8 = CoreObject.extend(
-  {
-    foo: '123',
-    bar: 456,
-    baz() {
-      return [this.foo, this.bar];
-    },
-    func1() {
-      // this includes stuff from CoreObject
-      this.init; // $ExpectType () => void
-      // this includes stuff from this extend-arg
-      this.foo; // $ExpectType string
-      // this does not include stuff from later extend args
-      // @ts-expect-error
-      this.bee;
-    },
-  },
-  {
-    foo: 99,
-    bee: 'honey',
-    func2() {
-      // this includes stuff from CoreObject
-      this.init; // $ExpectType () => void
-      // this includes stuff from this extend-arg
-      // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-      this.foo;
-      // this includes stuff from earlier extend-args
-      this.bar; // $ExpectType number
-      // this does not include stuff from later extend args
-      // @ts-expect-error
-      this.money;
-    },
-  },
-  {
-    foo: '99',
-    money: 'in the banana stand',
-    func3() {
-      // this includes stuff from CoreObject
-      this.init; // $ExpectType () => void
-      // this includes stuff from this extend-arg
-      this.money; // $ExpectType string
-      // this includes stuff from earlier extend-args
-      this.bee; // $ExpectType string
-      this.bar; // $ExpectType number
-      // this does not include stuff from later extend args
-      // @ts-expect-error
-      this.neighborhood;
-    },
-  },
-  {
-    foo: '99',
-    neighborhood: 'sudden valley',
-    func4() {
-      // this includes stuff from CoreObject
-      this.init; // $ExpectType () => void
-      // this includes stuff from this extend-arg
-      this.neighborhood; // $ExpectType string
-      // this includes stuff from earlier extend-args
-      this.bee; // $ExpectType string
-      this.bar; // $ExpectType number
-      this.money; // $ExpectType string
-    },
   }
-).create();
-
-// TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-// assertType<number>(co8.foo); // @ts-expect-error
-assertType<number>(co8.bar); // $ExpectType number
-assertType<string>(co8.money); // $ExpectType string
-assertType<() => Array<string | number>>(co8.baz); // $ExpectType () => (string | number)[]
+}
+// @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>();

From 19507dede997b7136ceb2bdba3d479d1005162c0 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Sun, 28 Aug 2022 20:45:06 -0600
Subject: [PATCH 05/39] Support the same type tests in the Ember namespace as
 in `@ember/object`

---
 types/preview/ember/test/core-object.ts | 213 +++---------------------
 1 file changed, 27 insertions(+), 186 deletions(-)

diff --git a/types/preview/ember/test/core-object.ts b/types/preview/ember/test/core-object.ts
index df469143166..3cc7862c645 100644
--- a/types/preview/ember/test/core-object.ts
+++ b/types/preview/ember/test/core-object.ts
@@ -1,8 +1,10 @@
 import Ember from 'ember';
-import { assertType } from './lib/assert';
+import { expectTypeOf } from 'expect-type';
+
+const { CoreObject } = Ember;
 
 /** Newable tests */
-const co1 = new Ember.CoreObject();
+const co1 = new CoreObject();
 
 // TODO: Enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
 // co1.concatenatedProperties; // $ExpectType string[]
@@ -12,7 +14,7 @@ co1.destroy(); // $ExpectType CoreObject
 co1.toString(); // $ExpectType string
 
 /** .create tests */
-const co2 = Ember.CoreObject.create();
+const co2 = CoreObject.create();
 // TODO: Enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
 // co2.concatenatedProperties; // $ExpectType string[]
 co2.isDestroyed; // $ExpectType boolean
@@ -21,198 +23,37 @@ co2.destroy(); // $ExpectType CoreObject
 co2.toString(); // $ExpectType string
 
 /** .create tests w/ initial instance data passed in */
-const co3 = Ember.CoreObject.create({ foo: '123', bar: 456 });
+declare class CO3 extends CoreObject {
+  foo: string;
+  bar: number;
+}
+const co3 = CO3.create({ foo: '123', bar: 456 });
 
 co3.foo; // $ExpectType string
 co3.bar; // $ExpectType number
 
 /** .extend with a zero-argument .create()  */
-const co4 = Ember.CoreObject.extend({
-    foo: '123',
-    bar: 456,
-    baz(): [string, number] {
-        return [this.foo, this.bar];
-    },
-}).create();
+class CO4 extends CO3 {
+  baz(): [string, number] {
+    return [this.foo, this.bar];
+  }
+}
+const co4 = CO4.create();
 
 co4.foo; // $ExpectType string
 co4.bar; // $ExpectType number
 co4.baz; // $ExpectType () => [string, number]
 
 /** .extend with inconsistent arguments passed into .create()  */
-const class05 = Ember.CoreObject.extend({
-    foo: '123' as string | boolean,
-    bar: 456,
-    baz() {
-        return [this.foo, this.bar];
-    },
-});
-// @ts-expect-error
-const c05 = class05.create({ foo: 99 });
-const c05b = class05.create({ foo: true });
-const c05c = class05.create({ foo: 'abc' });
+class CO5 extends CoreObject {
+  foo: string | boolean = 'hello';
+  bar = 123;
+  baz() {
+    return [this.foo, this.bar];
+  }
+}
 // @ts-expect-error
-assertType<string>(c05b.foo);
-// @ts-expect-error
-assertType<boolean>(c05c.foo);
-
-/** two .extend arguments with a zero-argument .create() */
-const co6 = Ember.CoreObject.extend(
-    {
-        foo: '123',
-        bar: 456,
-        baz() {
-            return [this.foo, this.bar];
-        },
-        func1() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            this.foo; // $ExpectType string
-            // this does not include stuff from later extend args
-            // @ts-expect-error
-            this.bee;
-        },
-    },
-    {
-        foo: 99,
-        bee: 'honey',
-        func2() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-            this.foo;
-            // this includes stuff from earlier extend-args
-            this.bar; // $ExpectType number
-        },
-    },
-).create();
-
-// TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-// assertType<string>(co6.foo); // @ts-expect-error
-assertType<number>(co6.bar); // $ExpectType number
-assertType<() => Array<string | number>>(co6.baz); // $ExpectType () => (string | number)[]
-
-/** three .extend arguments with a zero-argument .create() */
-const co7 = Ember.CoreObject.extend(
-    {
-        foo: '123',
-        bar: 456,
-        baz() {
-            return [this.foo, this.bar];
-        },
-        func1() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            this.foo; // $ExpectType string
-            // this does not include stuff from later extend args
-            // @ts-expect-error
-            this.bee;
-        },
-    },
-    {
-        foo: 99,
-        bee: 'honey',
-        func2() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-            this.foo;
-            // this includes stuff from earlier extend-args
-            this.bar; // $ExpectType number
-        },
-    },
-    {
-        foo: '99',
-        money: 'in the banana stand',
-        func3() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            this.money; // $ExpectType string
-            // this includes stuff from earlier extend-args
-            this.bee; // $ExpectType string
-            this.bar; // $ExpectType number
-        },
-    },
-).create();
-// TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-// assertType<number>(co7.foo); // @ts-expect-error
-assertType<number>(co7.bar); // $ExpectType number
-assertType<string>(co7.money); // $ExpectType string
-assertType<() => Array<string | number>>(co7.baz); // $ExpectType () => (string | number)[]
-
-/** four .extend arguments with a zero-argument .create() */
-const co8 = Ember.CoreObject.extend(
-    {
-        foo: '123',
-        bar: 456,
-        baz() {
-            return [this.foo, this.bar];
-        },
-        func1() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            this.foo; // $ExpectType string
-            // this does not include stuff from later extend args
-            // @ts-expect-error
-            this.bee;
-        },
-    },
-    {
-        foo: 99,
-        bee: 'honey',
-        func2() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            // TODO: switch to "$ExpectType number" in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-            this.foo;
-            // this includes stuff from earlier extend-args
-            this.bar; // $ExpectType number
-            // this does not include stuff from later extend args
-            // @ts-expect-error
-            this.money;
-        },
-    },
-    {
-        foo: '99',
-        money: 'in the banana stand',
-        func3() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            this.money; // $ExpectType string
-            // this includes stuff from earlier extend-args
-            this.bee; // $ExpectType string
-            this.bar; // $ExpectType number
-            // this does not include stuff from later extend args
-            // @ts-expect-error
-            this.neighborhood;
-        },
-    },
-    {
-        foo: '99',
-        neighborhood: 'sudden valley',
-        func4() {
-            // this includes stuff from CoreObject
-            this.init; // $ExpectType () => void
-            // this includes stuff from this extend-arg
-            this.neighborhood; // $ExpectType string
-            // this includes stuff from earlier extend-args
-            this.bee; // $ExpectType string
-            this.bar; // $ExpectType number
-            this.money; // $ExpectType string
-        },
-    },
-).create();
-
-// TODO: enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-// assertType<number>(co8.foo); // @ts-expect-error
-assertType<number>(co8.bar); // $ExpectType number
-assertType<string>(co8.money); // $ExpectType string
-assertType<() => Array<string | number>>(co8.baz); // $ExpectType () => (string | number)[]
+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>();

From f730d9e0d1121e946de7c383b2089a5d951be15f Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Sun, 28 Aug 2022 21:35:08 -0600
Subject: [PATCH 06/39] Fix preview type tests for @ember/object/observable

---
 .../preview/@ember/object/test/observable.ts  | 170 ++++++++++--------
 1 file changed, 98 insertions(+), 72 deletions(-)

diff --git a/types/preview/@ember/object/test/observable.ts b/types/preview/@ember/object/test/observable.ts
index 9d82e8de043..f28fe064ed7 100644
--- a/types/preview/@ember/object/test/observable.ts
+++ b/types/preview/@ember/object/test/observable.ts
@@ -1,102 +1,128 @@
-import { assertType } from './lib/assert';
+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';
+  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);
-    }
+  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
-    }
+  fooDidChange(sender: this, key: string) {
+    // your code
+  }
 }
 
 const myComponent = MyComponent.create();
 myComponent.addObserver('foo', null, () => {});
 myComponent.set('foo', 'baz');
 
-const person = EmberObject.create({
-    name: 'Fred',
-    age: 29,
-    capitalized: computed<string>(function () {
-        return this.get('name').toUpperCase();
-    }),
-});
+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() {
-    assertType<string>(get(person, 'name'));
-    assertType<number>(get(person, 'age'));
-    assertType<string>(get(person, 'capitalized'));
-    assertType<string>(person.get('name'));
-    assertType<number>(person.get('age'));
-    assertType<string>(person.get('capitalized'));
-    assertType<string>(get(pojo, 'name'));
+  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() {
-    assertType<{ name: string }>(getProperties(person, 'name'));
-    assertType<{ name: string; age: number }>(getProperties(person, 'name', 'age'));
-    assertType<{ name: string; age: number }>(getProperties(person, ['name', 'age']));
-    assertType<{ name: string; age: number; capitalized: string }>(getProperties(person, 'name', 'age', 'capitalized'));
-    assertType<{ name: string }>(person.getProperties('name'));
-    assertType<{ name: string; age: number }>(person.getProperties('name', 'age'));
-    assertType<{ name: string; age: number }>(person.getProperties(['name', 'age']));
-    assertType<{ name: string; age: number; capitalized: string }>(person.getProperties('name', 'age', 'capitalized'));
-    assertType<{ name: string; age: number }>(getProperties(pojo, 'name', 'age'));
+  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() {
-    assertType<string>(set(person, 'name', 'Joe'));
-    assertType<number>(set(person, 'age', 35));
-    assertType<string>(set(person, 'capitalized', 'JOE'));
-    assertType<string>(person.set('name', 'Joe'));
-    assertType<number>(person.set('age', 35));
-    assertType<string>(person.set('capitalized', 'JOE'));
-    assertType<string>(set(pojo, 'name', 'Joe'));
+  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() {
-    assertType<{ name: string }>(setProperties(person, { name: 'Joe' }));
-    assertType<{ name: string; age: number }>(setProperties(person, { name: 'Joe', age: 35 }));
-    assertType<{ name: string; capitalized: string }>(setProperties(person, { name: 'Joe', capitalized: 'JOE' }));
-    assertType<{ name: string }>(person.setProperties({ name: 'Joe' }));
-    assertType<{ name: string; age: number }>(person.setProperties({ name: 'Joe', age: 35 }));
-    assertType<{ name: string; capitalized: string }>(person.setProperties({ name: 'Joe', capitalized: 'JOE' }));
-    assertType<{ name: string; age: number }>(setProperties(pojo, { name: 'Joe', age: 35 }));
+  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: any = {};
-    const dynamicKey: string = 'dummy'; // tslint:disable-line:no-inferrable-types
+  const obj: any = {};
+  const dynamicKey: string = 'dummy'; // eslint-disable-line @typescript-eslint/no-inferrable-types
 
-    assertType<any>(get(obj, 'dummy'));
-    assertType<any>(get(obj, dynamicKey));
-    assertType<{ dummy: any }>(getProperties(obj, 'dummy'));
-    assertType<{ dummy: any }>(getProperties(obj, ['dummy']));
-    assertType<object>(getProperties(obj, dynamicKey));
-    assertType<object>(getProperties(obj, [dynamicKey]));
-    assertType<string>(set(obj, 'dummy', 'value'));
-    assertType<string>(set(obj, dynamicKey, 'value'));
-    assertType<{ dummy: string }>(setProperties(obj, { dummy: 'value ' }));
-    assertType<object>(setProperties(obj, { [dynamicKey]: 'value' }));
+  expectTypeOf(get(obj, 'dummy')).toBeAny();
+  expectTypeOf(get(obj, dynamicKey)).toBeAny();
+  expectTypeOf(getProperties(obj, 'dummy')).toEqualTypeOf<{ dummy: any }>();
+  expectTypeOf(getProperties(obj, ['dummy'])).toEqualTypeOf<{ dummy: any }>();
+  expectTypeOf(getProperties(obj, dynamicKey)).toEqualTypeOf<Record<string, any>>();
+  expectTypeOf(getProperties(obj, [dynamicKey])).toEqualTypeOf<Record<string, any>>();
+  expectTypeOf(set(obj, 'dummy', 'value')).toBeAny();
+  expectTypeOf(set(obj, dynamicKey, 'value')).toBeAny();
+  expectTypeOf(setProperties(obj, { dummy: 'value ' })).toEqualTypeOf<Record<'dummy', any>>();
+  expectTypeOf(setProperties(obj, { [dynamicKey]: 'value' })).toEqualTypeOf<
+    Record<string | number, any>
+  >();
 }

From 66c28fc4ee6793d4e3933dccfa9cfd5650600940 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Sun, 28 Aug 2022 21:52:45 -0600
Subject: [PATCH 07/39] type test fixes for 'ember-tests'

This file is a hot mess, and provides more and further evidence of two
increasingly-obvious realities from a TS POV:

- The Ember namespace is 99% useless; people should just use the
  module imports instead.
- The Classic types are *awful*, because Classic *code* was a mess
  compared to Octane, because ES5 was a mess.
---
 types/preview/ember/test/ember-tests.ts | 131 +++++++++++-------------
 1 file changed, 62 insertions(+), 69 deletions(-)

diff --git a/types/preview/ember/test/ember-tests.ts b/types/preview/ember/test/ember-tests.ts
index 493d98f9c82..e59a3436191 100755
--- a/types/preview/ember/test/ember-tests.ts
+++ b/types/preview/ember/test/ember-tests.ts
@@ -2,23 +2,33 @@ import Ember from 'ember';
 import { AnyFn } from 'ember/-private/type-utils';
 import { assertType } from './lib/assert';
 
-let App: any;
+class President extends Ember.Object {
+  name = 'Barack Obama';
+}
 
-App = Ember.Application.create();
-App.president = Ember.Object.create({
-  name: 'Barack Obama',
-});
-App.country = Ember.Object.create({
-  presidentNameBinding: 'MyApp.president.name',
-});
-App.country.get('presidentName');
-App.president = Ember.Object.create({
-  firstName: 'Barack',
-  lastName: 'Obama',
-  fullName: Ember.computed(function () {
+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 {
@@ -26,88 +36,71 @@ declare class MyPerson extends Ember.Object {
 }
 MyPerson.createMan();
 
-const Person1 = Ember.Object.extend({
-  say: (thing: string) => {
+class Person1 extends Ember.Object {
+  name?: string;
+  say = (thing: string) => {
     alert(thing);
-  },
-});
+  };
+}
 
 declare class MyPerson2 extends Ember.Object {
   helloWorld(): void;
 }
 MyPerson2.create().helloWorld();
 
-const tom = Person1.create({
-  name: 'Tom Dale',
+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');
 
-App.todosController = Ember.Object.create({
-  todos: [Ember.Object.create({ isDone: false })],
-  remaining: Ember.computed('todos.@each.isDone', function () {
+class Todo extends Ember.Object {
+  isDone = false;
+}
+
+class TodosController extends Ember.Object {
+  todos = [Todo.create()];
+
+  @Ember.computed('todos.@each.isDone')
+  get remaining() {
     const todos = this.get('todos');
-    return todos.filterProperty('isDone', false).get('length');
-  }),
-});
+    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);
+todo?.set('isDone', true);
 App.todosController.get('remaining');
-todo = Ember.Object.create({ isDone: false });
+todo = Todo.create({ isDone: true });
 todos.pushObject(todo);
 App.todosController.get('remaining');
 
-App.wife = Ember.Object.create({
-  householdIncome: 80000,
-});
-App.husband = Ember.Object.create({
-  householdIncomeBinding: 'App.wife.householdIncome',
-});
-App.husband.get('householdIncome');
-App.husband.set('householdIncome', 90000);
-App.wife.get('householdIncome');
-
-App.user = Ember.Object.create({
-  fullName: 'Kara Gates',
-});
-App.user.set('fullName', 'Krang Gates');
-App.userView.set('userName', 'Truckasaurus Gates');
-App.user.get('fullName');
-
-App = Ember.Application.create({
+const NormalApp = Ember.Application.create({
   rootElement: '#sidebar',
 });
 
-App.userController = Ember.Object.create({
-  content: Ember.Object.create({
-    firstName: 'Albert',
-    lastName: 'Hofmann',
-    posts: 25,
-    hobbies: 'Riding bicycles',
-  }),
-});
-
 Ember.Handlebars.registerHelper(
   'highlight',
   (property: string, options: any) =>
     new Ember.Handlebars.SafeString('<span class="highlight">' + 'some value' + '</span>')
 );
 
-const coolView = App.CoolView.create();
+class Person2 extends Ember.Object {
+  name = '';
 
-const Person2 = Ember.Object.extend({
-  name: '',
   sayHello() {
     console.log('Hello from ' + this.get('name'));
-  },
-});
+  }
+}
 const people = Ember.A([
   Person2.create({ name: 'Juan' }),
   Person2.create({ name: 'Charles' }),
@@ -131,16 +124,16 @@ arr.setEach('age', 123);
 // @ts-expect-error
 arr.getEach('age');
 
-const Person3 = Ember.Object.extend({
-  name: '',
-  isHappy: false,
-});
+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: typeof Person3.prototype): boolean => {
-  return !!person.get('isHappy');
+const isHappy = (person: Person3): boolean => {
+  return Boolean(person.get('isHappy'));
 };
 people2.every(isHappy);
 people2.any(isHappy);

From 71e1e3f5d293f44a5f7e481e02770f4386f88f6d Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 08:17:59 -0600
Subject: [PATCH 08/39] Update preview type tests for Ember.DataAdapter

---
 types/preview/ember/test/data-adapter.ts | 65 ++++++++++++------------
 1 file changed, 33 insertions(+), 32 deletions(-)

diff --git a/types/preview/ember/test/data-adapter.ts b/types/preview/ember/test/data-adapter.ts
index a77e6b66a14..e7a42b6a5cd 100644
--- a/types/preview/ember/test/data-adapter.ts
+++ b/types/preview/ember/test/data-adapter.ts
@@ -1,52 +1,53 @@
 import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
 
 const da = Ember.DataAdapter.create();
 
 const filters = da.getFilters();
-filters.includes({ name: 'foo', desc: 'bar' }); // $ExpectType boolean
+expectTypeOf(filters.includes({ name: 'foo', desc: 'bar' })).toBeBoolean();
 // @ts-expect-error
 filters.includes({});
 
-filters[0].name; // $ExpectType string
-filters[0].desc; // $ExpectType string
+expectTypeOf(filters[0]?.name).toEqualTypeOf<string | undefined>();
+expectTypeOf(filters[0]?.desc).toEqualTypeOf<string | undefined>();
 
 // $ExpectType () => void
 da.watchModelTypes(
-    function added(wrappedTypes) {
-        wrappedTypes;
-        wrappedTypes[0].release; // $ExpectType () => void
-        wrappedTypes[0].type.columns[0].desc; // $ExpectType string
-        wrappedTypes[0].type.columns[0].name; // $ExpectType string
-        wrappedTypes[0].type.count; // $ExpectType number
-        wrappedTypes[0].type.name; // $ExpectType string
-    },
-    function updated(wrappedTypes) {
-        wrappedTypes;
-        wrappedTypes[0].release; // $ExpectType () => void
-        wrappedTypes[0].type.columns[0].desc; // $ExpectType string
-        wrappedTypes[0].type.columns[0].name; // $ExpectType string
-        wrappedTypes[0].type.count; // $ExpectType number
-        wrappedTypes[0].type.name; // $ExpectType string
-    },
+  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>();
+  }
 );
 // @ts-expect-error
 da.watchModelTypes(() => {});
 
 // $ExpectType () => void
 da.watchRecords(
-    'house',
-    function added(records) {
-        records[0].object; // $ExpectType object
-        records[0].columnValues; // $ExpectType object
-    },
-    function updated(records) {
-        records[0].object; // $ExpectType object
-        records[0].columnValues; // $ExpectType object
-    },
-    function removed(idx, count) {
-        idx; // $ExpectType number
-        count; // $ExpectType number
-    },
+  '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) {
+    idx; // $ExpectType number
+    count; // $ExpectType number
+  }
 );
 // @ts-expect-error
 da.watchRecords(() => {});

From 81655aed415b191188bb9a960fd4ec58ad74c7db Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 09:30:09 -0600
Subject: [PATCH 09/39] Update preview type tests for EmberObject.create()

---
 types/preview/@ember/object/test/create.ts | 77 +++++++++++----------
 types/preview/ember/test/create.ts         | 78 +++++++++++-----------
 2 files changed, 80 insertions(+), 75 deletions(-)

diff --git a/types/preview/@ember/object/test/create.ts b/types/preview/@ember/object/test/create.ts
index a508679fa12..e615991b6b4 100644
--- a/types/preview/@ember/object/test/create.ts
+++ b/types/preview/@ember/object/test/create.ts
@@ -1,54 +1,57 @@
-import { assertType } from './lib/assert';
 import EmberObject, { computed } from '@ember/object';
-import ComputedProperty from '@ember/object/computed';
+import { expectTypeOf } from 'expect-type';
 
 /**
  * Zero-argument case
  */
 const o = EmberObject.create();
 // create returns an object
-assertType<object>(o);
-// object returned by create type-checks as an instance of Ember.Object
-assertType<boolean>(o.isDestroyed); // from instance
-assertType<boolean>(o.isDestroying); // from instance
-assertType<(key: keyof EmberObject) => any>(o.get); // from prototype
+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
  */
-const o1 = EmberObject.create({ x: 9, y: 'hello', z: false });
-assertType<number>(o1.x);
-assertType<string>(o1.y);
-o1.y; // $ExpectType string
-o1.z; // $ExpectType boolean
+class O1 extends EmberObject {
+  declare x: number;
+  declare y: string;
+  declare z: boolean;
+}
 
-const obj = EmberObject.create({ a: 1 }, { b: 2 }, { c: 3 });
-assertType<number>(obj.b);
-assertType<number>(obj.a);
-assertType<number>(obj.c);
+const o1 = O1.create({ x: 9, y: 'hello', z: false });
+expectTypeOf(o1.x).toBeNumber();
+expectTypeOf(o1.y).toBeString();
+expectTypeOf(o1.z).toBeBoolean();
 
-export class Person extends EmberObject {
-    fullName = computed('firstName', 'lastName', function () {
-        return [this.firstName + this.lastName].join(' ');
-    });
-    declare firstName: string;
-    declare lastName: string;
-    declare age: number;
+class O2 extends EmberObject {
+  declare a: number;
+  declare b: number;
+  declare c: number;
 }
-const p = new Person();
-
-assertType<string>(p.firstName);
-assertType<ComputedProperty<string>>(p.fullName);
-assertType<string>(p.get('fullName'));
+const obj = O2.create({ a: 1 }, { b: 2 }, { c: 3 });
+expectTypeOf(obj.b).toBeNumber();
+expectTypeOf(obj.a).toBeNumber();
+expectTypeOf(obj.c).toBeNumber();
 
-const p2 = Person.create({ firstName: 'string' });
-const p2b = Person.create({}, { firstName: 'string' });
-const p2c = Person.create({}, {}, { firstName: 'string' });
+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();
 
-export class PersonWithNumberName extends Person.extend({
-    fullName: 6,
-}) {}
+expectTypeOf(p.firstName).toBeString();
+expectTypeOf(p.fullName).toBeString();
+expectTypeOf(p.get('fullName')).toBeString();
 
-const p4 = new PersonWithNumberName();
-assertType<string>(p4.firstName);
-assertType<number>(p4.fullName);
+Person.create({ firstName: 'string' });
+Person.create({}, { firstName: 'string' });
+Person.create({}, {}, { firstName: 'string' });
diff --git a/types/preview/ember/test/create.ts b/types/preview/ember/test/create.ts
index 2412309691f..5846fd2b037 100755
--- a/types/preview/ember/test/create.ts
+++ b/types/preview/ember/test/create.ts
@@ -1,55 +1,57 @@
 import Ember from 'ember';
-import { assertType } from './lib/assert';
-import { UnwrapComputedPropertyGetter } from "@ember/object/-private/types";
+import { expectTypeOf } from 'expect-type';
 
 /**
  * Zero-argument case
  */
 const o = Ember.Object.create();
 // create returns an object
-assertType<object>(o);
+expectTypeOf(o).toBeObject();
 // object returned by create type-checks as an instance of Ember.Object
-assertType<boolean>(o.isDestroyed); // from instance
-assertType<boolean>(o.isDestroying); // from instance
-assertType<<K extends keyof Ember.Object>(key: K) => UnwrapComputedPropertyGetter<Ember.Object[K]>>(o.get); // from prototype
+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
  */
-const o1 = Ember.Object.create({ x: 9, y: 'hello', z: false });
-assertType<number>(o1.x);
-assertType<string>(o1.y);
-o1.y; // $ExpectType string
-o1.z; // $ExpectType boolean
-
-const obj = Ember.Object.create({ a: 1 }, { b: 2 }, { c: 3 });
-assertType<number>(obj.b);
-assertType<number>(obj.a);
-assertType<number>(obj.c);
-
-export class Person extends Ember.Object.extend({
-    fullName: Ember.computed('firstName', 'lastName', function () {
-        return [this.firstName + this.lastName].join(' ');
-    }),
-}) {
-    declare firstName: string;
-    declare lastName: string;
-    declare age: number;
+class O1 extends Ember.Object {
+  declare x: number;
+  declare y: string;
+  declare z: boolean;
 }
-const p = new Person();
 
-assertType<string>(p.firstName);
-assertType<Ember.ComputedProperty<string>>(p.fullName);
-assertType<string>(p.get('fullName'));
+const o1 = O1.create({ x: 9, y: 'hello', z: false });
+expectTypeOf(o1.x).toBeNumber();
+expectTypeOf(o1.y).toBeString();
+expectTypeOf(o1.z).toBeBoolean();
 
-const p2 = Person.create({ firstName: 'string' });
-const p2b = Person.create({}, { firstName: 'string' });
-const p2c = Person.create({}, {}, { firstName: 'string' });
+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();
 
-export class PersonWithNumberName extends Person.extend({
-    fullName: 6,
-}) {}
+expectTypeOf(p.firstName).toBeString();
+expectTypeOf(p.fullName).toBeString();
+expectTypeOf(p.get('fullName')).toBeString();
 
-const p4 = new PersonWithNumberName();
-assertType<string>(p4.firstName);
-assertType<number>(p4.fullName);
+Person.create({ firstName: 'string' });
+Person.create({}, { firstName: 'string' });
+Person.create({}, {}, { firstName: 'string' });

From 920901efa8a9734fdbdf26192ea7cf288d803d2e Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 09:33:50 -0600
Subject: [PATCH 10/39] Update preview type tests for EmberObject.reopen()

---
 types/preview/@ember/object/test/reopen.ts | 80 ++++++++++++----------
 types/preview/ember/test/reopen.ts         |  1 -
 2 files changed, 42 insertions(+), 39 deletions(-)

diff --git a/types/preview/@ember/object/test/reopen.ts b/types/preview/@ember/object/test/reopen.ts
index 10a2e9e1845..cd361c11d5f 100644
--- a/types/preview/@ember/object/test/reopen.ts
+++ b/types/preview/@ember/object/test/reopen.ts
@@ -1,75 +1,79 @@
-import { assertType } from './lib/assert';
 import EmberObject from '@ember/object';
 import Mixin from '@ember/object/mixin';
+import { expectTypeOf } from 'expect-type';
 
-type Person = typeof Person.prototype;
-const Person = EmberObject.extend({
-    name: '',
-    sayHello() {
-        alert(`Hello. My name is ${this.get('name')}`);
-    },
-});
+class Person extends EmberObject {
+  name = '';
+
+  sayHello() {
+    alert(`Hello. My name is ${this.get('name')}`);
+  }
+}
 
-assertType<Person>(Person.reopen());
+expectTypeOf(Person.reopen()).toMatchTypeOf<typeof Person>();
 
-assertType<string>(Person.create().name);
-// tslint:disable-next-line no-void-expression
-assertType<void>(Person.create().sayHello());
+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',
+  species: 'Homo sapiens',
 
-    createPerson(name: string): Person {
-        return Person.create({ name });
-    },
+  createPerson(name: string): Person {
+    return Person.create({ name });
+  },
 });
 
-assertType<string>(Person2.create().name);
-// tslint:disable-next-line no-void-expression
-assertType<void>(Person2.create().sayHello());
-assertType<string>(Person2.species);
+// 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',
+  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',
+  goodbyeMessage: 'goodbye',
 
-    sayGoodbye() {
-        alert(`${this.get('goodbyeMessage')}, ${this.get('name')}`);
-    },
+  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;
+  resizable: true;
 }
-declare const AutoResizeMixin: Mixin<AutoResizeMixin>;
-
-const ResizableTextArea = EmberObject.reopen(AutoResizeMixin, {
-    scaling: 1.0,
-});
-const text = ResizableTextArea.create();
-// TODO fix upstream
-// assertType<boolean>(text.resizable);
-assertType<number>(text.scaling);
+const AutoResizeMixin = Mixin.create({ resizable: true });
 
+// And the same here.
 const Reopened = EmberObject.reopenClass({ a: 1 }, { b: 2 }, { c: 3 });
-assertType<number>(Reopened.a);
-assertType<number>(Reopened.b);
-assertType<number>(Reopened.c);
+// @ts-expect-error
+Reopened.a;
+// @ts-expect-error
+Reopened.b;
+// @ts-expect-error
+Reopened.c;
diff --git a/types/preview/ember/test/reopen.ts b/types/preview/ember/test/reopen.ts
index 2df9f538d16..a4cf4673dcf 100755
--- a/types/preview/ember/test/reopen.ts
+++ b/types/preview/ember/test/reopen.ts
@@ -1,6 +1,5 @@
 import Ember from 'ember';
 import { expectTypeOf } from 'expect-type';
-import { assertType } from './lib/assert';
 
 class Person extends Ember.Object {
   name = '';

From a5e36423469108db1b49a9a04d2a752182904054 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 09:43:33 -0600
Subject: [PATCH 11/39] Update preview type tests for many Mixin types

---
 .../-private/class-names-support.d.ts         |  40 +++----
 .../@ember/component/-private/view-mixin.d.ts | 102 +++++++++---------
 .../@ember/debug/container-debug-adapter.d.ts |   6 +-
 .../engine/-private/registry-proxy-mixin.d.ts |  84 +++++++--------
 types/preview/@ember/engine/test/engine.ts    |  44 ++++----
 .../object/-private/action-handler.d.ts       |   5 +-
 types/preview/@ember/object/evented.d.ts      |  77 ++++++-------
 types/preview/@ember/object/observable.d.ts   |   4 +-
 .../@ember/object/promise-proxy-mixin.d.ts    |  56 +++++-----
 9 files changed, 202 insertions(+), 216 deletions(-)

diff --git a/types/preview/@ember/component/-private/class-names-support.d.ts b/types/preview/@ember/component/-private/class-names-support.d.ts
index 59fabab2fda..0944d06a3ad 100644
--- a/types/preview/@ember/component/-private/class-names-support.d.ts
+++ b/types/preview/@ember/component/-private/class-names-support.d.ts
@@ -1,25 +1,25 @@
 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[];
+  /**
+   * 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[];
 }
-declare const ClassNamesSupport: Mixin<ClassNamesSupport>;
+declare const ClassNamesSupport: Mixin;
 export default ClassNamesSupport;
diff --git a/types/preview/@ember/component/-private/view-mixin.d.ts b/types/preview/@ember/component/-private/view-mixin.d.ts
index 72b78927dad..d330e420e46 100644
--- a/types/preview/@ember/component/-private/view-mixin.d.ts
+++ b/types/preview/@ember/component/-private/view-mixin.d.ts
@@ -1,57 +1,57 @@
 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;
+  /**
+   * 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;
 }
-declare const ViewMixin: Mixin<ViewMixin>;
+declare const ViewMixin: Mixin;
 
 export default ViewMixin;
diff --git a/types/preview/@ember/debug/container-debug-adapter.d.ts b/types/preview/@ember/debug/container-debug-adapter.d.ts
index 3e03e0923fd..7789b086d1f 100644
--- a/types/preview/@ember/debug/container-debug-adapter.d.ts
+++ b/types/preview/@ember/debug/container-debug-adapter.d.ts
@@ -5,7 +5,7 @@ import Resolver from 'ember-resolver';
  * 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[];
+  resolver: Resolver;
+  canCatalogEntriesByType(type: string): boolean;
+  catalogEntriesByType(type: string): string[];
 }
diff --git a/types/preview/@ember/engine/-private/registry-proxy-mixin.d.ts b/types/preview/@ember/engine/-private/registry-proxy-mixin.d.ts
index f0718b2a83d..801abf8b0cf 100644
--- a/types/preview/@ember/engine/-private/registry-proxy-mixin.d.ts
+++ b/types/preview/@ember/engine/-private/registry-proxy-mixin.d.ts
@@ -6,47 +6,47 @@ import Mixin from '@ember/object/mixin';
  * 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;
+  /**
+   * 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;
 }
-declare const RegistryProxyMixin: Mixin<RegistryProxyMixin>;
+declare const RegistryProxyMixin: Mixin;
 export default RegistryProxyMixin;
diff --git a/types/preview/@ember/engine/test/engine.ts b/types/preview/@ember/engine/test/engine.ts
index cf01e987b7e..4426b7d8f3c 100755
--- a/types/preview/@ember/engine/test/engine.ts
+++ b/types/preview/@ember/engine/test/engine.ts
@@ -1,39 +1,41 @@
 import Engine from '@ember/engine';
 import EmberObject from '@ember/object';
 
-const BaseEngine = Engine.extend({
-    modulePrefix: 'my-engine',
-});
+class BaseEngine extends Engine {
+  modulePrefix = 'my-engine';
+}
 
-class Obj extends EmberObject.extend({ foo: 'bar' }) {}
+class Obj extends EmberObject {
+  foo = 'bar';
+}
 
 BaseEngine.initializer({
-    name: 'my-initializer',
-    initialize(engine) {
-        engine.register('foo:bar', Obj);
-    },
+  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');
-    },
+  name: 'my-instance-initializer',
+  initialize(engine) {
+    (engine.lookup('foo:bar') as Obj).get('foo');
+  },
 });
 
 const Engine1 = BaseEngine.create({
-    rootElement: '#engine-one',
-    customEvents: {
-        paste: 'paste',
-    },
+  rootElement: '#engine-one',
+  customEvents: {
+    paste: 'paste',
+  },
 });
 
 const Engine2 = BaseEngine.create({
-    rootElement: '#engine-two',
-    customEvents: {
-        mouseenter: null,
-        mouseleave: null,
-    },
+  rootElement: '#engine-two',
+  customEvents: {
+    mouseenter: null,
+    mouseleave: null,
+  },
 });
 
 const Engine3 = BaseEngine.create();
diff --git a/types/preview/@ember/object/-private/action-handler.d.ts b/types/preview/@ember/object/-private/action-handler.d.ts
index dae8f951509..ab1f89e9119 100644
--- a/types/preview/@ember/object/-private/action-handler.d.ts
+++ b/types/preview/@ember/object/-private/action-handler.d.ts
@@ -1,7 +1,8 @@
+import { AnyFn } from 'ember/-private/type-utils';
 import type Mixin from '../mixin';
 
 interface ActionsHash {
-  [index: string]: (...params: any[]) => any;
+  [index: string]: AnyFn;
 }
 
 /**
@@ -24,5 +25,5 @@ interface ActionHandler {
    */
   actions: ActionsHash;
 }
-declare const ActionHandler: Mixin<ActionHandler>;
+declare const ActionHandler: Mixin;
 export default ActionHandler;
diff --git a/types/preview/@ember/object/evented.d.ts b/types/preview/@ember/object/evented.d.ts
index d888571eeed..f3be2682036 100644
--- a/types/preview/@ember/object/evented.d.ts
+++ b/types/preview/@ember/object/evented.d.ts
@@ -1,60 +1,43 @@
 import Mixin from '@ember/object/mixin';
-import { AnyFn, EmberMethod, MethodNamesOf, MethodParams, MethodsOf } from 'ember/-private/type-utils';
+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[]): any;
-    /**
-     * 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;
+  /**
+   * 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[]): any;
+  /**
+   * 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;
 }
-declare const Evented: Mixin<Evented>;
+declare 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;
+export function on<F extends AnyFn>(...args: [...eventNames: string[], func: F]): F;
diff --git a/types/preview/@ember/object/observable.d.ts b/types/preview/@ember/object/observable.d.ts
index d0bbc08f1ff..74ed10570dd 100644
--- a/types/preview/@ember/object/observable.d.ts
+++ b/types/preview/@ember/object/observable.d.ts
@@ -5,7 +5,7 @@ import CoreObject from './core';
 /**
  * This mixin provides properties and property observing functionality, core features of the Ember object model.
  */
-interface Observable {
+interface Observable extends CoreObject {
   /**
    * Retrieves the value of a property from the object.
    */
@@ -79,5 +79,5 @@ interface Observable {
    */
   cacheFor<K extends keyof this>(key: K): this[K] | undefined;
 }
-declare const Observable: Mixin<Observable, CoreObject>;
+declare const Observable: Mixin;
 export default Observable;
diff --git a/types/preview/@ember/object/promise-proxy-mixin.d.ts b/types/preview/@ember/object/promise-proxy-mixin.d.ts
index c23f8e75494..2ccc0ca5694 100644
--- a/types/preview/@ember/object/promise-proxy-mixin.d.ts
+++ b/types/preview/@ember/object/promise-proxy-mixin.d.ts
@@ -1,35 +1,35 @@
-import Mixin from "@ember/object/mixin";
-import RSVP from "rsvp";
+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>;
+  /**
+   * 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>;
 }
-declare const PromiseProxyMixin: Mixin<PromiseProxyMixin<any>>;
+declare const PromiseProxyMixin: Mixin;
 export default PromiseProxyMixin;

From 9ca3053f1cc61b184c8f4de0886e7282bed34b03 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 10:11:16 -0600
Subject: [PATCH 12/39] Update preview type tests for arrays/array mixins

---
 .../@ember/array/-private/native-array.d.ts   | 10 +-
 types/preview/@ember/array/index.d.ts         | 99 +++++++++----------
 2 files changed, 50 insertions(+), 59 deletions(-)

diff --git a/types/preview/@ember/array/-private/native-array.d.ts b/types/preview/@ember/array/-private/native-array.d.ts
index c44ffbc1887..1a2c8fcf113 100644
--- a/types/preview/@ember/array/-private/native-array.d.ts
+++ b/types/preview/@ember/array/-private/native-array.d.ts
@@ -13,11 +13,11 @@ type GlobalArray<T> = T[];
  * at anytime by calling `Ember.NativeArray.apply(Array.prototype)`.
  */
 interface NativeArray<T> extends GlobalArray<T>, MutableArray<T>, Observable {
-    /**
-     * __Required.__ You must implement this method to apply this mixin.
-     */
-    length: number;
+  /**
+   * __Required.__ You must implement this method to apply this mixin.
+   */
+  length: number;
 }
 
-declare const NativeArray: Mixin<NativeArray<unknown>>;
+declare const NativeArray: Mixin;
 export default NativeArray;
diff --git a/types/preview/@ember/array/index.d.ts b/types/preview/@ember/array/index.d.ts
index 10b58c75dda..13f7597c5ce 100644
--- a/types/preview/@ember/array/index.d.ts
+++ b/types/preview/@ember/array/index.d.ts
@@ -1,66 +1,57 @@
-// Type definitions for non-npm package @ember/array 4.0
-// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Farray
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
-import ComputedProperty from "@ember/object/computed";
-import Mixin from "@ember/object/mixin";
-import Enumerable from "@ember/array/-private/enumerable";
-import NativeArray from "@ember/array/-private/native-array";
+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<T> {
-    /**
-     * __Required.__ You must implement this method to apply this mixin.
-     */
-    length: number | ComputedProperty<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`.
-     */
-    // tslint:disable-next-line:array-type
-    objectsAt(indexes: number[]): Array<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): 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;
-    /**
-     * Returns a special object that can be used to observe individual properties
-     * on the array. Just get an equivalent property on this object and it will
-     * return an enumerable that maps automatically to the named key on the
-     * member objects.
-     */
-    '@each': ComputedProperty<T>;
+  /**
+   * __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`.
+   */
+  // tslint:disable-next-line:array-type
+  objectsAt(indexes: number[]): Array<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): 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;
+  /**
+   * Returns a special object that can be used to observe individual properties
+   * on the array. Just get an equivalent property on this object and it will
+   * return an enumerable that maps automatically to the named key on the
+   * member objects.
+   */
+  '@each': T;
 }
 // Ember.Array rather than Array because the `array-type` lint rule doesn't realize the global is shadowed
 // tslint:disable-next-line:array-type
-declare const Array: Mixin<Array<unknown>>;
+declare const Array: Mixin;
 export default Array;
 
 /**

From d845d4a84b981b0b5c7df4985362ac94ffd2c9c5 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 10:12:43 -0600
Subject: [PATCH 13/39] Lint autofix and remove DT headers from a bunch of
 preview types

---
 types/preview/@ember/application/index.d.ts |  8 --
 types/preview/@ember/debug/index.d.ts       | 90 +++++++++----------
 types/preview/@ember/destroyable/index.d.ts | 16 +---
 types/preview/@ember/error/index.d.ts       |  8 --
 types/preview/@ember/helper/index.d.ts      |  8 --
 types/preview/@ember/modifier/index.d.ts    |  8 --
 types/preview/@ember/owner/index.d.ts       | 98 ++++++++++-----------
 types/preview/@ember/polyfills/index.d.ts   |  8 --
 types/preview/@ember/routing/index.d.ts     |  8 --
 types/preview/@ember/runloop/index.d.ts     |  8 --
 types/preview/@ember/service/index.d.ts     |  8 --
 types/preview/@ember/template/index.d.ts    |  8 --
 types/preview/@ember/test/index.d.ts        | 26 ++----
 types/preview/@ember/utils/index.d.ts       |  8 --
 types/preview/ember/index.d.ts              |  8 --
 15 files changed, 101 insertions(+), 217 deletions(-)

diff --git a/types/preview/@ember/application/index.d.ts b/types/preview/@ember/application/index.d.ts
index 16b359ce356..bc0826caeac 100644
--- a/types/preview/@ember/application/index.d.ts
+++ b/types/preview/@ember/application/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/application 4.0
-// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Fapplication
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 import Engine from '@ember/engine';
 import ApplicationInstance from '@ember/application/instance';
 import EventDispatcher from '@ember/application/-private/event-dispatcher';
diff --git a/types/preview/@ember/debug/index.d.ts b/types/preview/@ember/debug/index.d.ts
index 0500927bc3b..6554a0d082b 100644
--- a/types/preview/@ember/debug/index.d.ts
+++ b/types/preview/@ember/debug/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/debug 4.0
-// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Fdebug
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 /**
  * Define an assertion that will throw an exception if the condition is not met.
  */
@@ -24,11 +16,11 @@ export function debug(message: string): void;
  * 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,
+  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.
@@ -37,11 +29,11 @@ export function registerDeprecationHandler(
  * default warning behavior.
  */
 export function registerWarnHandler(
-    handler: (
-        message: string,
-        options: { id: string } | undefined,
-        next: (message: string, options?: { id: string }) => void,
-    ) => void,
+  handler: (
+    message: string,
+    options: { id: string } | undefined,
+    next: (message: string, options?: { id: string }) => void
+  ) => void
 ): void;
 
 /**
@@ -67,34 +59,38 @@ export function warn(message: string, options: { id: string }): void;
  * @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;
-    },
+  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; }
+export interface Available {
+  available: string;
+}
+export interface Enabled extends Available {
+  enabled: string;
+}
diff --git a/types/preview/@ember/destroyable/index.d.ts b/types/preview/@ember/destroyable/index.d.ts
index 855508cbbcf..e8dfee90dd9 100644
--- a/types/preview/@ember/destroyable/index.d.ts
+++ b/types/preview/@ember/destroyable/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/destroyable 4.0
-// Project: https://api.emberjs.com/ember/3.22/modules/@ember%2Fdestroyable
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 export function associateDestroyableChild<T extends object>(parent: object, child: T): T;
 
 export function isDestroying(destroyable: object): boolean;
@@ -19,11 +11,11 @@ export function assertDestroyablesDestroyed(): void;
 export function enableDestroyableTracking(): void;
 
 export function registerDestructor<T extends object>(
-destroyable: T,
-destructor: (destroyable: T) => void
+  destroyable: T,
+  destructor: (destroyable: T) => void
 ): (destroyable: T) => void;
 
 export function unregisterDestructor<T extends object>(
-destroyable: T,
-destructor: (destroyable: T) => void
+  destroyable: T,
+  destructor: (destroyable: T) => void
 ): void;
diff --git a/types/preview/@ember/error/index.d.ts b/types/preview/@ember/error/index.d.ts
index e1a44683d6f..8d13769d1f2 100644
--- a/types/preview/@ember/error/index.d.ts
+++ b/types/preview/@ember/error/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/error 4.0
-// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Ferror
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 /**
  * A subclass of the JavaScript Error object for use in Ember.
  */
diff --git a/types/preview/@ember/helper/index.d.ts b/types/preview/@ember/helper/index.d.ts
index 7081b026074..8b6f38d351f 100644
--- a/types/preview/@ember/helper/index.d.ts
+++ b/types/preview/@ember/helper/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/helper 4.0
-// Project: https://github.com/emberjs/ember.js
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 import type { Opaque } from 'ember/-private/type-utils';
 
 // In normal TypeScript, these helpers are essentially opaque tokens that just
diff --git a/types/preview/@ember/modifier/index.d.ts b/types/preview/@ember/modifier/index.d.ts
index 6d197ae5ee6..2281a7ea20e 100644
--- a/types/preview/@ember/modifier/index.d.ts
+++ b/types/preview/@ember/modifier/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/modifier 4.0
-// Project: https://github.com/emberjs/ember.js
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 import type Owner from '@ember/owner';
 import type { Opaque } from 'ember/-private/type-utils';
 
diff --git a/types/preview/@ember/owner/index.d.ts b/types/preview/@ember/owner/index.d.ts
index db9b3dbb28a..414de7abe1c 100644
--- a/types/preview/@ember/owner/index.d.ts
+++ b/types/preview/@ember/owner/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/owner 4.0
-// Project: https://emberjs.com/api/ember/4.0/
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 /**
  * The name for a factory consists of a namespace and the name of a specific
  * type within that namespace, like `'service:session'`.
@@ -22,47 +14,47 @@ export type FullName = `${string}:${string}`;
  * instantiation and manages its lifetime.
  */
 export default interface Owner {
-    /**
-     * Given a {@linkcode FullName} return a corresponding instance.
-     */
-    lookup(fullName: FullName): unknown;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  instantiate?: boolean | undefined;
+  singleton?: boolean | undefined;
 }
 
 /**
@@ -74,13 +66,13 @@ export interface RegisterOptions {
  * 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 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;
 }
 
 /**
@@ -96,8 +88,8 @@ export interface Factory<T> {
  *   a `FactoryManager` is via {@linkcode Owner.factoryFor}.
  */
 export interface FactoryManager<T> extends Factory<T> {
-    /** The registered or resolved class. */
-    readonly class: Factory<T>;
+  /** The registered or resolved class. */
+  readonly class: Factory<T>;
 }
 
 // Don't export things unless we *intend* to.
diff --git a/types/preview/@ember/polyfills/index.d.ts b/types/preview/@ember/polyfills/index.d.ts
index 487bc2cf648..8bc9e03dd30 100644
--- a/types/preview/@ember/polyfills/index.d.ts
+++ b/types/preview/@ember/polyfills/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/polyfills 4.0
-// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Fpolyfills
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 import type { Mix, Mix3, Mix4 } from './types';
 
 /**
diff --git a/types/preview/@ember/routing/index.d.ts b/types/preview/@ember/routing/index.d.ts
index 923ca316b6b..bc33c70dae5 100644
--- a/types/preview/@ember/routing/index.d.ts
+++ b/types/preview/@ember/routing/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/routing 4.0
-// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Frouting
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 export { default as Route } from '@ember/routing/route';
 export { default as Router } from '@ember/routing/router';
 
diff --git a/types/preview/@ember/runloop/index.d.ts b/types/preview/@ember/runloop/index.d.ts
index 25cd870cf0d..6e5159af0e5 100644
--- a/types/preview/@ember/runloop/index.d.ts
+++ b/types/preview/@ember/runloop/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/runloop 4.0
-// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Frunloop
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 import {
   EmberMethod,
   EmberMethodParams,
diff --git a/types/preview/@ember/service/index.d.ts b/types/preview/@ember/service/index.d.ts
index 798774107b8..c87f86f0346 100644
--- a/types/preview/@ember/service/index.d.ts
+++ b/types/preview/@ember/service/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/service 4.0
-// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Fservice
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 import EmberObject from '@ember/object';
 import ComputedProperty from '@ember/object/computed';
 
diff --git a/types/preview/@ember/template/index.d.ts b/types/preview/@ember/template/index.d.ts
index 40a7f0c2408..9079f7a96f4 100644
--- a/types/preview/@ember/template/index.d.ts
+++ b/types/preview/@ember/template/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/template 4.0
-// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Ftemplate
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 import { SafeString } from './-private/handlebars';
 export function htmlSafe(str: string): SafeString;
 export function isHTMLSafe(str: unknown): str is SafeString;
diff --git a/types/preview/@ember/test/index.d.ts b/types/preview/@ember/test/index.d.ts
index d3a6c468f7a..7e78f264120 100644
--- a/types/preview/@ember/test/index.d.ts
+++ b/types/preview/@ember/test/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/test 4.0
-// Project: https://emberjs.com/api/ember/4.0/modules/@ember%2Ftest
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 import Application from '@ember/application';
 
 /**
@@ -13,17 +5,17 @@ import Application from '@ember/application';
  * when `App.injectTestHelpers` is called.
  */
 export function registerHelper(
-    name: string,
-    helperMethod: (app: Application, ...args: any[]) => unknown,
-    options?: object
+  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
+  name: string,
+  helperMethod: (app: Application, ...args: any[]) => unknown
 ): void;
 
 /**
@@ -41,8 +33,8 @@ export function unregisterHelper(name: string): void;
  */
 export function registerWaiter(callback: () => boolean): unknown;
 export function registerWaiter<Context>(
-    context: Context,
-    callback: (this: Context) => boolean
+  context: Context,
+  callback: (this: Context) => boolean
 ): unknown;
 /**
  * `unregisterWaiter` is used to unregister a callback that was
@@ -50,6 +42,6 @@ export function registerWaiter<Context>(
  */
 export function unregisterWaiter(callback: () => boolean): unknown;
 export function unregisterWaiter<Context>(
-    context: Context,
-    callback: (this: Context) => boolean
+  context: Context,
+  callback: (this: Context) => boolean
 ): unknown;
diff --git a/types/preview/@ember/utils/index.d.ts b/types/preview/@ember/utils/index.d.ts
index 353be5f0e34..d28098e176b 100644
--- a/types/preview/@ember/utils/index.d.ts
+++ b/types/preview/@ember/utils/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for non-npm package @ember/utils 4.0
-// Project: https://api.emberjs.com/ember/3.16/modules/@ember%2Futils
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 Dan Freeman <https://github.com/dfreeman>
-//                 James C. Davis <https://github.com/jamescdavis>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 import type { TypeOf } from './-private/types';
 
 /**
diff --git a/types/preview/ember/index.d.ts b/types/preview/ember/index.d.ts
index a3210233f40..f6172c80012 100755
--- a/types/preview/ember/index.d.ts
+++ b/types/preview/ember/index.d.ts
@@ -1,11 +1,3 @@
-// Type definitions for Ember.js 4.0
-// Project: https://emberjs.com/, https://github.com/emberjs/ember
-// Definitions by: Chris Krycho <https://github.com/chriskrycho>
-//                 James C. Davis <https://github.com/jamescdavis>
-//                 Dan Freeman <https://github.com/dfreeman>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
-
 // Capitalization is intentional: this makes it much easier to re-export RSVP on
 // the Ember namespace.
 import Rsvp from 'rsvp';

From bb0811dbf4928e251d897e2572d653680a46cdb1 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 10:16:19 -0600
Subject: [PATCH 14/39] Update preview type tests for array and mutable

---
 types/preview/@ember/array/mutable.d.ts       | 126 +++++++++---------
 .../preview/@ember/array/test/array-proxy.ts  |  32 ++---
 2 files changed, 79 insertions(+), 79 deletions(-)

diff --git a/types/preview/@ember/array/mutable.d.ts b/types/preview/@ember/array/mutable.d.ts
index 505408a66be..e047a73974c 100644
--- a/types/preview/@ember/array/mutable.d.ts
+++ b/types/preview/@ember/array/mutable.d.ts
@@ -1,7 +1,7 @@
-import Mixin from "@ember/object/mixin";
-import MutableEnumerable from "@ember/array/-private/mutable-enumerable";
+import Mixin from '@ember/object/mixin';
+import MutableEnumerable from '@ember/array/-private/mutable-enumerable';
 import EmberArray from '@ember/array';
-import Enumerable from "@ember/array/-private/enumerable";
+import Enumerable from '@ember/array/-private/enumerable';
 
 /**
  * This mixin defines the API for modifying array-like objects. These methods
@@ -10,66 +10,66 @@ import Enumerable from "@ember/array/-private/enumerable";
  * One concrete implementations of this class include ArrayProxy.
  */
 interface MutableArray<T> extends EmberArray<T>, MutableEnumerable<T> {
-    /**
-     * __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: Enumerable<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: Enumerable<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: EmberArray<T>): this;
+  /**
+   * __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: Enumerable<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: Enumerable<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: EmberArray<T>): this;
 }
 
-declare const MutableArray: Mixin<MutableArray<unknown>>;
+declare const MutableArray: Mixin;
 export default MutableArray;
diff --git a/types/preview/@ember/array/test/array-proxy.ts b/types/preview/@ember/array/test/array-proxy.ts
index 397f08183f7..4aa3714dc08 100644
--- a/types/preview/@ember/array/test/array-proxy.ts
+++ b/types/preview/@ember/array/test/array-proxy.ts
@@ -11,16 +11,16 @@ proxy.set('content', A(['amoeba', 'paramecium']));
 proxy.get('firstObject'); // 'amoeba'
 
 const overridden = ArrayProxy.create({
-    content: A(pets),
-    objectAtContent(idx: number): string | undefined {
-        return this.get('content').objectAt(idx)?.toUpperCase();
-    },
+  content: A(pets),
+  objectAtContent(this: ArrayProxy<string>, idx: number): string | undefined {
+    return this.get('content').objectAt(idx)?.toUpperCase();
+  },
 });
 
 overridden.get('firstObject'); // 'DOG'
 
 class MyNewProxy<T> extends ArrayProxy<T> {
-    isNew = true;
+  isNew = true;
 }
 
 const x = MyNewProxy.create({ content: A([1, 2, 3]) }) as MyNewProxy<number>;
@@ -29,20 +29,20 @@ assertType<boolean>(x.isNew);
 
 // Custom EmberArray
 class MyArray<T> extends EmberObject.extend(EmberArray) {
-    constructor(content: ArrayLike<T>) {
-        super();
-        this._content = content;
-    }
+  constructor(content: ArrayLike<T>) {
+    super();
+    this._content = content;
+  }
 
-    _content: ArrayLike<T>;
+  _content: ArrayLike<T>;
 
-    get length() {
-        return this._content.length;
-    }
+  get length() {
+    return this._content.length;
+  }
 
-    objectAt(idx: number) {
-        return this._content[idx];
-    }
+  objectAt(idx: number) {
+    return this._content[idx];
+  }
 }
 
 const customArrayProxy = ArrayProxy.create({ content: new MyArray(pets) });

From 52abdf166e8a5c80063a6a6f59a6dfb7682d6287 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 10:24:05 -0600
Subject: [PATCH 15/39] Update preview types for @ember/controller

---
 types/preview/@ember/controller/index.d.ts | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/types/preview/@ember/controller/index.d.ts b/types/preview/@ember/controller/index.d.ts
index da29c40835e..1be720b28f6 100644
--- a/types/preview/@ember/controller/index.d.ts
+++ b/types/preview/@ember/controller/index.d.ts
@@ -1,7 +1,6 @@
 import ActionHandler from '@ember/object/-private/action-handler';
 import Mixin from '@ember/object/mixin';
 import EmberObject from '@ember/object';
-import ComputedProperty from '@ember/object/computed';
 
 type QueryParamTypes = 'boolean' | 'number' | 'array' | 'string';
 type QueryParamScopeTypes = 'controller' | 'model';
@@ -32,13 +31,13 @@ export interface ControllerMixin extends ActionHandler {
   queryParams: Array<string | Record<string, QueryParamConfig | string | undefined>>;
   target: object;
 }
-export const ControllerMixin: Mixin<ControllerMixin>;
+export const ControllerMixin: Mixin;
 
 export default class Controller extends EmberObject {}
 export default interface Controller extends ControllerMixin {}
 
-export function inject(): ComputedProperty<Controller>;
-export function inject<K extends keyof Registry>(name: K): ComputedProperty<Registry[K]>;
+export function inject(): Controller;
+export function inject<K extends keyof Registry>(name: K): Registry[K];
 export function inject(target: object, propertyKey: string | symbol): void;
 
 // A type registry for Ember `Controller`s. Meant to be declaration-merged

From 2dab32225421bda5a988c91174821ea0091e69a3 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 10:50:39 -0600
Subject: [PATCH 16/39] Fix more preview types and types tests for EmberArray

---
 .../@ember/array/-private/enumerable.d.ts     |  3 +-
 types/preview/@ember/array/test/array.ts      | 76 ++++++++++---------
 types/preview/ember/test/array.ts             | 73 +++++++++++-------
 3 files changed, 89 insertions(+), 63 deletions(-)

diff --git a/types/preview/@ember/array/-private/enumerable.d.ts b/types/preview/@ember/array/-private/enumerable.d.ts
index eb33abcf7df..876e81a3d08 100644
--- a/types/preview/@ember/array/-private/enumerable.d.ts
+++ b/types/preview/@ember/array/-private/enumerable.d.ts
@@ -165,7 +165,8 @@ interface Enumerable<T> {
    * this property, it will return this. If you set this property to a new
    * array, it will replace the current content.
    */
-  '[]': ComputedProperty;
+  get '[]'(): this;
+  set '[]'(newValue: Enumerable<T>);
 }
 
 declare const Enumerable: Mixin;
diff --git a/types/preview/@ember/array/test/array.ts b/types/preview/@ember/array/test/array.ts
index f035b6fdaa5..1f63d8f9eb7 100755
--- a/types/preview/@ember/array/test/array.ts
+++ b/types/preview/@ember/array/test/array.ts
@@ -1,56 +1,62 @@
-import { assertType } from './lib/assert';
 import EmberObject from '@ember/object';
 import EmberArray, { A } from '@ember/array';
 import MutableArray from '@ember/array/mutable';
+import { expectTypeOf } from 'expect-type';
 
-type Person = typeof Person.prototype;
-const Person = EmberObject.extend({
-    name: '',
-    isHappy: false,
-});
+class Person extends EmberObject {
+  name = '';
+  isHappy = false;
+}
 
-const people = A([Person.create({ name: 'Yehuda', isHappy: true }), Person.create({ name: 'Majd', isHappy: false })]);
+const people = A([
+  Person.create({ name: 'Yehuda', isHappy: true }),
+  Person.create({ name: 'Majd', isHappy: false }),
+]);
 
-assertType<number>(people.get('length'));
-assertType<Person>(people.get('lastObject'));
-assertType<Person>(people.get('firstObject'));
-assertType<boolean>(people.isAny('isHappy'));
-assertType<boolean>(people.isAny('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
-assertType<boolean>(people.isAny('isHappy', "false"));
+people.isAny('isHappy', 'false');
 
-assertType<Person | undefined>(people.objectAt(0));
-assertType<EmberArray<Person | undefined>>(people.objectsAt([1, 2, 3]));
+expectTypeOf(people.objectAt(0)).toEqualTypeOf<Person | undefined>();
+expectTypeOf(people.objectsAt([1, 2, 3])).toEqualTypeOf<EmberArray<Person | undefined>>();
 
-const persons1: Person[] = people.filterBy('isHappy');
-const persons2: MutableArray<Person> = people.filterBy('isHappy');
-const persons3: Person[] = people.rejectBy('isHappy');
-const persons4: MutableArray<Person> = people.rejectBy('isHappy');
-const persons5: Person[] = people.filter(person => person.get('name') === 'Yehuda');
-const persons6: MutableArray<Person> = people.filter(person => person.get('name') === 'Yehuda');
+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>
+>();
 
-assertType<typeof people>(people.get('[]'));
-assertType<Person>(people.get('[]').get('firstObject'));
+expectTypeOf(people.get('[]')).toEqualTypeOf<typeof people>();
+expectTypeOf(people.get('[]').get('firstObject')).toEqualTypeOf<Person | undefined>();
 
-assertType<boolean[]>(people.mapBy('isHappy'));
-assertType<unknown[]>(people.mapBy('name.length'));
+expectTypeOf(people.mapBy('isHappy')).toEqualTypeOf<boolean[]>();
+expectTypeOf(people.mapBy('name.length')).toEqualTypeOf<unknown[]>();
 
-const last = people.get('lastObject'); // $ExpectType ({ name: string; isHappy: boolean; } & EmberObject & { name: string; isHappy: boolean; }) | undefined
+const last = people.get('lastObject');
+expectTypeOf(last).toEqualTypeOf<Person | undefined>();
 if (last) {
-    assertType<string>(last.get('name'));
+  expectTypeOf(last.get('name')).toBeString();
 }
 
 const first = people.get('lastObject');
 if (first) {
-    assertType<boolean>(first.get('isHappy'));
+  expectTypeOf(first.get('isHappy')).toBeBoolean();
 }
 
 const letters: EmberArray<string> = A(['a', 'b', 'c']);
-const codes: number[] = letters.map((item, index, enumerable) => {
-    assertType<string>(item);
-    assertType<number>(index);
-    return item.charCodeAt(0);
+const codes = letters.map((item, index, enumerable) => {
+  expectTypeOf(item).toBeString();
+  expectTypeOf(index).toBeNumber();
+  return item.charCodeAt(0);
 });
+expectTypeOf(codes).toEqualTypeOf<number[]>();
 
 const value = '1,2,3';
 const filters = A(value.split(','));
@@ -58,8 +64,8 @@ filters.push('4');
 filters.sort();
 
 const multiSortArr = A([
-    { k: 'a', v: 'z' },
-    { k: 'a', v: 'y' },
-    { k: 'b', v: 'c' },
+  { k: 'a', v: 'z' },
+  { k: 'a', v: 'y' },
+  { k: 'b', v: 'c' },
 ]);
 multiSortArr.sortBy('k', 'v');
diff --git a/types/preview/ember/test/array.ts b/types/preview/ember/test/array.ts
index f4cbaae2d83..5c1588211e2 100755
--- a/types/preview/ember/test/array.ts
+++ b/types/preview/ember/test/array.ts
@@ -1,50 +1,69 @@
 import Ember from 'ember';
-import { assertType } from './lib/assert';
+import { expectTypeOf } from 'expect-type';
 
-type Person = typeof Person.prototype;
-const Person = Ember.Object.extend({
-    name: '',
-    isHappy: false,
-});
+class Person extends Ember.Object {
+  name = '';
+  isHappy = false;
+}
 
 const people = Ember.A([
-    Person.create({ name: 'Yehuda', isHappy: true }),
-    Person.create({ name: 'Majd', isHappy: false }),
+  Person.create({ name: 'Yehuda', isHappy: true }),
+  Person.create({ name: 'Majd', isHappy: false }),
 ]);
 
-assertType<number>(people.get('length'));
-assertType<Person>(people.get('lastObject'));
-assertType<boolean>(people.isAny('isHappy'));
+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
-assertType<boolean>(people.isAny('isHappy', 'false'));
-assertType<boolean>(people.isAny('isHappy', false));
-assertType<Ember.Enumerable<Person>>(people.filterBy('isHappy'));
-assertType<Ember.Enumerable<Person>>(people.rejectBy('isHappy'));
-assertType<Ember.Enumerable<Person>>(people.filter(person => person.get('name') === 'Yehuda'));
-assertType<typeof people>(people.get('[]'));
-assertType<Person>(people.get('[]').get('firstObject'));
+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>
+>();
 
-assertType<Ember.Array<boolean>>(people.mapBy('isHappy'));
-assertType<unknown[]>(people.mapBy('name.length'));
+expectTypeOf(people.get('[]')).toEqualTypeOf<typeof people>();
+expectTypeOf(people.get('[]').get('firstObject')).toEqualTypeOf<Person | undefined>();
+
+expectTypeOf(people.mapBy('isHappy')).toEqualTypeOf<boolean[]>();
+expectTypeOf(people.mapBy('name.length')).toEqualTypeOf<unknown[]>();
 
 const last = people.get('lastObject');
+expectTypeOf(last).toEqualTypeOf<Person | undefined>();
 if (last) {
-    assertType<string>(last.get('name'));
+  expectTypeOf(last.get('name')).toBeString();
 }
 
 const first = people.get('lastObject');
 if (first) {
-    assertType<boolean>(first.get('isHappy'));
+  expectTypeOf(first.get('isHappy')).toBeBoolean();
 }
 
-const letters: Ember.Enumerable<string> = Ember.A(['a', 'b', 'c']);
-const codes: number[] = letters.map((item, index, enumerable) => {
-    assertType<string>(item);
-    assertType<number>(index);
-    return item.charCodeAt(0);
+const letters: Ember.Array<string> = Ember.A(['a', 'b', 'c']);
+const codes = letters.map((item, index, enumerable) => {
+  expectTypeOf(item).toBeString();
+  expectTypeOf(index).toBeNumber();
+  return item.charCodeAt(0);
 });
+expectTypeOf(codes).toEqualTypeOf<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');

From 4730ecd8b7a8e6b7b3f560fb7dabd3de605c3753 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 10:58:59 -0600
Subject: [PATCH 17/39] Fix preview types and tests for `Evented`

---
 types/preview/@ember/object/test/event.ts | 160 +++++++++++-----------
 types/preview/ember/index.d.ts            |   1 +
 types/preview/ember/test/event.ts         |  91 ++++++------
 3 files changed, 129 insertions(+), 123 deletions(-)

diff --git a/types/preview/@ember/object/test/event.ts b/types/preview/@ember/object/test/event.ts
index 386735b5098..dc80b26f1ec 100644
--- a/types/preview/@ember/object/test/event.ts
+++ b/types/preview/@ember/object/test/event.ts
@@ -1,92 +1,96 @@
-import EmberObject, { observer } from '@ember/object';
+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!'
+  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() {
-    const Person = EmberObject.extend(Evented, {
-        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();
+  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
-        // })
-    });
+  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() {}
-
-    EmberObject.extend({
-        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();
-        },
-    });
+  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/types/preview/ember/index.d.ts b/types/preview/ember/index.d.ts
index f6172c80012..ff367607257 100755
--- a/types/preview/ember/index.d.ts
+++ b/types/preview/ember/index.d.ts
@@ -138,6 +138,7 @@ export namespace Ember {
   const Error: typeof EmberError;
 
   const Evented: typeof EmberObjectEventedNs.default;
+  interface Evented extends EmberObjectEventedNs.default {}
 
   class Mixin extends EmberMixin {}
 
diff --git a/types/preview/ember/test/event.ts b/types/preview/ember/test/event.ts
index ab53935c8f5..90580d8ba9a 100755
--- a/types/preview/ember/test/event.ts
+++ b/types/preview/ember/test/event.ts
@@ -1,60 +1,61 @@
 import Ember from 'ember';
 
 function testOn() {
-    const Job = Ember.Object.extend({
-        logCompleted: Ember.on('completed', () => {
-            console.log('Job completed!');
-        }),
-    });
+  const Job = Ember.Object.extend({
+    logCompleted: Ember.on('completed', () => {
+      console.log('Job completed!');
+    }),
+  });
 
-    const job = Job.create();
+  const job = Job.create();
 
-    Ember.sendEvent(job, 'completed'); // Logs 'Job completed!'
+  Ember.sendEvent(job, 'completed'); // Logs 'Job completed!'
 }
 
 function testEvented() {
-    const Person = Ember.Object.extend(Ember.Evented, {
-        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();
+  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
-        }),
-    });
+  Ember.Object.extend({
+    valueObserver: Ember.observer('value', () => {
+      // Executes whenever the "value" property changes
+    }),
+  });
 }
 
 function testListener() {
-    Ember.Component.extend({
-        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() {},
-    });
+  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() {}
+  }
 }

From b450bc81479a0225771eefe7aa4a30c47c24bc2d Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 11:05:36 -0600
Subject: [PATCH 18/39] Fix preview types and tests for `.create()` and
 `.extend()`

---
 types/preview/@ember/object/test/extend.ts | 76 ++++++++--------------
 types/preview/ember/test/extend.ts         | 76 ++++++++--------------
 2 files changed, 54 insertions(+), 98 deletions(-)

diff --git a/types/preview/@ember/object/test/extend.ts b/types/preview/@ember/object/test/extend.ts
index c70d2e24b18..235271801e9 100644
--- a/types/preview/@ember/object/test/extend.ts
+++ b/types/preview/@ember/object/test/extend.ts
@@ -1,61 +1,39 @@
 import EmberObject from '@ember/object';
-import { assertType } from './lib/assert';
-
-const Person = EmberObject.extend({
-    firstName: '',
-    lastName: '',
-
-    getFullName() {
-        return `${this.firstName} ${this.lastName}`;
-    },
-    getFullName2(): string {
-        return `${this.get('firstName')} ${this.get('lastName')}`;
-    },
-});
-
-assertType<string>(Person.prototype.firstName);
-assertType<() => string>(Person.prototype.getFullName);
-
-const person = Person.create({
-    firstName: 'Joe',
-    lastName: 'Blow',
-    extra: 42,
-});
-
-assertType<string>(person.getFullName());
-assertType<number>(person.extra);
-
-class ES6Person 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')}`;
-    }
+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')}`;
+  }
 }
 
-assertType<string>(ES6Person.prototype.firstName);
-assertType<string>(ES6Person.prototype.fullName);
+expectTypeOf(Person.prototype.firstName).toBeString();
+expectTypeOf(Person.prototype.fullName).toBeString();
 
-const es6Person = ES6Person.create({
-    firstName: 'Joe',
-    lastName: 'Blow',
-    extra: 42,
+const person = Person.create({
+  firstName: 'Joe',
+  lastName: 'Blow',
+  // @ts-expect-error
+  extra: 42,
 });
 
-assertType<string>(es6Person.fullName);
-assertType<number>(es6Person.extra);
+expectTypeOf(person.fullName).toBeString();
+// @ts-expect-error
+person.extra;
 
 class PersonWithStatics extends EmberObject {
-    static isPerson = true;
+  static isPerson = true;
 }
 const PersonWithStatics2 = PersonWithStatics.extend({});
 class PersonWithStatics3 extends PersonWithStatics {}
 class PersonWithStatics4 extends PersonWithStatics2 {}
-assertType<boolean>(PersonWithStatics.isPerson);
-assertType<boolean>(PersonWithStatics2.isPerson);
-assertType<boolean>(PersonWithStatics3.isPerson);
-assertType<boolean>(PersonWithStatics4.isPerson);
+expectTypeOf(PersonWithStatics.isPerson).toBeBoolean();
+expectTypeOf(PersonWithStatics2.isPerson).toBeBoolean();
+expectTypeOf(PersonWithStatics3.isPerson).toBeBoolean();
+expectTypeOf(PersonWithStatics4.isPerson).toBeBoolean();
diff --git a/types/preview/ember/test/extend.ts b/types/preview/ember/test/extend.ts
index 61dd852accb..a8a50e1b0de 100755
--- a/types/preview/ember/test/extend.ts
+++ b/types/preview/ember/test/extend.ts
@@ -1,61 +1,39 @@
 import Ember from 'ember';
-import { assertType } from './lib/assert';
-
-const Person = Ember.Object.extend({
-    firstName: '',
-    lastName: '',
-
-    getFullName() {
-        return `${this.firstName} ${this.lastName}`;
-    },
-    getFullName2(): string {
-        return `${this.get('firstName')} ${this.get('lastName')}`;
-    },
-});
-
-assertType<string>(Person.prototype.firstName);
-assertType<() => string>(Person.prototype.getFullName);
-
-const person = Person.create({
-    firstName: 'Joe',
-    lastName: 'Blow',
-    extra: 42,
-});
-
-assertType<string>(person.getFullName());
-assertType<number>(person.extra);
-
-class ES6Person 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')}`;
-    }
+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')}`;
+  }
 }
 
-assertType<string>(ES6Person.prototype.firstName);
-assertType<string>(ES6Person.prototype.fullName);
+expectTypeOf(Person.prototype.firstName).toBeString();
+expectTypeOf(Person.prototype.fullName).toBeString();
 
-const es6Person = ES6Person.create({
-    firstName: 'Joe',
-    lastName: 'Blow',
-    extra: 42,
+const person = Person.create({
+  firstName: 'Joe',
+  lastName: 'Blow',
+  // @ts-expect-error
+  extra: 42,
 });
 
-assertType<string>(es6Person.fullName);
-assertType<number>(es6Person.extra);
+expectTypeOf(person.fullName).toBeString();
+// @ts-expect-error
+person.extra;
 
 class PersonWithStatics extends Ember.Object {
-    static isPerson = true;
+  static isPerson = true;
 }
 const PersonWithStatics2 = PersonWithStatics.extend({});
 class PersonWithStatics3 extends PersonWithStatics {}
 class PersonWithStatics4 extends PersonWithStatics2 {}
-assertType<boolean>(PersonWithStatics.isPerson);
-assertType<boolean>(PersonWithStatics2.isPerson);
-assertType<boolean>(PersonWithStatics3.isPerson);
-assertType<boolean>(PersonWithStatics4.isPerson);
+expectTypeOf(PersonWithStatics.isPerson).toBeBoolean();
+expectTypeOf(PersonWithStatics2.isPerson).toBeBoolean();
+expectTypeOf(PersonWithStatics3.isPerson).toBeBoolean();
+expectTypeOf(PersonWithStatics4.isPerson).toBeBoolean();

From cb5fb2b1f13558a05e11c358072691ecc2bc4fc0 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 11:07:03 -0600
Subject: [PATCH 19/39] Fix preview type tests for `@ember/object/observable`

---
 .../ember/test/private/observable-tests.ts     | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/types/preview/ember/test/private/observable-tests.ts b/types/preview/ember/test/private/observable-tests.ts
index ed4a2371a9a..7e48fd3f785 100644
--- a/types/preview/ember/test/private/observable-tests.ts
+++ b/types/preview/ember/test/private/observable-tests.ts
@@ -52,6 +52,24 @@ class DemoObservable implements Observable {
     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) {}

From fe030dc5df8d2dee15f1a9ad68df4d77deccf516 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 11:17:56 -0600
Subject: [PATCH 20/39] Fix a few more preview type test issues around
 observable

---
 .../preview/@ember/object/test/observable.ts  | 24 +++++++++----------
 types/preview/ember/test/observable.ts        | 12 ++++++----
 2 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/types/preview/@ember/object/test/observable.ts b/types/preview/@ember/object/test/observable.ts
index f28fe064ed7..fc9ccdcc146 100644
--- a/types/preview/@ember/object/test/observable.ts
+++ b/types/preview/@ember/object/test/observable.ts
@@ -110,19 +110,19 @@ function testSetProperties() {
 }
 
 function testDynamic() {
-  const obj: any = {};
-  const dynamicKey: string = 'dummy'; // eslint-disable-line @typescript-eslint/no-inferrable-types
+  const obj: Record<string, string> = {};
+  const dynamicKey = 'dummy' as string;
 
-  expectTypeOf(get(obj, 'dummy')).toBeAny();
-  expectTypeOf(get(obj, dynamicKey)).toBeAny();
-  expectTypeOf(getProperties(obj, 'dummy')).toEqualTypeOf<{ dummy: any }>();
-  expectTypeOf(getProperties(obj, ['dummy'])).toEqualTypeOf<{ dummy: any }>();
-  expectTypeOf(getProperties(obj, dynamicKey)).toEqualTypeOf<Record<string, any>>();
-  expectTypeOf(getProperties(obj, [dynamicKey])).toEqualTypeOf<Record<string, any>>();
-  expectTypeOf(set(obj, 'dummy', 'value')).toBeAny();
-  expectTypeOf(set(obj, dynamicKey, 'value')).toBeAny();
-  expectTypeOf(setProperties(obj, { dummy: 'value ' })).toEqualTypeOf<Record<'dummy', any>>();
+  expectTypeOf(get(obj, 'dummy')).toEqualTypeOf<string | undefined>();
+  expectTypeOf(get(obj, dynamicKey)).toEqualTypeOf<string | undefined>();
+  expectTypeOf(getProperties(obj, 'dummy')).toEqualTypeOf<{ dummy: string | undefined }>();
+  expectTypeOf(getProperties(obj, ['dummy'])).toEqualTypeOf<{ dummy: string | undefined }>();
+  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 | number, any>
+    Record<string, string>
   >();
 }
diff --git a/types/preview/ember/test/observable.ts b/types/preview/ember/test/observable.ts
index afb5aadf508..c4ccd9c4469 100755
--- a/types/preview/ember/test/observable.ts
+++ b/types/preview/ember/test/observable.ts
@@ -115,8 +115,12 @@ function testDynamic() {
   expectTypeOf(Ember.getProperties(obj, ['dummy'])).toEqualTypeOf<{ dummy: string | undefined }>();
   expectTypeOf(Ember.getProperties(obj, dynamicKey)).toEqualTypeOf<Record<string, string>>();
   expectTypeOf(Ember.getProperties(obj, [dynamicKey])).toEqualTypeOf<Record<string, string>>();
-  assertType<string | undefined>(Ember.set(obj, 'dummy', 'value'));
-  assertType<string | undefined>(Ember.set(obj, dynamicKey, 'value'));
-  assertType<{ dummy: string | undefined }>(Ember.setProperties(obj, { dummy: 'value ' }));
-  assertType<Record<string, string>>(Ember.setProperties(obj, { [dynamicKey]: 'value' }));
+  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>
+  >();
 }

From d95a927fdcd851bbada245190f94d024734d6d30 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 11:33:20 -0600
Subject: [PATCH 21/39] Fix preview type tests for Ember Component

---
 .../@ember/component/test/component.ts        | 167 +++++++++--------
 types/preview/ember/test/component.ts         | 173 +++++++++---------
 2 files changed, 166 insertions(+), 174 deletions(-)

diff --git a/types/preview/@ember/component/test/component.ts b/types/preview/@ember/component/test/component.ts
index 64596a83fa6..adb2a269a90 100644
--- a/types/preview/@ember/component/test/component.ts
+++ b/types/preview/@ember/component/test/component.ts
@@ -1,141 +1,138 @@
 import Component from '@ember/component';
 import Object, { computed, get } from '@ember/object';
-import hbs from 'htmlbars-inline-precompile';
 import { assertType } from './lib/assert';
 
 Component.extend({
-    layout: hbs`
-        <div>
-          {{yield}}
-        </div>
-    `,
-});
-
-Component.extend({
-    layout: 'my-layout',
+  layout: 'my-layout',
 });
 
 const MyComponent = Component.extend();
 assertType<string | string[]>(get(MyComponent, 'positionalParams'));
 
 const component1 = Component.extend({
-    actions: {
-        hello(name: string) {
-            console.log('Hello', name);
-        },
-    },
-});
-
-Component.extend({
-    name: '',
+  actions: {
     hello(name: string) {
-        this.set('name', name);
+      console.log('Hello', name);
     },
+  },
 });
 
-Component.extend({
-    tagName: 'em',
-});
+class AnotherComponent extends Component {
+  name = '';
+
+  hello(name: string) {
+    this.set('name', name);
+    this.name = name;
+  }
+}
 
 Component.extend({
-    classNames: ['my-class', 'my-other-class'],
+  tagName: 'em',
 });
 
 Component.extend({
-    classNameBindings: ['propertyA', 'propertyB'],
-    propertyA: 'from-a',
-    propertyB: computed(function () {
-        if (!this.get('propertyA')) {
-            return 'from-b';
-        }
-    }),
+  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,
+  classNameBindings: ['hovered'],
+  hovered: true,
 });
 
+class Message extends Object {
+  empty = false;
+}
+
 Component.extend({
-    classNameBindings: ['messages.empty'],
-    messages: Object.create({
-        empty: true,
-    }),
+  classNameBindings: ['messages.empty'],
+  messages: Message.create({
+    empty: true,
+  }),
 });
 
 Component.extend({
-    classNameBindings: ['isEnabled:enabled:disabled'],
-    isEnabled: true,
+  classNameBindings: ['isEnabled:enabled:disabled'],
+  isEnabled: true,
 });
 
 Component.extend({
-    classNameBindings: ['isEnabled::disabled'],
-    isEnabled: true,
+  classNameBindings: ['isEnabled::disabled'],
+  isEnabled: true,
 });
 
 Component.extend({
-    tagName: 'a',
-    attributeBindings: ['href'],
-    href: 'http://google.com',
+  tagName: 'a',
+  attributeBindings: ['href'],
+  href: 'http://google.com',
 });
 
 Component.extend({
-    tagName: 'a',
-    attributeBindings: ['url:href'],
-    url: 'http://google.com',
+  tagName: 'a',
+  attributeBindings: ['url:href'],
+  url: 'http://google.com',
 });
 
 Component.extend({
-    tagName: 'use',
-    attributeBindings: ['xlinkHref:xlink:href'],
-    xlinkHref: '#triangle',
+  tagName: 'use',
+  attributeBindings: ['xlinkHref:xlink:href'],
+  xlinkHref: '#triangle',
 });
 
 Component.extend({
-    tagName: 'input',
-    attributeBindings: ['disabled'],
-    disabled: false,
+  tagName: 'input',
+  attributeBindings: ['disabled'],
+  disabled: false,
 });
 
 Component.extend({
-    tagName: 'input',
-    attributeBindings: ['disabled'],
-    disabled: computed(() => {
-        if ('someLogic') {
-            return true;
-        } else {
-            return false;
-        }
-    }),
+  tagName: 'input',
+  attributeBindings: ['disabled'],
+  disabled: computed(() => {
+    return someLogic();
+  }),
 });
 
+declare function someLogic(): boolean;
+
 Component.extend({
-    tagName: 'form',
-    attributeBindings: ['novalidate'],
-    novalidate: null,
+  tagName: 'form',
+  attributeBindings: ['novalidate'],
+  novalidate: null,
 });
 
 Component.extend({
-    click(event: object) {
-        // will be called when an instance's
-        // rendered element is clicked
-    },
+  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: '',
+  attributeBindings: ['metadata:data-my-metadata'],
+  metadata: '',
 });
 
 interface MySig {
-    Args: {
-        Named: {
-            name: string;
-            age: number;
-        };
-        Positional: [action: () => void];
+  Args: {
+    Named: {
+      name: string;
+      age: number;
     };
+    Positional: [action: () => void];
+  };
 }
 
 // These type helpers are stolen (and tweaked) from Glimmer and Glint internals
@@ -146,12 +143,12 @@ type NamedArgsFor<T> = GetWithFallback<GetWithFallback<T, 'Args', {}>, 'Named',
 
 interface SigExample extends NamedArgsFor<MySig> {}
 class SigExample extends Component<MySig> {
-    get accessArgs() {
-        const {
-            name, // $ExpectType string
-            age, // $ExpectType number
-        } = this;
-
-        return `${name} is ${age} years old`;
-    }
+  get accessArgs() {
+    const {
+      name, // $ExpectType string
+      age, // $ExpectType number
+    } = this;
+
+    return `${name} is ${age} years old`;
+  }
 }
diff --git a/types/preview/ember/test/component.ts b/types/preview/ember/test/component.ts
index 925a2e7b451..493645d31e2 100755
--- a/types/preview/ember/test/component.ts
+++ b/types/preview/ember/test/component.ts
@@ -1,124 +1,119 @@
 import Ember from 'ember';
-import Component from '@ember/component';
-import Object, { computed } from '@ember/object';
-import hbs from 'htmlbars-inline-precompile';
-import { assertType } from './lib/assert';
-
-Component.extend({
-    layout: hbs`
-        <div>
-          {{yield}}
-        </div>
-    `,
-});
+import { expectTypeOf } from 'expect-type';
 
-Component.extend({
-    layout: 'my-layout',
+Ember.Component.extend({
+  layout: 'my-layout',
 });
 
-const MyComponent = Component.extend();
-assertType<string | string[]>(Ember.get(MyComponent, 'positionalParams'));
-
-const component1 = Component.extend({
-    actions: {
-        hello(name: string) {
-            console.log('Hello', name);
-        },
-    },
-});
+const MyComponent = Ember.Component.extend();
+expectTypeOf(Ember.get(MyComponent, 'positionalParams')).toEqualTypeOf<string | string[]>();
 
-Component.extend({
-    name: '',
+const component1 = Ember.Component.extend({
+  actions: {
     hello(name: string) {
-        this.set('name', name);
+      console.log('Hello', name);
     },
+  },
 });
 
-Component.extend({
-    tagName: 'em',
-});
+class AnotherComponent extends Ember.Component {
+  name = '';
+
+  hello(name: string) {
+    this.set('name', name);
+    this.name = name;
+  }
+}
 
-Component.extend({
-    classNames: ['my-class', 'my-other-class'],
+Ember.Component.extend({
+  tagName: 'em',
 });
 
-Component.extend({
-    classNameBindings: ['propertyA', 'propertyB'],
-    propertyA: 'from-a',
-    propertyB: computed(function () {
-        if (!this.get('propertyA')) {
-            return 'from-b';
-        }
-    }),
+Ember.Component.extend({
+  classNames: ['my-class', 'my-other-class'],
 });
 
-Component.extend({
-    classNameBindings: ['hovered'],
-    hovered: true,
+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,
 });
 
-Component.extend({
-    classNameBindings: ['messages.empty'],
-    messages: Object.create({
-        empty: true,
-    }),
+class Message extends Ember.Object {
+  empty = false;
+}
+
+Ember.Component.extend({
+  classNameBindings: ['messages.empty'],
+  messages: Message.create({
+    empty: true,
+  }),
 });
 
-Component.extend({
-    classNameBindings: ['isEnabled:enabled:disabled'],
-    isEnabled: true,
+Ember.Component.extend({
+  classNameBindings: ['isEnabled:enabled:disabled'],
+  isEnabled: true,
 });
 
-Component.extend({
-    classNameBindings: ['isEnabled::disabled'],
-    isEnabled: true,
+Ember.Component.extend({
+  classNameBindings: ['isEnabled::disabled'],
+  isEnabled: true,
 });
 
-Component.extend({
-    tagName: 'a',
-    attributeBindings: ['href'],
-    href: 'http://google.com',
+Ember.Component.extend({
+  tagName: 'a',
+  attributeBindings: ['href'],
+  href: 'http://google.com',
 });
 
-Component.extend({
-    tagName: 'a',
-    attributeBindings: ['url:href'],
-    url: 'http://google.com',
+Ember.Component.extend({
+  tagName: 'a',
+  attributeBindings: ['url:href'],
+  url: 'http://google.com',
 });
 
-Component.extend({
-    tagName: 'use',
-    attributeBindings: ['xlinkHref:xlink:href'],
-    xlinkHref: '#triangle',
+Ember.Component.extend({
+  tagName: 'use',
+  attributeBindings: ['xlinkHref:xlink:href'],
+  xlinkHref: '#triangle',
 });
 
-Component.extend({
-    tagName: 'input',
-    attributeBindings: ['disabled'],
-    disabled: false,
+Ember.Component.extend({
+  tagName: 'input',
+  attributeBindings: ['disabled'],
+  disabled: false,
 });
 
-Component.extend({
-    tagName: 'input',
-    attributeBindings: ['disabled'],
-    disabled: computed(() => {
-        if ('someLogic') {
-            return true;
-        } else {
-            return false;
-        }
-    }),
+Ember.Component.extend({
+  tagName: 'input',
+  attributeBindings: ['disabled'],
+  disabled: Ember.computed(() => {
+    return someLogic();
+  }),
 });
 
-Component.extend({
-    tagName: 'form',
-    attributeBindings: ['novalidate'],
-    novalidate: null,
+declare function someLogic(): boolean;
+
+Ember.Component.extend({
+  tagName: 'form',
+  attributeBindings: ['novalidate'],
+  novalidate: null,
 });
 
-Component.extend({
-    click(event: object) {
-        // will be called when an instance's
-        // rendered element is clicked
-    },
+Ember.Component.extend({
+  click(event: object) {
+    // will be called when an instance's
+    // rendered element is clicked
+  },
 });

From 69eda9f3e0271cd2bd5d309a3f8ed22b175e34ef Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 11:43:00 -0600
Subject: [PATCH 22/39] Improve preview types and tests for helper

---
 types/preview/@ember/component/helper.d.ts    | 104 ++++++------
 types/preview/@ember/component/test/helper.ts | 160 ++++++++++--------
 2 files changed, 144 insertions(+), 120 deletions(-)

diff --git a/types/preview/@ember/component/helper.d.ts b/types/preview/@ember/component/helper.d.ts
index 28a8cf37ec8..1e41c007ce0 100644
--- a/types/preview/@ember/component/helper.d.ts
+++ b/types/preview/@ember/component/helper.d.ts
@@ -21,7 +21,7 @@ declare const Empty: unique symbol;
  *   themselves, so ***DO NOT RELY ON IT***.
  */
 export interface EmptyObject {
-    [Empty]?: true;
+  [Empty]?: true;
 }
 
 type DefaultPositional = unknown[];
@@ -33,24 +33,24 @@ type DefaultNamed = EmptyObject;
  *   "normal" signature shape: `Args: { Named: { ... }, Positional: [...] }`.
  */
 export interface HelperSignature {
-    NamedArgs?: DefaultNamed;
-    PositionalArgs?: DefaultPositional;
-    Return?: unknown;
+  NamedArgs?: DefaultNamed;
+  PositionalArgs?: DefaultPositional;
+  Return?: unknown;
 }
 
 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: [] };
+  ? {
+      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>;
+  Named: GetOrElse<T, 'NamedArgs', DefaultNamed>;
+  Positional: GetOrElse<T, 'PositionalArgs', DefaultPositional>;
 }
 
 // This type allows us to present a slightly-less-obtuse error message
@@ -58,12 +58,12 @@ interface LegacyArgsFor<T> {
 // one declared from within a tool like Glint.
 declare const BadType: unique symbol;
 interface BadType<Message> {
-    [BadType]: Message;
+  [BadType]: Message;
 }
 
 interface MissingSignatureArgs {
-    Named: BadType<'This helper is missing a signature'>;
-    Positional: unknown[];
+  Named: BadType<'This helper is missing a signature'>;
+  Positional: unknown[];
 }
 
 /**
@@ -84,19 +84,21 @@ interface MissingSignatureArgs {
 // all `ExpandSignature` types fully general to work with *any* invokable. But
 // "future" here probably means Ember v5. :sobbing:
 export interface ExpandSignature<T> {
-    Args: unknown extends T // Is this the default (i.e. unspecified) signature?
-        ? MissingSignatureArgs // Then return our special "missing signature" type
-        : keyof T extends 'Args' | 'Return' // Is this a `Signature`?
-        ? ArgsFor<T> // Then use `Signature` args
-        : LegacyArgsFor<T>; // Otherwise fall back to classic `Args`.
-    Return: 'Return' extends keyof T ? T['Return'] : unknown;
+  Args: unknown extends T // Is this the default (i.e. unspecified) signature?
+    ? MissingSignatureArgs // Then return our special "missing signature" type
+    : keyof T extends 'Args' | 'Return' // Is this a `Signature`?
+    ? ArgsFor<T> // Then use `Signature` args
+    : LegacyArgsFor<T>; // Otherwise fall back to classic `Args`.
+  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`.
-type NamedArgs<S> = unknown extends S ? Record<string, unknown> : ExpandSignature<S>['Args']['Named'];
+type NamedArgs<S> = unknown extends S
+  ? Record<string, unknown>
+  : ExpandSignature<S>['Args']['Named'];
 type PositionalArgs<S> = unknown extends S ? unknown[] : ExpandSignature<S>['Args']['Positional'];
 
 type Return<S> = GetOrElse<S, 'Return', unknown>;
@@ -106,23 +108,23 @@ type Return<S> = GetOrElse<S, 'Return', unknown>;
  * 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;
+  /**
+   * 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
@@ -140,7 +142,7 @@ export default interface Helper<S> extends Opaque<S> {}
 // 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;
+  protected abstract __concrete__: never;
 }
 
 /**
@@ -172,13 +174,13 @@ export type FunctionBasedHelper<S> = abstract new () => FunctionBasedHelperInsta
 // 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,
+  helperFn: (positional: P, named: N) => R
 ): FunctionBasedHelper<{
-    Args: {
-        Positional: P;
-        Named: N;
-    };
-    Return: R;
+  Args: {
+    Positional: P;
+    Named: N;
+  };
+  Return: R;
 }>;
 
 // This overload allows users to provide a `Signature` type explicitly at the
@@ -186,13 +188,13 @@ export function helper<P extends DefaultPositional, N = EmptyObject, R = unknown
 // 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>,
+  helperFn: (positional: PositionalArgs<S>, named: NamedArgs<S>) => Return<S>
 ): FunctionBasedHelper<{
-    Args: {
-        Positional: PositionalArgs<S>;
-        Named: NamedArgs<S>;
-    };
-    Return: Return<S>;
+  Args: {
+    Positional: PositionalArgs<S>;
+    Named: NamedArgs<S>;
+  };
+  Return: Return<S>;
 }>;
 
 export {};
diff --git a/types/preview/@ember/component/test/helper.ts b/types/preview/@ember/component/test/helper.ts
index 301a167ffb2..2371fd666da 100644
--- a/types/preview/@ember/component/test/helper.ts
+++ b/types/preview/@ember/component/test/helper.ts
@@ -1,120 +1,142 @@
 import Helper, { ExpandSignature, helper } from '@ember/component/helper';
 
 class DeprecatedSignatureForm extends Helper<{
-    PositionalArgs: [offset: Date];
-    Return: Date;
+  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() {
-        clearInterval(this.timer);
+  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];
+  Args: {
+    Named: {
+      name: string;
+      age: number;
     };
-    Return: string;
+    Positional: [i18nizer: (s: string) => string];
+  };
+  Return: string;
 }
 
 function testMissingSignature({ Args, Return }: ExpandSignature<unknown>) {
-    // $ExpectType BadType<"This helper is missing a signature">
-    Args.Named;
+  // $ExpectType BadType<"This helper is missing a signature">
+  Args.Named;
 
-    // $ExpectType unknown[]
-    Args.Positional;
+  // $ExpectType unknown[]
+  Args.Positional;
 
-    // $ExpectType unknown
-    Return;
+  // $ExpectType unknown
+  Return;
 }
 
 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`);
-    }
+  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`);
-    }
+  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`);
-    }
+  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`);
-    }
+  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`));
-    }
+  compute(
+    [i18nizer]: [i18nizer: (s: string) => string],
+    { name, age }: { name: string; age: number }
+  ): string {
+    // @ts-expect-error
+    return Boolean(i18nizer(`${name} is ${age} years old`));
+  }
 }
 
 // $ExpectType FunctionBasedHelper<{ Args: { Positional: [number, number]; Named: EmptyObject; }; Return: number; }>
 const inferenceOnPositional = helper(function add([a, b]: [number, number]) {
-    return a + b;
+  return a + b;
 });
 
-const coolHelper = helper(([], named) => {
-    // $ExpectType EmptyObject
-    named;
+const coolHelper = helper((_, named) => {
+  // $ExpectType EmptyObject
+  named;
 });
 
 // $ExpectType FunctionBasedHelper<{ Args: { Positional: DefaultPositional; Named: { cool: boolean; }; }; Return: 123 | "neat"; }>
-const typeInferenceOnNamed = helper(([], { cool }: { cool: boolean }) => {
-    // $ExpectType boolean
-    cool;
+const typeInferenceOnNamed = helper((_, { cool }: { cool: boolean }) => {
+  // $ExpectType boolean
+  cool;
 
-    return cool ? 123 : 'neat';
+  return cool ? 123 : 'neat';
 });
 
 // $ExpectType FunctionBasedHelper<{ Args: { Positional: [string]; Named: { delim?: string; }; }; Return: string; }>
-const dasherizeHelper = helper(function dasherize([str]: [string], { delim = '-' }: { delim?: string }) {
-    return str.split(/[\s\n\_\.]+/g).join(delim);
+const dasherizeHelper = helper(function dasherize(
+  [str]: [string],
+  { delim = '-' }: { delim?: string }
+) {
+  return str.split(/[\s\n_.]+/g).join(delim);
 });
 
-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`));
+const signatureForm = helper<DemoSig>(([i18nizer], { 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 badPosArgsSig = helper<DemoSig>(([i18nizer, extra], { name, age }) =>
+  i18nizer(`${name} is ${age} years old`)
+);
 
 // @ts-expect-error
-const badReturnSig = helper<DemoSig>(([i18nizer], { name, age }) => Boolean(i18nizer(`${name} is ${age} years old`)));
+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}`);
 

From d32122b36f28c0781ba3da5d84a4689d975c1b7a Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 11:43:15 -0600
Subject: [PATCH 23/39] Improve preview types and tests for controllers

---
 types/preview/@ember/controller/index.d.ts    |  3 +-
 types/preview/@ember/controller/test/main.ts  | 20 ++++----
 .../preview/@ember/controller/test/octane.ts  | 48 +++++++++----------
 3 files changed, 36 insertions(+), 35 deletions(-)

diff --git a/types/preview/@ember/controller/index.d.ts b/types/preview/@ember/controller/index.d.ts
index 1be720b28f6..44d6c65edef 100644
--- a/types/preview/@ember/controller/index.d.ts
+++ b/types/preview/@ember/controller/index.d.ts
@@ -1,6 +1,7 @@
 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';
@@ -37,7 +38,7 @@ 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];
+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
diff --git a/types/preview/@ember/controller/test/main.ts b/types/preview/@ember/controller/test/main.ts
index e34d763e167..4fc8c2f0347 100644
--- a/types/preview/@ember/controller/test/main.ts
+++ b/types/preview/@ember/controller/test/main.ts
@@ -1,14 +1,14 @@
 import Controller, { inject } from '@ember/controller';
 
-Controller.extend({
-    queryParams: ['category'],
-    category: null,
-    isExpanded: false,
+class MyController extends Controller {
+  queryParams = ['category'];
+  category = null;
+  isExpanded = false;
 
-    first: inject(),
-    second: inject('second'),
+  @inject declare first: Controller;
+  @inject('second') declare second: Controller;
 
-    toggleBody() {
-        this.toggleProperty('isExpanded');
-    },
-});
+  toggleBody() {
+    this.toggleProperty('isExpanded');
+  }
+}
diff --git a/types/preview/@ember/controller/test/octane.ts b/types/preview/@ember/controller/test/octane.ts
index 1ce829a275b..9d22f33f37b 100644
--- a/types/preview/@ember/controller/test/octane.ts
+++ b/types/preview/@ember/controller/test/octane.ts
@@ -1,36 +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>;
+  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',
-        },
-    ];
+  queryParams = [
+    'category',
+    {
+      searchTerm: {
+        as: 'search',
+      },
+      subCategory: 'sub-category',
+    },
+  ];
 
-    first() {
-        return '';
-    }
+  first() {
+    return '';
+  }
 }
 const SecondController = Controller.extend({
-    foo: 'bar',
+  foo: 'bar',
 
-    second() {
-        return '';
-    },
+  second() {
+    return '';
+  },
 });
 
 declare module '@ember/controller' {
-    interface Registry {
-        first: FirstController;
-        second: InstanceType<typeof SecondController>;
-    }
+  interface Registry {
+    first: FirstController;
+    second: InstanceType<typeof SecondController>;
+  }
 }

From 20c6148c42df5514e8e8a5712e3dbe522a952d8f Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 11:47:33 -0600
Subject: [PATCH 24/39] Fix preview types/tests for @ember/service

---
 types/preview/@ember/service/index.d.ts     | 10 ++--
 types/preview/@ember/service/test/main.ts   | 58 ------------------
 types/preview/@ember/service/test/octane.ts | 34 -----------
 types/preview/ember/test/inject.ts          | 66 +++++++++++----------
 4 files changed, 39 insertions(+), 129 deletions(-)
 delete mode 100644 types/preview/@ember/service/test/main.ts
 delete mode 100644 types/preview/@ember/service/test/octane.ts

diff --git a/types/preview/@ember/service/index.d.ts b/types/preview/@ember/service/index.d.ts
index c87f86f0346..a9fe6f68536 100644
--- a/types/preview/@ember/service/index.d.ts
+++ b/types/preview/@ember/service/index.d.ts
@@ -1,22 +1,22 @@
 import EmberObject from '@ember/object';
-import ComputedProperty from '@ember/object/computed';
+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(): ComputedProperty<Service>; // @inject() foo, foo: inject()
+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): ComputedProperty<Registry[K]>; // @inject('store') foo      @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(): ComputedProperty<Service>; // @service() foo, foo: service()
+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): ComputedProperty<Registry[K]>; // @service('store') foo      @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.
diff --git a/types/preview/@ember/service/test/main.ts b/types/preview/@ember/service/test/main.ts
deleted file mode 100644
index 3fca6a674aa..00000000000
--- a/types/preview/@ember/service/test/main.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-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 '';
-    },
-});
-
-class ThirdSvc extends Service.extend({
-    foo: 'bar',
-    third() {
-        return '';
-    },
-}) {}
-
-declare module '@ember/service' {
-    interface Registry {
-        first: FirstSvc;
-        second: InstanceType<typeof SecondSvc>;
-        third: ThirdSvc;
-    }
-}
-
-const ServiceTriplet = EmberObject.extend({
-    sFirst: inject('first'),
-    sSecond: inject('second'),
-    sThird: inject('third'),
-    unknownService: inject(),
-});
-
-const obj = ServiceTriplet.create();
-
-obj.get('sFirst'); // $ExpectType FirstSvc
-obj.get('sSecond').second(); // $ExpectType ""
-obj.get('sThird'); // $ExpectType ThirdSvc
-obj.get('unknownService'); // $ExpectType Service
-
-const ServiceTripletService = EmberObject.extend({
-    sFirst: service('first'),
-    sSecond: service('second'),
-    sThird: service('third'),
-    unknownService: service(),
-});
-
-const objService = ServiceTripletService.create();
-
-objService.get('sFirst'); // $ExpectType FirstSvc
-objService.get('sSecond').second(); // $ExpectType ""
-objService.get('sThird'); // $ExpectType ThirdSvc
-objService.get('unknownService'); // $ExpectType Service
diff --git a/types/preview/@ember/service/test/octane.ts b/types/preview/@ember/service/test/octane.ts
deleted file mode 100644
index e176dece15b..00000000000
--- a/types/preview/@ember/service/test/octane.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-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/types/preview/ember/test/inject.ts b/types/preview/ember/test/inject.ts
index 961923c03ba..491ad8def50 100755
--- a/types/preview/ember/test/inject.ts
+++ b/types/preview/ember/test/inject.ts
@@ -1,41 +1,41 @@
 import Ember from 'ember';
 
 class AuthService extends Ember.Service {
-    declare isAuthenticated: boolean;
+  declare isAuthenticated: boolean;
 }
 
 class ApplicationController extends Ember.Controller {
-    model = {};
-    declare string: string;
-    transitionToLogin() {}
+  model = {};
+  declare string: string;
+  transitionToLogin() {}
 }
 
 declare module '@ember/service' {
-    interface Registry {
-        auth: AuthService;
-    }
+  interface Registry {
+    auth: AuthService;
+  }
 }
 
 declare module '@ember/controller' {
-    interface Registry {
-        application: ApplicationController;
-    }
+  interface Registry {
+    application: ApplicationController;
+  }
 }
 
 class LoginRoute extends Ember.Route {
-    auth = Ember.inject.service('auth');
-    application = Ember.inject.controller('application');
+  auth = Ember.inject.service('auth');
+  application = Ember.inject.controller('application');
 
-    didTransition() {
-        if (!this.get('auth').get('isAuthenticated')) {
-            this.get('application').transitionToLogin();
-        }
+  didTransition() {
+    if (!this.get('auth').get('isAuthenticated')) {
+      this.get('application').transitionToLogin();
     }
+  }
 
-    anyOldMethod() {
-        this.get('application').set('string', 'must be a string');
-        this.controllerFor('application'); // $ExpectType Controller
-    }
+  anyOldMethod() {
+    this.get('application').set('string', 'must be a string');
+    this.controllerFor('application'); // $ExpectType Controller
+  }
 }
 
 // New module injection style.
@@ -44,17 +44,19 @@ import Service, { inject as service } from '@ember/service';
 import { assertType } from './lib/assert';
 
 class ComponentInjection extends Ember.Component {
-    applicationController = controller('application');
-    auth = service('auth');
-    router = service('router');
-    misc = service();
-
-    testem() {
-        assertType<Ember.Service>(this.get('misc'));
-        const url = this.get('router').urlFor('some-route', 1, 2, 3, { queryParams: { seriously: 'yes' } });
-        assertType<string>(url);
-        if (!this.get('auth').isAuthenticated) {
-            this.get('applicationController').transitionToLogin();
-        }
+  applicationController = controller('application');
+  auth = service('auth');
+  router = service('router');
+  misc = service();
+
+  testem() {
+    assertType<Ember.Service>(this.get('misc'));
+    const url = this.get('router').urlFor('some-route', 1, 2, 3, {
+      queryParams: { seriously: 'yes' },
+    });
+    assertType<string>(url);
+    if (!this.get('auth').isAuthenticated) {
+      this.get('applicationController').transitionToLogin();
     }
+  }
 }

From 94716e41eab8e88eeb1d94dfd72f068005afe2ff Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 19:26:33 -0600
Subject: [PATCH 25/39] Introduce type utilities for safe `get(Properties)`

These allows us to make `get` or `getProperties` correctly handle index
access the same way direct field access would. This gets us back to the
same level of safety we had with our old `UnwrapComputedProperty*`
types for this kind of index access: those types did *many* things, but
included among them was distributing across the requested properties.
---
 types/preview/@ember/object/index.d.ts        | 28 +++++++++++++++++--
 .../preview/@ember/object/test/observable.ts  | 24 ++++++++++++----
 types/preview/ember/test/object.ts            |  1 -
 types/preview/ember/test/observable.ts        |  8 ++++--
 4 files changed, 50 insertions(+), 11 deletions(-)

diff --git a/types/preview/@ember/object/index.d.ts b/types/preview/@ember/object/index.d.ts
index 09348748992..5a6a0370eb9 100644
--- a/types/preview/@ember/object/index.d.ts
+++ b/types/preview/@ember/object/index.d.ts
@@ -33,12 +33,34 @@ export function observer<Fn extends (target: any, key: string) => void>(
   ...args: [...propertyNames: string[], func: Fn]
 ): Fn;
 
+// Allows us to split apart `Record` types which have distinct keys (e.g. using
+// an enum or a union of specific keys) from those which just have an index type
+// and therefore to get the same behavior with `get` and friends as we would
+// when indexing directly with JS.
+// See https://stackoverflow.com/a/68261113/564181
+type RemoveIndex<T> = {
+  [K in keyof T as {} extends Record<K, 1> ? never : K]: T[K];
+};
+
+// Using `RemoveIndex` here then allows us to keep the desired behavior under
+// `noUncheckedIndexedAccess` as direct property access.
+type Get<T, K extends keyof T> = K extends keyof RemoveIndex<T> ? T[K] : T[K] | undefined;
+
+// We do the same here. Additionally, this uses an array type so that we can
+// distribute over each item in the list (accessing with `[number]`) instead of
+// over the list as a union, so that doing an index access gets the type for
+// that specific key rather then a union of the types associated with all the
+// keys.
+type GetProperties<T, Keys extends Array<keyof T>> = {
+  [K in Keys[number]]: Get<T, K>;
+};
+
 /**
  * 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<T, K extends keyof T>(obj: T, key: K): Get<T, K>;
 export function get(obj: unknown, key: string): unknown;
 
 /**
@@ -53,8 +75,8 @@ export function set<T, K extends keyof T>(obj: T, key: K, value: T[K]): T[K];
  * 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>;
+export function getProperties<T, K extends Array<keyof T>>(obj: T, list: K): GetProperties<T, K>;
+export function getProperties<T, K extends Array<keyof T>>(obj: T, ...list: K): GetProperties<T, K>;
 
 /**
  * Set a list of properties on an object. These properties are set inside
diff --git a/types/preview/@ember/object/test/observable.ts b/types/preview/@ember/object/test/observable.ts
index fc9ccdcc146..11fb46016d5 100644
--- a/types/preview/@ember/object/test/observable.ts
+++ b/types/preview/@ember/object/test/observable.ts
@@ -63,9 +63,11 @@ function testGetProperties() {
     name: string;
     age: number;
   }>();
-  expectTypeOf(getProperties(person, 'name', 'age', 'capitalized')).toEqualTypeOf<
-    Pick<Person, 'name' | 'age' | 'capitalized'>
-  >();
+  expectTypeOf(getProperties(person, 'name', 'age', 'capitalized')).toEqualTypeOf<{
+    name: string;
+    age: number;
+    capitalized: string;
+  }>();
   expectTypeOf(person.getProperties('name')).toEqualTypeOf<{ name: string }>();
   expectTypeOf(person.getProperties('name', 'age')).toEqualTypeOf<{ name: string; age: number }>();
   expectTypeOf(person.getProperties(['name', 'age'])).toEqualTypeOf<{
@@ -117,12 +119,24 @@ function testDynamic() {
   expectTypeOf(get(obj, dynamicKey)).toEqualTypeOf<string | undefined>();
   expectTypeOf(getProperties(obj, 'dummy')).toEqualTypeOf<{ dummy: string | undefined }>();
   expectTypeOf(getProperties(obj, ['dummy'])).toEqualTypeOf<{ dummy: string | undefined }>();
-  expectTypeOf(getProperties(obj, dynamicKey)).toEqualTypeOf<Record<string, string>>();
-  expectTypeOf(getProperties(obj, [dynamicKey])).toEqualTypeOf<Record<string, string>>();
+  expectTypeOf(getProperties(obj, dynamicKey)).toEqualTypeOf<Record<string, string | undefined>>();
+  expectTypeOf(getProperties(obj, [dynamicKey])).toEqualTypeOf<
+    Record<string, string | undefined>
+  >();
   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/types/preview/ember/test/object.ts b/types/preview/ember/test/object.ts
index 98a8cd909b7..edeff03fb92 100755
--- a/types/preview/ember/test/object.ts
+++ b/types/preview/ember/test/object.ts
@@ -60,7 +60,6 @@ export class Foo2 extends Ember.Object {
   name = '';
 
   changeName(name: string) {
-    expectTypeOf(this.set('name', name)).toEqualTypeOf<string>();
     // This is checking for assignability; `expectTypeOf` doesn't work correctly
     // here because TS isn't resolving `this['name']` eagerly, and so it is not
     // (currently) possible for the type utility to match it.
diff --git a/types/preview/ember/test/observable.ts b/types/preview/ember/test/observable.ts
index c4ccd9c4469..1707e9ed58e 100755
--- a/types/preview/ember/test/observable.ts
+++ b/types/preview/ember/test/observable.ts
@@ -113,8 +113,12 @@ function testDynamic() {
   expectTypeOf(Ember.get(obj, dynamicKey)).toEqualTypeOf<string | undefined>();
   expectTypeOf(Ember.getProperties(obj, 'dummy')).toEqualTypeOf<{ dummy: string | undefined }>();
   expectTypeOf(Ember.getProperties(obj, ['dummy'])).toEqualTypeOf<{ dummy: string | undefined }>();
-  expectTypeOf(Ember.getProperties(obj, dynamicKey)).toEqualTypeOf<Record<string, string>>();
-  expectTypeOf(Ember.getProperties(obj, [dynamicKey])).toEqualTypeOf<Record<string, string>>();
+  expectTypeOf(Ember.getProperties(obj, dynamicKey)).toEqualTypeOf<
+    Record<string, string | undefined>
+  >();
+  expectTypeOf(Ember.getProperties(obj, [dynamicKey])).toEqualTypeOf<
+    Record<string, string | undefined>
+  >();
   expectTypeOf(Ember.set(obj, 'dummy', 'value')).toBeString();
   expectTypeOf(Ember.set(obj, dynamicKey, 'value')).toBeString();
   expectTypeOf(Ember.setProperties(obj, { dummy: 'value ' })).toEqualTypeOf<

From 2dc87a1060efe1dbe8616a7c50d68fa78ed4149b Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 19:28:57 -0600
Subject: [PATCH 26/39] Add sundry improvements to preview types.

---
 .../runtime/lib/mixins/registry_proxy.ts      |  16 +-
 types/preview/@ember/engine/test/engine.ts    |  20 +-
 .../@ember/object/test/create-negative.ts     |   5 +-
 types/preview/@ember/object/test/object.ts    | 166 +++++-----
 types/preview/@ember/object/test/proxy.ts     |  89 +++---
 types/preview/@ember/routing/test/route.ts    | 288 +++++++++---------
 types/preview/@ember/runloop/index.d.ts       |   7 +
 types/preview/@ember/service/service-test.ts  |  34 +++
 types/preview/ember/index.d.ts                |   4 +-
 types/preview/ember/test/access-modifier.ts   |  42 ---
 .../ember/test/application-instance.ts        |  10 +-
 types/preview/ember/test/array-proxy.ts       |  10 +-
 types/preview/ember/test/controller.ts        |  18 +-
 types/preview/ember/test/create-negative.ts   |   8 +-
 .../preview/ember/test/ember-module-tests.ts  |  60 ++--
 types/preview/ember/test/engine.ts            |  55 ++--
 types/preview/ember/test/inject.ts            |  36 ++-
 17 files changed, 435 insertions(+), 433 deletions(-)
 create mode 100644 types/preview/@ember/service/service-test.ts
 delete mode 100644 types/preview/ember/test/access-modifier.ts

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/types/preview/@ember/engine/test/engine.ts b/types/preview/@ember/engine/test/engine.ts
index 4426b7d8f3c..994ff9da610 100755
--- a/types/preview/@ember/engine/test/engine.ts
+++ b/types/preview/@ember/engine/test/engine.ts
@@ -23,20 +23,20 @@ BaseEngine.instanceInitializer({
   },
 });
 
-const Engine1 = BaseEngine.create({
-  rootElement: '#engine-one',
-  customEvents: {
+class Engine1 extends BaseEngine {
+  rootElement = '#engine-one';
+  customEvents = {
     paste: 'paste',
-  },
-});
+  };
+}
 
-const Engine2 = BaseEngine.create({
-  rootElement: '#engine-two',
-  customEvents: {
+class Engine2 extends BaseEngine {
+  rootElement = '#engine-two';
+  customEvents = {
     mouseenter: null,
     mouseleave: null,
-  },
-});
+  };
+}
 
 const Engine3 = BaseEngine.create();
 
diff --git a/types/preview/@ember/object/test/create-negative.ts b/types/preview/@ember/object/test/create-negative.ts
index e1e01ff9a13..86557265951 100644
--- a/types/preview/@ember/object/test/create-negative.ts
+++ b/types/preview/@ember/object/test/create-negative.ts
@@ -1,5 +1,4 @@
-import { assertType } from './lib/assert';
-import { PersonWithNumberName, Person } from './create';
+import { Person } from './create';
 
 // @ts-expect-error
 Person.create({ firstName: 99 });
@@ -7,5 +6,3 @@ Person.create({ firstName: 99 });
 Person.create({}, { firstName: 99 });
 // @ts-expect-error
 Person.create({}, {}, { firstName: 99 });
-
-const p4 = new PersonWithNumberName();
diff --git a/types/preview/@ember/object/test/object.ts b/types/preview/@ember/object/test/object.ts
index 703ab737616..44abefa12fa 100644
--- a/types/preview/@ember/object/test/object.ts
+++ b/types/preview/@ember/object/test/object.ts
@@ -1,102 +1,88 @@
-import EmberObject, { computed, notifyPropertyChange } from '@ember/object';
+import Object, { computed, get, notifyPropertyChange, set, setProperties } from '@ember/object';
+import { expectTypeOf } from 'expect-type';
 
-const LifetimeHooks = EmberObject.extend({
-    resource: undefined as {} | undefined,
+class LifetimeHooks extends Object {
+  resource: {} | undefined;
 
-    init() {
-        this._super();
-        this.resource = {};
-    },
+  init() {
+    this._super();
+    this.resource = {};
+  }
 
-    willDestroy() {
-        this.resource = undefined;
-        this._super();
-    },
-});
+  willDestroy() {
+    this.resource = undefined;
+    this._super();
+  }
+}
 
-class MyObject30 extends EmberObject {
-    constructor() {
-        super();
-    }
+class MyObject30 extends Object {
+  constructor() {
+    super();
+  }
 }
 
-class MyObject31 extends EmberObject {
-    constructor(properties: object) {
-        super(properties);
-    }
+class MyObject31 extends Object {
+  constructor(properties: object) {
+    super(properties);
+  }
 }
 
-class Foo extends EmberObject {
-    a = computed({
-        get() {
-            return '';
-        },
-        set(key: string, newVal: string) {
-            return '';
-        },
-    });
-    b = 5;
-    c = computed({
-        get() {
-            return '';
-        },
-        set(key: string, newVal: string | number) {
-            return '';
-        }
-    });
-    baz() {
-        const x = this.a; // $ExpectType ComputedProperty<string, string>
-        const y = this.b; // $ExpectType number
-        const z = this.c; // $ExpectType ComputedProperty<string, string | number>
-        this.b = 10;
-        this.get('b').toFixed(4); // $ExpectType string
-        this.set('a', 'abc').split(','); // $ExpectType string[]
-        this.set('b', 10).toFixed(4); // $ExpectType string
-        this.get('c').split(','); // $ExpectType string[]
-        this.set('c', '10').split(','); // $ExpectType string[]
-        this.set('c', 10);
-        // @ts-expect-error
-        this.set('c', 10).split(',');
+class Foo extends Object {
+  @computed()
+  get a() {
+    return '';
+  }
+
+  set a(newVal: string) {
+    /* no-op */
+  }
+
+  b = 5;
+
+  baz() {
+    const y = this.b; // $ExpectType number
+    const z = this.a; // $ExpectType ComputedProperty<string, string>
+    this.b = 10;
+    this.get('b').toFixed(4); // $ExpectType string
+    this.set('a', 'abc').split(','); // $ExpectType string[]
+    this.set('b', 10).toFixed(4); // $ExpectType string
 
-        this.setProperties({ b: 11 });
-        // this.setProperties({ b: '11' }); // @ts-expect-error
-        this.setProperties({
-            a: 'def',
-            b: 11,
-        });
-    }
-    bar() {
-        notifyPropertyChange(this, 'name');
-        // @ts-expect-error
-        notifyPropertyChange(this);
-        // @ts-expect-error
-        notifyPropertyChange('name');
-        // @ts-expect-error
-        notifyPropertyChange(this, 'name', 'bar');
-    }
+    this.setProperties({ b: 11 });
+    // this.setProperties({ b: '11' }); // @ts-expect-error
+    this.setProperties({
+      a: 'def',
+      b: 11,
+    });
+  }
 }
 
-// TODO: enable after TS 3.0 https://github.com/typed-ember/ember-cli-typescript/issues/291
-// class Foo extends EmberObject.extend({
-//     a: computed({
-//         get() { return ''; },
-//         set(key: string, newVal: string) { return ''; }
-//     })
-// }) {
-//     b = 5;
-//     baz() {
-//         const y = this.b; // $ExpectType number
-//         const z = this.a; // $ExpectType ComputedProperty<string, string>
-//         this.b = 10;
-//         this.get('b').toFixed(4); // $ExpectType string
-//         this.set('a', 'abc').split(','); // $ExpectType string[]
-//         this.set('b', 10).toFixed(4); // $ExpectType string
+export class Foo2 extends Object {
+  name = '';
 
-//         this.setProperties({ b: 11 });
-//         // this.setProperties({ b: '11' }); // @ts-expect-error
-//         this.setProperties({
-//             a: 'def',
-//             b: 11
-//         });
-//     }
-// }
+  changeName(name: string) {
+    expectTypeOf(this.set('name', name)).toEqualTypeOf<string>();
+    // This is checking for assignability; `expectTypeOf` doesn't work correctly
+    // here because TS isn't resolving `this['name']` eagerly, and so it is not
+    // (currently) possible for the type utility to match it.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const x: string = set(this, 'name', name);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const y: string = get(this, 'name');
+    this.setProperties({
+      name,
+    });
+    setProperties(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/types/preview/@ember/object/test/proxy.ts b/types/preview/@ember/object/test/proxy.ts
index 14a8a386570..d05aa51917d 100644
--- a/types/preview/@ember/object/test/proxy.ts
+++ b/types/preview/@ember/object/test/proxy.ts
@@ -1,44 +1,50 @@
 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 }>;
+  title: string;
+  subtitle: string;
+  chapters: Array<{ title: string }>;
 }
 
 class DefaultProxy extends ObjectProxy {}
 DefaultProxy.create().content; // $ExpectType object | undefined
 
 class BookProxy extends ObjectProxy<Book> {
-    private readonly baz = 'baz';
+  private readonly baz = 'baz';
 
-    altTitle = 'Alt';
+  altTitle = 'Alt';
 
-    getTitle() {
-        return this.get('title');
-    }
+  getTitle() {
+    return this.get('title');
+  }
 
-    getPropertiesTitleSubtitle() {
-        return this.getProperties('title', 'subtitle');
-    }
+  getPropertiesTitleSubtitle() {
+    return this.getProperties('title', 'subtitle');
+  }
 }
 
 const book = BookProxy.create();
-book.content; // $ExpectType Book | undefined
+expectTypeOf(book.content).toEqualTypeOf<Book | undefined>(); // $ExpectType Book | undefined
 
 // @ts-expect-error
 book.get('unknownProperty');
-book.get('title'); // $ExpectType string | undefined
-book.get('altTitle'); // $ExpectType string
-book.getTitle(); // $ExpectType string | undefined
+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');
-book.getProperties('title', 'subtitle'); // $ExpectType Pick<Partial<UnwrapComputedPropertyGetters<Book>>, "title" | "subtitle">
-book.getPropertiesTitleSubtitle(); // $ExpectType Pick<Partial<UnwrapComputedPropertyGetters<Book>>, "title" | "subtitle">
-// tslint:disable-next-line
-book.getProperties(['subtitle', 'chapters']); // $ExpectType Pick<Partial<UnwrapComputedPropertyGetters<Book>>, "subtitle" | "chapters"> || Pick<Partial<UnwrapComputedPropertyGetters<Book>>, "chapters" | "subtitle">
+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']);
 
@@ -52,9 +58,9 @@ book.set('altTitle', 'Alternate');
 // @ts-expect-error
 book.set('altTitle', 1);
 book.setProperties({
-    title: 'new',
-    subtitle: 'and improved',
-    altTitle: 'Alternate2',
+  title: 'new',
+  subtitle: 'and improved',
+  altTitle: 'Alternate2',
 });
 // @ts-expect-error
 book.setProperties({ title: 1 });
@@ -64,39 +70,38 @@ book.setProperties({ altTitle: 1 });
 book.setProperties({ invalid: true });
 
 class Person extends Ember.Object {
-    firstName = 'Peter';
+  firstName = 'Peter';
 
-    lastName = 'Wagenet';
+  lastName = 'Wagenet';
 
-    fullName = Ember.computed('firstName', 'lastName', {
-        get() {
-          return `${this.firstName} ${this.lastName}`;
-        },
+  @Ember.computed('firstName', 'lastName')
+  get fullName() {
+    return `${this.firstName} ${this.lastName}`;
+  }
 
-        set(key, value: string) {
-          const [firstName, lastName] = value.split(' ');
+  set fullName(value: string) {
+    const [firstName, lastName] = value.split(' ');
 
-          Ember.set(this, 'firstName', firstName);
-          Ember.set(this, 'lastName', lastName);
-
-          return value;
-        }
-    });
+    Ember.set(this, 'firstName', firstName ?? '');
+    Ember.set(this, 'lastName', lastName ?? '');
+  }
 }
 
-class PersonProxy extends ObjectProxy<Person> { }
+class PersonProxy extends ObjectProxy<Person> {}
 
 const person = PersonProxy.create();
 
-person.get('firstName'); // $ExpectType string | undefined
-person.get('fullName'); // $ExpectType string | undefined
-person.set('fullName', 'John Doe'); // $ExpectType string
+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);
-person.setProperties({ fullName: 'John Doe' }); // $ExpectType Pick<UnwrapComputedPropertySetters<PersonProxy & Person>, "fullName">
-person.setProperties({ fullName: 'John Doe' }).fullName; // $ExpectType string
+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
diff --git a/types/preview/@ember/routing/test/route.ts b/types/preview/@ember/routing/test/route.ts
index 42c53d4e73b..fea2b336b2e 100755
--- a/types/preview/@ember/routing/test/route.ts
+++ b/types/preview/@ember/routing/test/route.ts
@@ -1,3 +1,4 @@
+/* eslint-disable prefer-const */
 import Route from '@ember/routing/route';
 import Array from '@ember/array';
 import EmberObject from '@ember/object';
@@ -9,201 +10,201 @@ class Post extends EmberObject {}
 
 interface Posts extends Array<Post> {}
 
-Route.extend({
-    beforeModel(transition: Transition) {
-        this.transitionTo('someOtherRoute');
-    },
-});
-
-Route.extend({
-    afterModel(posts: Posts, transition: Transition) {
-        if (posts.firstObject) {
-            this.transitionTo('post.show', posts.firstObject);
-        }
-    },
-});
-
-Route.extend({
-    model() {
-        return this.modelFor('post');
-    },
-});
-
-Route.extend({
-    queryParams: {
-        memberQp: { refreshModel: true },
-    },
-});
-
-Route.extend({
-    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 BeforeModelText extends Route {
+  beforeModel(transition: Transition) {
+    this.transitionTo('someOtherRoute');
+  }
 }
 
-class DeactivateRoute extends Route {
-    deactivate(transition: Transition) {
-        this.transitionTo('someOtherRoute');
+class AfterModel extends Route {
+  afterModel(posts: Posts, transition: Transition) {
+    if (posts.firstObject) {
+      this.transitionTo('post.show', posts.firstObject);
     }
+  }
 }
 
-class RedirectRoute extends Route {
-    redirect(model: {}, a: Transition) {
-        if (!model) {
-            this.transitionTo('there');
-        }
-    }
+class ModelTest extends Route {
+  model() {
+    return this.modelFor('post');
+  }
 }
 
-class InvalidRedirect extends Route {
-    // @ts-expect-error
-    redirect(model: {}, a: Transition, anOddArg: unknown) {
-        if (!model) {
-            this.transitionTo('there');
-        }
-    }
+class QPsTest extends Route {
+  queryParams = {
+    memberQp: { refreshModel: true },
+  };
 }
 
-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() {
-        // $ExpectType Transition<unknown>
-        this.transitionTo('somewhere', { queryParams: { neat: true } });
-    }
-
-    transitionToJustQP() {
-        // $ExpectType Transition<unknown>
-        this.transitionTo({ queryParams: { neat: 'true' } });
-    }
-
-    transitionToNonsense() {
-        // @ts-expect-error
-        this.transitionTo({ cannotDoModelHere: true });
+class ResetControllerTest extends Route {
+  resetController(controller: Controller, isExiting: boolean, transition: Transition) {
+    if (isExiting) {
+      //   controller.set('page', 1);
+      transition.abort();
     }
+  }
+}
 
-    transitionToBadQP() {
-        // @ts-expect-error
-        this.transitionTo({ queryParams: 12 });
-    }
+class ActivateRoute extends Route {
+  activate(transition: Transition) {
+    this.transitionTo('someOtherRoute');
+  }
+}
 
-    transitionToId() {
-        // $ExpectType Transition<unknown>
-        this.transitionTo('blog-post', 1);
-    }
+class DeactivateRoute extends Route {
+  deactivate(transition: Transition) {
+    this.transitionTo('someOtherRoute');
+  }
+}
 
-    transitionToIdWithQP() {
-        // $ExpectType Transition<unknown>
-        this.transitionTo('blog-post', 1, { queryParams: { includeComments: true } });
+class RedirectRoute extends Route {
+  redirect(model: {}, a: Transition) {
+    if (!model) {
+      this.transitionTo('there');
     }
+  }
+}
 
-    transitionToIds() {
-        // $ExpectType Transition<unknown>
-        this.transitionTo('blog-comment', 1, '13');
+class InvalidRedirect extends Route {
+  // @ts-expect-error
+  redirect(model: {}, a: Transition, anOddArg: unknown) {
+    if (!model) {
+      this.transitionTo('there');
     }
+  }
+}
 
-    transitionToIdsWithQP() {
-        // $ExpectType Transition<unknown>
-        this.transitionTo('blog-comment', 1, '13', { queryParams: { includePost: true } });
-    }
+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 });
+  }
 
-    buildRouteInfoMetadata() {
-        return { foo: 'bar' };
-    }
+  transitionToBadQP() {
+    // @ts-expect-error
+    this.transitionTo({ queryParams: 12 });
+  }
+
+  transitionToId() {
+    // $ExpectType Transition<unknown>
+    this.transitionTo('blog-post', 1);
+  }
+
+  transitionToIdWithQP() {
+    // $ExpectType Transition<unknown>
+    this.transitionTo('blog-post', 1, { queryParams: { includeComments: true } });
+  }
+
+  transitionToIds() {
+    // $ExpectType Transition<unknown>
+    this.transitionTo('blog-comment', 1, '13');
+  }
+
+  transitionToIdsWithQP() {
+    // $ExpectType Transition<unknown>
+    this.transitionTo('blog-comment', 1, '13', { queryParams: { includePost: true } });
+  }
+
+  buildRouteInfoMetadata() {
+    return { foo: 'bar' };
+  }
 }
 
 class ApplicationController extends Controller {}
 declare module '@ember/controller' {
-    interface Registry {
-        application: ApplicationController;
-    }
+  interface Registry {
+    application: ApplicationController;
+  }
 }
 
-Route.extend({
-    setupController(controller: Controller, model: {}, transition: Transition) {
-        this._super(controller, model);
-        this.controllerFor('application').set('model', model);
-        transition.abort();
-    },
-});
+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();
-route.controllerFor('whatever'); // $ExpectType Controller
-route.paramsFor('whatever'); // $ExpectType object
+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',
+  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, {});
-    }
+  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;
-    }
+  beforeModel(transition: Transition): void | Promise<unknown> {
+    return;
+  }
 
-    afterModel(resolvedModel: unknown, transition: Transition): void {
-        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')";
-    }
+  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')";
-    }
+  afterModel(resolvedModel: unknown, transition: Transition): void {
+    // @ts-expect-error
+    return "returning anything else is nonsensical (if 'legal')";
+  }
 }
 
 interface RouteParams {
-    cool: string;
+  cool: string;
 }
 
 class WithParamsInModel extends Route<boolean, RouteParams> {
-    model(params: RouteParams, transition: Transition) {
-        return true;
-    }
+  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' };
-    }
+  model(params: RouteParams) {
+    return { whatUp: 'dog' };
+  }
 }
 
-// $ExpectType RouteParams
 type ImplicitParams = WithImplicitParams extends Route<any, infer T> ? T : never;
+expectTypeOf<ImplicitParams>().toEqualTypeOf<RouteParams>();
 
 // back-compat for existing users of these
 // NOTE: we will *not* migrate the private import locations when moving to
@@ -221,6 +222,7 @@ publicRouteInfo = privateRouteInfo;
 privateRouteInfo = publicRouteInfo;
 
 import PrivateRouteInfoWithAttributes from '@ember/routing/-private/route-info-with-attributes';
+import { expectTypeOf } from 'expect-type';
 declare let publicRouteInfoWithAttributes: RouteInfoWithAttributes;
 declare let privateRouteInfoWithAttributes: PrivateRouteInfoWithAttributes;
 publicRouteInfoWithAttributes = privateRouteInfoWithAttributes;
diff --git a/types/preview/@ember/runloop/index.d.ts b/types/preview/@ember/runloop/index.d.ts
index 6e5159af0e5..372df3a5fa4 100644
--- a/types/preview/@ember/runloop/index.d.ts
+++ b/types/preview/@ember/runloop/index.d.ts
@@ -3,6 +3,7 @@ import {
   EmberMethodParams,
   AnyFn,
   EmberMethodReturn,
+  AnyMethod,
 } from 'ember/-private/type-utils';
 import { EmberRunQueues } from './-private/types';
 import { EmberRunTimer } from '@ember/runloop/types';
@@ -100,6 +101,12 @@ export function once<T, M extends EmberMethod<T>>(
   ...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
diff --git a/types/preview/@ember/service/service-test.ts b/types/preview/@ember/service/service-test.ts
new file mode 100644
index 00000000000..7ba6f553a86
--- /dev/null
+++ b/types/preview/@ember/service/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/types/preview/ember/index.d.ts b/types/preview/ember/index.d.ts
index ff367607257..c2fdf3e1af8 100755
--- a/types/preview/ember/index.d.ts
+++ b/types/preview/ember/index.d.ts
@@ -236,7 +236,9 @@ export namespace Ember {
      * Can only be used when defining another controller.
      */
     function controller(): Controller;
-    function controller<K extends keyof ControllerRegistry>(name: K): ControllerRegistry[K];
+    function controller<K extends keyof ControllerRegistry>(
+      name: K
+    ): ControllerRegistry[K] & EmberObjectComputedNs.BasicComputedProperty;
     const service: typeof EmberServiceNs.inject;
   }
   namespace ENV {
diff --git a/types/preview/ember/test/access-modifier.ts b/types/preview/ember/test/access-modifier.ts
deleted file mode 100644
index 3b3a27f6641..00000000000
--- a/types/preview/ember/test/access-modifier.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-/**
- * Tests to ensure that access modifier keywords are appropriately
- * respected and supported
- */
-import Ember from 'ember';
-import { assertType } from './lib/assert';
-
-class Foo extends Ember.Object {
-    hello() {
-        return 'world';
-    }
-    protected bar() {
-        return 'bar';
-    }
-    private baz() {
-        return 'baz';
-    }
-}
-const f = new Foo();
-assertType<string>(f.hello());
-// protected property should not be visible from outside of Foo
-// @ts-expect-error
-assertType<string>(f.bar());
-// private property should not be visible from outside of Foo
-// @ts-expect-error
-assertType<string>(f.baz());
-
-class Foo2 extends Ember.Object.extend({
-    bar: '',
-}) {
-    hello() {
-        return 'world';
-    }
-    // Cannot override with a mis-matched property type
-    // @ts-expect-error
-    protected bar() {
-        return 'bar';
-    }
-    private baz() {
-        return 'baz';
-    }
-}
diff --git a/types/preview/ember/test/application-instance.ts b/types/preview/ember/test/application-instance.ts
index e151828fa60..e8893defbf8 100644
--- a/types/preview/ember/test/application-instance.ts
+++ b/types/preview/ember/test/application-instance.ts
@@ -5,18 +5,18 @@ const appInstance = ApplicationInstance.create();
 appInstance.register('some:injection', class Foo {});
 
 appInstance.register('some:injection', class Foo {}, {
-    singleton: true,
+  singleton: true,
 });
 
 appInstance.register('some:injection', class Foo {}, {
-    instantiate: false,
+  instantiate: false,
 });
 
 appInstance.register('templates:foo/bar', hbs`<h1>Hello World</h1>`);
 
 appInstance.register('some:injection', class Foo {}, {
-    singleton: false,
-    instantiate: true,
+  singleton: false,
+  instantiate: true,
 });
 
 appInstance.factoryFor('router:main');
@@ -25,5 +25,5 @@ appInstance.lookup('route:basic');
 appInstance.boot();
 
 (async () => {
-    await appInstance.boot();
+  await appInstance.boot();
 })();
diff --git a/types/preview/ember/test/array-proxy.ts b/types/preview/ember/test/array-proxy.ts
index 53b6ec7e0a9..8099af3aa98 100644
--- a/types/preview/ember/test/array-proxy.ts
+++ b/types/preview/ember/test/array-proxy.ts
@@ -9,16 +9,16 @@ proxy.set('content', Ember.A(['amoeba', 'paramecium']));
 proxy.get('firstObject'); // 'amoeba'
 
 const overridden = Ember.ArrayProxy.create({
-    content: Ember.A(pets),
-    objectAtContent(idx: number): string {
-        return this.get('content').objectAt(idx)!.toUpperCase();
-    },
+  content: Ember.A(pets),
+  objectAtContent(this: Ember.ArrayProxy<string>, idx: number): string {
+    return this.get('content').objectAt(idx)!.toUpperCase();
+  },
 });
 
 overridden.get('firstObject'); // 'DOG'
 
 class MyNewProxy<T> extends Ember.ArrayProxy<T> {
-    isNew = true;
+  isNew = true;
 }
 
 const x = MyNewProxy.create({ content: Ember.A([1, 2, 3]) }) as MyNewProxy<number>;
diff --git a/types/preview/ember/test/controller.ts b/types/preview/ember/test/controller.ts
index 208babb8fd1..7e89a8d8334 100755
--- a/types/preview/ember/test/controller.ts
+++ b/types/preview/ember/test/controller.ts
@@ -1,11 +1,11 @@
-import Controller from '@ember/controller';
+import Ember from 'ember';
 
-Controller.extend({
-    queryParams: ['category'],
-    category: null,
-    isExpanded: false,
+class MyController extends Ember.Controller {
+  queryParams = ['category'];
+  category = null;
+  isExpanded = false;
 
-    toggleBody() {
-        this.toggleProperty('isExpanded');
-    },
-});
+  toggleBody() {
+    this.toggleProperty('isExpanded');
+  }
+}
diff --git a/types/preview/ember/test/create-negative.ts b/types/preview/ember/test/create-negative.ts
index ff86313e31a..86557265951 100644
--- a/types/preview/ember/test/create-negative.ts
+++ b/types/preview/ember/test/create-negative.ts
@@ -1,6 +1,4 @@
-import { assertType } from './lib/assert';
-import Ember from 'ember';
-import { PersonWithNumberName, Person } from './create';
+import { Person } from './create';
 
 // @ts-expect-error
 Person.create({ firstName: 99 });
@@ -8,7 +6,3 @@ Person.create({ firstName: 99 });
 Person.create({}, { firstName: 99 });
 // @ts-expect-error
 Person.create({}, {}, { firstName: 99 });
-
-const p4 = new PersonWithNumberName();
-
-// assertType<Ember.ComputedProperty<string, string>>(p4.fullName); // @ts-expect-error
diff --git a/types/preview/ember/test/ember-module-tests.ts b/types/preview/ember/test/ember-module-tests.ts
index 63e49dc2c40..89d645a63de 100644
--- a/types/preview/ember/test/ember-module-tests.ts
+++ b/types/preview/ember/test/ember-module-tests.ts
@@ -34,8 +34,8 @@ Ember.compare('31', '114'); // $ExpectType number
 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',
+  id: 'no-longer-allowed',
+  until: '99.0.0',
 });
 // get
 Ember.get({ z: 23 }, 'z'); // $ExpectType number
@@ -76,16 +76,16 @@ Ember.isPresent(''); // $ExpectType boolean
 Ember.isPresent([]); // $ExpectType boolean
 // observer
 const o2 = Ember.Object.extend({
-    name: 'foo',
-    age: 3,
-    nameWatcher: Ember.observer('name', () => {}),
-    nameWatcher2: Ember.observer('name', 'fullName', () => {}),
+  name: 'foo',
+  age: 3,
+  nameWatcher: Ember.observer('name', () => {}),
+  nameWatcher2: Ember.observer('name', 'fullName', () => {}),
 });
 // on
 const o3 = Ember.Object.extend({
-    name: 'foo',
-    nameWatcher: Ember.on('init', () => {}),
-    nameWatcher2: Ember.on('destroy', () => {}),
+  name: 'foo',
+  nameWatcher: Ember.on('init', () => {}),
+  nameWatcher2: Ember.on('destroy', () => {}),
 });
 // removeListener
 Ember.removeListener(o2, 'create', null, () => {});
@@ -148,7 +148,7 @@ new Ember.ArrayProxy<number>([3, 3, 2]); // $ExpectType ArrayProxy<number>
 // Ember.Component
 const C1 = Ember.Component.extend({ classNames: ['foo'] });
 class C2 extends Ember.Component {
-    classNames = ['foo'];
+  classNames = ['foo'];
 }
 const c1 = new C1();
 const c2 = new C2();
@@ -158,12 +158,12 @@ c1.didInsertElement();
 c2.didInsertElement();
 // Ember.ComputedProperty
 const cp: Ember.ComputedProperty<string, string> = Ember.computed('foo', {
-    get(): string {
-        return '';
-    },
-    set(_key: string, newVal: string): string {
-        return '';
-    },
+  get(): string {
+    return '';
+  },
+  set(_key: string, newVal: string): string {
+    return '';
+  },
 });
 // Ember.ContainerDebugAdapter
 const cda = new Ember.ContainerDebugAdapter(); // $ExpectType ContainerDebugAdapter
@@ -193,18 +193,18 @@ oe1.on('bar', { foo() {} }, () => {});
 const hl = new Ember.HashLocation(); // $ExpectType HashLocation
 // Ember.Helper
 const h1 = Ember.Helper.extend({
-    compute() {
-        this.recompute();
-        return '';
-    },
+  compute() {
+    this.recompute();
+    return '';
+  },
 });
 // Ember.HistoryLocation
 const hil = new Ember.HistoryLocation(); // $ExpectType HistoryLocation
 // Ember.Mixin
 Ember.Object.extend(Ember.Mixin.create({ foo: 'bar' }), {
-    baz() {
-        this.foo; // $ExpectType string
-    },
+  baz() {
+    this.foo; // $ExpectType string
+  },
 });
 // Ember.MutableArray
 const ma1: Ember.MutableArray<string> = ['money', 'in', 'the', 'bananna', 'stand'];
@@ -213,7 +213,11 @@ ma1.addObject('!'); // $ExpectType string
 ma1.filterBy('');
 ma1.firstObject; // $ExpectType string | undefined
 ma1.lastObject; // $ExpectType string | undefined
-const ma2: Ember.MutableArray<{ name: string }> = [{ name: 'chris' }, { name: 'dan' }, { name: 'james' }];
+const ma2: Ember.MutableArray<{ name: string }> = [
+  { name: 'chris' },
+  { name: 'dan' },
+  { name: 'james' },
+];
 ma2.filterBy('name', 'chris'); // $ExpectType NativeArray<{ name: string; }>
 // Ember.MutableEnumerable
 const me1: Ember.MutableEnumerable<string | null | undefined> = ['foo', undefined, null];
@@ -234,10 +238,10 @@ new Ember.ObjectProxy(); // $ExpectType ObjectProxy
 Ember.Object.extend(Ember.Observable, {});
 // Ember.PromiseProxyMixin
 Ember.Object.extend(Ember.PromiseProxyMixin, {
-    foo() {
-        this.reason; // $ExpectType unknown
-        this.isPending; // $ExpectType boolean
-    },
+  foo() {
+    this.reason; // $ExpectType unknown
+    this.isPending; // $ExpectType boolean
+  },
 });
 // Ember.Route
 new Ember.Route();
diff --git a/types/preview/ember/test/engine.ts b/types/preview/ember/test/engine.ts
index 094cbfcc82d..f8ebea2ce65 100755
--- a/types/preview/ember/test/engine.ts
+++ b/types/preview/ember/test/engine.ts
@@ -1,40 +1,41 @@
 import Ember from 'ember';
-import { assertType } from './lib/assert';
 
-const BaseEngine = Ember.Engine.extend({
-    modulePrefix: 'my-engine',
-});
+class BaseEngine extends Ember.Engine {
+  modulePrefix = 'my-engine';
+}
 
-class Obj extends Ember.Object.extend({ foo: 'bar' }) {}
+class Obj extends Ember.Object {
+  foo = 'bar';
+}
 
 BaseEngine.initializer({
-    name: 'my-initializer',
-    initialize(engine) {
-        engine.register('foo:bar', Obj);
-    },
+  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');
-    },
-});
-
-const Engine1 = BaseEngine.create({
-    rootElement: '#engine-one',
-    customEvents: {
-        paste: 'paste',
-    },
+  name: 'my-instance-initializer',
+  initialize(engine) {
+    (engine.lookup('foo:bar') as Obj).get('foo');
+  },
 });
 
-const Engine2 = BaseEngine.create({
-    rootElement: '#engine-two',
-    customEvents: {
-        mouseenter: null,
-        mouseleave: null,
-    },
-});
+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();
 
diff --git a/types/preview/ember/test/inject.ts b/types/preview/ember/test/inject.ts
index 491ad8def50..34858b5ef20 100755
--- a/types/preview/ember/test/inject.ts
+++ b/types/preview/ember/test/inject.ts
@@ -1,4 +1,5 @@
 import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
 
 class AuthService extends Ember.Service {
   declare isAuthenticated: boolean;
@@ -18,13 +19,16 @@ declare module '@ember/service' {
 
 declare module '@ember/controller' {
   interface Registry {
-    application: ApplicationController;
+    emberApplication: ApplicationController;
   }
 }
 
 class LoginRoute extends Ember.Route {
-  auth = Ember.inject.service('auth');
-  application = Ember.inject.controller('application');
+  @Ember.inject.service('auth')
+  declare auth: AuthService;
+
+  @Ember.inject.controller('emberApplication')
+  declare application: ApplicationController;
 
   didTransition() {
     if (!this.get('auth').get('isAuthenticated')) {
@@ -34,24 +38,32 @@ class LoginRoute extends Ember.Route {
 
   anyOldMethod() {
     this.get('application').set('string', 'must be a string');
-    this.controllerFor('application'); // $ExpectType Controller
+    expectTypeOf(this.controllerFor('emberApplication')).toEqualTypeOf<Controller>();
   }
 }
 
 // New module injection style.
-import Controller, { inject as controller } from '@ember/controller';
-import Service, { inject as service } from '@ember/service';
 import { assertType } from './lib/assert';
+import RouterService from '@ember/routing/router-service';
+import Controller from '@ember/controller';
 
 class ComponentInjection extends Ember.Component {
-  applicationController = controller('application');
-  auth = service('auth');
-  router = service('router');
-  misc = service();
+  @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() {
-    assertType<Ember.Service>(this.get('misc'));
-    const url = this.get('router').urlFor('some-route', 1, 2, 3, {
+    expectTypeOf(this.misc).toEqualTypeOf<Ember.Service>();
+
+    const url = this.router.urlFor('some-route', 1, 2, 3, {
       queryParams: { seriously: 'yes' },
     });
     assertType<string>(url);

From a0fd30ad4ea3927e23f0563002a4f2c8fc77f7ab Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Mon, 29 Aug 2022 20:36:16 -0600
Subject: [PATCH 27/39] Ignore a case where Ember.get is distinct from get

While we would prefer this to work, it is not a hard necessity, for (at
least) two reasons:

1. Use of `Ember.get` vs. the import from `@ember/object` is rare and
   should be discouraged.

2. Use of `get` is itself fairly unusual to *need* these days; most
   uses either will not hit this case, as in the deep key lookup (which
   is always just `unknown` anyways) or should be trivially replaced
   with direct property access (since Ember 3.1!).
---
 types/preview/ember/test/object.ts | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/types/preview/ember/test/object.ts b/types/preview/ember/test/object.ts
index edeff03fb92..d9405d4dae8 100755
--- a/types/preview/ember/test/object.ts
+++ b/types/preview/ember/test/object.ts
@@ -65,8 +65,18 @@ export class Foo2 extends Ember.Object {
     // (currently) possible for the type utility to match it.
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const x: string = Ember.set(this, 'name', name);
+
+    // TODO: it would be nice if we can get this to work correctly; it is
+    // unclear why the version on the namespace does *not* work correctly but
+    // the standalone version *does*. However, the Ember namespace should be
+    // little used (and hopefully we will deprecate it soon), and `get` itself
+    // is in much the same bucket: 99% of cases are *either* totally unsafe deep
+    // key access like `get(foo, 'bar.baz.quux')` which we do not support at all
+    // *or* they can be trivially codemodded to direct property access.
+    // @ts-ignore
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const y: string = Ember.get(this, 'name');
+
     this.setProperties({
       name,
     });

From 241a9181007fe07d1a904bc9eb8ab41e6b0ec534 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Tue, 30 Aug 2022 09:29:01 -0600
Subject: [PATCH 28/39] Simplify handling of preview types for get(Properties)

Unlike in the previous pass, this does not try to handle index access
'correctly', instead choosing to just push people to use normal JS if
they want that safety.
---
 types/preview/@ember/object/index.d.ts        | 30 ++------------
 types/preview/@ember/object/test/object.ts    | 40 ++++++++++++-------
 .../preview/@ember/object/test/observable.ts  | 22 +++++-----
 types/preview/ember/test/object.ts            | 31 +++++---------
 types/preview/ember/test/observable.ts        | 20 +++++-----
 5 files changed, 59 insertions(+), 84 deletions(-)

diff --git a/types/preview/@ember/object/index.d.ts b/types/preview/@ember/object/index.d.ts
index 5a6a0370eb9..05a3cbb5129 100644
--- a/types/preview/@ember/object/index.d.ts
+++ b/types/preview/@ember/object/index.d.ts
@@ -33,34 +33,12 @@ export function observer<Fn extends (target: any, key: string) => void>(
   ...args: [...propertyNames: string[], func: Fn]
 ): Fn;
 
-// Allows us to split apart `Record` types which have distinct keys (e.g. using
-// an enum or a union of specific keys) from those which just have an index type
-// and therefore to get the same behavior with `get` and friends as we would
-// when indexing directly with JS.
-// See https://stackoverflow.com/a/68261113/564181
-type RemoveIndex<T> = {
-  [K in keyof T as {} extends Record<K, 1> ? never : K]: T[K];
-};
-
-// Using `RemoveIndex` here then allows us to keep the desired behavior under
-// `noUncheckedIndexedAccess` as direct property access.
-type Get<T, K extends keyof T> = K extends keyof RemoveIndex<T> ? T[K] : T[K] | undefined;
-
-// We do the same here. Additionally, this uses an array type so that we can
-// distribute over each item in the list (accessing with `[number]`) instead of
-// over the list as a union, so that doing an index access gets the type for
-// that specific key rather then a union of the types associated with all the
-// keys.
-type GetProperties<T, Keys extends Array<keyof T>> = {
-  [K in Keys[number]]: Get<T, K>;
-};
-
 /**
  * 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): Get<T, K>;
+export function get<T, K extends keyof T>(obj: T, key: K): T[K];
 export function get(obj: unknown, key: string): unknown;
 
 /**
@@ -69,14 +47,14 @@ export function get(obj: unknown, key: string): unknown;
  * 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>(obj: T, key: K, value: T[K]): T[K];
+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 Array<keyof T>>(obj: T, list: K): GetProperties<T, K>;
-export function getProperties<T, K extends Array<keyof T>>(obj: T, ...list: K): GetProperties<T, K>;
+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
diff --git a/types/preview/@ember/object/test/object.ts b/types/preview/@ember/object/test/object.ts
index 44abefa12fa..1ff499ba089 100644
--- a/types/preview/@ember/object/test/object.ts
+++ b/types/preview/@ember/object/test/object.ts
@@ -40,9 +40,18 @@ class Foo extends Object {
   b = 5;
 
   baz() {
-    const y = this.b; // $ExpectType number
-    const z = this.a; // $ExpectType ComputedProperty<string, string>
+    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');
+
     this.get('b').toFixed(4); // $ExpectType string
     this.set('a', 'abc').split(','); // $ExpectType string[]
     this.set('b', 10).toFixed(4); // $ExpectType string
@@ -60,20 +69,21 @@ export class Foo2 extends Object {
   name = '';
 
   changeName(name: string) {
-    expectTypeOf(this.set('name', name)).toEqualTypeOf<string>();
-    // This is checking for assignability; `expectTypeOf` doesn't work correctly
-    // here because TS isn't resolving `this['name']` eagerly, and so it is not
-    // (currently) possible for the type utility to match it.
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const x: string = set(this, 'name', name);
+    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 y: string = get(this, 'name');
-    this.setProperties({
-      name,
-    });
-    setProperties(this, {
-      name,
-    });
+    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() {
diff --git a/types/preview/@ember/object/test/observable.ts b/types/preview/@ember/object/test/observable.ts
index 11fb46016d5..cec5a0f11c5 100644
--- a/types/preview/@ember/object/test/observable.ts
+++ b/types/preview/@ember/object/test/observable.ts
@@ -63,11 +63,9 @@ function testGetProperties() {
     name: string;
     age: number;
   }>();
-  expectTypeOf(getProperties(person, 'name', 'age', 'capitalized')).toEqualTypeOf<{
-    name: string;
-    age: number;
-    capitalized: string;
-  }>();
+  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<{
@@ -115,14 +113,12 @@ function testDynamic() {
   const obj: Record<string, string> = {};
   const dynamicKey = 'dummy' as string;
 
-  expectTypeOf(get(obj, 'dummy')).toEqualTypeOf<string | undefined>();
-  expectTypeOf(get(obj, dynamicKey)).toEqualTypeOf<string | undefined>();
-  expectTypeOf(getProperties(obj, 'dummy')).toEqualTypeOf<{ dummy: string | undefined }>();
-  expectTypeOf(getProperties(obj, ['dummy'])).toEqualTypeOf<{ dummy: string | undefined }>();
-  expectTypeOf(getProperties(obj, dynamicKey)).toEqualTypeOf<Record<string, string | undefined>>();
-  expectTypeOf(getProperties(obj, [dynamicKey])).toEqualTypeOf<
-    Record<string, string | undefined>
-  >();
+  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>>();
diff --git a/types/preview/ember/test/object.ts b/types/preview/ember/test/object.ts
index d9405d4dae8..e3f4a6cfaec 100755
--- a/types/preview/ember/test/object.ts
+++ b/types/preview/ember/test/object.ts
@@ -60,29 +60,20 @@ export class Foo2 extends Ember.Object {
   name = '';
 
   changeName(name: string) {
-    // This is checking for assignability; `expectTypeOf` doesn't work correctly
-    // here because TS isn't resolving `this['name']` eagerly, and so it is not
-    // (currently) possible for the type utility to match it.
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const x: string = Ember.set(this, 'name', name);
+    expectTypeOf(Ember.set(this, 'name', name)).toBeString();
 
-    // TODO: it would be nice if we can get this to work correctly; it is
-    // unclear why the version on the namespace does *not* work correctly but
-    // the standalone version *does*. However, the Ember namespace should be
-    // little used (and hopefully we will deprecate it soon), and `get` itself
-    // is in much the same bucket: 99% of cases are *either* totally unsafe deep
-    // key access like `get(foo, 'bar.baz.quux')` which we do not support at all
-    // *or* they can be trivially codemodded to direct property access.
-    // @ts-ignore
+    // 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 y: string = Ember.get(this, 'name');
+    const s: string = this.get('name');
+    expectTypeOf(Ember.get(this as Foo2, 'name')).toBeString();
+    expectTypeOf((this as Foo2).get('name')).toBeString();
 
-    this.setProperties({
-      name,
-    });
-    Ember.setProperties(this, {
-      name,
-    });
+    expectTypeOf(this.setProperties({ name })).toEqualTypeOf<Pick<this, 'name'>>();
+    expectTypeOf(Ember.setProperties(this, { name })).toEqualTypeOf<Pick<this, 'name'>>();
   }
 
   bar() {
diff --git a/types/preview/ember/test/observable.ts b/types/preview/ember/test/observable.ts
index 1707e9ed58e..c2371d8f789 100755
--- a/types/preview/ember/test/observable.ts
+++ b/types/preview/ember/test/observable.ts
@@ -109,16 +109,16 @@ function testDynamic() {
   const obj: Record<string, string> = {};
   const dynamicKey = 'dummy' as string;
 
-  expectTypeOf(Ember.get(obj, 'dummy')).toEqualTypeOf<string | undefined>();
-  expectTypeOf(Ember.get(obj, dynamicKey)).toEqualTypeOf<string | undefined>();
-  expectTypeOf(Ember.getProperties(obj, 'dummy')).toEqualTypeOf<{ dummy: string | undefined }>();
-  expectTypeOf(Ember.getProperties(obj, ['dummy'])).toEqualTypeOf<{ dummy: string | undefined }>();
-  expectTypeOf(Ember.getProperties(obj, dynamicKey)).toEqualTypeOf<
-    Record<string, string | undefined>
-  >();
-  expectTypeOf(Ember.getProperties(obj, [dynamicKey])).toEqualTypeOf<
-    Record<string, string | undefined>
-  >();
+  // 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<

From d7667a508d76189336952a7ea113f8e0b2415afe Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Tue, 30 Aug 2022 17:03:02 -0600
Subject: [PATCH 29/39] Finish getting preview types type checking

- fix runloop test
- provide an internal-only type for Resolver` that should be
  compatible with the one in `@types/ember-resolver`
---
 types/preview/@ember/-internals/resolver.d.ts | 33 +++++++
 types/preview/@ember/application/index.d.ts   |  2 +-
 .../@ember/debug/container-debug-adapter.d.ts |  2 +-
 types/preview/@ember/engine/index.d.ts        | 24 +----
 .../@ember/runloop/ember__runloop-tests.ts    | 64 ++++++------
 types/preview/ember/index.d.ts                |  1 +
 .../ember/test/application-instance.ts        |  4 +-
 .../preview/ember/test/ember-module-tests.ts  | 97 +++++++++++--------
 types/preview/ember/test/run.ts               |  8 +-
 9 files changed, 138 insertions(+), 97 deletions(-)
 create mode 100644 types/preview/@ember/-internals/resolver.d.ts

diff --git a/types/preview/@ember/-internals/resolver.d.ts b/types/preview/@ember/-internals/resolver.d.ts
new file mode 100644
index 00000000000..715f3f0168d
--- /dev/null
+++ b/types/preview/@ember/-internals/resolver.d.ts
@@ -0,0 +1,33 @@
+/**
+ * @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/index.d.ts b/types/preview/@ember/application/index.d.ts
index bc0826caeac..3a2265ac053 100644
--- a/types/preview/@ember/application/index.d.ts
+++ b/types/preview/@ember/application/index.d.ts
@@ -4,7 +4,7 @@ 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 { Resolver } from '@ember/engine';
+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';
diff --git a/types/preview/@ember/debug/container-debug-adapter.d.ts b/types/preview/@ember/debug/container-debug-adapter.d.ts
index 7789b086d1f..d8528cc934b 100644
--- a/types/preview/@ember/debug/container-debug-adapter.d.ts
+++ b/types/preview/@ember/debug/container-debug-adapter.d.ts
@@ -1,4 +1,4 @@
-import Resolver from 'ember-resolver';
+import type { Resolver} from '@ember/-internals/resolver';
 
 /**
  * The ContainerDebugAdapter helps the container and resolver interface
diff --git a/types/preview/@ember/engine/index.d.ts b/types/preview/@ember/engine/index.d.ts
index 130449d87de..03e729f808a 100644
--- a/types/preview/@ember/engine/index.d.ts
+++ b/types/preview/@ember/engine/index.d.ts
@@ -2,29 +2,7 @@ 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 { Factory, FullName } from '@ember/owner';
-
-export type KnownForTypeResult<Type extends string> = {
-  [fullName in `${Type}:${string}`]: boolean | undefined;
-};
-
-/**
- * A `Resolver` 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 {
-  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;
-}
+import type { Resolver} from '@ember/-internals/resolver';
 
 /**
  * The `Engine` class contains core functionality for both applications and
diff --git a/types/preview/@ember/runloop/ember__runloop-tests.ts b/types/preview/@ember/runloop/ember__runloop-tests.ts
index 5192db4bcae..a36e1b46ac9 100644
--- a/types/preview/@ember/runloop/ember__runloop-tests.ts
+++ b/types/preview/@ember/runloop/ember__runloop-tests.ts
@@ -15,7 +15,7 @@ import {
   // private, supported via `declare module` below
   _backburner
 } from '@ember/runloop';
-import EmberObject from '@ember/object';
+import EmberObject, { action } from '@ember/object';
 import { 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
@@ -61,19 +61,21 @@ function testRun() {
     }
 }
 
-function testBind() {
-    EmberObject.extend({
-        init() {
-            const bound = bind(this, this.setupEditor);
-            bound();
-        },
-
-        editor: null as string | null,
-
-        setupEditor(editor: string) {
-            this.set('editor', editor);
-        }
-    });
+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() {
@@ -158,17 +160,23 @@ function testDebounce() {
     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) {},
 
-        actions: {
-            handleTyping() {
-                // the fetchResults function is passed into the component from its parent
-                debounce(this, this.get('fetchResults'), this.get('searchValue'), 250);
-            }
-        }
+        
     });
 }
 
@@ -215,17 +223,17 @@ function testNext() {
     });
 }
 
-function testOnce() {
-    EmberObject.extend({
-        init() {
-            once(this, 'processFullName');
-        },
+class TestOnce extends EmberObject {
+  init() {
+      once(this as TestOnce, 'processFullName');
+      once(this, this.processFullName);
+  }
 
-        processFullName() {
-        }
-    });
+  processFullName() {
+  }
 }
 
+
 function testSchedule() {
     EmberObject.extend({
         init() {
diff --git a/types/preview/ember/index.d.ts b/types/preview/ember/index.d.ts
index c2fdf3e1af8..81f76ca76f1 100755
--- a/types/preview/ember/index.d.ts
+++ b/types/preview/ember/index.d.ts
@@ -123,6 +123,7 @@ export namespace Ember {
   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: {
diff --git a/types/preview/ember/test/application-instance.ts b/types/preview/ember/test/application-instance.ts
index e8893defbf8..ecff4b7b087 100644
--- a/types/preview/ember/test/application-instance.ts
+++ b/types/preview/ember/test/application-instance.ts
@@ -1,5 +1,4 @@
 import ApplicationInstance from '@ember/application/instance';
-import hbs from 'htmlbars-inline-precompile';
 
 const appInstance = ApplicationInstance.create();
 appInstance.register('some:injection', class Foo {});
@@ -12,7 +11,8 @@ appInstance.register('some:injection', class Foo {}, {
   instantiate: false,
 });
 
-appInstance.register('templates:foo/bar', hbs`<h1>Hello World</h1>`);
+// 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,
diff --git a/types/preview/ember/test/ember-module-tests.ts b/types/preview/ember/test/ember-module-tests.ts
index 89d645a63de..b4953f4948c 100644
--- a/types/preview/ember/test/ember-module-tests.ts
+++ b/types/preview/ember/test/ember-module-tests.ts
@@ -1,4 +1,5 @@
 import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
 
 const top = (<T>(x?: T): T => x!)();
 type Top = typeof top;
@@ -75,43 +76,49 @@ Ember.isNone([]); // $ExpectType boolean
 Ember.isPresent(''); // $ExpectType boolean
 Ember.isPresent([]); // $ExpectType boolean
 // observer
-const o2 = Ember.Object.extend({
+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,
-  nameWatcher: Ember.observer('name', () => {}),
-  nameWatcher2: Ember.observer('name', 'fullName', () => {}),
 });
 // on
-const o3 = Ember.Object.extend({
-  name: 'foo',
-  nameWatcher: Ember.on('init', () => {}),
-  nameWatcher2: Ember.on('destroy', () => {}),
-});
+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');
+Ember.removeListener(O2, 'create', null, () => {});
+Ember.removeListener(O2, 'create', null, 'create');
 // @ts-expect-error
 Ember.removeListener({}, 'create', null, 'blah');
 // removeObserver
-Ember.removeObserver(o2, 'create', () => {});
+Ember.removeObserver(O2, 'create', () => {});
 // @ts-expect-error
 Ember.removeObserver({}, 'create', () => {});
 // runInDebug
 Ember.runInDebug(() => {});
 // sendEvent
-Ember.sendEvent(o2, 'clicked', [1, 2]); // $ExpectType boolean
+expectTypeOf(Ember.sendEvent(o2, 'clicked', [1, 2])).toBeBoolean();
 // set
-Ember.set(o2.create(), 'name', 'bar'); // $ExpectType string
-Ember.set(o2.create(), 'age', 4); // $ExpectType number
+Ember.set(O2.create(), 'name', 'bar'); // $ExpectType string
+Ember.set(O2.create(), 'age', 4); // $ExpectType number
 // @ts-expect-error
-Ember.set(o2.create(), 'nam', 'bar');
+Ember.set(O2.create(), 'nam', 'bar');
 // setOwner
 declare let app: Ember.ApplicationInstance;
-Ember.setOwner(o2.create(), app);
+Ember.setOwner(O2.create(), app);
 // setProperties
-Ember.setProperties(o2.create(), { name: 'bar' }).name; // $ExpectType string
+Ember.setProperties(O2.create(), { name: 'bar' }).name; // $ExpectType string
 // trySet
-Ember.trySet(o2, 'nam', ''); // $ExpectType any
+Ember.trySet(O2, 'nam', ''); // $ExpectType any
 // typeOf
 Ember.typeOf(''); // $ExpectType "string"
 Ember.typeOf(Ember.A()); // $ExpectType "array"
@@ -156,15 +163,20 @@ C1.create();
 C2.create();
 c1.didInsertElement();
 c2.didInsertElement();
-// Ember.ComputedProperty
-const cp: Ember.ComputedProperty<string, string> = Ember.computed('foo', {
-  get(): string {
-    return '';
-  },
-  set(_key: string, newVal: string): string {
-    return '';
-  },
-});
+
+class Foo {
+  foo = '';
+  
+  @Ember.computed('foo')
+  get wat(): string {
+    return this.foo
+  }
+  
+  set wat(newValue: string) {
+    this.foo = newValue;
+  }
+}
+
 // Ember.ContainerDebugAdapter
 const cda = new Ember.ContainerDebugAdapter(); // $ExpectType ContainerDebugAdapter
 // Ember.Controller
@@ -185,27 +197,33 @@ ei1.lookup('data:foo');
 // Ember.Error
 new Ember.Error('Halp!');
 // Ember.Evented
-const oe1 = Ember.Object.extend(Ember.Evented).create();
+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(); // $ExpectType HashLocation
 // Ember.Helper
-const h1 = Ember.Helper.extend({
+class H1 extends Ember.Helper {
   compute() {
     this.recompute();
     return '';
-  },
-});
+  }
+}
 // Ember.HistoryLocation
-const hil = new Ember.HistoryLocation(); // $ExpectType HistoryLocation
+const hil = Ember.HistoryLocation.create();
+expectTypeOf(hil).toEqualTypeOf<Ember.HistoryLocation>();
 // Ember.Mixin
-Ember.Object.extend(Ember.Mixin.create({ foo: 'bar' }), {
+interface UsesMixin {
+  foo: string
+}
+class UsesMixin extends Ember.Object {
   baz() {
-    this.foo; // $ExpectType string
-  },
-});
+    expectTypeOf(this.foo).toBeString();
+  }
+}
 // Ember.MutableArray
 const ma1: Ember.MutableArray<string> = ['money', 'in', 'the', 'bananna', 'stand'];
 ma1.addObject('!'); // $ExpectType string
@@ -237,12 +255,13 @@ new Ember.ObjectProxy(); // $ExpectType ObjectProxy
 // Ember.Observable
 Ember.Object.extend(Ember.Observable, {});
 // Ember.PromiseProxyMixin
-Ember.Object.extend(Ember.PromiseProxyMixin, {
+interface PPM<T> extends Ember.PromiseProxyMixin<T> {}
+class PPM<T> extends Ember.Object.extend(Ember.PromiseProxyMixin) {
   foo() {
     this.reason; // $ExpectType unknown
     this.isPending; // $ExpectType boolean
-  },
-});
+  }
+}
 // Ember.Route
 new Ember.Route();
 // Ember.Router
diff --git a/types/preview/ember/test/run.ts b/types/preview/ember/test/run.ts
index aa86a35ddc2..2bebd3e019e 100755
--- a/types/preview/ember/test/run.ts
+++ b/types/preview/ember/test/run.ts
@@ -160,12 +160,14 @@ function testNext() {
   });
 }
 
-class TestOnce extends Ember.Component {
+class TestOnce extends Ember.Object {
   init() {
-    Ember.run.once(this, 'processFullName');
+      Ember.run.once(this as TestOnce, 'processFullName');
+      Ember.run.once(this, this.processFullName);
   }
 
-  processFullName() {}
+  processFullName() {
+  }
 }
 
 {

From 225c291060c5ca630cee019d6624ec1a28182dcb Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Tue, 30 Aug 2022 17:03:19 -0600
Subject: [PATCH 30/39] Run Prettier on types/preview directory

---
 types/preview/@ember/-internals/resolver.d.ts |   4 +-
 .../-private/event-dispatcher.d.ts            |  12 +-
 .../@ember/application/-private/registry.d.ts |   6 +-
 .../@ember/application/test/deprecations.ts   |  10 +-
 .../preview/@ember/application/test/index.ts  |   2 +-
 types/preview/@ember/application/types.d.ts   |  50 +-
 types/preview/@ember/array/test/array-ext.ts  |   8 +-
 .../@ember/component/template-only.d.ts       |   2 +-
 .../@ember/component/test/template-only.ts    |  16 +-
 .../@ember/debug/container-debug-adapter.d.ts |   2 +-
 types/preview/@ember/debug/data-adapter.d.ts  | 104 +-
 .../@ember/debug/ember__debug-tests.ts        | 122 ++-
 types/preview/@ember/destroyable/test/main.ts |  82 +-
 .../engine/-private/types/initializer.d.ts    |   8 +-
 types/preview/@ember/engine/index.d.ts        |   2 +-
 .../@ember/engine/test/engine-instance.ts     |  10 +-
 .../@ember/error/ember__error-tests.ts        |   3 +-
 types/preview/@ember/object/events.d.ts       |  38 +-
 types/preview/@ember/object/observers.d.ts    |  30 +-
 .../@ember/object/test/access-modifier.ts     |  18 +-
 types/preview/@ember/object/test/compat.ts    |  12 +-
 .../@ember/owner/ember__owner-tests.ts        |  38 +-
 .../polyfills/ember__polyfills-tests.ts       |  36 +-
 .../@ember/routing/-private/router-dsl.d.ts   |  32 +-
 .../preview/@ember/routing/auto-location.d.ts |   2 +-
 .../preview/@ember/routing/hash-location.d.ts |   2 +-
 .../@ember/routing/history-location.d.ts      |   2 +-
 .../preview/@ember/routing/none-location.d.ts |   2 +-
 types/preview/@ember/routing/route-info.d.ts  | 102 +-
 types/preview/@ember/routing/route.d.ts       | 973 +++++++++---------
 .../@ember/routing/router-service.d.ts        | 658 ++++++------
 types/preview/@ember/routing/router.d.ts      |  66 +-
 .../@ember/routing/test/router-service.ts     |  16 +-
 types/preview/@ember/routing/transition.d.ts  | 220 ++--
 types/preview/@ember/routing/types.d.ts       |  16 +-
 .../@ember/runloop/-private/backburner.d.ts   |  58 +-
 .../@ember/runloop/-private/types.d.ts        |   8 +-
 .../@ember/runloop/ember__runloop-tests.ts    | 397 +++----
 types/preview/@ember/runloop/types.d.ts       |   2 +-
 .../@ember/template/ember__template-tests.ts  |   8 +-
 types/preview/@ember/test/adapter.d.ts        |  28 +-
 .../preview/@ember/test/ember__test-tests.ts  |  44 +-
 types/preview/ember/test/application.ts       |  36 +-
 types/preview/ember/test/array-ext.ts         |   6 +-
 types/preview/ember/test/debug.ts             |  86 +-
 .../preview/ember/test/ember-module-tests.ts  |  12 +-
 types/preview/ember/test/engine-instance.ts   |  10 +-
 types/preview/ember/test/run.ts               |   7 +-
 .../test/techniques/properties-from-this.ts   |  44 +-
 types/preview/ember/test/test.ts              |  26 +-
 types/preview/ember/test/view-utils.ts        |   2 +-
 51 files changed, 1762 insertions(+), 1718 deletions(-)

diff --git a/types/preview/@ember/-internals/resolver.d.ts b/types/preview/@ember/-internals/resolver.d.ts
index 715f3f0168d..a32bc036942 100644
--- a/types/preview/@ember/-internals/resolver.d.ts
+++ b/types/preview/@ember/-internals/resolver.d.ts
@@ -9,11 +9,11 @@
 
 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,
diff --git a/types/preview/@ember/application/-private/event-dispatcher.d.ts b/types/preview/@ember/application/-private/event-dispatcher.d.ts
index 3df6d612ad7..3f72b1653b4 100644
--- a/types/preview/@ember/application/-private/event-dispatcher.d.ts
+++ b/types/preview/@ember/application/-private/event-dispatcher.d.ts
@@ -7,10 +7,10 @@ import { EventDispatcherEvents } from '@ember/application/types';
  * 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;
+  /**
+   * 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
index dc5ca32d531..60604ceae87 100644
--- a/types/preview/@ember/application/-private/registry.d.ts
+++ b/types/preview/@ember/application/-private/registry.d.ts
@@ -5,5 +5,9 @@ import { EmberClassConstructor } from '@ember/object/-private/types';
  * by type.
  */
 export default class Registry {
-    register(fullName: string, factory: EmberClassConstructor<unknown>, options?: { singleton?: boolean | undefined }): void;
+  register(
+    fullName: string,
+    factory: EmberClassConstructor<unknown>,
+    options?: { singleton?: boolean | undefined }
+  ): void;
 }
diff --git a/types/preview/@ember/application/test/deprecations.ts b/types/preview/@ember/application/test/deprecations.ts
index e9bb19ed390..414e38af111 100644
--- a/types/preview/@ember/application/test/deprecations.ts
+++ b/types/preview/@ember/application/test/deprecations.ts
@@ -1,13 +1,13 @@
 import { deprecate, deprecateFunc } from '@ember/application/deprecations';
 
 deprecate('this is no longer advised', false, {
-    id: 'no-longer-advised',
-    until: 'v4.0',
+  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',
+  id: 'no-longer-advised',
+  until: 'v4.0',
+  url: 'https://emberjs.com',
 });
 // @ts-expect-error
 deprecate('this is no longer advised', false);
diff --git a/types/preview/@ember/application/test/index.ts b/types/preview/@ember/application/test/index.ts
index 521a4b6936d..f04751e2290 100644
--- a/types/preview/@ember/application/test/index.ts
+++ b/types/preview/@ember/application/test/index.ts
@@ -9,7 +9,7 @@ getOwner({});
 
 // Confirm that random subclasses work as expected.
 declare class MyService extends Service {
-    withStuff: true;
+  withStuff: true;
 }
 declare let myService: MyService;
 // $ExpectType Owner
diff --git a/types/preview/@ember/application/types.d.ts b/types/preview/@ember/application/types.d.ts
index f03863c4d29..75e3f6d8487 100644
--- a/types/preview/@ember/application/types.d.ts
+++ b/types/preview/@ember/application/types.d.ts
@@ -1,27 +1,27 @@
 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;
+  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/test/array-ext.ts b/types/preview/@ember/array/test/array-ext.ts
index d4fa40cf36c..beeba72a113 100755
--- a/types/preview/@ember/array/test/array-ext.ts
+++ b/types/preview/@ember/array/test/array-ext.ts
@@ -3,11 +3,11 @@ import EmberObject from '@ember/object';
 import ArrayPrototypeExtensions from '@ember/array/types/prototype-extensions';
 
 declare global {
-    interface Array<T> extends ArrayPrototypeExtensions<T> {}
+  interface Array<T> extends ArrayPrototypeExtensions<T> {}
 }
 
 class Person extends EmberObject {
-    declare name: string;
+  declare name: string;
 }
 
 const person = Person.create({ name: 'Joe' });
@@ -16,8 +16,8 @@ const array = [person];
 assertType<number>(array.get('length'));
 assertType<Person | undefined>(array.get('firstObject'));
 assertType<string[]>(array.mapBy('name'));
-assertType<string[]>(array.map(p => p.get('name')));
+assertType<string[]>(array.map((p) => p.get('name')));
 assertType<Person[]>(array.sortBy('name'));
 assertType<Person[]>(array.uniq());
 assertType<Person[]>(array.uniqBy('name'));
-assertType<Person[]>(array.uniqBy(p => p.get('name')));
+assertType<Person[]>(array.uniqBy((p) => p.get('name')));
diff --git a/types/preview/@ember/component/template-only.d.ts b/types/preview/@ember/component/template-only.d.ts
index 6f652be7b20..853d3a0e1c9 100644
--- a/types/preview/@ember/component/template-only.d.ts
+++ b/types/preview/@ember/component/template-only.d.ts
@@ -29,7 +29,7 @@ import { Opaque } from 'ember/-private/type-utils';
  * the template.
  */
 export interface TemplateOnlyComponent<S = unknown> extends Opaque<S> {
-    toString(): string;
+  toString(): string;
 }
 
 /**
diff --git a/types/preview/@ember/component/test/template-only.ts b/types/preview/@ember/component/test/template-only.ts
index ce494a181a8..6a9e0d01c19 100644
--- a/types/preview/@ember/component/test/template-only.ts
+++ b/types/preview/@ember/component/test/template-only.ts
@@ -8,14 +8,14 @@ to.toString(); // $ExpectType string
 new TemplateOnlyComponent();
 
 interface MySig {
-    Element: HTMLAnchorElement;
-    Args: {
-        name: string;
-        age: number;
-    };
-    Blocks: {
-        default: [(newName: string) => void];
-    };
+  Element: HTMLAnchorElement;
+  Args: {
+    name: string;
+    age: number;
+  };
+  Blocks: {
+    default: [(newName: string) => void];
+  };
 }
 
 // $ExpectType TemplateOnlyComponent<MySig>
diff --git a/types/preview/@ember/debug/container-debug-adapter.d.ts b/types/preview/@ember/debug/container-debug-adapter.d.ts
index d8528cc934b..d0f9c8aa6ae 100644
--- a/types/preview/@ember/debug/container-debug-adapter.d.ts
+++ b/types/preview/@ember/debug/container-debug-adapter.d.ts
@@ -1,4 +1,4 @@
-import type { Resolver} from '@ember/-internals/resolver';
+import type { Resolver } from '@ember/-internals/resolver';
 
 /**
  * The ContainerDebugAdapter helps the container and resolver interface
diff --git a/types/preview/@ember/debug/data-adapter.d.ts b/types/preview/@ember/debug/data-adapter.d.ts
index 9ed2f3c7515..6dcae185384 100644
--- a/types/preview/@ember/debug/data-adapter.d.ts
+++ b/types/preview/@ember/debug/data-adapter.d.ts
@@ -1,24 +1,24 @@
-import ContainerDebugAdapter from "@ember/debug/container-debug-adapter";
-import EmberObject from "@ember/object";
+import ContainerDebugAdapter from '@ember/debug/container-debug-adapter';
+import EmberObject from '@ember/object';
 
 declare 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;
-    }
+  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;
+  }
 }
 
 /**
@@ -26,37 +26,37 @@ declare namespace DataAdapter {
  * 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;
+  /**
+   * 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/ember__debug-tests.ts b/types/preview/@ember/debug/ember__debug-tests.ts
index 9df7cf532de..3a803dae675 100644
--- a/types/preview/@ember/debug/ember__debug-tests.ts
+++ b/types/preview/@ember/debug/ember__debug-tests.ts
@@ -1,11 +1,11 @@
 import {
-    runInDebug,
-    warn,
-    debug,
-    assert,
-    registerWarnHandler,
-    registerDeprecationHandler,
-    deprecate,
+  runInDebug,
+  warn,
+  debug,
+  assert,
+  registerWarnHandler,
+  registerDeprecationHandler,
+  deprecate,
 } from '@ember/debug';
 
 /**
@@ -23,8 +23,9 @@ warn('Too many tomsters!', { id: 'some-warning' }); // $ExpectType void
 // @ts-expect-error
 warn('Too many tomsters!', tomsterCount <= 3);
 warn('Too many tomsters!', tomsterCount <= 3, { id: 'some-warning' }); // $ExpectType void
-warn('Too many tomsters!', tomsterCount <= 3, { // $ExpectType void
-    id: 'ember-debug.too-many-tomsters'
+warn('Too many tomsters!', tomsterCount <= 3, {
+  // $ExpectType void
+  id: 'ember-debug.too-many-tomsters',
 });
 
 // @ts-expect-error
@@ -56,52 +57,60 @@ assert();
 // @ts-expect-error
 registerWarnHandler();
 registerWarnHandler(() => {}); // $ExpectType void
-registerWarnHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; } | undefined
-    next; // $ExpectType (message: string, options?: { id: string; } | undefined) => void
-});
-registerWarnHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; } | undefined
-    // @ts-expect-error
-    next();
+registerWarnHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; } | undefined
+  next; // $ExpectType (message: string, options?: { id: string; } | undefined) => void
+});
+registerWarnHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; } | undefined
+  // @ts-expect-error
+  next();
 });
-registerWarnHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; } | undefined
-    next(message); // $ExpectType void
+registerWarnHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; } | undefined
+  next(message); // $ExpectType void
 });
-registerWarnHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; } | undefined
-    next(message, options); // $ExpectType void
+registerWarnHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; } | undefined
+  next(message, options); // $ExpectType void
 });
 
 // next is not called, so no warnings get the default behavior
 // @ts-expect-error
 registerDeprecationHandler();
 registerDeprecationHandler(() => {}); // $ExpectType void
-registerDeprecationHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; until: string; } | undefined
-    next; // $ExpectType (message: string, options?: { id: string; until: string; } | undefined) => void
-});
-registerDeprecationHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; until: string; } | undefined
-    // @ts-expect-error
-    next();
+registerDeprecationHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; until: string; } | undefined
+  next; // $ExpectType (message: string, options?: { id: string; until: string; } | undefined) => void
+});
+registerDeprecationHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; until: string; } | undefined
+  // @ts-expect-error
+  next();
 });
-registerDeprecationHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; until: string; } | undefined
-    next(message); // $ExpectType void
+registerDeprecationHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; until: string; } | undefined
+  next(message); // $ExpectType void
 });
-registerDeprecationHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; until: string; } | undefined
-    next(message, options); // $ExpectType void
+registerDeprecationHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; until: string; } | undefined
+  next(message, options); // $ExpectType void
 });
 
 // @ts-expect-error
@@ -118,7 +127,8 @@ deprecate('missing options body', true, {});
 deprecate('missing options id', true, { until: 'v4.0.0' });
 // @ts-expect-error
 deprecate('missing options until', true, { id: 'some.deprecation' });
-deprecate('a valid deprecation without `url`', true, { // $ExpectType void
+deprecate('a valid deprecation without `url`', true, {
+  // $ExpectType void
   id: 'some.deprecation',
   until: 'v4.0.0',
   for: 'some.namespace',
@@ -138,7 +148,8 @@ deprecate('incorrect options `url`', true, {
     enabled: 'some.version',
   },
 });
-deprecate('a valid deprecation with `url`', true, { // $ExpectType void
+deprecate('a valid deprecation with `url`', true, {
+  // $ExpectType void
   id: 'some.deprecation',
   until: 'v4.0.0',
   url: 'https://example.com/ember-deprecations-yo',
@@ -148,7 +159,8 @@ deprecate('a valid deprecation with `url`', true, { // $ExpectType void
     enabled: 'some.version',
   },
 });
-deprecate('a valid deprecation with `for`', true, { // $ExpectType void
+deprecate('a valid deprecation with `for`', true, {
+  // $ExpectType void
   id: 'some.deprecation',
   until: 'v4.0.0',
   for: 'some.namespace',
@@ -167,7 +179,8 @@ deprecate('incorrect options `for`', true, {
     enabled: 'some.version',
   },
 });
-deprecate('a valid deprecation with `since`', true, { // $ExpectType void
+deprecate('a valid deprecation with `since`', true, {
+  // $ExpectType void
   id: 'some.deprecation',
   until: 'v4.0.0',
   for: 'some.namespace',
@@ -175,7 +188,8 @@ deprecate('a valid deprecation with `since`', true, { // $ExpectType void
     available: 'some.version',
   },
 });
-deprecate('a valid deprecation with `since`', true, { // $ExpectType void
+deprecate('a valid deprecation with `since`', true, {
+  // $ExpectType void
   id: 'some.deprecation',
   until: 'v4.0.0',
   for: 'some.namespace',
@@ -214,9 +228,9 @@ deprecate('incorrect options `since` enabled', true, {
   until: 'v4.0.0',
   for: 'some.namespace',
   since: {
-      available: 'some.earlier.version',
-      // @ts-expect-error
-      enabled: 123,
+    available: 'some.earlier.version',
+    // @ts-expect-error
+    enabled: 123,
   },
 });
 deprecate('incorrect options `since` empty', true, {
@@ -232,6 +246,6 @@ deprecate('incorrect options `since` enabled w/o available', true, {
   for: 'some.namespace',
   // @ts-expect-error
   since: {
-      enabled: 'some.version',
+    enabled: 'some.version',
   },
 });
diff --git a/types/preview/@ember/destroyable/test/main.ts b/types/preview/@ember/destroyable/test/main.ts
index 4c5e3619045..c852d7c303d 100644
--- a/types/preview/@ember/destroyable/test/main.ts
+++ b/types/preview/@ember/destroyable/test/main.ts
@@ -1,12 +1,12 @@
 import {
-    assertDestroyablesDestroyed,
-    associateDestroyableChild,
-    destroy,
-    enableDestroyableTracking,
-    isDestroyed,
-    isDestroying,
-    registerDestructor,
-    unregisterDestructor
+  assertDestroyablesDestroyed,
+  associateDestroyableChild,
+  destroy,
+  enableDestroyableTracking,
+  isDestroyed,
+  isDestroying,
+  registerDestructor,
+  unregisterDestructor,
 } from '@ember/destroyable';
 
 import { assertType } from './lib/assert';
@@ -22,45 +22,45 @@ 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);
-    }
+  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;
-    }
+  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);
-    }
+  keepForever() {
+    // @ts-expect-error
+    unregisterDestructor();
+    // @ts-expect-error
+    unregisterDestructor(this);
+    // @ts-expect-error
+    unregisterDestructor(this.stateDestructor);
+    unregisterDestructor(this, this.stateDestructor);
+  }
 }
 
 class Parent {
-    child: object;
+  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);
-    }
+  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();
diff --git a/types/preview/@ember/engine/-private/types/initializer.d.ts b/types/preview/@ember/engine/-private/types/initializer.d.ts
index 515c89f5194..2a7f29ccb85 100644
--- a/types/preview/@ember/engine/-private/types/initializer.d.ts
+++ b/types/preview/@ember/engine/-private/types/initializer.d.ts
@@ -1,6 +1,6 @@
 export default interface Initializer<T> {
-    name: string;
-    before?: string[] | undefined;
-    after?: string[] | undefined;
-    initialize(application: T): void;
+  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
index 03e729f808a..6cae348a092 100644
--- a/types/preview/@ember/engine/index.d.ts
+++ b/types/preview/@ember/engine/index.d.ts
@@ -2,7 +2,7 @@ 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';
+import type { Resolver } from '@ember/-internals/resolver';
 
 /**
  * The `Engine` class contains core functionality for both applications and
diff --git a/types/preview/@ember/engine/test/engine-instance.ts b/types/preview/@ember/engine/test/engine-instance.ts
index 2663ba996ff..eaec71e5722 100644
--- a/types/preview/@ember/engine/test/engine-instance.ts
+++ b/types/preview/@ember/engine/test/engine-instance.ts
@@ -4,16 +4,16 @@ const engineInstance = EngineInstance.create();
 engineInstance.register('some:injection', class Foo {});
 
 engineInstance.register('some:injection', class Foo {}, {
-    singleton: true,
+  singleton: true,
 });
 
 engineInstance.register('some:injection', class Foo {}, {
-    instantiate: false,
+  instantiate: false,
 });
 
 engineInstance.register('some:injection', class Foo {}, {
-    singleton: false,
-    instantiate: true,
+  singleton: false,
+  instantiate: true,
 });
 
 engineInstance.factoryFor('router:main');
@@ -22,5 +22,5 @@ engineInstance.lookup('route:basic');
 engineInstance.boot();
 
 (async () => {
-    await engineInstance.boot();
+  await engineInstance.boot();
 })();
diff --git a/types/preview/@ember/error/ember__error-tests.ts b/types/preview/@ember/error/ember__error-tests.ts
index 503d16ee5af..d54bd7e0aad 100644
--- a/types/preview/@ember/error/ember__error-tests.ts
+++ b/types/preview/@ember/error/ember__error-tests.ts
@@ -3,5 +3,4 @@ import Error from '@ember/error';
 new Error('Fuuuuuuuu'); // $ExpectType EmberError
 
 // allows to extend from EmberError
-class AjaxError extends Error {
-}
+class AjaxError extends Error {}
diff --git a/types/preview/@ember/object/events.d.ts b/types/preview/@ember/object/events.d.ts
index 04fd9b029ca..17d6df2cbf3 100644
--- a/types/preview/@ember/object/events.d.ts
+++ b/types/preview/@ember/object/events.d.ts
@@ -4,32 +4,32 @@ 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
+  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
+  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
+  obj: Context,
+  eventName: string,
+  target: unknown,
+  method: keyof Context | AnyFunction
 ): void;
 export function removeListener<Context>(
-    obj: Context,
-    eventName: string,
-    method: keyof Context | AnyFunction
+  obj: Context,
+  eventName: string,
+  method: keyof Context | AnyFunction
 ): void;
 
 /**
@@ -42,8 +42,4 @@ export function removeListener<Context>(
  * @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;
+export function sendEvent(obj: unknown, eventName: string, params?: unknown[]): boolean;
diff --git a/types/preview/@ember/object/observers.d.ts b/types/preview/@ember/object/observers.d.ts
index f1decdb96fe..bbf57e4b3fa 100644
--- a/types/preview/@ember/object/observers.d.ts
+++ b/types/preview/@ember/object/observers.d.ts
@@ -1,18 +1,18 @@
-import { ObserverMethod } from "@ember/object/-private/types";
+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>
+  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>
+  obj: Context,
+  key: keyof Context,
+  method: ObserverMethod<Context, Context>
 ): void;
 /**
  * Remove an observer you have previously registered on this object. Pass
@@ -20,13 +20,13 @@ export function addObserver<Context>(
  * target will no longer receive notifications.
  */
 export function removeObserver<Context, Target>(
-    obj: Context,
-    key: keyof Context,
-    target: Target,
-    method: ObserverMethod<Target, Context>
+  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>
+  obj: Context,
+  key: keyof Context,
+  method: ObserverMethod<Context, Context>
 ): any;
diff --git a/types/preview/@ember/object/test/access-modifier.ts b/types/preview/@ember/object/test/access-modifier.ts
index 3551a20dd36..04e6dc510b5 100644
--- a/types/preview/@ember/object/test/access-modifier.ts
+++ b/types/preview/@ember/object/test/access-modifier.ts
@@ -2,15 +2,15 @@ import { assertType } from './lib/assert';
 import EmberObject from '@ember/object';
 
 class Foo extends EmberObject {
-    hello() {
-        return 'world';
-    }
-    protected bar() {
-        return 'bar';
-    }
-    private baz() {
-        return 'baz';
-    }
+  hello() {
+    return 'world';
+  }
+  protected bar() {
+    return 'bar';
+  }
+  private baz() {
+    return 'baz';
+  }
 }
 const f = new Foo();
 assertType<string>(f.hello());
diff --git a/types/preview/@ember/object/test/compat.ts b/types/preview/@ember/object/test/compat.ts
index f661c37529a..e6b08c0d7b4 100644
--- a/types/preview/@ember/object/test/compat.ts
+++ b/types/preview/@ember/object/test/compat.ts
@@ -2,11 +2,11 @@ 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;
+  declare firstName: string;
+  declare lastName: string;
 
-    @dependentKeyCompat
-    get fullName() {
-        return `${this.firstName} ${this.lastName}`;
-    }
+  @dependentKeyCompat
+  get fullName() {
+    return `${this.firstName} ${this.lastName}`;
+  }
 }
diff --git a/types/preview/@ember/owner/ember__owner-tests.ts b/types/preview/@ember/owner/ember__owner-tests.ts
index 27b57933cca..f5a6603df5a 100644
--- a/types/preview/@ember/owner/ember__owner-tests.ts
+++ b/types/preview/@ember/owner/ember__owner-tests.ts
@@ -2,7 +2,7 @@ import Owner, { Factory, FactoryManager, FullName, RegisterOptions } from '@embe
 
 // Just a class we can construct in the Factory and FactoryManager tests
 declare class ConstructThis {
-    hasProps: boolean;
+  hasProps: boolean;
 }
 
 // ----- RegisterOptions ----- //
@@ -17,10 +17,10 @@ declare let aFactory: Factory<ConstructThis>;
 aFactory.create();
 aFactory.create({});
 aFactory.create({
-    hasProps: true,
+  hasProps: true,
 });
 aFactory.create({
-    hasProps: false,
+  hasProps: false,
 });
 
 // These should be rejected by way of EPC
@@ -102,9 +102,9 @@ owner.lookup(aTypedName); // $ExpectType unknown
 // correct type.
 declare const justStrings: string[];
 // @ts-expect-error
-justStrings.map(aString => owner.lookup(aString));
+justStrings.map((aString) => owner.lookup(aString));
 declare let typedStrings: FullName[];
-typedStrings.map(aString => owner.lookup(aString));
+typedStrings.map((aString) => owner.lookup(aString));
 
 // Also make sure it keeps working with const bindings
 const aConstName = 'type:name';
@@ -113,23 +113,23 @@ owner.lookup(aConstName); // $ExpectType unknown
 // ----- Minimal further coverage for POJOs ----- //
 // `Factory` and `FactoryManager` don't have to deal in actual classes. :sigh:
 const Creatable = {
-    hasProps: true,
+  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;
-    },
+  create(initialValues?) {
+    const instance = Creatable;
+    if (initialValues) {
+      if (initialValues.hasProps) {
+        Object.defineProperty(instance, 'hasProps', {
+          value: initialValues.hasProps,
+          enumerable: true,
+          writable: true,
+        });
+      }
+    }
+    return instance;
+  },
 };
 
 pojoFactory.create(); // $ExpectType { hasProps: boolean; }
diff --git a/types/preview/@ember/polyfills/ember__polyfills-tests.ts b/types/preview/@ember/polyfills/ember__polyfills-tests.ts
index 859ca779645..06f1261b6e6 100644
--- a/types/preview/@ember/polyfills/ember__polyfills-tests.ts
+++ b/types/preview/@ember/polyfills/ember__polyfills-tests.ts
@@ -1,23 +1,23 @@
 import { assign } from '@ember/polyfills';
 
 (() => {
-    /* assign */
-    assign({}, { a: 'b' });
-    assign({}, { a: 'b' }).a; // $ExpectType string
-    assign({ a: 6 }, { a: 'b' }).a; // $ExpectType string
-    assign({ a: 6 }, {}).a; // $ExpectType number
-    // @ts-expect-error
-    assign({ b: 6 }, {}).a;
-    assign({}, { b: 6 }, {}).b; // $ExpectType number
-    assign({ a: 'hello' }, { b: 6 }, {}).a; // $ExpectType string
-    assign({ a: 'hello' }, { b: 6 }, { a: true }).a; // $ExpectType boolean
-    // @ts-expect-error
-    assign({ a: 'hello' }, '', { a: true }).a;
-    assign({ d: ['gobias industries'] }, { a: 'hello' }, { b: 6 }, { a: true }).d; // $ExpectType string[]
-    // @ts-expect-error
-    assign({}, { a: 0 }, { b: 1 }, { c: 2 }, { d: 3 }).a;
+  /* assign */
+  assign({}, { a: 'b' });
+  assign({}, { a: 'b' }).a; // $ExpectType string
+  assign({ a: 6 }, { a: 'b' }).a; // $ExpectType string
+  assign({ a: 6 }, {}).a; // $ExpectType number
+  // @ts-expect-error
+  assign({ b: 6 }, {}).a;
+  assign({}, { b: 6 }, {}).b; // $ExpectType number
+  assign({ a: 'hello' }, { b: 6 }, {}).a; // $ExpectType string
+  assign({ a: 'hello' }, { b: 6 }, { a: true }).a; // $ExpectType boolean
+  // @ts-expect-error
+  assign({ a: 'hello' }, '', { a: true }).a;
+  assign({ d: ['gobias industries'] }, { a: 'hello' }, { b: 6 }, { a: true }).d; // $ExpectType string[]
+  // @ts-expect-error
+  assign({}, { a: 0 }, { b: 1 }, { c: 2 }, { d: 3 }).a;
 
-    // matches Object.assign
-    assign({}, null); // $ExpectType never
-    assign({}, undefined); // $ExpectType never
+  // matches Object.assign
+  assign({}, null); // $ExpectType never
+  assign({}, undefined); // $ExpectType never
 })();
diff --git a/types/preview/@ember/routing/-private/router-dsl.d.ts b/types/preview/@ember/routing/-private/router-dsl.d.ts
index 86c6b086494..00c91f826df 100644
--- a/types/preview/@ember/routing/-private/router-dsl.d.ts
+++ b/types/preview/@ember/routing/-private/router-dsl.d.ts
@@ -1,18 +1,18 @@
 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;
+  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
index 86be671620b..eb17614eb76 100644
--- a/types/preview/@ember/routing/auto-location.d.ts
+++ b/types/preview/@ember/routing/auto-location.d.ts
@@ -1,4 +1,4 @@
-import EmberObject from "@ember/object";
+import EmberObject from '@ember/object';
 
 /**
  * AutoLocation will select the best location option based off browser support with the priority order: history, hash, none.
diff --git a/types/preview/@ember/routing/hash-location.d.ts b/types/preview/@ember/routing/hash-location.d.ts
index a045285fbc6..55b92d265ee 100644
--- a/types/preview/@ember/routing/hash-location.d.ts
+++ b/types/preview/@ember/routing/hash-location.d.ts
@@ -1,4 +1,4 @@
-import EmberObject from "@ember/object";
+import EmberObject from '@ember/object';
 
 /**
  * `Ember.HashLocation` implements the location API using the browser's
diff --git a/types/preview/@ember/routing/history-location.d.ts b/types/preview/@ember/routing/history-location.d.ts
index 8921fdb15e2..67d4399f038 100644
--- a/types/preview/@ember/routing/history-location.d.ts
+++ b/types/preview/@ember/routing/history-location.d.ts
@@ -1,4 +1,4 @@
-import EmberObject from "@ember/object";
+import EmberObject from '@ember/object';
 
 /**
  * Ember.HistoryLocation implements the location API using the browser's
diff --git a/types/preview/@ember/routing/none-location.d.ts b/types/preview/@ember/routing/none-location.d.ts
index 22934d7cece..286860db69f 100644
--- a/types/preview/@ember/routing/none-location.d.ts
+++ b/types/preview/@ember/routing/none-location.d.ts
@@ -1,4 +1,4 @@
-import EmberObject from "@ember/object";
+import EmberObject from '@ember/object';
 
 /**
  * Ember.NoneLocation does not interact with the browser. It is useful for
diff --git a/types/preview/@ember/routing/route-info.d.ts b/types/preview/@ember/routing/route-info.d.ts
index 2261063b669..acc8095ed2e 100644
--- a/types/preview/@ember/routing/route-info.d.ts
+++ b/types/preview/@ember/routing/route-info.d.ts
@@ -5,52 +5,52 @@
  * 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;
+  /**
+   * 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
@@ -64,9 +64,9 @@ export default interface RouteInfo {
  * changed after creation.
  */
 export interface RouteInfoWithAttributes extends RouteInfo {
-    /**
-     * This is the resolved return value from the
-     * route's model hook.
-     */
-    readonly attributes: unknown;
+  /**
+   * 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
index 07c4c5c9156..7735a954299 100644
--- a/types/preview/@ember/routing/route.d.ts
+++ b/types/preview/@ember/routing/route.d.ts
@@ -12,514 +12,521 @@ 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;
+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;
+  /**
+   * 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;
+  /**
+   * 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>;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  // 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;
+  // 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 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;
+  /**
+   * 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 };
+  /**
+   * Configuration hash for this route's queryParams.
+   */
+  queryParams: { [key: string]: RouteQueryParam };
 
-    /**
-     * The name of the route, dot-delimited
-     */
-    routeName: string;
+  /**
+   * 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;
+  /**
+   * 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;
+  // 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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 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;
+  /**
+   * 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;
+  /**
+   * 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
index 827d40dbb92..2d8ff069df9 100644
--- a/types/preview/@ember/routing/router-service.d.ts
+++ b/types/preview/@ember/routing/router-service.d.ts
@@ -10,351 +10,341 @@ type RouteModel = object | string | number;
  * 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;
+  //
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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/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/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://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.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=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=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=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;
+  /**
+   * 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 `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;
+  /**
+   * 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;
+  /**
+   * 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
index ca70289b2b7..348c410a0b6 100644
--- a/types/preview/@ember/routing/router.d.ts
+++ b/types/preview/@ember/routing/router.d.ts
@@ -1,43 +1,43 @@
-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";
-import RouterService from "@ember/routing/router-service";
+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';
+import RouterService from '@ember/routing/router-service';
 
 /**
  * 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.extend(Evented) {
-    /**
-     * 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;
-    transitionTo(name: string, ...models: any[]): Transition;
-    transitionTo(name: string, options: {}): Transition;
+  /**
+   * 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;
+  transitionTo(name: string, ...models: any[]): Transition;
+  transitionTo(name: string, options: {}): Transition;
 }
 
 declare module '@ember/service' {
-    interface Registry {
-        'router': RouterService;
-    }
+  interface Registry {
+    router: RouterService;
+  }
 }
diff --git a/types/preview/@ember/routing/test/router-service.ts b/types/preview/@ember/routing/test/router-service.ts
index 10875f86b1d..5abf1b622e6 100644
--- a/types/preview/@ember/routing/test/router-service.ts
+++ b/types/preview/@ember/routing/test/router-service.ts
@@ -6,10 +6,10 @@ router.transitionTo('someRoute');
 router.transitionTo('someRoute', { withModel: true });
 router.transitionTo('someRoute', { withModel: true }, { queryParams: {} });
 router.transitionTo(
-    'someRoute',
-    { withModel: true },
-    { withMultipleModels: 'still checks correctly' },
-    { queryParams: {} },
+  'someRoute',
+  { withModel: true },
+  { withMultipleModels: 'still checks correctly' },
+  { queryParams: {} }
 );
 
 const routeWillChangeHandler = () => {};
@@ -36,7 +36,7 @@ transition.abort();
 
 // $ExpectType Promise<unknown>
 transition.catch();
-transition.catch(err => console.log(err), 'label');
+transition.catch((err) => console.log(err), 'label');
 
 // $ExpectType Promise<unknown>
 transition.finally();
@@ -56,9 +56,9 @@ transition.retry();
 // $ExpectType Promise<unknown>
 transition.then();
 transition.then(
-    result => console.log(result),
-    err => console.log(err),
-    'label',
+  (result) => console.log(result),
+  (err) => console.log(err),
+  'label'
 );
 
 // $ExpectType void
diff --git a/types/preview/@ember/routing/transition.d.ts b/types/preview/@ember/routing/transition.d.ts
index b623b76b634..f575b9da974 100644
--- a/types/preview/@ember/routing/transition.d.ts
+++ b/types/preview/@ember/routing/transition.d.ts
@@ -11,114 +11,114 @@ import RouteInfo, { RouteInfoWithAttributes } from './route-info';
  *   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;
+  /**
+   * 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/types.d.ts b/types/preview/@ember/routing/types.d.ts
index 251a295fcc4..0895070ec9a 100644
--- a/types/preview/@ember/routing/types.d.ts
+++ b/types/preview/@ember/routing/types.d.ts
@@ -1,13 +1,13 @@
 export interface RenderOptions {
-    into?: string | undefined;
-    controller?: string | undefined;
-    model?: unknown;
-    outlet?: string | undefined;
-    view?: string | undefined;
+  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;
+  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
index 676a3b36ada..146cdcb611c 100644
--- a/types/preview/@ember/runloop/-private/backburner.d.ts
+++ b/types/preview/@ember/runloop/-private/backburner.d.ts
@@ -1,41 +1,41 @@
-import { EmberMethod, EmberMethodParams } from "ember/-private/type-utils";
+import { EmberMethod, EmberMethodParams } from 'ember/-private/type-utils';
 
 export interface QueueItem {
-    method: string;
-    target: object;
-    args: object[];
-    stack: string | undefined;
+  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;
+  [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[];
+  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;
+  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
index 48384ec84bb..5bdf61ef241 100644
--- a/types/preview/@ember/runloop/-private/types.d.ts
+++ b/types/preview/@ember/runloop/-private/types.d.ts
@@ -1 +1,7 @@
-export type EmberRunQueues = 'sync' | 'actions' | 'routerTransitions' | 'render' | 'afterRender' | 'destroy';
+export type EmberRunQueues =
+  | 'sync'
+  | 'actions'
+  | 'routerTransitions'
+  | 'render'
+  | 'afterRender'
+  | 'destroy';
diff --git a/types/preview/@ember/runloop/ember__runloop-tests.ts b/types/preview/@ember/runloop/ember__runloop-tests.ts
index a36e1b46ac9..f62a8889f8e 100644
--- a/types/preview/@ember/runloop/ember__runloop-tests.ts
+++ b/types/preview/@ember/runloop/ember__runloop-tests.ts
@@ -13,10 +13,15 @@ import {
   scheduleOnce,
   throttle,
   // private, supported via `declare module` below
-  _backburner
+  _backburner,
 } from '@ember/runloop';
 import EmberObject, { action } from '@ember/object';
-import { Backburner, DebugInfo, QueueItem, DeferredActionQueues } from '@ember/runloop/-private/backburner';
+import {
+  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.
@@ -25,259 +30,275 @@ declare module '@ember/runloop' {
 }
 
 function testRun() {
-    run(() => { // $ExpectType number
-        // code to be executed within a RunLoop
-        return 123;
-    });
+  run(() => {
+    // $ExpectType number
+    // 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)
+  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();
     });
-
-    // 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");
+    // 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);
+    this.set('editor', editor);
   }
 }
 
 function testCancel() {
-    const myContext = {
-        method(arg: string, another: number): number {
-            return arg.length + another;
-        }
-    };
+  const myContext = {
+    method(arg: string, another: number): number {
+      return arg.length + another;
+    },
+  };
 
-    cancel(undefined);
+  cancel(undefined);
 
-    const runNext = next(myContext, () => {
-        // will not be executed
-    });
+  const runNext = next(myContext, () => {
+    // will not be executed
+  });
 
-    cancel(runNext);
+  cancel(runNext);
 
-    const anotherRunNext = next(myContext, 'method', "hello", 123);
-    // @ts-expect-error
-    const aBadRunNext = next(myContext, 'method', false, "goodbye");
+  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 aSimpleNext = next((name: string) => name.length, 'hello');
 
-    const runLater = later(myContext, () => {
-        // will not be executed
-    }, 500);
+  const runLater = later(
+    myContext,
+    () => {
+      // will not be executed
+    },
+    500
+  );
 
-    cancel(runLater);
-
-    const runScheduleOnce = scheduleOnce('afterRender', myContext, () => {
-        // will not be executed
-    });
+  cancel(runLater);
 
-    cancel(runScheduleOnce);
+  const runScheduleOnce = scheduleOnce('afterRender', myContext, () => {
+    // will not be executed
+  });
 
-    const anotherScheduleOnce =
-        scheduleOnce('render', myContext, 'method', "hello", 123);
+  cancel(runScheduleOnce);
 
-    const aBadScheduleOnce =
-        // @ts-expect-error
-        scheduleOnce('render', myContext, 'method', true, "boo");
+  const anotherScheduleOnce = scheduleOnce('render', myContext, 'method', 'hello', 123);
 
-    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);
+  const aBadScheduleOnce =
     // @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);
+    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);
+}
 
-    cancel(debounced);
+function testDebounce() {
+  function runIt() {}
 
-    const debounceImmediate = debounce(myContext, () => {
-        // will be executed since we passed in true (immediate)
-    }, 100, true);
+  const myContext = { name: 'debounce' };
 
-    // the 100ms delay until this method can be called again will be canceled
-    cancel(debounceImmediate);
-}
+  debounce(runIt, 150);
+  debounce(myContext, runIt, 150);
+  debounce(myContext, runIt, 150, true);
 
-function testDebounce() {
-    function runIt() {
-    }
+  class DebounceExample extends EmberObject {
+    searchValue = 'test';
+    fetchResults(value: string) {}
 
-    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);
-      }
+    @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) {},
-
-        
-    });
+  EmberObject.extend({
+    searchValue: 'test',
+    fetchResults(value: string) {},
+  });
 }
 
 function testBegin() {
-    begin();
-    // code to be executed within a RunLoop
-    end();
+  begin();
+  // code to be executed within a RunLoop
+  end();
 }
 
 function testJoin() {
-    join(() => {
-        // creates a new run-loop
-    });
+  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.
-        });
+  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);
+  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);
+  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
-    });
+  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);
+    once(this as TestOnce, 'processFullName');
+    once(this, this.processFullName);
   }
 
-  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
-    });
+  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');
-    }
+  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');
-    });
+  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() {
-    }
+  function runIt() {}
 
-    const myContext = { name: 'throttle' };
+  const myContext = { name: 'throttle' };
 
-    throttle(runIt, 150);
-    throttle(myContext, runIt, 150);
+  throttle(runIt, 150);
+  throttle(myContext, runIt, 150);
 }
 
 function testBackburner() {
diff --git a/types/preview/@ember/runloop/types.d.ts b/types/preview/@ember/runloop/types.d.ts
index 2aeaa44726a..0ba5585ad72 100644
--- a/types/preview/@ember/runloop/types.d.ts
+++ b/types/preview/@ember/runloop/types.d.ts
@@ -1,3 +1,3 @@
 export interface EmberRunTimer {
-    __ember_run_timer_brand__: boolean;
+  __ember_run_timer_brand__: boolean;
 }
diff --git a/types/preview/@ember/template/ember__template-tests.ts b/types/preview/@ember/template/ember__template-tests.ts
index 4ed95f22c74..ae0a832925b 100644
--- a/types/preview/@ember/template/ember__template-tests.ts
+++ b/types/preview/@ember/template/ember__template-tests.ts
@@ -7,9 +7,9 @@ htmlSafe('lorem ipsum...'); // $ExpectType SafeString
 const regularString: string = htmlSafe('lorem ipsum...');
 
 function isSafeTest(a: string | SafeString) {
-    if (isHTMLSafe(a)) {
-        a = a.toString();
-    }
+  if (isHTMLSafe(a)) {
+    a = a.toString();
+  }
 
-    a.toLowerCase();
+  a.toLowerCase();
 }
diff --git a/types/preview/@ember/test/adapter.d.ts b/types/preview/@ember/test/adapter.d.ts
index b991607531e..a1573f0d416 100644
--- a/types/preview/@ember/test/adapter.d.ts
+++ b/types/preview/@ember/test/adapter.d.ts
@@ -3,18 +3,18 @@
  * 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;
+  /**
+   * 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/ember__test-tests.ts b/types/preview/@ember/test/ember__test-tests.ts
index 5833196292c..29a689158b1 100644
--- a/types/preview/@ember/test/ember__test-tests.ts
+++ b/types/preview/@ember/test/ember__test-tests.ts
@@ -5,38 +5,38 @@ const pending = 0;
 registerWaiter(() => pending !== 0);
 
 declare const MyDb: {
-    hasPendingTransactions(): boolean;
+  hasPendingTransactions(): boolean;
 };
 
 registerWaiter(MyDb, MyDb.hasPendingTransactions);
 // @ts-expect-error
 registerWaiter();
 
-registerHelper('boot', app => {
-    app.advanceReadiness(); // $ExpectType void
-    app.deferReadiness(); // $ExpectType void
-    app.register('foo', class {}); // $ExpectType void
-    // @ts-expect-error
-    app.register('foo');
-    // @ts-expect-error
-    app.register();
+registerHelper('boot', (app) => {
+  app.advanceReadiness(); // $ExpectType void
+  app.deferReadiness(); // $ExpectType void
+  app.register('foo', class {}); // $ExpectType void
+  // @ts-expect-error
+  app.register('foo');
+  // @ts-expect-error
+  app.register();
 });
 
-registerAsyncHelper('boot', app => {
-    app.advanceReadiness();
-    app.deferReadiness();
-    app.register('foo', class {});
+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();
-        });
+  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/types/preview/ember/test/application.ts b/types/preview/ember/test/application.ts
index fcc65a70009..a59fc150578 100755
--- a/types/preview/ember/test/application.ts
+++ b/types/preview/ember/test/application.ts
@@ -2,38 +2,38 @@ import EmberObject from '@ember/object';
 import Ember from 'ember';
 
 const BaseApp = Ember.Application.extend({
-    modulePrefix: 'my-app',
+  modulePrefix: 'my-app',
 });
 
 class Obj extends EmberObject.extend({ foo: 'bar' }) {}
 
 BaseApp.initializer({
-    name: 'my-initializer',
-    initialize(app) {
-        app.register('foo:bar', Obj);
-    },
+  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');
-    },
+  name: 'my-instance-initializer',
+  initialize(app) {
+    (app.lookup('foo:bar') as Obj).get('foo');
+  },
 });
 
 const App1 = BaseApp.create({
-    rootElement: '#app-one',
-    customEvents: {
-        paste: 'paste',
-    },
+  rootElement: '#app-one',
+  customEvents: {
+    paste: 'paste',
+  },
 });
 
 const App2 = BaseApp.create({
-    rootElement: '#app-two',
-    customEvents: {
-        mouseenter: null,
-        mouseleave: null,
-    },
+  rootElement: '#app-two',
+  customEvents: {
+    mouseenter: null,
+    mouseleave: null,
+  },
 });
 
 const App3 = BaseApp.create();
diff --git a/types/preview/ember/test/array-ext.ts b/types/preview/ember/test/array-ext.ts
index 50698a70292..0b87d139900 100755
--- a/types/preview/ember/test/array-ext.ts
+++ b/types/preview/ember/test/array-ext.ts
@@ -2,11 +2,11 @@ import Ember from 'ember';
 import { assertType } from './lib/assert';
 
 declare global {
-    interface Array<T> extends Ember.ArrayPrototypeExtensions<T> {}
+  interface Array<T> extends Ember.ArrayPrototypeExtensions<T> {}
 }
 
 class Person extends Ember.Object {
-    declare name: string;
+  declare name: string;
 }
 
 const person = Person.create({ name: 'Joe' });
@@ -15,7 +15,7 @@ const array = [person];
 assertType<number>(array.get('length'));
 assertType<Person | undefined>(array.get('firstObject'));
 assertType<string[]>(array.mapBy('name'));
-assertType<string[]>(array.map(p => p.get('name')));
+assertType<string[]>(array.map((p) => p.get('name')));
 assertType<Person[]>(array.sortBy('name'));
 assertType<Person[]>(array.uniq());
 assertType<Person[]>(array.uniqBy('name'));
diff --git a/types/preview/ember/test/debug.ts b/types/preview/ember/test/debug.ts
index 5220e793301..69396503e07 100644
--- a/types/preview/ember/test/debug.ts
+++ b/types/preview/ember/test/debug.ts
@@ -1,10 +1,10 @@
 import Ember from 'ember';
 
 const {
-    runInDebug,
-    warn,
-    debug,
-    Debug: { registerDeprecationHandler, registerWarnHandler },
+  runInDebug,
+  warn,
+  debug,
+  Debug: { registerDeprecationHandler, registerWarnHandler },
 } = Ember;
 
 // Workaround for https://github.com/microsoft/TypeScript/issues/36931.
@@ -27,7 +27,7 @@ warn('Too many tomsters!', tomsterCount <= 3);
 warn('Too many tomsters!', tomsterCount <= 3, { id: 'some-warning' }); // $ExpectType void
 // $ExpectType void
 warn('Too many tomsters!', tomsterCount <= 3, {
-    id: 'ember-debug.too-many-tomsters',
+  id: 'ember-debug.too-many-tomsters',
 });
 
 // @ts-expect-error
@@ -40,52 +40,60 @@ debug('Too many tomsters!', 'foo');
 // @ts-expect-error
 registerWarnHandler();
 registerWarnHandler(() => {}); // $ExpectType void
-registerWarnHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; } | undefined
-    next; // $ExpectType (message: string, options?: { id: string; } | undefined) => void
+registerWarnHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; } | undefined
+  next; // $ExpectType (message: string, options?: { id: string; } | undefined) => void
 });
-registerWarnHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; } | undefined
-    // @ts-expect-error
-    next();
+registerWarnHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; } | undefined
+  // @ts-expect-error
+  next();
 });
-registerWarnHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; } | undefined
-    next(message); // $ExpectType void
+registerWarnHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; } | undefined
+  next(message); // $ExpectType void
 });
-registerWarnHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; } | undefined
-    next(message, options); // $ExpectType void
+registerWarnHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; } | undefined
+  next(message, options); // $ExpectType void
 });
 
 // next is not called, so no warnings get the default behavior
 // @ts-expect-error
 registerDeprecationHandler();
 registerDeprecationHandler(() => {}); // $ExpectType void
-registerDeprecationHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; until: string; } | undefined
-    next; // $ExpectType (message: string, options?: { id: string; until: string; } | undefined) => void
+registerDeprecationHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; until: string; } | undefined
+  next; // $ExpectType (message: string, options?: { id: string; until: string; } | undefined) => void
 });
-registerDeprecationHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; until: string; } | undefined
-    // @ts-expect-error
-    next();
+registerDeprecationHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; until: string; } | undefined
+  // @ts-expect-error
+  next();
 });
-registerDeprecationHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; until: string; } | undefined
-    next(message); // $ExpectType void
+registerDeprecationHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; until: string; } | undefined
+  next(message); // $ExpectType void
 });
-registerDeprecationHandler((message, options, next) => { // $ExpectType void
-    message; // $ExpectType string
-    options; // $ExpectType { id: string; until: string; } | undefined
-    next(message, options); // $ExpectType void
+registerDeprecationHandler((message, options, next) => {
+  // $ExpectType void
+  message; // $ExpectType string
+  options; // $ExpectType { id: string; until: string; } | undefined
+  next(message, options); // $ExpectType void
 });
 
 // Test for truthiness
diff --git a/types/preview/ember/test/ember-module-tests.ts b/types/preview/ember/test/ember-module-tests.ts
index b4953f4948c..cc361b97a8b 100644
--- a/types/preview/ember/test/ember-module-tests.ts
+++ b/types/preview/ember/test/ember-module-tests.ts
@@ -77,9 +77,9 @@ Ember.isPresent(''); // $ExpectType boolean
 Ember.isPresent([]); // $ExpectType boolean
 // observer
 class O2 extends Ember.Object {
-  name = 'foo'
+  name = 'foo';
   age = 3;
-  
+
   nameWatcher = Ember.observer('name', () => {});
   nameWatcher2 = Ember.observer('name', 'fullName', () => {});
 }
@@ -166,12 +166,12 @@ c2.didInsertElement();
 
 class Foo {
   foo = '';
-  
+
   @Ember.computed('foo')
   get wat(): string {
-    return this.foo
+    return this.foo;
   }
-  
+
   set wat(newValue: string) {
     this.foo = newValue;
   }
@@ -217,7 +217,7 @@ const hil = Ember.HistoryLocation.create();
 expectTypeOf(hil).toEqualTypeOf<Ember.HistoryLocation>();
 // Ember.Mixin
 interface UsesMixin {
-  foo: string
+  foo: string;
 }
 class UsesMixin extends Ember.Object {
   baz() {
diff --git a/types/preview/ember/test/engine-instance.ts b/types/preview/ember/test/engine-instance.ts
index e3f8c0b3aae..0da036e13af 100644
--- a/types/preview/ember/test/engine-instance.ts
+++ b/types/preview/ember/test/engine-instance.ts
@@ -5,16 +5,16 @@ const engineInstance = EngineInstance.create();
 engineInstance.register('some:injection', class Foo {});
 
 engineInstance.register('some:injection', class Foo {}, {
-    singleton: true,
+  singleton: true,
 });
 
 engineInstance.register('some:injection', class Foo {}, {
-    instantiate: false,
+  instantiate: false,
 });
 
 engineInstance.register('some:injection', class Foo {}, {
-    singleton: false,
-    instantiate: true,
+  singleton: false,
+  instantiate: true,
 });
 
 engineInstance.factoryFor('router:main');
@@ -23,5 +23,5 @@ engineInstance.lookup('route:basic');
 engineInstance.boot();
 
 (async () => {
-    await engineInstance.boot();
+  await engineInstance.boot();
 })();
diff --git a/types/preview/ember/test/run.ts b/types/preview/ember/test/run.ts
index 2bebd3e019e..9a6d829a2a1 100755
--- a/types/preview/ember/test/run.ts
+++ b/types/preview/ember/test/run.ts
@@ -162,12 +162,11 @@ function testNext() {
 
 class TestOnce extends Ember.Object {
   init() {
-      Ember.run.once(this as TestOnce, 'processFullName');
-      Ember.run.once(this, this.processFullName);
+    Ember.run.once(this as TestOnce, 'processFullName');
+    Ember.run.once(this, this.processFullName);
   }
 
-  processFullName() {
-  }
+  processFullName() {}
 }
 
 {
diff --git a/types/preview/ember/test/techniques/properties-from-this.ts b/types/preview/ember/test/techniques/properties-from-this.ts
index 78b5b96dd1d..7dc3e618f67 100644
--- a/types/preview/ember/test/techniques/properties-from-this.ts
+++ b/types/preview/ember/test/techniques/properties-from-this.ts
@@ -5,8 +5,8 @@
  */
 
 class BoxedProperty<Get, Set = Get> {
-    declare private [GetType]: Get;
-    declare private [SetType]: Set;
+  private declare [GetType]: Get;
+  private declare [SetType]: Set;
 }
 
 declare const GetType: unique symbol;
@@ -16,30 +16,30 @@ 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;
+  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';
-    }
+  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();
diff --git a/types/preview/ember/test/test.ts b/types/preview/ember/test/test.ts
index d3eecc5a2b5..f91b8c54f09 100755
--- a/types/preview/ember/test/test.ts
+++ b/types/preview/ember/test/test.ts
@@ -4,29 +4,29 @@ const pending = 0;
 Ember.Test.registerWaiter(() => pending !== 0);
 
 declare const MyDb: {
-    hasPendingTransactions(): boolean;
+  hasPendingTransactions(): boolean;
 };
 Ember.Test.registerWaiter(MyDb, MyDb.hasPendingTransactions);
 
-Ember.Test.promise(resolve => {
-    window.setTimeout(resolve, 500);
+Ember.Test.promise((resolve) => {
+  window.setTimeout(resolve, 500);
 });
 
-Ember.Test.registerHelper('boot', app => {
-    Ember.run(app, app.advanceReadiness);
+Ember.Test.registerHelper('boot', (app) => {
+  Ember.run(app, app.advanceReadiness);
 });
 
-Ember.Test.registerAsyncHelper('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();
+  return new Ember.Test.Promise((resolve) => {
+    Ember.Test.adapter.asyncStart();
 
-        promise.then(() => {
-            Ember.run.schedule('afterRender', null, resolve);
-            Ember.Test.adapter.asyncEnd();
-        });
+    promise.then(() => {
+      Ember.run.schedule('afterRender', null, resolve);
+      Ember.Test.adapter.asyncEnd();
     });
+  });
 });
diff --git a/types/preview/ember/test/view-utils.ts b/types/preview/ember/test/view-utils.ts
index a45f4f3ce59..7cce69bc61f 100644
--- a/types/preview/ember/test/view-utils.ts
+++ b/types/preview/ember/test/view-utils.ts
@@ -2,6 +2,6 @@ import Ember from 'ember';
 import { assertType } from './lib/assert';
 
 const {
-    ViewUtils: { isSimpleClick },
+  ViewUtils: { isSimpleClick },
 } = Ember;
 assertType<boolean>(isSimpleClick(new Event('wat')));

From 33fb32b850830ed0898e8f7c7c846dc87030f209 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Wed, 31 Aug 2022 09:09:04 -0600
Subject: [PATCH 31/39] Implement publishable types preview layout

1.  Introduce a root import, `types/preview/index.d.ts`, which itself
    imports every module which is part of Ember's type definitions.
    Then wrap each module definition in a `declare module '<name>' {}`
    so that importing it makes the module visible in the type system.
    This makes it so that users can use the types by simply writing a
    single import:

    ```ts
    import 'ember-source/types/preview';
    ```

    This approach will scale forward to all sorts of future work in TS
    in Ember, including publishing at `ember-source/types/stable`, or
    for future editions e.g. at `ember-source/types/polaris`. Moreover,
    this allows these to happen *simultaneously*. That is, as we publish
    types from source, those can go directly into the `stable` directory
    and users can simply have both imports present:

    ```ts
    import 'ember-source/types/preview';
    import 'ember-source/types/stable';
    ```

    Similarly, because this relies on module declarations, module
    merging works and this will allow us to at some point publish
    stable types supporting *only* new editions, with the default type
    import being at `stable` but users being able to opt into types
    which support the old edition:

    ```ts
    import 'ember-source/types/stable';
    import 'ember-source/types/classic';
    ```

2.  Extract the type tests for the published types into a `type-tests`
    directory, which actually *uses* those mechanics to validate that
    the types are all importable and usable as expected with that
    single import statement.

    Do *not* include that directory in `files` in `package.json`, so the
    tests are never published, only the type definitions themselves.

Making those changes and getting the test suite passing also
highlighted a number of errors in the existing type definitions (and
tests!) for `EmberArray` and its related types, which had historically
been masked by the way our tests incorporated the prototype extensions:
*all* arrays appeared to act as a `NativeArray`. Fixing that involved
pulling those type tests out into a dedicated test package, and then
fixing all the bugs in the existing type definitions, including
restructuring to match the *actual* structure of Ember's internals.

However, fixing the *regular* types for arrays *also* highlighted that
it is currently impossible to properly represent the array prototype
extensions. Accordingly, those are excluded from this, and will be
addressed in some other way.
---
 .eslintrc.js                                  |   24 +
 packages/@ember/array/index.ts                |    7 +-
 .../application-test}/application-instance.ts |    0
 .../@ember/application-test}/application.ts   |    7 +-
 .../@ember/application-test}/deprecations.ts  |    0
 .../preview/@ember/application-test}/index.ts |   13 +-
 .../preview/@ember/array-test}/array-proxy.ts |   11 +-
 .../preview/@ember/array-test}/array.ts       |   20 +-
 .../@ember/component-test/built-ins.ts        |    6 +
 .../@ember/component-test}/component.ts       |   12 +-
 .../preview/@ember/component-test}/helper.ts  |   51 +-
 .../@ember/component-test}/template-only.ts   |   12 +-
 .../preview/@ember/controller-test}/main.ts   |    0
 .../preview/@ember/controller-test}/octane.ts |    0
 type-tests/preview/@ember/debug-tests.ts      |  273 +++++
 .../preview/@ember/destroyable-test.ts        |   15 +-
 .../@ember/engine-test}/engine-instance.ts    |    0
 .../preview/@ember/engine-test}/engine.ts     |    0
 .../preview/@ember/error-tests.ts             |    3 +-
 type-tests/preview/@ember/helper-tests.ts     |   19 +
 type-tests/preview/@ember/modifier-tests.ts   |    6 +
 .../preview/@ember/object-test}/compat.ts     |    0
 .../preview/@ember/object-test}/computed.ts   |    0
 .../preview/@ember/object-test}/core.ts       |   30 +-
 .../@ember/object-test}/create-negative.ts    |    0
 .../preview/@ember/object-test}/create.ts     |    0
 .../preview/@ember/object-test}/event.ts      |    0
 .../preview/@ember/object-test}/extend.ts     |    0
 .../preview/@ember/object-test/get-set.ts     |   15 +
 .../preview/@ember/object-test/internals.ts   |    7 +
 .../preview/@ember/object-test}/object.ts     |    6 +-
 .../preview/@ember/object-test}/observable.ts |    0
 .../preview/@ember/object-test}/proxy.ts      |    4 +-
 .../preview/@ember/object-test}/reopen.ts     |    0
 .../preview/@ember/owner-tests.ts             |   75 +-
 type-tests/preview/@ember/polyfills-tests.ts  |   26 +
 .../preview/@ember/routing-test/built-ins.ts  |    5 +
 .../preview/@ember/routing-test}/route.ts     |   30 +-
 .../@ember/routing-test/router-service.ts     |  102 ++
 .../preview/@ember/routing-test}/router.ts    |    0
 .../preview/@ember/runloop-tests.ts           |    3 +-
 .../preview/@ember}/service-test.ts           |    0
 .../preview/@ember/string-tests.ts            |    0
 .../preview/@ember/template-tests.ts          |    5 +-
 .../preview/@ember/test-tests.ts              |    7 +-
 .../preview/@ember/utils-tests.ts             |   55 +-
 .../preview/ember}/application-instance.ts    |    0
 .../preview/ember}/application.ts             |    0
 .../preview/ember}/array-proxy.ts             |   11 +-
 .../preview/ember}/array.ts                   |   10 +-
 .../preview/ember}/component.ts               |    0
 .../preview/ember}/computed.ts                |    0
 .../preview/ember}/controller.ts              |    0
 .../preview/ember}/core-object.ts             |   30 +-
 .../preview/ember}/create-negative.ts         |    0
 .../preview/ember}/create.ts                  |    0
 type-tests/preview/ember/data-adapter.ts      |   62 +
 type-tests/preview/ember/debug.ts             |  121 ++
 .../preview/ember}/ember-module-tests.ts      |  133 +--
 .../preview/ember}/ember-tests.ts             |   18 +-
 .../preview/ember}/engine-instance.ts         |    0
 .../preview/ember}/engine.ts                  |    0
 type-tests/preview/ember/error.ts             |    5 +
 .../preview/ember}/event.ts                   |    0
 .../preview/ember}/extend.ts                  |    0
 .../preview/ember}/helper.ts                  |    0
 .../preview/ember}/inject.ts                  |    3 +-
 .../preview/ember}/mixin.ts                   |   10 +-
 .../preview/ember}/object.ts                  |    8 +-
 .../preview/ember}/observable.ts              |   81 +-
 .../preview/ember/private/computed-tests.ts   |   26 +
 .../ember}/private/observable-tests.ts        |   80 +-
 .../preview/ember}/reopen.ts                  |    0
 .../preview/ember}/route.ts                   |    0
 .../preview/ember}/router.ts                  |    0
 .../test => type-tests/preview/ember}/run.ts  |    0
 .../preview/ember}/string.ts                  |   22 +-
 .../ember}/techniques/properties-from-this.ts |   18 +-
 .../test => type-tests/preview/ember}/test.ts |    0
 .../preview/ember}/transition.ts              |    0
 type-tests/preview/ember/utils.ts             |  154 +++
 type-tests/preview/ember/view-utils.ts        |    7 +
 type-tests/preview/index.d.ts                 |    1 +
 type-tests/preview/tsconfig.json              |    3 +
 types/preview/@ember/-internals/resolver.d.ts |   60 +-
 .../-private/event-dispatcher.d.ts            |   26 +-
 .../@ember/application/-private/registry.d.ts |   24 +-
 .../@ember/application/deprecations.d.ts      |   41 +-
 types/preview/@ember/application/index.d.ts   |  280 ++---
 .../preview/@ember/application/instance.d.ts  |   14 +-
 types/preview/@ember/application/types.d.ts   |   54 +-
 .../@ember/array/-private/enumerable.d.ts     |  178 +--
 .../array/-private/mutable-enumerable.d.ts    |   33 +-
 .../@ember/array/-private/native-array.d.ts   |   36 +-
 types/preview/@ember/array/index.d.ts         |  298 ++++-
 types/preview/@ember/array/mutable.d.ts       |  161 +--
 types/preview/@ember/array/proxy.d.ts         |   52 +-
 types/preview/@ember/array/test/array-ext.ts  |   23 -
 types/preview/@ember/array/test/lib/assert.ts |    2 -
 .../array/types/prototype-extensions.d.ts     |    9 +-
 .../-private/class-names-support.d.ts         |   48 +-
 .../@ember/component/-private/core-view.d.ts  |   24 +-
 .../-private/glimmer-interfaces.d.ts          |   74 +-
 .../component/-private/signature-utils.d.ts   |  107 ++
 .../@ember/component/-private/view-mixin.d.ts |  112 +-
 types/preview/@ember/component/helper.d.ts    |  304 ++---
 types/preview/@ember/component/index.d.ts     |  240 ++--
 .../@ember/component/template-only.d.ts       |   87 +-
 .../@ember/component/test/built-ins.ts        |    4 -
 .../@ember/component/test/lib/assert.ts       |    2 -
 types/preview/@ember/controller/index.d.ts    |   80 +-
 .../@ember/debug/container-debug-adapter.d.ts |   20 +-
 types/preview/@ember/debug/data-adapter.d.ts  |  112 +-
 .../@ember/debug/ember__debug-tests.ts        |  251 -----
 types/preview/@ember/debug/index.d.ts         |  180 +--
 types/preview/@ember/destroyable/index.d.ts   |   30 +-
 .../@ember/destroyable/test/lib/assert.ts     |    2 -
 .../-private/container-proxy-mixin.d.ts       |   24 +-
 .../engine/-private/registry-proxy-mixin.d.ts |  100 +-
 .../engine/-private/types/initializer.d.ts    |   12 +-
 types/preview/@ember/engine/index.d.ts        |   76 +-
 types/preview/@ember/engine/instance.d.ts     |   36 +-
 types/preview/@ember/error/index.d.ts         |   10 +-
 .../@ember/helper/ember__helper-tests.ts      |    7 -
 types/preview/@ember/helper/index.d.ts        |   84 +-
 .../@ember/modifier/ember__modifier-tests.ts  |    8 -
 types/preview/@ember/modifier/index.d.ts      |   56 +-
 .../object/-private/action-handler.d.ts       |   50 +-
 .../preview/@ember/object/-private/types.d.ts |  122 +-
 types/preview/@ember/object/compat.d.ts       |   16 +-
 types/preview/@ember/object/computed.d.ts     |  476 ++++----
 types/preview/@ember/object/core.d.ts         |  148 +--
 types/preview/@ember/object/evented.d.ts      |   76 +-
 types/preview/@ember/object/events.d.ts       |   86 +-
 types/preview/@ember/object/index.d.ts        |  202 ++--
 types/preview/@ember/object/internals.d.ts    |   30 +-
 types/preview/@ember/object/mixin.d.ts        |   26 +-
 types/preview/@ember/object/observable.d.ts   |  164 +--
 types/preview/@ember/object/observers.d.ts    |   64 +-
 .../@ember/object/promise-proxy-mixin.d.ts    |   64 +-
 types/preview/@ember/object/proxy.d.ts        |   36 +-
 .../@ember/object/test/access-modifier.ts     |   29 -
 types/preview/@ember/object/test/get-set.ts   |   14 -
 types/preview/@ember/object/test/internals.ts |   10 -
 .../preview/@ember/object/test/lib/assert.ts  |    2 -
 types/preview/@ember/owner/index.d.ts         |  168 +--
 .../polyfills/ember__polyfills-tests.ts       |   23 -
 types/preview/@ember/polyfills/index.d.ts     |   42 +-
 types/preview/@ember/polyfills/types.d.ts     |   10 +-
 .../-private/route-info-with-attributes.d.ts  |    4 +-
 .../@ember/routing/-private/route-info.d.ts   |    4 +-
 .../@ember/routing/-private/router-dsl.d.ts   |   36 +-
 .../@ember/routing/-private/transition.d.ts   |    4 +-
 .../preview/@ember/routing/auto-location.d.ts |   12 +-
 .../preview/@ember/routing/hash-location.d.ts |   16 +-
 .../@ember/routing/history-location.d.ts      |   14 +-
 types/preview/@ember/routing/index.d.ts       |   32 +-
 .../preview/@ember/routing/none-location.d.ts |   18 +-
 types/preview/@ember/routing/route-info.d.ts  |  134 +--
 types/preview/@ember/routing/route.d.ts       | 1002 +++++++++--------
 .../@ember/routing/router-service.d.ts        |  666 +++++------
 types/preview/@ember/routing/router.d.ts      |   72 +-
 .../preview/@ember/routing/test/built-ins.ts  |    3 -
 .../preview/@ember/routing/test/lib/assert.ts |    2 -
 .../@ember/routing/test/router-service.ts     |  120 --
 types/preview/@ember/routing/transition.d.ts  |  240 ++--
 types/preview/@ember/routing/types.d.ts       |   24 +-
 .../@ember/runloop/-private/backburner.d.ts   |   74 +-
 .../@ember/runloop/-private/types.d.ts        |   16 +-
 types/preview/@ember/runloop/index.d.ts       |  318 +++---
 types/preview/@ember/runloop/types.d.ts       |    6 +-
 types/preview/@ember/service/index.d.ts       |   44 +-
 types/preview/@ember/string/index.d.ts        |   16 +-
 .../@ember/template/-private/handlebars.d.ts  |   10 +-
 types/preview/@ember/template/index.d.ts      |    8 +-
 types/preview/@ember/test/adapter.d.ts        |   36 +-
 types/preview/@ember/test/index.d.ts          |   90 +-
 .../preview/@ember/utils/-private/types.d.ts  |   51 +-
 types/preview/@ember/utils/index.d.ts         |   69 +-
 types/preview/ember/-private/type-utils.d.ts  |   74 +-
 types/preview/ember/index.d.ts                |  688 +++++------
 types/preview/ember/test/array-ext.ts         |   21 -
 types/preview/ember/test/data-adapter.ts      |   60 -
 types/preview/ember/test/debug.ts             |  107 --
 types/preview/ember/test/error.ts             |    5 -
 types/preview/ember/test/lib/assert.ts        |    2 -
 .../ember/test/private/computed-tests.ts      |   30 -
 types/preview/ember/test/utils.ts             |  148 ---
 types/preview/ember/test/view-utils.ts        |    7 -
 types/preview/index.d.ts                      |  121 ++
 190 files changed, 5841 insertions(+), 5454 deletions(-)
 rename {types/preview/@ember/application/test => type-tests/preview/@ember/application-test}/application-instance.ts (100%)
 rename {types/preview/@ember/application/test => type-tests/preview/@ember/application-test}/application.ts (73%)
 rename {types/preview/@ember/application/test => type-tests/preview/@ember/application-test}/deprecations.ts (100%)
 rename {types/preview/@ember/application/test => type-tests/preview/@ember/application-test}/index.ts (63%)
 rename {types/preview/@ember/array/test => type-tests/preview/@ember/array-test}/array-proxy.ts (77%)
 rename {types/preview/@ember/array/test => type-tests/preview/@ember/array-test}/array.ts (77%)
 create mode 100644 type-tests/preview/@ember/component-test/built-ins.ts
 rename {types/preview/@ember/component/test => type-tests/preview/@ember/component-test}/component.ts (92%)
 rename {types/preview/@ember/component/test => type-tests/preview/@ember/component-test}/helper.ts (72%)
 rename {types/preview/@ember/component/test => type-tests/preview/@ember/component-test}/template-only.ts (53%)
 rename {types/preview/@ember/controller/test => type-tests/preview/@ember/controller-test}/main.ts (100%)
 rename {types/preview/@ember/controller/test => type-tests/preview/@ember/controller-test}/octane.ts (100%)
 create mode 100644 type-tests/preview/@ember/debug-tests.ts
 rename types/preview/@ember/destroyable/test/main.ts => type-tests/preview/@ember/destroyable-test.ts (85%)
 rename {types/preview/@ember/engine/test => type-tests/preview/@ember/engine-test}/engine-instance.ts (100%)
 rename {types/preview/@ember/engine/test => type-tests/preview/@ember/engine-test}/engine.ts (100%)
 rename types/preview/@ember/error/ember__error-tests.ts => type-tests/preview/@ember/error-tests.ts (50%)
 create mode 100644 type-tests/preview/@ember/helper-tests.ts
 create mode 100644 type-tests/preview/@ember/modifier-tests.ts
 rename {types/preview/@ember/object/test => type-tests/preview/@ember/object-test}/compat.ts (100%)
 rename {types/preview/@ember/object/test => type-tests/preview/@ember/object-test}/computed.ts (100%)
 rename {types/preview/@ember/object/test => type-tests/preview/@ember/object-test}/core.ts (55%)
 rename {types/preview/@ember/object/test => type-tests/preview/@ember/object-test}/create-negative.ts (100%)
 rename {types/preview/@ember/object/test => type-tests/preview/@ember/object-test}/create.ts (100%)
 rename {types/preview/@ember/object/test => type-tests/preview/@ember/object-test}/event.ts (100%)
 rename {types/preview/@ember/object/test => type-tests/preview/@ember/object-test}/extend.ts (100%)
 create mode 100644 type-tests/preview/@ember/object-test/get-set.ts
 create mode 100644 type-tests/preview/@ember/object-test/internals.ts
 rename {types/preview/@ember/object/test => type-tests/preview/@ember/object-test}/object.ts (92%)
 rename {types/preview/@ember/object/test => type-tests/preview/@ember/object-test}/observable.ts (100%)
 rename {types/preview/@ember/object/test => type-tests/preview/@ember/object-test}/proxy.ts (94%)
 rename {types/preview/@ember/object/test => type-tests/preview/@ember/object-test}/reopen.ts (100%)
 rename types/preview/@ember/owner/ember__owner-tests.ts => type-tests/preview/@ember/owner-tests.ts (53%)
 create mode 100644 type-tests/preview/@ember/polyfills-tests.ts
 create mode 100644 type-tests/preview/@ember/routing-test/built-ins.ts
 rename {types/preview/@ember/routing/test => type-tests/preview/@ember/routing-test}/route.ts (84%)
 create mode 100644 type-tests/preview/@ember/routing-test/router-service.ts
 rename {types/preview/@ember/routing/test => type-tests/preview/@ember/routing-test}/router.ts (100%)
 rename types/preview/@ember/runloop/ember__runloop-tests.ts => type-tests/preview/@ember/runloop-tests.ts (99%)
 rename {types/preview/@ember/service => type-tests/preview/@ember}/service-test.ts (100%)
 rename types/preview/@ember/string/ember__string-tests.ts => type-tests/preview/@ember/string-tests.ts (100%)
 rename types/preview/@ember/template/ember__template-tests.ts => type-tests/preview/@ember/template-tests.ts (68%)
 rename types/preview/@ember/test/ember__test-tests.ts => type-tests/preview/@ember/test-tests.ts (81%)
 rename types/preview/@ember/utils/ember__utils-tests.ts => type-tests/preview/@ember/utils-tests.ts (73%)
 rename {types/preview/ember/test => type-tests/preview/ember}/application-instance.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/application.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/array-proxy.ts (67%)
 rename {types/preview/ember/test => type-tests/preview/ember}/array.ts (84%)
 rename {types/preview/ember/test => type-tests/preview/ember}/component.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/computed.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/controller.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/core-object.ts (55%)
 rename {types/preview/ember/test => type-tests/preview/ember}/create-negative.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/create.ts (100%)
 create mode 100644 type-tests/preview/ember/data-adapter.ts
 create mode 100644 type-tests/preview/ember/debug.ts
 rename {types/preview/ember/test => type-tests/preview/ember}/ember-module-tests.ts (57%)
 rename {types/preview/ember/test => type-tests/preview/ember}/ember-tests.ts (87%)
 rename {types/preview/ember/test => type-tests/preview/ember}/engine-instance.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/engine.ts (100%)
 create mode 100644 type-tests/preview/ember/error.ts
 rename {types/preview/ember/test => type-tests/preview/ember}/event.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/extend.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/helper.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/inject.ts (96%)
 rename {types/preview/ember/test => type-tests/preview/ember}/mixin.ts (84%)
 rename {types/preview/ember/test => type-tests/preview/ember}/object.ts (87%)
 rename {types/preview/ember/test => type-tests/preview/ember}/observable.ts (59%)
 create mode 100644 type-tests/preview/ember/private/computed-tests.ts
 rename {types/preview/ember/test => type-tests/preview/ember}/private/observable-tests.ts (73%)
 rename {types/preview/ember/test => type-tests/preview/ember}/reopen.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/route.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/router.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/run.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/string.ts (50%)
 rename {types/preview/ember/test => type-tests/preview/ember}/techniques/properties-from-this.ts (74%)
 rename {types/preview/ember/test => type-tests/preview/ember}/test.ts (100%)
 rename {types/preview/ember/test => type-tests/preview/ember}/transition.ts (100%)
 create mode 100755 type-tests/preview/ember/utils.ts
 create mode 100644 type-tests/preview/ember/view-utils.ts
 create mode 100644 type-tests/preview/index.d.ts
 create mode 100644 type-tests/preview/tsconfig.json
 delete mode 100755 types/preview/@ember/array/test/array-ext.ts
 delete mode 100755 types/preview/@ember/array/test/lib/assert.ts
 create mode 100644 types/preview/@ember/component/-private/signature-utils.d.ts
 delete mode 100644 types/preview/@ember/component/test/built-ins.ts
 delete mode 100755 types/preview/@ember/component/test/lib/assert.ts
 delete mode 100644 types/preview/@ember/debug/ember__debug-tests.ts
 delete mode 100644 types/preview/@ember/destroyable/test/lib/assert.ts
 delete mode 100644 types/preview/@ember/helper/ember__helper-tests.ts
 delete mode 100644 types/preview/@ember/modifier/ember__modifier-tests.ts
 delete mode 100644 types/preview/@ember/object/test/access-modifier.ts
 delete mode 100644 types/preview/@ember/object/test/get-set.ts
 delete mode 100644 types/preview/@ember/object/test/internals.ts
 delete mode 100644 types/preview/@ember/object/test/lib/assert.ts
 delete mode 100644 types/preview/@ember/polyfills/ember__polyfills-tests.ts
 delete mode 100644 types/preview/@ember/routing/test/built-ins.ts
 delete mode 100755 types/preview/@ember/routing/test/lib/assert.ts
 delete mode 100644 types/preview/@ember/routing/test/router-service.ts
 delete mode 100755 types/preview/ember/test/array-ext.ts
 delete mode 100644 types/preview/ember/test/data-adapter.ts
 delete mode 100644 types/preview/ember/test/debug.ts
 delete mode 100644 types/preview/ember/test/error.ts
 delete mode 100755 types/preview/ember/test/lib/assert.ts
 delete mode 100644 types/preview/ember/test/private/computed-tests.ts
 delete mode 100755 types/preview/ember/test/utils.ts
 delete mode 100644 types/preview/ember/test/view-utils.ts
 create mode 100644 types/preview/index.d.ts

diff --git a/.eslintrc.js b/.eslintrc.js
index 25aece7add1..a768459eaee 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -89,6 +89,30 @@ module.exports = {
         'no-console': 'off',
       },
     },
+    {
+      files: ['type-tests/preview/**/*.ts'],
+      parserOptions: {
+        sourceType: 'module',
+        project: './type-tests/preview/tsconfig.json',
+        tsconfigRootDir: __dirname,
+      },
+      rules: {
+        'no-console': 'off',
+        '@typescript-eslint/no-empty-interface': 'off',
+      },
+    },
+    {
+      files: ['type-tests/preview-prototype-extensions/**/*.ts'],
+      parserOptions: {
+        sourceType: 'module',
+        project: './type-tests/preview-prototype-extensions/tsconfig.json',
+        tsconfigRootDir: __dirname,
+      },
+      rules: {
+        'no-console': 'off',
+        '@typescript-eslint/no-empty-interface': 'off',
+      },
+    },
     {
       // TODO: files: ['packages/**/*.[jt]s'],
       files: ['packages/**/*.js'],
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/types/preview/@ember/application/test/application-instance.ts b/type-tests/preview/@ember/application-test/application-instance.ts
similarity index 100%
rename from types/preview/@ember/application/test/application-instance.ts
rename to type-tests/preview/@ember/application-test/application-instance.ts
diff --git a/types/preview/@ember/application/test/application.ts b/type-tests/preview/@ember/application-test/application.ts
similarity index 73%
rename from types/preview/@ember/application/test/application.ts
rename to type-tests/preview/@ember/application-test/application.ts
index e3bb601c492..fa90f68b203 100755
--- a/types/preview/@ember/application/test/application.ts
+++ b/type-tests/preview/@ember/application-test/application.ts
@@ -1,5 +1,7 @@
 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',
@@ -38,6 +40,5 @@ const App2 = BaseApp.create({
 
 const App3 = BaseApp.create();
 
-const App3Instance1 = App3.buildInstance(); // $ExpectType ApplicationInstance
-
-const App3Instance2 = App3.buildInstance({ foo: 'bar' }); // $ExpectType ApplicationInstance
+expectTypeOf(App3.buildInstance()).toEqualTypeOf<ApplicationInstance>();
+expectTypeOf(App3.buildInstance({ foo: 'bar' })).toEqualTypeOf<ApplicationInstance>();
diff --git a/types/preview/@ember/application/test/deprecations.ts b/type-tests/preview/@ember/application-test/deprecations.ts
similarity index 100%
rename from types/preview/@ember/application/test/deprecations.ts
rename to type-tests/preview/@ember/application-test/deprecations.ts
diff --git a/types/preview/@ember/application/test/index.ts b/type-tests/preview/@ember/application-test/index.ts
similarity index 63%
rename from types/preview/@ember/application/test/index.ts
rename to type-tests/preview/@ember/application-test/index.ts
index f04751e2290..aa0d14e762d 100644
--- a/types/preview/@ember/application/test/index.ts
+++ b/type-tests/preview/@ember/application-test/index.ts
@@ -3,26 +3,25 @@ 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';
 
-// $ExpectType Owner | undefined
-getOwner({});
+expectTypeOf(getOwner({})).toEqualTypeOf<Owner | undefined>();
 
 // Confirm that random subclasses work as expected.
 declare class MyService extends Service {
   withStuff: true;
 }
 declare let myService: MyService;
-// $ExpectType Owner
-getOwner(myService);
+expectTypeOf(getOwner(myService)).toEqualTypeOf<Owner>();
 
 // @ts-expect-error
 getOwner();
 
 declare let baseOwner: Owner;
-setOwner({}, baseOwner);
+expectTypeOf(setOwner({}, baseOwner)).toBeVoid();
 
 declare let engine: EngineInstance;
-setOwner({}, engine);
+expectTypeOf(setOwner({}, engine)).toBeVoid();
 
 declare let application: ApplicationInstance;
-setOwner({}, application);
+expectTypeOf(setOwner({}, application)).toBeVoid();
diff --git a/types/preview/@ember/array/test/array-proxy.ts b/type-tests/preview/@ember/array-test/array-proxy.ts
similarity index 77%
rename from types/preview/@ember/array/test/array-proxy.ts
rename to type-tests/preview/@ember/array-test/array-proxy.ts
index 4aa3714dc08..9b2c81782ff 100644
--- a/types/preview/@ember/array/test/array-proxy.ts
+++ b/type-tests/preview/@ember/array-test/array-proxy.ts
@@ -1,7 +1,7 @@
-import { assertType } from './lib/assert';
 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) });
@@ -13,7 +13,9 @@ proxy.get('firstObject'); // 'amoeba'
 const overridden = ArrayProxy.create({
   content: A(pets),
   objectAtContent(this: ArrayProxy<string>, idx: number): string | undefined {
-    return this.get('content').objectAt(idx)?.toUpperCase();
+    // 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();
   },
 });
 
@@ -24,10 +26,11 @@ class MyNewProxy<T> extends ArrayProxy<T> {
 }
 
 const x = MyNewProxy.create({ content: A([1, 2, 3]) }) as MyNewProxy<number>;
-assertType<number | undefined>(x.get('firstObject'));
-assertType<boolean>(x.isNew);
+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();
diff --git a/types/preview/@ember/array/test/array.ts b/type-tests/preview/@ember/array-test/array.ts
similarity index 77%
rename from types/preview/@ember/array/test/array.ts
rename to type-tests/preview/@ember/array-test/array.ts
index 1f63d8f9eb7..8f7df294f56 100755
--- a/types/preview/@ember/array/test/array.ts
+++ b/type-tests/preview/@ember/array-test/array.ts
@@ -1,6 +1,7 @@
 import EmberObject from '@ember/object';
-import EmberArray, { A } from '@ember/array';
-import MutableArray from '@ember/array/mutable';
+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 {
@@ -18,11 +19,11 @@ 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
+// @ts-expect-error -- string != boolean
 people.isAny('isHappy', 'false');
 
 expectTypeOf(people.objectAt(0)).toEqualTypeOf<Person | undefined>();
-expectTypeOf(people.objectsAt([1, 2, 3])).toEqualTypeOf<EmberArray<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>>();
@@ -36,8 +37,8 @@ expectTypeOf(people.filter((person) => person.get('name') === 'Yehuda')).toMatch
 expectTypeOf(people.get('[]')).toEqualTypeOf<typeof people>();
 expectTypeOf(people.get('[]').get('firstObject')).toEqualTypeOf<Person | undefined>();
 
-expectTypeOf(people.mapBy('isHappy')).toEqualTypeOf<boolean[]>();
-expectTypeOf(people.mapBy('name.length')).toEqualTypeOf<unknown[]>();
+expectTypeOf(people.mapBy('isHappy')).toMatchTypeOf<boolean[]>();
+expectTypeOf(people.mapBy('name.length')).toMatchTypeOf<unknown[]>();
 
 const last = people.get('lastObject');
 expectTypeOf(last).toEqualTypeOf<Person | undefined>();
@@ -50,13 +51,14 @@ if (first) {
   expectTypeOf(first.get('isHappy')).toBeBoolean();
 }
 
-const letters: EmberArray<string> = A(['a', 'b', 'c']);
-const codes = letters.map((item, index, enumerable) => {
+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).toEqualTypeOf<number[]>();
+expectTypeOf(codes).toMatchTypeOf<number[]>();
 
 const value = '1,2,3';
 const filters = A(value.split(','));
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/types/preview/@ember/component/test/component.ts b/type-tests/preview/@ember/component-test/component.ts
similarity index 92%
rename from types/preview/@ember/component/test/component.ts
rename to type-tests/preview/@ember/component-test/component.ts
index adb2a269a90..3df213d853c 100644
--- a/types/preview/@ember/component/test/component.ts
+++ b/type-tests/preview/@ember/component-test/component.ts
@@ -1,13 +1,13 @@
 import Component from '@ember/component';
 import Object, { computed, get } from '@ember/object';
-import { assertType } from './lib/assert';
+import { expectTypeOf } from 'expect-type';
 
 Component.extend({
   layout: 'my-layout',
 });
 
 const MyComponent = Component.extend();
-assertType<string | string[]>(get(MyComponent, 'positionalParams'));
+expectTypeOf(get(MyComponent, 'positionalParams')).toEqualTypeOf<string | string[]>();
 
 const component1 = Component.extend({
   actions: {
@@ -144,10 +144,10 @@ type NamedArgsFor<T> = GetWithFallback<GetWithFallback<T, 'Args', {}>, 'Named',
 interface SigExample extends NamedArgsFor<MySig> {}
 class SigExample extends Component<MySig> {
   get accessArgs() {
-    const {
-      name, // $ExpectType string
-      age, // $ExpectType number
-    } = this;
+    const { name, age } = this;
+
+    expectTypeOf(name).toBeString();
+    expectTypeOf(age).toBeNumber();
 
     return `${name} is ${age} years old`;
   }
diff --git a/types/preview/@ember/component/test/helper.ts b/type-tests/preview/@ember/component-test/helper.ts
similarity index 72%
rename from types/preview/@ember/component/test/helper.ts
rename to type-tests/preview/@ember/component-test/helper.ts
index 2371fd666da..f63a4c6077f 100644
--- a/types/preview/@ember/component/test/helper.ts
+++ b/type-tests/preview/@ember/component-test/helper.ts
@@ -1,4 +1,11 @@
-import Helper, { ExpandSignature, helper } from '@ember/component/helper';
+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];
@@ -35,14 +42,10 @@ interface DemoSig {
 }
 
 function testMissingSignature({ Args, Return }: ExpandSignature<unknown>) {
-  // $ExpectType BadType<"This helper is missing a signature">
-  Args.Named;
+  expectTypeOf(Args.Named).toEqualTypeOf<BadType<'This helper is missing a signature'>>();
 
-  // $ExpectType unknown[]
-  Args.Positional;
-
-  // $ExpectType unknown
-  Return;
+  expectTypeOf(Args.Positional).toEqualTypeOf<unknown[]>();
+  expectTypeOf(Return).toBeUnknown();
 }
 
 class SignatureForm extends Helper<DemoSig> {
@@ -93,31 +96,42 @@ class BadReturnForm extends Helper<DemoSig> {
   }
 }
 
-// $ExpectType FunctionBasedHelper<{ Args: { Positional: [number, number]; Named: EmptyObject; }; Return: number; }>
 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) => {
-  // $ExpectType EmptyObject
-  named;
+  expectTypeOf(named).toEqualTypeOf<EmptyObject>();
 });
 
-// $ExpectType FunctionBasedHelper<{ Args: { Positional: DefaultPositional; Named: { cool: boolean; }; }; Return: 123 | "neat"; }>
 const typeInferenceOnNamed = helper((_, { cool }: { cool: boolean }) => {
-  // $ExpectType boolean
-  cool;
+  expectTypeOf(cool).toBeBoolean();
 
   return cool ? 123 : 'neat';
 });
+expectTypeOf(typeInferenceOnNamed).toEqualTypeOf<
+  FunctionBasedHelper<{
+    Args: { Positional: DefaultPositional; Named: { cool: boolean } };
+    Return: 123 | 'neat';
+  }>
+>();
 
-// $ExpectType FunctionBasedHelper<{ Args: { Positional: [string]; Named: { delim?: string; }; }; Return: string; }>
 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`)
@@ -146,5 +160,10 @@ new greet();
 // @ts-expect-error
 class Subgreet extends greet {}
 
-// $ExpectType abstract new <T>() => FunctionBasedHelperInstance<{ Args: { Positional: [T]; Named: EmptyObject; }; Return: [T, T]; }>
 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/types/preview/@ember/component/test/template-only.ts b/type-tests/preview/@ember/component-test/template-only.ts
similarity index 53%
rename from types/preview/@ember/component/test/template-only.ts
rename to type-tests/preview/@ember/component-test/template-only.ts
index 6a9e0d01c19..1e06e9bf369 100644
--- a/types/preview/@ember/component/test/template-only.ts
+++ b/type-tests/preview/@ember/component-test/template-only.ts
@@ -1,8 +1,10 @@
 import templateOnly, { TemplateOnlyComponent, TOC } from '@ember/component/template-only';
+import { expectTypeOf } from 'expect-type';
 
-const to = templateOnly(); // $ExpectType TemplateOnlyComponent<unknown>
+const to = templateOnly();
+expectTypeOf(to).toEqualTypeOf<TemplateOnlyComponent<unknown>>();
 
-to.toString(); // $ExpectType string
+expectTypeOf(to.toString()).toBeString();
 
 // @ts-expect-error
 new TemplateOnlyComponent();
@@ -18,11 +20,11 @@ interface MySig {
   };
 }
 
-// $ExpectType TemplateOnlyComponent<MySig>
 const toc: TOC<MySig> = templateOnly();
+expectTypeOf(toc).toEqualTypeOf<TemplateOnlyComponent<MySig>>();
 
-// $ExpectType TemplateOnlyComponent<MySig>
 const tocInferred = templateOnly<MySig>();
+expectTypeOf(tocInferred).toEqualTypeOf<TemplateOnlyComponent<MySig>>();
 
-// $ExpectType TemplateOnlyComponent<MySig>
 const longToc: TemplateOnlyComponent<MySig> = templateOnly();
+expectTypeOf(longToc).toEqualTypeOf<TemplateOnlyComponent<MySig>>();
diff --git a/types/preview/@ember/controller/test/main.ts b/type-tests/preview/@ember/controller-test/main.ts
similarity index 100%
rename from types/preview/@ember/controller/test/main.ts
rename to type-tests/preview/@ember/controller-test/main.ts
diff --git a/types/preview/@ember/controller/test/octane.ts b/type-tests/preview/@ember/controller-test/octane.ts
similarity index 100%
rename from types/preview/@ember/controller/test/octane.ts
rename to type-tests/preview/@ember/controller-test/octane.ts
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/types/preview/@ember/destroyable/test/main.ts b/type-tests/preview/@ember/destroyable-test.ts
similarity index 85%
rename from types/preview/@ember/destroyable/test/main.ts
rename to type-tests/preview/@ember/destroyable-test.ts
index c852d7c303d..918f34296ce 100644
--- a/types/preview/@ember/destroyable/test/main.ts
+++ b/type-tests/preview/@ember/destroyable-test.ts
@@ -8,8 +8,7 @@ import {
   registerDestructor,
   unregisterDestructor,
 } from '@ember/destroyable';
-
-import { assertType } from './lib/assert';
+import { expectTypeOf } from 'expect-type';
 
 // @ts-expect-error
 enableDestroyableTracking(true);
@@ -69,16 +68,16 @@ const p = new Parent(c);
 // @ts-expect-error
 destroy();
 
-assertType<boolean>(isDestroyed(c));
-assertType<boolean>(isDestroyed(p));
+expectTypeOf(isDestroyed(c)).toBeBoolean();
+expectTypeOf(isDestroyed(p)).toBeBoolean();
 
 destroy(p);
 
-assertType<boolean>(isDestroying(c));
-assertType<boolean>(isDestroying(p));
+expectTypeOf(isDestroying(c)).toBeBoolean();
+expectTypeOf(isDestroying(p)).toBeBoolean();
 
-assertType<boolean>(isDestroyed(c));
-assertType<boolean>(isDestroyed(p));
+expectTypeOf(isDestroyed(c)).toBeBoolean();
+expectTypeOf(isDestroyed(p)).toBeBoolean();
 
 // @ts-expect-error
 assertDestroyablesDestroyed(true);
diff --git a/types/preview/@ember/engine/test/engine-instance.ts b/type-tests/preview/@ember/engine-test/engine-instance.ts
similarity index 100%
rename from types/preview/@ember/engine/test/engine-instance.ts
rename to type-tests/preview/@ember/engine-test/engine-instance.ts
diff --git a/types/preview/@ember/engine/test/engine.ts b/type-tests/preview/@ember/engine-test/engine.ts
similarity index 100%
rename from types/preview/@ember/engine/test/engine.ts
rename to type-tests/preview/@ember/engine-test/engine.ts
diff --git a/types/preview/@ember/error/ember__error-tests.ts b/type-tests/preview/@ember/error-tests.ts
similarity index 50%
rename from types/preview/@ember/error/ember__error-tests.ts
rename to type-tests/preview/@ember/error-tests.ts
index d54bd7e0aad..3ffd32c5af9 100644
--- a/types/preview/@ember/error/ember__error-tests.ts
+++ b/type-tests/preview/@ember/error-tests.ts
@@ -1,6 +1,7 @@
 import Error from '@ember/error';
+import { expectTypeOf } from 'expect-type';
 
-new Error('Fuuuuuuuu'); // $ExpectType EmberError
+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/types/preview/@ember/object/test/compat.ts b/type-tests/preview/@ember/object-test/compat.ts
similarity index 100%
rename from types/preview/@ember/object/test/compat.ts
rename to type-tests/preview/@ember/object-test/compat.ts
diff --git a/types/preview/@ember/object/test/computed.ts b/type-tests/preview/@ember/object-test/computed.ts
similarity index 100%
rename from types/preview/@ember/object/test/computed.ts
rename to type-tests/preview/@ember/object-test/computed.ts
diff --git a/types/preview/@ember/object/test/core.ts b/type-tests/preview/@ember/object-test/core.ts
similarity index 55%
rename from types/preview/@ember/object/test/core.ts
rename to type-tests/preview/@ember/object-test/core.ts
index 2030d672887..bc028dc41e4 100644
--- a/types/preview/@ember/object/test/core.ts
+++ b/type-tests/preview/@ember/object-test/core.ts
@@ -4,21 +4,17 @@ import { expectTypeOf } from 'expect-type';
 /** Newable tests */
 const co1 = new CoreObject();
 
-// TODO: Enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-// co1.concatenatedProperties; // $ExpectType string[]
-co1.isDestroyed; // $ExpectType boolean
-co1.isDestroying; // $ExpectType boolean
-co1.destroy(); // $ExpectType CoreObject
-co1.toString(); // $ExpectType string
+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();
-// TODO: Enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-// co2.concatenatedProperties; // $ExpectType string[]
-co2.isDestroyed; // $ExpectType boolean
-co2.isDestroying; // $ExpectType boolean
-co2.destroy(); // $ExpectType CoreObject
-co2.toString(); // $ExpectType string
+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 {
@@ -27,8 +23,8 @@ declare class CO3 extends CoreObject {
 }
 const co3 = CO3.create({ foo: '123', bar: 456 });
 
-co3.foo; // $ExpectType string
-co3.bar; // $ExpectType number
+expectTypeOf(co3.foo).toEqualTypeOf<string>();
+expectTypeOf(co3.bar).toEqualTypeOf<number>();
 
 /** .extend with a zero-argument .create()  */
 class CO4 extends CO3 {
@@ -38,9 +34,9 @@ class CO4 extends CO3 {
 }
 const co4 = CO4.create();
 
-co4.foo; // $ExpectType string
-co4.bar; // $ExpectType number
-co4.baz; // $ExpectType () => [string, number]
+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 {
diff --git a/types/preview/@ember/object/test/create-negative.ts b/type-tests/preview/@ember/object-test/create-negative.ts
similarity index 100%
rename from types/preview/@ember/object/test/create-negative.ts
rename to type-tests/preview/@ember/object-test/create-negative.ts
diff --git a/types/preview/@ember/object/test/create.ts b/type-tests/preview/@ember/object-test/create.ts
similarity index 100%
rename from types/preview/@ember/object/test/create.ts
rename to type-tests/preview/@ember/object-test/create.ts
diff --git a/types/preview/@ember/object/test/event.ts b/type-tests/preview/@ember/object-test/event.ts
similarity index 100%
rename from types/preview/@ember/object/test/event.ts
rename to type-tests/preview/@ember/object-test/event.ts
diff --git a/types/preview/@ember/object/test/extend.ts b/type-tests/preview/@ember/object-test/extend.ts
similarity index 100%
rename from types/preview/@ember/object/test/extend.ts
rename to type-tests/preview/@ember/object-test/extend.ts
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/types/preview/@ember/object/test/object.ts b/type-tests/preview/@ember/object-test/object.ts
similarity index 92%
rename from types/preview/@ember/object/test/object.ts
rename to type-tests/preview/@ember/object-test/object.ts
index 1ff499ba089..6a022f01099 100644
--- a/types/preview/@ember/object/test/object.ts
+++ b/type-tests/preview/@ember/object-test/object.ts
@@ -52,9 +52,9 @@ class Foo extends Object {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const a: number = this.get('b');
 
-    this.get('b').toFixed(4); // $ExpectType string
-    this.set('a', 'abc').split(','); // $ExpectType string[]
-    this.set('b', 10).toFixed(4); // $ExpectType string
+    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
diff --git a/types/preview/@ember/object/test/observable.ts b/type-tests/preview/@ember/object-test/observable.ts
similarity index 100%
rename from types/preview/@ember/object/test/observable.ts
rename to type-tests/preview/@ember/object-test/observable.ts
diff --git a/types/preview/@ember/object/test/proxy.ts b/type-tests/preview/@ember/object-test/proxy.ts
similarity index 94%
rename from types/preview/@ember/object/test/proxy.ts
rename to type-tests/preview/@ember/object-test/proxy.ts
index d05aa51917d..fec756a37c3 100644
--- a/types/preview/@ember/object/test/proxy.ts
+++ b/type-tests/preview/@ember/object-test/proxy.ts
@@ -9,7 +9,7 @@ interface Book {
 }
 
 class DefaultProxy extends ObjectProxy {}
-DefaultProxy.create().content; // $ExpectType object | undefined
+expectTypeOf(DefaultProxy.create().content).toEqualTypeOf<object | undefined>();
 
 class BookProxy extends ObjectProxy<Book> {
   private readonly baz = 'baz';
@@ -26,7 +26,7 @@ class BookProxy extends ObjectProxy<Book> {
 }
 
 const book = BookProxy.create();
-expectTypeOf(book.content).toEqualTypeOf<Book | undefined>(); // $ExpectType Book | undefined
+expectTypeOf(book.content).toEqualTypeOf<Book | undefined>();
 
 // @ts-expect-error
 book.get('unknownProperty');
diff --git a/types/preview/@ember/object/test/reopen.ts b/type-tests/preview/@ember/object-test/reopen.ts
similarity index 100%
rename from types/preview/@ember/object/test/reopen.ts
rename to type-tests/preview/@ember/object-test/reopen.ts
diff --git a/types/preview/@ember/owner/ember__owner-tests.ts b/type-tests/preview/@ember/owner-tests.ts
similarity index 53%
rename from types/preview/@ember/owner/ember__owner-tests.ts
rename to type-tests/preview/@ember/owner-tests.ts
index f5a6603df5a..4effdfb996b 100644
--- a/types/preview/@ember/owner/ember__owner-tests.ts
+++ b/type-tests/preview/@ember/owner-tests.ts
@@ -1,4 +1,5 @@
 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 {
@@ -7,8 +8,8 @@ declare class ConstructThis {
 
 // ----- RegisterOptions ----- //
 declare let regOptionsA: RegisterOptions;
-regOptionsA.instantiate; // $ExpectType boolean | undefined
-regOptionsA.singleton; // $ExpectType boolean | undefined
+expectTypeOf(regOptionsA.instantiate).toEqualTypeOf<boolean | undefined>();
+expectTypeOf(regOptionsA.singleton).toEqualTypeOf<boolean | undefined>();
 
 // ----- Factory ----- //
 // This gives us coverage for the cases where you are *casting*.
@@ -40,15 +41,15 @@ aFactory.create(badPojo);
 
 // ----- FactoryManager ----- //
 declare let aFactoryManager: FactoryManager<ConstructThis>;
-aFactoryManager.class; // $ExpectType Factory<ConstructThis>
-aFactoryManager.create({}); // $ExpectType ConstructThis
-aFactoryManager.create({ hasProps: true }); // $ExpectType ConstructThis
-aFactoryManager.create({ hasProps: false }); // $ExpectType 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' });
-aFactoryManager.create(goodPojo); // $ExpectType ConstructThis
+expectTypeOf(aFactoryManager.create(goodPojo)).toEqualTypeOf<ConstructThis>();
 // @ts-expect-error
 aFactoryManager.create(badPojo);
 
@@ -58,33 +59,45 @@ declare let owner: Owner;
 
 // @ts-expect-error
 owner.lookup();
-owner.lookup('type:name'); // $ExpectType unknown
+expectTypeOf(owner.lookup('type:name')).toEqualTypeOf<unknown>();
 // @ts-expect-error
 owner.lookup('non-namespace-string');
-owner.lookup('namespace@type:name'); // $ExpectType unknown
-
-owner.register('type:name', aFactory); // $ExpectType void
-owner.register('type:name', aFactory, {}); // $ExpectType void
-owner.register('type:name', aFactory, { instantiate: true }); // $ExpectType void
-owner.register('type:name', aFactory, { instantiate: false }); // $ExpectType void
-owner.register('type:name', aFactory, { singleton: true }); // $ExpectType void
-owner.register('type:name', aFactory, { singleton: false }); // $ExpectType void
-owner.register('type:name', aFactory, { instantiate: true, singleton: true }); // $ExpectType void
-owner.register('type:name', aFactory, { instantiate: true, singleton: false }); // $ExpectType void
-owner.register('type:name', aFactory, { instantiate: false, singleton: true }); // $ExpectType void
-owner.register('type:name', aFactory, { instantiate: false, singleton: false }); // $ExpectType void
+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);
-owner.register('namespace@type:name', aFactory); // $ExpectType void
-
-owner.factoryFor('type:name'); // $ExpectType FactoryManager<unknown> | undefined
-owner.factoryFor('type:name')?.class; // $ExpectType Factory<unknown> | undefined
-owner.factoryFor('type:name')?.create(); // $ExpectType unknown
-owner.factoryFor('type:name')?.create({}); // $ExpectType unknown
-owner.factoryFor('type:name')?.create({ anythingGoes: true }); // $ExpectType unknown
+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');
-owner.factoryFor('namespace@type:name'); // $ExpectType FactoryManager<unknown> | undefined
+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
@@ -96,7 +109,7 @@ owner.lookup(aName);
 
 let aTypedName: FullName;
 aTypedName = 'type:name';
-owner.lookup(aTypedName); // $ExpectType unknown
+expectTypeOf(owner.lookup(aTypedName)).toBeUnknown();
 
 // Nor will callbacks work "out of the box". But they can work if they have the
 // correct type.
@@ -108,7 +121,7 @@ typedStrings.map((aString) => owner.lookup(aString));
 
 // Also make sure it keeps working with const bindings
 const aConstName = 'type:name';
-owner.lookup(aConstName); // $ExpectType unknown
+expectTypeOf(owner.lookup(aConstName)).toBeUnknown();
 
 // ----- Minimal further coverage for POJOs ----- //
 // `Factory` and `FactoryManager` don't have to deal in actual classes. :sigh:
@@ -132,4 +145,4 @@ const pojoFactory: Factory<typeof Creatable> = {
   },
 };
 
-pojoFactory.create(); // $ExpectType { hasProps: boolean; }
+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/types/preview/@ember/routing/test/route.ts b/type-tests/preview/@ember/routing-test/route.ts
similarity index 84%
rename from types/preview/@ember/routing/test/route.ts
rename to type-tests/preview/@ember/routing-test/route.ts
index fea2b336b2e..b550e7180f6 100755
--- a/types/preview/@ember/routing/test/route.ts
+++ b/type-tests/preview/@ember/routing-test/route.ts
@@ -1,10 +1,12 @@
+/* eslint-disable @typescript-eslint/no-empty-interface */
 /* eslint-disable prefer-const */
 import Route from '@ember/routing/route';
-import Array from '@ember/array';
+import type Array from '@ember/array';
 import EmberObject from '@ember/object';
 import Controller from '@ember/controller';
-import Transition from '@ember/routing/transition';
-import RouteInfo, { RouteInfoWithAttributes } from '@ember/routing/route-info';
+import type Transition from '@ember/routing/transition';
+import type { RouteInfoWithAttributes } from '@ember/routing/route-info';
+import type RouteInfo from '@ember/routing/route-info';
 
 class Post extends EmberObject {}
 
@@ -99,23 +101,23 @@ class TransitionToExamples extends Route {
   }
 
   transitionToId() {
-    // $ExpectType Transition<unknown>
-    this.transitionTo('blog-post', 1);
+    expectTypeOf(this.transitionTo('blog-post', 1)).toEqualTypeOf<Transition<unknown>>();
   }
 
   transitionToIdWithQP() {
-    // $ExpectType Transition<unknown>
-    this.transitionTo('blog-post', 1, { queryParams: { includeComments: true } });
+    expectTypeOf(
+      this.transitionTo('blog-post', 1, { queryParams: { includeComments: true } })
+    ).toEqualTypeOf<Transition<unknown>>();
   }
 
   transitionToIds() {
-    // $ExpectType Transition<unknown>
-    this.transitionTo('blog-comment', 1, '13');
+    expectTypeOf(this.transitionTo('blog-comment', 1, '13')).toEqualTypeOf<Transition<unknown>>();
   }
 
   transitionToIdsWithQP() {
-    // $ExpectType Transition<unknown>
-    this.transitionTo('blog-comment', 1, '13', { queryParams: { includePost: true } });
+    expectTypeOf(
+      this.transitionTo('blog-comment', 1, '13', { queryParams: { includePost: true } })
+    ).toEqualTypeOf<Transition<unknown>>();
   }
 
   buildRouteInfoMetadata() {
@@ -209,19 +211,19 @@ expectTypeOf<ImplicitParams>().toEqualTypeOf<RouteParams>();
 // back-compat for existing users of these
 // NOTE: we will *not* migrate the private import locations when moving to
 // publish from Ember itself.
-import PrivateTransition from '@ember/routing/-private/transition';
+import type PrivateTransition from '@ember/routing/-private/transition';
 declare let publicTransition: Transition;
 declare let oldPrivateTransition: PrivateTransition;
 publicTransition = oldPrivateTransition;
 oldPrivateTransition = publicTransition;
 
-import PrivateRouteInfo from '@ember/routing/-private/route-info';
+import type PrivateRouteInfo from '@ember/routing/-private/route-info';
 declare let publicRouteInfo: RouteInfo;
 declare let privateRouteInfo: PrivateRouteInfo;
 publicRouteInfo = privateRouteInfo;
 privateRouteInfo = publicRouteInfo;
 
-import PrivateRouteInfoWithAttributes from '@ember/routing/-private/route-info-with-attributes';
+import type PrivateRouteInfoWithAttributes from '@ember/routing/-private/route-info-with-attributes';
 import { expectTypeOf } from 'expect-type';
 declare let publicRouteInfoWithAttributes: RouteInfoWithAttributes;
 declare let privateRouteInfoWithAttributes: PrivateRouteInfoWithAttributes;
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/types/preview/@ember/routing/test/router.ts b/type-tests/preview/@ember/routing-test/router.ts
similarity index 100%
rename from types/preview/@ember/routing/test/router.ts
rename to type-tests/preview/@ember/routing-test/router.ts
diff --git a/types/preview/@ember/runloop/ember__runloop-tests.ts b/type-tests/preview/@ember/runloop-tests.ts
similarity index 99%
rename from types/preview/@ember/runloop/ember__runloop-tests.ts
rename to type-tests/preview/@ember/runloop-tests.ts
index f62a8889f8e..799d86ef5c6 100644
--- a/types/preview/@ember/runloop/ember__runloop-tests.ts
+++ b/type-tests/preview/@ember/runloop-tests.ts
@@ -16,7 +16,7 @@ import {
   _backburner,
 } from '@ember/runloop';
 import EmberObject, { action } from '@ember/object';
-import {
+import type {
   Backburner,
   DebugInfo,
   QueueItem,
@@ -31,7 +31,6 @@ declare module '@ember/runloop' {
 
 function testRun() {
   run(() => {
-    // $ExpectType number
     // code to be executed within a RunLoop
     return 123;
   });
diff --git a/types/preview/@ember/service/service-test.ts b/type-tests/preview/@ember/service-test.ts
similarity index 100%
rename from types/preview/@ember/service/service-test.ts
rename to type-tests/preview/@ember/service-test.ts
diff --git a/types/preview/@ember/string/ember__string-tests.ts b/type-tests/preview/@ember/string-tests.ts
similarity index 100%
rename from types/preview/@ember/string/ember__string-tests.ts
rename to type-tests/preview/@ember/string-tests.ts
diff --git a/types/preview/@ember/template/ember__template-tests.ts b/type-tests/preview/@ember/template-tests.ts
similarity index 68%
rename from types/preview/@ember/template/ember__template-tests.ts
rename to type-tests/preview/@ember/template-tests.ts
index ae0a832925b..7c38e72387e 100644
--- a/types/preview/@ember/template/ember__template-tests.ts
+++ b/type-tests/preview/@ember/template-tests.ts
@@ -1,11 +1,14 @@
 import { SafeString } from '@ember/template/-private/handlebars';
 import { htmlSafe, isHTMLSafe } from '@ember/template';
+import { expectTypeOf } from 'expect-type';
 
 const handlebarsSafeString: SafeString = htmlSafe('lorem ipsum...');
-htmlSafe('lorem ipsum...'); // $ExpectType SafeString
+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();
diff --git a/types/preview/@ember/test/ember__test-tests.ts b/type-tests/preview/@ember/test-tests.ts
similarity index 81%
rename from types/preview/@ember/test/ember__test-tests.ts
rename to type-tests/preview/@ember/test-tests.ts
index 29a689158b1..c21818e92aa 100644
--- a/types/preview/@ember/test/ember__test-tests.ts
+++ b/type-tests/preview/@ember/test-tests.ts
@@ -1,5 +1,6 @@
 import { registerWaiter, registerHelper, registerAsyncHelper } from '@ember/test';
 import TestAdapter from '@ember/test/adapter';
+import { expectTypeOf } from 'expect-type';
 
 const pending = 0;
 registerWaiter(() => pending !== 0);
@@ -13,9 +14,9 @@ registerWaiter(MyDb, MyDb.hasPendingTransactions);
 registerWaiter();
 
 registerHelper('boot', (app) => {
-  app.advanceReadiness(); // $ExpectType void
-  app.deferReadiness(); // $ExpectType void
-  app.register('foo', class {}); // $ExpectType void
+  expectTypeOf(app.advanceReadiness()).toBeVoid();
+  expectTypeOf(app.deferReadiness()).toBeVoid();
+  expectTypeOf(app.register('foo', class {})).toBeVoid();
   // @ts-expect-error
   app.register('foo');
   // @ts-expect-error
diff --git a/types/preview/@ember/utils/ember__utils-tests.ts b/type-tests/preview/@ember/utils-tests.ts
similarity index 73%
rename from types/preview/@ember/utils/ember__utils-tests.ts
rename to type-tests/preview/@ember/utils-tests.ts
index b9be7a5b34d..506dfb94b1b 100644
--- a/types/preview/@ember/utils/ember__utils-tests.ts
+++ b/type-tests/preview/@ember/utils-tests.ts
@@ -1,5 +1,6 @@
 /* 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';
 
@@ -9,7 +10,7 @@ import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@
   if (isNone(maybeUndefined)) {
     return;
   }
-  const anotherString = maybeUndefined + 'another string';
+  expectTypeOf(maybeUndefined).toBeString();
   expectTypeOf(isNone()).toEqualTypeOf<boolean>();
   expectTypeOf(isNone(null)).toEqualTypeOf<boolean>();
   expectTypeOf(isNone(undefined)).toEqualTypeOf<boolean>();
@@ -41,38 +42,32 @@ import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@
 
 (function () {
   /** typeOf */
-  typeOf(null); // $ExpectType "null"
-  typeOf(undefined); // $ExpectType "undefined"
-  typeOf('michael'); // $ExpectType "string"
-  // tslint:disable-next-line:no-construct
-  typeOf(new String('michael')); // $ExpectType "string"
-  typeOf(101); // $ExpectType "number"
-  // tslint:disable-next-line:no-construct
-  typeOf(new Number(101)); // $ExpectType "number"
-  typeOf(true); // $ExpectType "boolean"
-  // tslint:disable-next-line:no-construct
-  typeOf(new Boolean(true)); // $ExpectType "boolean"
-  typeOf(() => 4); // $ExpectType "function"
-  typeOf([1, 2, 90]); // $ExpectType "array"
-  typeOf(/abc/); // $ExpectType "regexp"
-  typeOf(new Date()); // $ExpectType "date"
-  typeOf(new FileList()); // $ExpectType "filelist"
-  // typeOf(EmberObject.extend());   // $ExpectType "class"
-  // typeOf(EmberObject.create());   // $ExpectType "instance"
-  typeOf(new Error('teamocil')); // $ExpectType "error"
-  typeOf({ justAPojo: true }); // $ExpectType "object"
+  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');
-  // tslint:disable-next-line:no-construct
   typeOf(new String('michael'));
   typeOf(101);
-  // tslint:disable-next-line:no-construct
   typeOf(new Number(101));
   typeOf(true);
-  // tslint:disable-next-line:no-construct
   typeOf(new Boolean(true));
   typeOf(() => 4);
   typeOf([1, 2, 90]);
@@ -101,12 +96,12 @@ import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@
 
 (function () {
   /** compare */
-  compare('foo', 'bar'); // $ExpectType number
-  compare(14, 37); // $ExpectType number
-  compare(class {}, class {}); // $ExpectType number
-  compare([], class {}); // $ExpectType number
-  compare([], undefined); // $ExpectType number
-  compare({}, () => 4); // $ExpectType number
+  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
diff --git a/types/preview/ember/test/application-instance.ts b/type-tests/preview/ember/application-instance.ts
similarity index 100%
rename from types/preview/ember/test/application-instance.ts
rename to type-tests/preview/ember/application-instance.ts
diff --git a/types/preview/ember/test/application.ts b/type-tests/preview/ember/application.ts
similarity index 100%
rename from types/preview/ember/test/application.ts
rename to type-tests/preview/ember/application.ts
diff --git a/types/preview/ember/test/array-proxy.ts b/type-tests/preview/ember/array-proxy.ts
similarity index 67%
rename from types/preview/ember/test/array-proxy.ts
rename to type-tests/preview/ember/array-proxy.ts
index 8099af3aa98..d88fe73fff8 100644
--- a/types/preview/ember/test/array-proxy.ts
+++ b/type-tests/preview/ember/array-proxy.ts
@@ -1,5 +1,6 @@
+import type Array from '@ember/array';
 import Ember from 'ember';
-import { assertType } from './lib/assert';
+import { expectTypeOf } from 'expect-type';
 
 const pets = ['dog', 'cat', 'fish'];
 const proxy = Ember.ArrayProxy.create({ content: Ember.A(pets) });
@@ -10,8 +11,8 @@ proxy.get('firstObject'); // 'amoeba'
 
 const overridden = Ember.ArrayProxy.create({
   content: Ember.A(pets),
-  objectAtContent(this: Ember.ArrayProxy<string>, idx: number): string {
-    return this.get('content').objectAt(idx)!.toUpperCase();
+  objectAtContent(this: Ember.ArrayProxy<string>, idx: number): string | undefined {
+    return (this.get('content') as Array<string>).objectAt(idx)?.toUpperCase();
   },
 });
 
@@ -22,5 +23,5 @@ class MyNewProxy<T> extends Ember.ArrayProxy<T> {
 }
 
 const x = MyNewProxy.create({ content: Ember.A([1, 2, 3]) }) as MyNewProxy<number>;
-assertType<number | undefined>(x.get('firstObject'));
-assertType<boolean>(x.isNew);
+expectTypeOf(x.get('firstObject')).toEqualTypeOf<number | undefined>();
+expectTypeOf(x.isNew).toBeBoolean();
diff --git a/types/preview/ember/test/array.ts b/type-tests/preview/ember/array.ts
similarity index 84%
rename from types/preview/ember/test/array.ts
rename to type-tests/preview/ember/array.ts
index 5c1588211e2..b5db931246a 100755
--- a/types/preview/ember/test/array.ts
+++ b/type-tests/preview/ember/array.ts
@@ -34,8 +34,8 @@ expectTypeOf(people.filter((person) => person.get('name') === 'Yehuda')).toMatch
 expectTypeOf(people.get('[]')).toEqualTypeOf<typeof people>();
 expectTypeOf(people.get('[]').get('firstObject')).toEqualTypeOf<Person | undefined>();
 
-expectTypeOf(people.mapBy('isHappy')).toEqualTypeOf<boolean[]>();
-expectTypeOf(people.mapBy('name.length')).toEqualTypeOf<unknown[]>();
+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>();
@@ -49,12 +49,14 @@ if (first) {
 }
 
 const letters: Ember.Array<string> = Ember.A(['a', 'b', 'c']);
-const codes = letters.map((item, index, enumerable) => {
+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).toEqualTypeOf<number[]>();
+expectTypeOf(codes).toMatchTypeOf<number[]>();
+expectTypeOf(codes).toEqualTypeOf<Ember.NativeArray<number>>();
 
 const value = '1,2,3';
 const filters = Ember.A(value.split(','));
diff --git a/types/preview/ember/test/component.ts b/type-tests/preview/ember/component.ts
similarity index 100%
rename from types/preview/ember/test/component.ts
rename to type-tests/preview/ember/component.ts
diff --git a/types/preview/ember/test/computed.ts b/type-tests/preview/ember/computed.ts
similarity index 100%
rename from types/preview/ember/test/computed.ts
rename to type-tests/preview/ember/computed.ts
diff --git a/types/preview/ember/test/controller.ts b/type-tests/preview/ember/controller.ts
similarity index 100%
rename from types/preview/ember/test/controller.ts
rename to type-tests/preview/ember/controller.ts
diff --git a/types/preview/ember/test/core-object.ts b/type-tests/preview/ember/core-object.ts
similarity index 55%
rename from types/preview/ember/test/core-object.ts
rename to type-tests/preview/ember/core-object.ts
index 3cc7862c645..98dfc21a3a1 100644
--- a/types/preview/ember/test/core-object.ts
+++ b/type-tests/preview/ember/core-object.ts
@@ -6,21 +6,17 @@ const { CoreObject } = Ember;
 /** Newable tests */
 const co1 = new CoreObject();
 
-// TODO: Enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-// co1.concatenatedProperties; // $ExpectType string[]
-co1.isDestroyed; // $ExpectType boolean
-co1.isDestroying; // $ExpectType boolean
-co1.destroy(); // $ExpectType CoreObject
-co1.toString(); // $ExpectType string
+expectTypeOf(co1.isDestroyed).toBeBoolean();
+expectTypeOf(co1.isDestroying).toBeBoolean();
+expectTypeOf(co1.destroy()).toEqualTypeOf<Ember.CoreObject>();
+expectTypeOf(co1.toString()).toBeString();
 
 /** .create tests */
 const co2 = CoreObject.create();
-// TODO: Enable in TS 3.0  see: https://github.com/typed-ember/ember-cli-typescript/issues/291
-// co2.concatenatedProperties; // $ExpectType string[]
-co2.isDestroyed; // $ExpectType boolean
-co2.isDestroying; // $ExpectType boolean
-co2.destroy(); // $ExpectType CoreObject
-co2.toString(); // $ExpectType string
+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 {
@@ -29,8 +25,8 @@ declare class CO3 extends CoreObject {
 }
 const co3 = CO3.create({ foo: '123', bar: 456 });
 
-co3.foo; // $ExpectType string
-co3.bar; // $ExpectType number
+expectTypeOf(co3.foo).toBeString();
+expectTypeOf(co3.bar).toBeNumber();
 
 /** .extend with a zero-argument .create()  */
 class CO4 extends CO3 {
@@ -40,9 +36,9 @@ class CO4 extends CO3 {
 }
 const co4 = CO4.create();
 
-co4.foo; // $ExpectType string
-co4.bar; // $ExpectType number
-co4.baz; // $ExpectType () => [string, number]
+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 {
diff --git a/types/preview/ember/test/create-negative.ts b/type-tests/preview/ember/create-negative.ts
similarity index 100%
rename from types/preview/ember/test/create-negative.ts
rename to type-tests/preview/ember/create-negative.ts
diff --git a/types/preview/ember/test/create.ts b/type-tests/preview/ember/create.ts
similarity index 100%
rename from types/preview/ember/test/create.ts
rename to type-tests/preview/ember/create.ts
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/types/preview/ember/test/ember-module-tests.ts b/type-tests/preview/ember/ember-module-tests.ts
similarity index 57%
rename from types/preview/ember/test/ember-module-tests.ts
rename to type-tests/preview/ember/ember-module-tests.ts
index cc361b97a8b..fd01363e59a 100644
--- a/types/preview/ember/test/ember-module-tests.ts
+++ b/type-tests/preview/ember/ember-module-tests.ts
@@ -1,3 +1,5 @@
+import type Owner from '@ember/owner';
+import type { SafeString } from '@ember/template/-private/handlebars';
 import Ember from 'ember';
 import { expectTypeOf } from 'expect-type';
 
@@ -6,7 +8,7 @@ type Top = typeof top;
 declare function expectTypeNativeArrayTop(x: Ember.NativeArray<Top>): void;
 // A
 expectTypeNativeArrayTop(Ember.A());
-Ember.A([1, 2]); // $ExpectType NativeArray<number>
+expectTypeOf(Ember.A([1, 2])).toEqualTypeOf<Ember.NativeArray<number>>();
 // addListener
 Ember.addListener({ a: 'foo' }, 'event', {}, () => {});
 Ember.addListener({ a: 'foo' }, 'event', {}, 'a');
@@ -20,17 +22,17 @@ Ember.addObserver({ a: 'foo' }, 'a', {}, () => {});
 Ember.assert('2+2 should always be 4', 2 + 2 === 4);
 // assign
 const o1 = Ember.assign({ a: 1 }, { b: 2 });
-o1.a; // $ExpectType number
-o1.b; // $ExpectType number
+expectTypeOf(o1.a).toBeNumber();
+expectTypeOf(o1.b).toBeNumber();
 // @ts-expect-error
 o1.c;
 // Ember.bind // @ts-expect-error
 // cacheFor
-Ember.cacheFor({ a: 123 }, 'a'); // $ExpectType number | undefined
+expectTypeOf(Ember.cacheFor({ a: 123 }, 'a')).toEqualTypeOf<number | undefined>();
 // @ts-expect-error
 Ember.cacheFor({ a: 123 }, 'x');
 // compare
-Ember.compare('31', '114'); // $ExpectType number
+expectTypeOf(Ember.compare('31', '114')).toEqualTypeOf<number>();
 // debug
 Ember.debug('some info for developers');
 // deprecate
@@ -39,42 +41,44 @@ Ember.deprecate("you shouldn't use this anymore", 3 === 3, {
   until: '99.0.0',
 });
 // get
-Ember.get({ z: 23 }, 'z'); // $ExpectType number
-Ember.get({ z: 23 }, 'zz'); // $ExpectType unknown
+expectTypeOf(Ember.get({ z: 23 }, 'z')).toEqualTypeOf<number>();
+expectTypeOf(Ember.get({ z: 23 }, 'zz')).toEqualTypeOf<unknown>();
 // getEngineParent
-Ember.getEngineParent(new Ember.EngineInstance()); // $ExpectType EngineInstance
+expectTypeOf(
+  Ember.getEngineParent(new Ember.EngineInstance())
+).toEqualTypeOf<Ember.EngineInstance>();
 // getOwner
-Ember.getOwner(new Ember.Component()); // $ExpectType Owner
+expectTypeOf(Ember.getOwner(new Ember.Component())).toEqualTypeOf<Owner>();
 // getProperties
-Ember.getProperties({ z: 23 }, 'z').z; // $ExpectType number
-Ember.getProperties({ z: 23 }, 'z', 'z').z; // $ExpectType number
+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;
-Ember.getProperties({ z: 23 }, ['z', 'z']).z; // $ExpectType number
+expectTypeOf(Ember.getProperties({ z: 23 }, ['z', 'z']).z).toEqualTypeOf<number>();
 // @ts-expect-error
 Ember.getProperties({ z: 23 }, ['z', 'a']).z;
 
 // guidFor
-Ember.guidFor({}); // $ExpectType string
-Ember.guidFor(''); // $ExpectType string
+expectTypeOf(Ember.guidFor({})).toEqualTypeOf<string>();
+expectTypeOf(Ember.guidFor('')).toEqualTypeOf<string>();
 // isArray
-Ember.isArray(''); // $ExpectType boolean
-Ember.isArray([]); // $ExpectType boolean
+expectTypeOf(Ember.isArray('')).toEqualTypeOf<boolean>();
+expectTypeOf(Ember.isArray([])).toEqualTypeOf<boolean>();
 // isBlank
-Ember.isBlank(''); // $ExpectType boolean
-Ember.isBlank([]); // $ExpectType boolean
+expectTypeOf(Ember.isBlank('')).toEqualTypeOf<boolean>();
+expectTypeOf(Ember.isBlank([])).toEqualTypeOf<boolean>();
 // isEmpty
-Ember.isEmpty(''); // $ExpectType boolean
-Ember.isEmpty([]); // $ExpectType boolean
+expectTypeOf(Ember.isEmpty('')).toEqualTypeOf<boolean>();
+expectTypeOf(Ember.isEmpty([])).toEqualTypeOf<boolean>();
 // isEqual
-Ember.isEqual('', 'foo'); // $ExpectType boolean
-Ember.isEqual([], ''); // $ExpectType boolean
+expectTypeOf(Ember.isEqual('', 'foo')).toEqualTypeOf<boolean>();
+expectTypeOf(Ember.isEqual([], '')).toEqualTypeOf<boolean>();
 // isNone
-Ember.isNone(''); // $ExpectType boolean
-Ember.isNone([]); // $ExpectType boolean
+expectTypeOf(Ember.isNone('')).toEqualTypeOf<boolean>();
+expectTypeOf(Ember.isNone([])).toEqualTypeOf<boolean>();
 // isPresent
-Ember.isPresent(''); // $ExpectType boolean
-Ember.isPresent([]); // $ExpectType boolean
+expectTypeOf(Ember.isPresent('')).toEqualTypeOf<boolean>();
+expectTypeOf(Ember.isPresent([])).toEqualTypeOf<boolean>();
 // observer
 class O2 extends Ember.Object {
   name = 'foo';
@@ -108,26 +112,29 @@ Ember.runInDebug(() => {});
 // sendEvent
 expectTypeOf(Ember.sendEvent(o2, 'clicked', [1, 2])).toBeBoolean();
 // set
-Ember.set(O2.create(), 'name', 'bar'); // $ExpectType string
-Ember.set(O2.create(), 'age', 4); // $ExpectType number
+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
-Ember.setProperties(O2.create(), { name: 'bar' }).name; // $ExpectType string
+expectTypeOf(Ember.setProperties(O2.create(), { name: 'bar' }).name).toEqualTypeOf<string>();
 // trySet
-Ember.trySet(O2, 'nam', ''); // $ExpectType any
+expectTypeOf(Ember.trySet(O2, 'nam', '')).toBeUnknown();
 // typeOf
-Ember.typeOf(''); // $ExpectType "string"
-Ember.typeOf(Ember.A()); // $ExpectType "array"
+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
-Ember.VERSION; // $ExpectType string
+expectTypeOf(Ember.VERSION).toEqualTypeOf<string>();
 
 // onerror
 
@@ -140,18 +147,17 @@ Ember.onerror = undefined;
 // TODO ContainerProxyMixin
 // Ember
 // Ember.Application
-new Ember.Application(); // $ExpectType Application
-Ember.Application.create(); // $ExpectType Application
+expectTypeOf(new Ember.Application()).toEqualTypeOf<Ember.Application>();
+expectTypeOf(Ember.Application.create()).toEqualTypeOf<Ember.Application>();
 // Ember.ApplicationInstance
-new Ember.ApplicationInstance(); // $ExpectType ApplicationInstance
-Ember.ApplicationInstance.create(); // $ExpectType ApplicationInstance
-// TODO: Ember.ApplicationInstance.BootOptions
+expectTypeOf(new Ember.ApplicationInstance()).toEqualTypeOf<Ember.ApplicationInstance>();
+expectTypeOf(Ember.ApplicationInstance.create()).toEqualTypeOf<Ember.ApplicationInstance>();
 // Ember.Array
-const a1: Ember.Array<string> = [];
+const a1: Ember.Array<string> = Ember.A([]);
 // @ts-expect-error
 const a2: Ember.Array<string> = {};
 // Ember.ArrayProxy
-new Ember.ArrayProxy<number>([3, 3, 2]); // $ExpectType ArrayProxy<number>
+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 {
@@ -178,13 +184,13 @@ class Foo {
 }
 
 // Ember.ContainerDebugAdapter
-const cda = new Ember.ContainerDebugAdapter(); // $ExpectType ContainerDebugAdapter
+expectTypeOf(new Ember.ContainerDebugAdapter()).toEqualTypeOf<Ember.ContainerDebugAdapter>();
 // Ember.Controller
-const con = new Ember.Controller(); // $ExpectType Controller
+expectTypeOf(new Ember.Controller()).toEqualTypeOf<Ember.Controller>();
 // Ember.CoreObject
-const co = new Ember.CoreObject(); // $ExpectType CoreObject
+expectTypeOf(new Ember.CoreObject()).toEqualTypeOf<Ember.CoreObject>();
 // Ember.DataAdapter
-const da = new Ember.DataAdapter(); // $ExpectType DataAdapter
+expectTypeOf(new Ember.DataAdapter()).toEqualTypeOf<Ember.DataAdapter>();
 // Ember.Debug
 Ember.Debug.registerDeprecationHandler(() => {});
 Ember.Debug.registerWarnHandler(() => {});
@@ -204,7 +210,8 @@ oe1.trigger('foo');
 oe1.on('bar', () => {});
 oe1.on('bar', { foo() {} }, () => {});
 // Ember.HashLocation
-const hl = new Ember.HashLocation(); // $ExpectType HashLocation
+const hl = new Ember.HashLocation();
+expectTypeOf(hl).toEqualTypeOf<Ember.HashLocation>();
 // Ember.Helper
 class H1 extends Ember.Helper {
   compute() {
@@ -225,41 +232,41 @@ class UsesMixin extends Ember.Object {
   }
 }
 // Ember.MutableArray
-const ma1: Ember.MutableArray<string> = ['money', 'in', 'the', 'bananna', 'stand'];
-ma1.addObject('!'); // $ExpectType string
+const ma1: Ember.MutableArray<string> = Ember.A(['money', 'in', 'the', 'bananna', 'stand']);
+expectTypeOf(ma1.addObject('!')).toBeString();
 // @ts-expect-error
 ma1.filterBy('');
-ma1.firstObject; // $ExpectType string | undefined
-ma1.lastObject; // $ExpectType string | undefined
-const ma2: Ember.MutableArray<{ name: string }> = [
+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' },
-];
-ma2.filterBy('name', 'chris'); // $ExpectType NativeArray<{ name: string; }>
+]);
+expectTypeOf(ma2.filterBy('name', 'chris')).toEqualTypeOf<Ember.NativeArray<{ name: string }>>();
 // Ember.MutableEnumerable
-const me1: Ember.MutableEnumerable<string | null | undefined> = ['foo', undefined, null];
-me1.compact(); // $ExpectType NativeArray<string>
+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]);
-na; // $ExpectType NativeArray<number>
-na.clear(); // $ExpectType NativeArray<number>
+expectTypeOf(na).toEqualTypeOf<Ember.NativeArray<number>>();
+expectTypeOf(na.clear()).toEqualTypeOf<Ember.NativeArray<number>>();
 // Ember.NoneLocation
-new Ember.NoneLocation(); // $ExpectType NoneLocation
+expectTypeOf(new Ember.NoneLocation()).toEqualTypeOf<Ember.NoneLocation>();
 // Ember.Object
 new Ember.Object();
 // Ember.ObjectProxy
-new Ember.ObjectProxy(); // $ExpectType 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() {
-    this.reason; // $ExpectType unknown
-    this.isPending; // $ExpectType boolean
+    expectTypeOf(this.reason).toEqualTypeOf<unknown>();
+    expectTypeOf(this.isPending).toEqualTypeOf<boolean>();
   }
 }
 // Ember.Route
@@ -280,11 +287,11 @@ Ember.Helper.helper(([a, b]: [number, number]) => a + b);
 // Ember.String
 Ember.String;
 // htmlSafe
-Ember.String.htmlSafe('foo'); // $ExpectType SafeString
+expectTypeOf(Ember.String.htmlSafe('foo')).toEqualTypeOf<SafeString>();
 // isHTMLSafe
-Ember.String.isHTMLSafe('foo'); // $ExpectType boolean
+expectTypeOf(Ember.String.isHTMLSafe('foo')).toEqualTypeOf<boolean>();
 // Ember.Test
-Ember.Test.checkWaiters(); // $ExpectType boolean
+expectTypeOf(Ember.Test.checkWaiters()).toEqualTypeOf<boolean>();
 // checkWaiters
 
 /**
diff --git a/types/preview/ember/test/ember-tests.ts b/type-tests/preview/ember/ember-tests.ts
similarity index 87%
rename from types/preview/ember/test/ember-tests.ts
rename to type-tests/preview/ember/ember-tests.ts
index e59a3436191..18bfa6cccc7 100755
--- a/types/preview/ember/test/ember-tests.ts
+++ b/type-tests/preview/ember/ember-tests.ts
@@ -1,6 +1,8 @@
+import { A } from '@ember/array';
+import type { SafeString } from '@ember/template/-private/handlebars';
 import Ember from 'ember';
-import { AnyFn } from 'ember/-private/type-utils';
-import { assertType } from './lib/assert';
+import type { AnyFn } from 'ember/-private/type-utils';
+import { expectTypeOf } from 'expect-type';
 
 class President extends Ember.Object {
   name = 'Barack Obama';
@@ -65,7 +67,7 @@ class Todo extends Ember.Object {
 }
 
 class TodosController extends Ember.Object {
-  todos = [Todo.create()];
+  todos = A([Todo.create()]);
 
   @Ember.computed('todos.@each.isDone')
   get remaining() {
@@ -116,9 +118,9 @@ type Arr = Ember.NativeArray<
   }
 >;
 const arr: Arr = Ember.A([Ember.Object.create(), Ember.Object.create()]);
-arr.setEach('name', 'unknown'); // $ExpectType void
-arr.setEach('name', undefined); // $ExpectType void
-arr.getEach('name'); // $ExpectType (string | undefined)[]
+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
@@ -156,7 +158,7 @@ const promise = new Ember.RSVP.Promise<string>((resolve: AnyFn, reject: AnyFn) =
 promise.then(
   (value) => {
     // on fulfillment
-    assertType<string>(value);
+    expectTypeOf(value).toBeString();
   },
   (reason: unknown) => {
     // on rejection
@@ -180,4 +182,4 @@ const component1 = Ember.Component.extend(mix1, mix2, {
 });
 
 // make sure htmlSafe returns a SafeString
-Ember.String.htmlSafe('hello'); // $ExpectType SafeString
+expectTypeOf(Ember.String.htmlSafe('hello')).toEqualTypeOf<SafeString>();
diff --git a/types/preview/ember/test/engine-instance.ts b/type-tests/preview/ember/engine-instance.ts
similarity index 100%
rename from types/preview/ember/test/engine-instance.ts
rename to type-tests/preview/ember/engine-instance.ts
diff --git a/types/preview/ember/test/engine.ts b/type-tests/preview/ember/engine.ts
similarity index 100%
rename from types/preview/ember/test/engine.ts
rename to type-tests/preview/ember/engine.ts
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/types/preview/ember/test/event.ts b/type-tests/preview/ember/event.ts
similarity index 100%
rename from types/preview/ember/test/event.ts
rename to type-tests/preview/ember/event.ts
diff --git a/types/preview/ember/test/extend.ts b/type-tests/preview/ember/extend.ts
similarity index 100%
rename from types/preview/ember/test/extend.ts
rename to type-tests/preview/ember/extend.ts
diff --git a/types/preview/ember/test/helper.ts b/type-tests/preview/ember/helper.ts
similarity index 100%
rename from types/preview/ember/test/helper.ts
rename to type-tests/preview/ember/helper.ts
diff --git a/types/preview/ember/test/inject.ts b/type-tests/preview/ember/inject.ts
similarity index 96%
rename from types/preview/ember/test/inject.ts
rename to type-tests/preview/ember/inject.ts
index 34858b5ef20..42df94317e7 100755
--- a/types/preview/ember/test/inject.ts
+++ b/type-tests/preview/ember/inject.ts
@@ -43,7 +43,6 @@ class LoginRoute extends Ember.Route {
 }
 
 // New module injection style.
-import { assertType } from './lib/assert';
 import RouterService from '@ember/routing/router-service';
 import Controller from '@ember/controller';
 
@@ -66,7 +65,7 @@ class ComponentInjection extends Ember.Component {
     const url = this.router.urlFor('some-route', 1, 2, 3, {
       queryParams: { seriously: 'yes' },
     });
-    assertType<string>(url);
+    expectTypeOf(url).toBeString();
     if (!this.get('auth').isAuthenticated) {
       this.get('applicationController').transitionToLogin();
     }
diff --git a/types/preview/ember/test/mixin.ts b/type-tests/preview/ember/mixin.ts
similarity index 84%
rename from types/preview/ember/test/mixin.ts
rename to type-tests/preview/ember/mixin.ts
index 1fb85c78d9d..55176a725ce 100755
--- a/types/preview/ember/test/mixin.ts
+++ b/type-tests/preview/ember/mixin.ts
@@ -1,5 +1,5 @@
 import Ember from 'ember';
-import { assertType } from './lib/assert';
+import { expectTypeOf } from 'expect-type';
 
 interface EditableMixin extends Ember.Mixin {
   edit(): void;
@@ -37,8 +37,8 @@ const comment = EditableComment.create({
 comment.edit();
 comment.canEdit();
 comment.tryEdit();
-assertType<boolean>(comment.isEditing);
-assertType<number>(comment.postId);
+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 });
@@ -62,5 +62,5 @@ interface EditableAndCancelableComment extends EditableAndCancelableMixin {}
 class EditableAndCancelableComment extends Ember.Route.extend(EditableAndCancelableMixin) {}
 
 const editableAndCancelable = EditableAndCancelableComment.create();
-assertType<boolean>(editableAndCancelable.isEditing);
-assertType<boolean>(editableAndCancelable.cancelled);
+expectTypeOf(editableAndCancelable.isEditing).toBeBoolean();
+expectTypeOf(editableAndCancelable.cancelled).toBeBoolean();
diff --git a/types/preview/ember/test/object.ts b/type-tests/preview/ember/object.ts
similarity index 87%
rename from types/preview/ember/test/object.ts
rename to type-tests/preview/ember/object.ts
index e3f4a6cfaec..ada59c9eff4 100755
--- a/types/preview/ember/test/object.ts
+++ b/type-tests/preview/ember/object.ts
@@ -40,12 +40,10 @@ class Foo extends Ember.Object {
   b = 5;
 
   baz() {
-    const y = this.b; // $ExpectType number
-    const z = this.a; // $ExpectType ComputedProperty<string, string>
     this.b = 10;
-    this.get('b').toFixed(4); // $ExpectType string
-    this.set('a', 'abc').split(','); // $ExpectType string[]
-    this.set('b', 10).toFixed(4); // $ExpectType string
+    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
diff --git a/types/preview/ember/test/observable.ts b/type-tests/preview/ember/observable.ts
similarity index 59%
rename from types/preview/ember/test/observable.ts
rename to type-tests/preview/ember/observable.ts
index c2371d8f789..013bf77e61b 100755
--- a/types/preview/ember/test/observable.ts
+++ b/type-tests/preview/ember/observable.ts
@@ -1,5 +1,4 @@
 import Ember from 'ember';
-import { assertType } from './lib/assert';
 import { expectTypeOf } from 'expect-type';
 
 class MyComponent extends Ember.Component {
@@ -66,43 +65,61 @@ function testGet() {
 }
 
 function testGetProperties() {
-  assertType<{ name: string }>(Ember.getProperties(person, 'name'));
-  assertType<{ name: string; age: number }>(Ember.getProperties(person, 'name', 'age'));
-  assertType<{ name: string; age: number }>(Ember.getProperties(person, ['name', 'age']));
-  assertType<{ name: string; age: number; capitalized: string }>(
-    Ember.getProperties(person, 'name', 'age', 'capitalized')
-  );
-  assertType<{ name: string }>(person.getProperties('name'));
-  assertType<{ name: string; age: number }>(person.getProperties('name', 'age'));
-  assertType<{ name: string; age: number }>(person.getProperties(['name', 'age']));
-  assertType<{ name: string; age: number; capitalized: string }>(
-    person.getProperties('name', 'age', 'capitalized')
-  );
-  assertType<{ name: string; age: number }>(Ember.getProperties(pojo, 'name', 'age'));
+  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() {
-  assertType<string>(Ember.set(person, 'name', 'Joe'));
-  assertType<number>(Ember.set(person, 'age', 35));
-  assertType<string>(Ember.set(person, 'capitalized', 'JOE'));
-  assertType<string>(person.set('name', 'Joe'));
-  assertType<number>(person.set('age', 35));
-  assertType<string>(person.set('capitalized', 'JOE'));
-  assertType<string>(Ember.set(pojo, 'name', 'Joe'));
+  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() {
-  assertType<{ name: string }>(Ember.setProperties(person, { name: 'Joe' }));
-  assertType<{ name: string; age: number }>(Ember.setProperties(person, { name: 'Joe', age: 35 }));
-  assertType<{ name: string; capitalized: string }>(
-    Ember.setProperties(person, { name: 'Joe', capitalized: 'JOE' })
-  );
-  assertType<{ name: string }>(person.setProperties({ name: 'Joe' }));
-  assertType<{ name: string; age: number }>(person.setProperties({ name: 'Joe', age: 35 }));
-  assertType<{ name: string; capitalized: string }>(
-    person.setProperties({ name: 'Joe', capitalized: 'JOE' })
-  );
-  assertType<{ name: string; age: number }>(Ember.setProperties(pojo, { name: 'Joe', age: 35 }));
+  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() {
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/types/preview/ember/test/private/observable-tests.ts b/type-tests/preview/ember/private/observable-tests.ts
similarity index 73%
rename from types/preview/ember/test/private/observable-tests.ts
rename to type-tests/preview/ember/private/observable-tests.ts
index 7e48fd3f785..abc323ed238 100644
--- a/types/preview/ember/test/private/observable-tests.ts
+++ b/type-tests/preview/ember/private/observable-tests.ts
@@ -1,8 +1,7 @@
-// tslint-disable-next-line
-import { assertType } from '../lib/assert';
 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) {}
@@ -43,10 +42,18 @@ class DemoObservable implements Observable {
     };
     this.addObserver('foo', lambda);
     this.addObserver('foo', (sender, key, value, rev) => {
-      assertType<DemoObservable>(sender);
-      assertType<'foo'>(key);
-      assertType<string>(value);
-      assertType<number>(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);
@@ -76,6 +83,7 @@ class DemoObservable implements Observable {
   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 {
@@ -142,32 +150,32 @@ const o = new DemoObservable();
 /**
  * get
  */
-assertType<string>(o.get('foo')); // $ExpectType string
-assertType<[boolean, boolean]>(o.get('bar')); // $ExpectType [boolean, boolean]
-assertType<number | undefined>(o.get('baz')); // $ExpectType number | undefined
+expectTypeOf(o.get('foo')).toBeString();
+expectTypeOf(o.get('bar')).toEqualTypeOf<[boolean, boolean]>();
+expectTypeOf(o.get('baz')).toEqualTypeOf<number | undefined>();
 
 /**
  * incrementProperty, decrementProperty
  */
-assertType<number>(o.incrementProperty('baz')); // $ExpectType number
-assertType<number>(o.decrementProperty('baz')); // $ExpectType number
-assertType<number>(o.incrementProperty('baz', 3)); // $ExpectType number
-assertType<number>(o.decrementProperty('baz', 12)); // $ExpectType number
+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
-assertType<number>(o.incrementProperty('bar'));
+o.incrementProperty('bar');
 // @ts-expect-error
-assertType<number>(o.decrementProperty('bar'));
+o.decrementProperty('bar');
 // empty case
 // @ts-expect-error
-assertType<number>(o.incrementProperty());
+o.incrementProperty();
 // @ts-expect-error
-assertType<number>(o.decrementProperty());
+o.decrementProperty();
 
 /**
  * toggleProperty
  */
-o.toggleProperty('isFoo'); // $ExpectType boolean
+expectTypeOf(o.toggleProperty('isFoo')).toBeBoolean();
 // @ts-expect-error
 o.toggleProperty();
 
@@ -175,12 +183,18 @@ o.toggleProperty();
  * getProperties
  */
 // ('foo', 'bar')
-assertType<{ foo: string; bar: [boolean, boolean] }>(o.getProperties('foo', 'bar')); // $ExpectType { foo: string; bar: [boolean, boolean]; }
+expectTypeOf(o.getProperties('foo', 'bar')).toEqualTypeOf<{
+  foo: string;
+  bar: [boolean, boolean];
+}>();
 // ['foo', 'bar']
-assertType<{ foo: string; bar: [boolean, boolean] }>(o.getProperties(['foo', 'bar'])); // $ExpectType { foo: string; bar: [boolean, boolean]; }
+expectTypeOf(o.getProperties(['foo', 'bar'])).toEqualTypeOf<{
+  foo: string;
+  bar: [boolean, boolean];
+}>();
 // empty cases
-assertType<{}>(o.getProperties()); // $ExpectType {}
-assertType<{}>(o.getProperties([])); // $ExpectType {}
+expectTypeOf(o.getProperties()).toEqualTypeOf<{}>();
+expectTypeOf(o.getProperties([])).toEqualTypeOf<{}>();
 // property that doesn't exist
 // @ts-expect-error
 o.getProperties('jeanShorts', 'foo');
@@ -190,10 +204,10 @@ o.getProperties(['foo', 'jeanShorts']);
 /**
  * set
  */
-assertType<string>(o.set('foo', 'abc')); // $ExpectType string
-assertType<[boolean, boolean]>(o.set('bar', [false, false])); // $ExpectType [boolean, boolean]
-assertType<number | undefined>(o.set('baz', undefined)); // $ExpectType number | undefined
-assertType<number | undefined>(o.set('baz', 10)); // $ExpectType number | undefined
+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);
@@ -201,11 +215,12 @@ o.set('jeanShorts', 10);
 /**
  * setProperties
  */
-assertType<{ foo: string; bar: [boolean, boolean] }>(
-  o.setProperties({ foo: 'abc', bar: [true, true] })
-); // $ExpectType { foo: string; bar: [boolean, boolean]; }
+expectTypeOf(o.setProperties({ foo: 'abc', bar: [true, true] })).toEqualTypeOf<{
+  foo: string;
+  bar: [boolean, boolean];
+}>();
 // empty case
-assertType<{}>(o.setProperties({})); // $ExpectType {}
+expectTypeOf(o.setProperties({})).toEqualTypeOf<{}>();
 // property that doesn't exist
 // @ts-expect-error
 o.setProperties({ jeanShorts: 'under the pants' });
@@ -213,6 +228,5 @@ o.setProperties({ jeanShorts: 'under the pants' });
 /**
  * notifyPropertyChange
  */
-assertType<DemoObservable>(o.notifyPropertyChange('foo')); // $ExpectType DemoObservable
-// @ts-expect-error
-assertType<Observable>(o.notifyPropertyChange('jeanShorts'));
+expectTypeOf(o.notifyPropertyChange('foo')).toEqualTypeOf<DemoObservable>();
+expectTypeOf(o.notifyPropertyChange('jeanShorts')).not.toMatchTypeOf<Observable>();
diff --git a/types/preview/ember/test/reopen.ts b/type-tests/preview/ember/reopen.ts
similarity index 100%
rename from types/preview/ember/test/reopen.ts
rename to type-tests/preview/ember/reopen.ts
diff --git a/types/preview/ember/test/route.ts b/type-tests/preview/ember/route.ts
similarity index 100%
rename from types/preview/ember/test/route.ts
rename to type-tests/preview/ember/route.ts
diff --git a/types/preview/ember/test/router.ts b/type-tests/preview/ember/router.ts
similarity index 100%
rename from types/preview/ember/test/router.ts
rename to type-tests/preview/ember/router.ts
diff --git a/types/preview/ember/test/run.ts b/type-tests/preview/ember/run.ts
similarity index 100%
rename from types/preview/ember/test/run.ts
rename to type-tests/preview/ember/run.ts
diff --git a/types/preview/ember/test/string.ts b/type-tests/preview/ember/string.ts
similarity index 50%
rename from types/preview/ember/test/string.ts
rename to type-tests/preview/ember/string.ts
index d494d78a94e..5770a3a469a 100644
--- a/types/preview/ember/test/string.ts
+++ b/type-tests/preview/ember/string.ts
@@ -1,52 +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();
-dasherize('blue man group'); // $ExpectType string
+expectTypeOf(dasherize('blue man group')).toEqualTypeOf<string>();
 // @ts-expect-error
 dasherize('', '');
 
 // @ts-expect-error
 camelize();
-camelize('blue man group'); // $ExpectType string
+expectTypeOf(camelize('blue man group')).toEqualTypeOf<string>();
 // @ts-expect-error
 camelize('', '');
 
 // @ts-expect-error
 decamelize();
-decamelize('blue man group'); // $ExpectType string
+expectTypeOf(decamelize('blue man group')).toEqualTypeOf<string>();
 // @ts-expect-error
 decamelize('', '');
 
 // @ts-expect-error
 underscore();
-underscore('blue man group'); // $ExpectType string
+expectTypeOf(underscore('blue man group')).toEqualTypeOf<string>();
 // @ts-expect-error
 underscore('', '');
 
 // @ts-expect-error
 w();
-w('blue man group'); // $ExpectType string[]
+expectTypeOf(w('blue man group')).toEqualTypeOf<string[]>();
 // @ts-expect-error
 w('', '');
 
 // @ts-expect-error
 classify();
-classify('blue man group'); // $ExpectType string
+expectTypeOf(classify('blue man group')).toEqualTypeOf<string>();
 // @ts-expect-error
 classify('', '');
 
 // @ts-expect-error
 capitalize();
-capitalize('blue man group'); // $ExpectType string
+expectTypeOf(capitalize('blue man group')).toEqualTypeOf<string>();
 // @ts-expect-error
 capitalize('', '');
 
-const handlebarsSafeString: SafeString = Ember.String.htmlSafe('lorem ipsum...');
-Ember.String.htmlSafe('lorem ipsum...'); // $ExpectType SafeString
-// @ts-expect-error
-const regularString: string = Ember.String.htmlSafe('lorem ipsum...');
+const handlebarsSafeString = htmlSafe('lorem ipsum...');
+expectTypeOf(handlebarsSafeString).toEqualTypeOf<SafeString>();
+expectTypeOf(handlebarsSafeString).not.toEqualTypeOf<string>();
diff --git a/types/preview/ember/test/techniques/properties-from-this.ts b/type-tests/preview/ember/techniques/properties-from-this.ts
similarity index 74%
rename from types/preview/ember/test/techniques/properties-from-this.ts
rename to type-tests/preview/ember/techniques/properties-from-this.ts
index 7dc3e618f67..1c3b78a9f83 100644
--- a/types/preview/ember/test/techniques/properties-from-this.ts
+++ b/type-tests/preview/ember/techniques/properties-from-this.ts
@@ -4,6 +4,8 @@
  * 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;
@@ -44,28 +46,28 @@ class Foo123 extends GetAndSet {
 
 let f = new Foo123();
 
-f.get('a'); // $ExpectType number
+expectTypeOf(f.get('a')).toEqualTypeOf<number>();
 // @ts-expect-error
 f.set('a');
 // @ts-expect-error
 f.set('a', '1');
-f.set('a', 1); // $ExpectType number
+expectTypeOf(f.set('a', 1)).toEqualTypeOf<number>();
 
-f.get('b'); // $ExpectType [boolean, boolean]
+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]);
-f.set('b', [false, true]); // $ExpectType [boolean, boolean]
+expectTypeOf(f.set('b', [false, true])).toEqualTypeOf<[boolean, boolean]>();
 // @ts-expect-error
 f.set('b', [false, true, false]);
 
-f.get('c'); // $ExpectType string
-f.set('c', '1'); // $ExpectType string
+expectTypeOf(f.get('c')).toEqualTypeOf<string>();
+expectTypeOf(f.set('c', '1')).toEqualTypeOf<string>();
 
-f.get('cpA'); // $ExpectType string
+expectTypeOf(f.get('cpA')).toEqualTypeOf<string>();
 // @ts-expect-error
 f.set('cpA', ['newValue']);
-f.set('cpA', 'newValue'); // $ExpectType string
+expectTypeOf(f.set('cpA', 'newValue')).toEqualTypeOf<string>();
diff --git a/types/preview/ember/test/test.ts b/type-tests/preview/ember/test.ts
similarity index 100%
rename from types/preview/ember/test/test.ts
rename to type-tests/preview/ember/test.ts
diff --git a/types/preview/ember/test/transition.ts b/type-tests/preview/ember/transition.ts
similarity index 100%
rename from types/preview/ember/test/transition.ts
rename to type-tests/preview/ember/transition.ts
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
index a32bc036942..9bb05c01fce 100644
--- a/types/preview/@ember/-internals/resolver.d.ts
+++ b/types/preview/@ember/-internals/resolver.d.ts
@@ -1,33 +1,35 @@
-/**
- * @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`.
- */
+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';
+  import EmberObject from '@ember/object';
+  import type { Factory, FullName } from '@ember/owner';
 
-export type KnownForTypeResult<Type extends string> = {
-  [fullName in `${Type}:${string}`]: boolean | undefined;
-};
+  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;
+  /**
+   * 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
index 3f72b1653b4..f88ebe85a7c 100644
--- a/types/preview/@ember/application/-private/event-dispatcher.d.ts
+++ b/types/preview/@ember/application/-private/event-dispatcher.d.ts
@@ -1,16 +1,18 @@
-import { EventDispatcherEvents } from '@ember/application/types';
+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.
+   * `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.
    */
-  events: EventDispatcherEvents;
+  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
index 60604ceae87..1af8dff3ef8 100644
--- a/types/preview/@ember/application/-private/registry.d.ts
+++ b/types/preview/@ember/application/-private/registry.d.ts
@@ -1,13 +1,15 @@
-import { EmberClassConstructor } from '@ember/object/-private/types';
+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;
+  /**
+   * 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
index 0ed913f11b6..272cdbfc726 100644
--- a/types/preview/@ember/application/deprecations.d.ts
+++ b/types/preview/@ember/application/deprecations.d.ts
@@ -1,23 +1,24 @@
-import { AnyFn } from 'ember/-private/type-utils';
+declare module '@ember/application/deprecations' {
+  import { AnyFn } from 'ember/-private/type-utils';
 
-// tslint:disable-next-line:strict-export-declare-modifiers
-interface DeprecationOptions {
-  id: string;
-  until: string;
-  url?: string | undefined;
-}
+  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;
+  /**
+   * 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;
+  /**
+   * 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
index 3a2265ac053..d4d9cd8c09b 100644
--- a/types/preview/@ember/application/index.d.ts
+++ b/types/preview/@ember/application/index.d.ts
@@ -1,151 +1,153 @@
-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';
+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 {};
+  // 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;
+   * 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;
+
   /**
-   * Called when the Application has become ready.
-   * The call will be delayed until the DOM has become ready.
+   * 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.
    */
-  ready: AnyFn;
+  export function getOwner(object: FrameworkObject): Owner;
+  export function getOwner(object: unknown): Owner | undefined;
   /**
-   * Application's router.
+   * `setOwner` forces a new owner on a given object instance. This is primarily
+   * useful in some testing cases.
    */
-  Router: Router;
-  registry: Registry;
+  export function setOwner(object: unknown, owner: Owner): void;
+
   /**
-   *  Initialize the application and return a promise that resolves with the `Application`
-   *  object when the boot process is complete.
+   * Detects when a specific package of Ember (e.g. 'Ember.Application')
+   * has fully loaded and is available for extension.
    */
-  boot(): Promise<Application>;
+  export function onLoad(name: string, callback: AnyFn): unknown;
+
   /**
-   * Create an ApplicationInstance for this Application.
+   * Called when an Ember.js package (e.g Ember.Application) has finished
+   * loading. Triggers any callbacks registered for this event.
    */
-  buildInstance(options?: object): ApplicationInstance;
+  export function runLoadHooks(name: string, object?: {}): unknown;
 }
-
-// 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
index 74215a39a46..37b60353c6f 100644
--- a/types/preview/@ember/application/instance.d.ts
+++ b/types/preview/@ember/application/instance.d.ts
@@ -1,7 +1,9 @@
-import EngineInstance from '@ember/engine/instance';
+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 {}
+  /**
+   * 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/types.d.ts b/types/preview/@ember/application/types.d.ts
index 75e3f6d8487..fa3692e2458 100644
--- a/types/preview/@ember/application/types.d.ts
+++ b/types/preview/@ember/application/types.d.ts
@@ -1,27 +1,29 @@
-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;
+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
index 876e81a3d08..36b0120eb94 100644
--- a/types/preview/@ember/array/-private/enumerable.d.ts
+++ b/types/preview/@ember/array/-private/enumerable.d.ts
@@ -1,173 +1,13 @@
-import ComputedProperty from '@ember/object/computed';
-import Mixin from '@ember/object/mixin';
-import NativeArray from '@ember/array/-private/native-array';
-import { MethodNamesOf, MethodParams, MethodReturns } from 'ember/-private/type-utils';
+declare module '@ember/array/-private/enumerable' {
+  import Mixin from '@ember/object/mixin';
 
-/**
- * This mixin defines the common interface implemented by enumerable objects
- * in Ember. Most of these methods follow the standard Array iteration
- * API defined up to JavaScript 1.8 (excluding language-specific features that
- * cannot be emulated in older versions of JavaScript).
- */
-interface Enumerable<T> {
   /**
-   * 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.
+   * 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.
    */
-  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;
-  /**
-   * Iterates through the enumerable, calling the passed function on each
-   * item. This method corresponds to the `forEach()` method defined in
-   * JavaScript 1.6.
-   */
-  forEach: T[]['forEach'];
-  /**
-   * Alias for `mapBy`
-   */
-  getEach<K extends keyof T>(key: K): Array<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: T[]['map'];
-  /**
-   * 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): Array<T[K]>;
-  mapBy(key: string): 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: T[]['filter'];
-  /**
-   * 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(
-    callbackfn: (value: T, index: number, array: T[]) => unknown,
-    thisArg?: any
-  ): 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: T[]['find'];
-  /**
-   * 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: T[]['every'];
-  /**
-   * 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(callback: (value: T, index: number, array: T[]) => boolean, 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 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>;
-  /**
-   * 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 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>;
-  /**
-   * Returns `true` if the passed object can be found in the enumerable.
-   */
-  includes(searchElement: T, fromIndex?: number): boolean;
-  /**
-   * 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 '[]'(): this;
-  set '[]'(newValue: Enumerable<T>);
-}
+  interface Enumerable {}
 
-declare const Enumerable: Mixin;
-export default 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
index b6785f8fe33..d3bc4972cc3 100644
--- a/types/preview/@ember/array/-private/mutable-enumerable.d.ts
+++ b/types/preview/@ember/array/-private/mutable-enumerable.d.ts
@@ -1,28 +1,13 @@
-import Mixin from '@ember/object/mixin';
-import Enumerable from '@ember/array/-private/enumerable';
+declare module '@ember/array/-private/mutable-enumerable' {
+  import Mixin from '@ember/object/mixin';
+  import Enumerable from '@ember/array/-private/enumerable';
 
-/**
- * This mixin defines the API for modifying generic enumerables. These methods
- * can be applied to an object regardless of whether it is ordered or
- * unordered.
- */
-interface MutableEnumerable<T> extends Enumerable<T> {
   /**
-   * __Required.__ You must implement this method to apply this mixin.
+   * 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.
    */
-  addObject(object: T): T;
-  /**
-   * Adds each object in the passed enumerable to the receiver.
-   */
-  addObjects(objects: Enumerable<T>): this;
-  /**
-   * __Required.__ You must implement this method to apply this mixin.
-   */
-  removeObject(object: T): T;
-  /**
-   * Removes each object in the passed enumerable from the receiver.
-   */
-  removeObjects(objects: Enumerable<T>): this;
+  interface MutableEnumerable extends Enumerable {}
+  const MutableEnumerable: Mixin;
+  export default MutableEnumerable;
 }
-declare 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
index 1a2c8fcf113..814eb825abd 100644
--- a/types/preview/@ember/array/-private/native-array.d.ts
+++ b/types/preview/@ember/array/-private/native-array.d.ts
@@ -1,23 +1,23 @@
-import MutableArray from '@ember/array/mutable';
-import Observable from '@ember/object/observable';
-import Mixin from '@ember/object/mixin';
+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 GlobalArray<T> = T[];
+  // 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 GlobalArray<T>, MutableArray<T>, Observable {
   /**
-   * __Required.__ You must implement this method to apply this mixin.
+   * 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)`.
    */
-  length: number;
-}
+  interface NativeArray<T>
+    extends Omit<Array<T>, 'every' | 'filter' | 'find' | 'forEach' | 'map' | 'reduce' | 'slice'>,
+      Observable,
+      MutableArray<T> {}
 
-declare const NativeArray: Mixin;
-export default NativeArray;
+  const NativeArray: Mixin;
+  export default NativeArray;
+}
diff --git a/types/preview/@ember/array/index.d.ts b/types/preview/@ember/array/index.d.ts
index 13f7597c5ce..2667e7289f1 100644
--- a/types/preview/@ember/array/index.d.ts
+++ b/types/preview/@ember/array/index.d.ts
@@ -1,70 +1,244 @@
-import Mixin from '@ember/object/mixin';
-import Enumerable from '@ember/array/-private/enumerable';
-import NativeArray from '@ember/array/-private/native-array';
+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<T> {
   /**
-   * __Required.__ You must implement this method to apply this mixin.
+   * 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.
    */
-  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`.
-   */
-  // tslint:disable-next-line:array-type
-  objectsAt(indexes: number[]): Array<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): 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;
+  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`.
+     */
+    // tslint:disable-next-line:array-type
+    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;
+
   /**
-   * 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.
+   * 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`.
    */
-  lastIndexOf(searchElement: T, fromIndex?: number): number;
+  export function A<T>(arr?: T[]): NativeArray<T>;
+
   /**
-   * Returns a special object that can be used to observe individual properties
-   * on the array. Just get an equivalent property on this object and it will
-   * return an enumerable that maps automatically to the named key on the
-   * member objects.
+   * Returns true if the passed object is an array or Array-like.
    */
-  '@each': T;
+  export function isArray(obj: unknown): obj is ArrayLike<unknown>;
 }
-// Ember.Array rather than Array because the `array-type` lint rule doesn't realize the global is shadowed
-// tslint:disable-next-line:array-type
-declare 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
index e047a73974c..30c365bb953 100644
--- a/types/preview/@ember/array/mutable.d.ts
+++ b/types/preview/@ember/array/mutable.d.ts
@@ -1,75 +1,94 @@
-import Mixin from '@ember/object/mixin';
-import MutableEnumerable from '@ember/array/-private/mutable-enumerable';
-import EmberArray from '@ember/array';
-import Enumerable from '@ember/array/-private/enumerable';
+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<T> {
-  /**
-   * __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: Enumerable<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: Enumerable<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.
+   * 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.
    */
-  setObjects(objects: EmberArray<T>): this;
-}
+  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;
+  }
 
-declare const MutableArray: Mixin;
-export default MutableArray;
+  const MutableArray: Mixin;
+  export default MutableArray;
+}
diff --git a/types/preview/@ember/array/proxy.d.ts b/types/preview/@ember/array/proxy.d.ts
index 590f65fc2e7..37efc898204 100644
--- a/types/preview/@ember/array/proxy.d.ts
+++ b/types/preview/@ember/array/proxy.d.ts
@@ -1,31 +1,29 @@
-import type MutableArray from '@ember/array/mutable';
-import EmberObject from '@ember/object';
-
-interface EmberArrayLike<T> {
-  length: number;
-  objectAt(idx: number): T | undefined;
-}
-
-/**
- * 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[] | EmberArrayLike<T>;
+declare module '@ember/array/proxy' {
+  import Array from '@ember/array';
+  import type MutableArray from '@ember/array/mutable';
+  import EmberObject from '@ember/object';
 
   /**
-   * 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.
+   * 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.
    */
-  objectAtContent(idx: number): T | undefined;
+  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/test/array-ext.ts b/types/preview/@ember/array/test/array-ext.ts
deleted file mode 100755
index beeba72a113..00000000000
--- a/types/preview/@ember/array/test/array-ext.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { assertType } from './lib/assert';
-import EmberObject from '@ember/object';
-import ArrayPrototypeExtensions from '@ember/array/types/prototype-extensions';
-
-declare global {
-  interface Array<T> extends ArrayPrototypeExtensions<T> {}
-}
-
-class Person extends EmberObject {
-  declare name: string;
-}
-
-const person = Person.create({ name: 'Joe' });
-const array = [person];
-
-assertType<number>(array.get('length'));
-assertType<Person | undefined>(array.get('firstObject'));
-assertType<string[]>(array.mapBy('name'));
-assertType<string[]>(array.map((p) => p.get('name')));
-assertType<Person[]>(array.sortBy('name'));
-assertType<Person[]>(array.uniq());
-assertType<Person[]>(array.uniqBy('name'));
-assertType<Person[]>(array.uniqBy((p) => p.get('name')));
diff --git a/types/preview/@ember/array/test/lib/assert.ts b/types/preview/@ember/array/test/lib/assert.ts
deleted file mode 100755
index dad227ab5e9..00000000000
--- a/types/preview/@ember/array/test/lib/assert.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-/** Static assertion that `value` has type `T` */
-export declare function assertType<T>(value: T): T;
diff --git a/types/preview/@ember/array/types/prototype-extensions.d.ts b/types/preview/@ember/array/types/prototype-extensions.d.ts
index 4609906857a..20db9620ebd 100644
--- a/types/preview/@ember/array/types/prototype-extensions.d.ts
+++ b/types/preview/@ember/array/types/prototype-extensions.d.ts
@@ -1,5 +1,6 @@
-// import Ember from 'ember';
-import Observable from '@ember/object/observable';
-import MutableArray from '@ember/array/mutable';
+declare module '@ember/array/types/prototype-extensions' {
+  import Observable from '@ember/object/observable';
+  import MutableArray from '@ember/array/mutable';
 
-export default interface ArrayPrototypeExtensions<T> extends MutableArray<T>, Observable {}
+  export default interface ArrayPrototypeExtensions<T> extends MutableArray<T>, Observable {}
+}
diff --git a/types/preview/@ember/component/-private/class-names-support.d.ts b/types/preview/@ember/component/-private/class-names-support.d.ts
index 0944d06a3ad..a8dc9cf4e28 100644
--- a/types/preview/@ember/component/-private/class-names-support.d.ts
+++ b/types/preview/@ember/component/-private/class-names-support.d.ts
@@ -1,25 +1,27 @@
-import Mixin from '@ember/object/mixin';
+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[];
+  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;
 }
-declare 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
index 6a98d1716fb..cc1b307640f 100644
--- a/types/preview/@ember/component/-private/core-view.d.ts
+++ b/types/preview/@ember/component/-private/core-view.d.ts
@@ -1,12 +1,14 @@
-import EmberObject from '@ember/object';
-import type Evented from '@ember/object/evented';
-import type ActionHandler from '@ember/object/-private/action-handler';
+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 {}
+  /**
+   * 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
index 1b27d8f716f..e77e6f1eb89 100644
--- a/types/preview/@ember/component/-private/glimmer-interfaces.d.ts
+++ b/types/preview/@ember/component/-private/glimmer-interfaces.d.ts
@@ -1,44 +1,46 @@
-// 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.
+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
-// tslint:disable-next-line:strict-export-declare-modifiers
-declare const CAPABILITIES: unique symbol;
+  // 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
+  // tslint:disable-next-line:strict-export-declare-modifiers
+  const CAPABILITIES: unique symbol;
 
-export interface Capabilities {
-  [CAPABILITIES]: true;
-}
+  export interface Capabilities {
+    [CAPABILITIES]: true;
+  }
 
-export interface Arguments {
-  positional: readonly unknown[];
-  named: Record<string, unknown>;
-}
+  export interface Arguments {
+    positional: readonly unknown[];
+    named: Record<string, unknown>;
+  }
 
-export interface ComponentCapabilitiesVersions {
-  '3.4': {
-    asyncLifecycleCallbacks?: boolean;
-    destructor?: boolean;
-  };
+  export interface ComponentCapabilitiesVersions {
+    '3.4': {
+      asyncLifecycleCallbacks?: boolean;
+      destructor?: boolean;
+    };
 
-  '3.13': {
-    asyncLifecycleCallbacks?: boolean;
-    destructor?: boolean;
-    updateHook?: boolean;
-  };
-}
+    '3.13': {
+      asyncLifecycleCallbacks?: boolean;
+      destructor?: boolean;
+      updateHook?: boolean;
+    };
+  }
 
-export interface ComponentCapabilities extends Capabilities {
-  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;
+  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
index d330e420e46..152f75af973 100644
--- a/types/preview/@ember/component/-private/view-mixin.d.ts
+++ b/types/preview/@ember/component/-private/view-mixin.d.ts
@@ -1,57 +1,59 @@
-import Mixin from '@ember/object/mixin';
+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;
-}
-declare const ViewMixin: 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;
+  export default ViewMixin;
+}
diff --git a/types/preview/@ember/component/helper.d.ts b/types/preview/@ember/component/helper.d.ts
index 1e41c007ce0..d4c00902a8c 100644
--- a/types/preview/@ember/component/helper.d.ts
+++ b/types/preview/@ember/component/helper.d.ts
@@ -1,200 +1,122 @@
-import EmberObject from '@ember/object';
-import { Opaque } from 'ember/-private/type-utils';
+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 };
 
-// --- Type utilities for signatures --- //
-// Type-only "symbol" to use with `EmptyObject` below, so that it is *not*
-// equivalent to an empty interface.
-declare 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;
-
-/**
- * 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;
-}
-
-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.
-declare const BadType: unique symbol;
-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:
-export interface ExpandSignature<T> {
-  Args: unknown extends T // Is this the default (i.e. unspecified) signature?
-    ? MissingSignatureArgs // Then return our special "missing signature" type
-    : keyof T extends 'Args' | 'Return' // Is this a `Signature`?
-    ? ArgsFor<T> // Then use `Signature` args
-    : LegacyArgsFor<T>; // Otherwise fall back to classic `Args`.
-  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`.
-type NamedArgs<S> = unknown extends S
-  ? Record<string, unknown>
-  : ExpandSignature<S>['Args']['Named'];
-type PositionalArgs<S> = unknown extends S ? unknown[] : ExpandSignature<S>['Args']['Positional'];
-
-type Return<S> = GetOrElse<S, '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:
+   * The public shape of a helper.
+   * @deprecated Do not use this directly. Instead, write a `Signature` with the
+   *   "normal" signature shape: `Args: { Named: { ... }, Positional: [...] }`.
    */
-  static helper<P extends DefaultPositional, N = EmptyObject, R = unknown>(
-    helper: (positional: P, named: N) => R
-  ): Helper<{ Args: { Positional: P; Named: N }; Return: R }>;
+  export interface HelperSignature {
+    NamedArgs?: DefaultNamed;
+    PositionalArgs?: DefaultPositional;
+    Return?: unknown;
+  }
+
   /**
-   * Override this function when writing a class-based helper.
+   * Ember Helpers are functions that can compute values, and are used in templates.
+   * For example, this code calls a helper named `format-currency`:
    */
-  compute(positional: PositionalArgs<S>, named: NamedArgs<S>): Return<S>;
+  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;
+  }
+
   /**
-   * 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.
+   * 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).
    */
-  recompute(): void;
-}
-
-// 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.
-// tslint:disable-next-line:no-unnecessary-generics
-export default interface Helper<S> extends Opaque<S> {}
+  // 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>;
 
-// 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;
+  /**
+   * 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 {};
 }
-
-/**
- * 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
index 069e9d2c923..c78cb25c62a 100644
--- a/types/preview/@ember/component/index.d.ts
+++ b/types/preview/@ember/component/index.d.ts
@@ -1,131 +1,133 @@
-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 './-private/glimmer-interfaces';
-import { Opaque } from 'ember/-private/type-utils';
+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 };
+  // Re-export these types so people can use them!
+  export { ComponentManager, Capabilities };
 
-interface TemplateFactory {
-  __htmlbars_inline_precompile_template_factory: any;
-}
+  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.
+  // tslint:disable-next-line:no-unnecessary-generics
+  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;
+  }
 
-// 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.
-// tslint:disable-next-line:no-unnecessary-generics
-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):
+   * 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).
    *
-   * 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.
+   * @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
    */
-  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;
+  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'> { }
+
   /**
-   * Called when the component is about to update and rerender itself. Called only during a rerender,
-   * not during an initial render.
+   * 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
    */
-  willUpdate(): void;
+  export const Input: Input;
 
   /**
-   * `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.
+   * 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
    */
-  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'> {}
+  export const Textarea: 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 {};
+  // 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
index 853d3a0e1c9..86762e3dab8 100644
--- a/types/preview/@ember/component/template-only.d.ts
+++ b/types/preview/@ember/component/template-only.d.ts
@@ -1,46 +1,47 @@
-import { Opaque } from 'ember/-private/type-utils';
+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;
-}
+  /**
+   * 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>;
+  /**
+   * 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.
-// tslint:disable-next-line:no-unnecessary-generics
-export default function templateOnly<S>(moduleName?: string): 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/test/built-ins.ts b/types/preview/@ember/component/test/built-ins.ts
deleted file mode 100644
index ec95d1b50a6..00000000000
--- a/types/preview/@ember/component/test/built-ins.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { Input, Textarea } from '@ember/component';
-
-Input; // $ExpectType Input
-Textarea; // $ExpectType Textarea
diff --git a/types/preview/@ember/component/test/lib/assert.ts b/types/preview/@ember/component/test/lib/assert.ts
deleted file mode 100755
index dad227ab5e9..00000000000
--- a/types/preview/@ember/component/test/lib/assert.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-/** Static assertion that `value` has type `T` */
-export declare function assertType<T>(value: T): T;
diff --git a/types/preview/@ember/controller/index.d.ts b/types/preview/@ember/controller/index.d.ts
index 44d6c65edef..d270a29ecee 100644
--- a/types/preview/@ember/controller/index.d.ts
+++ b/types/preview/@ember/controller/index.d.ts
@@ -1,47 +1,49 @@
-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';
+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';
+  type QueryParamTypes = 'boolean' | 'number' | 'array' | 'string';
+  type QueryParamScopeTypes = 'controller' | 'model';
 
-interface QueryParamConfig {
-  type?: QueryParamTypes | undefined;
-  scope?: QueryParamScopeTypes | undefined;
-  as?: string | undefined;
-}
+  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.
+   * Additional methods for the Controller.
    */
-  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 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 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;
+  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.
-// tslint:disable-next-line no-empty-interface
-export interface Registry {}
+  // A type registry for Ember `Controller`s. Meant to be declaration-merged
+  // so string lookups resolve to the correct type.
+  // tslint:disable-next-line no-empty-interface
+  export interface Registry {}
+}
diff --git a/types/preview/@ember/debug/container-debug-adapter.d.ts b/types/preview/@ember/debug/container-debug-adapter.d.ts
index d0f9c8aa6ae..edc16cc568b 100644
--- a/types/preview/@ember/debug/container-debug-adapter.d.ts
+++ b/types/preview/@ember/debug/container-debug-adapter.d.ts
@@ -1,11 +1,13 @@
-import type { Resolver } from '@ember/-internals/resolver';
+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[];
+  /**
+   * 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
index 6dcae185384..0159212085b 100644
--- a/types/preview/@ember/debug/data-adapter.d.ts
+++ b/types/preview/@ember/debug/data-adapter.d.ts
@@ -1,62 +1,64 @@
-import ContainerDebugAdapter from '@ember/debug/container-debug-adapter';
-import EmberObject from '@ember/object';
+declare module '@ember/debug/data-adapter' {
+  import ContainerDebugAdapter from '@ember/debug/container-debug-adapter';
+  import EmberObject from '@ember/object';
 
-declare namespace DataAdapter {
-  interface Column {
-    name: string;
-    desc: string;
-  }
-  interface WrappedRecord {
-    columnValues: object;
-    object: object;
-  }
-  interface WrappedType {
-    type: {
+  namespace DataAdapter {
+    interface Column {
       name: string;
-      count: number;
-      columns: Column[];
-      object: typeof Object;
-    };
-    release: () => void;
+      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.
+   * The `DataAdapter` helps a data persistence library
+   * interface with tools that debug Ember such as Chrome and Firefox.
    */
-  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;
+  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/ember__debug-tests.ts b/types/preview/@ember/debug/ember__debug-tests.ts
deleted file mode 100644
index 3a803dae675..00000000000
--- a/types/preview/@ember/debug/ember__debug-tests.ts
+++ /dev/null
@@ -1,251 +0,0 @@
-import {
-  runInDebug,
-  warn,
-  debug,
-  assert,
-  registerWarnHandler,
-  registerDeprecationHandler,
-  deprecate,
-} from '@ember/debug';
-
-/**
- * @ember/debug tests
- */
-// @ts-expect-error
-runInDebug();
-runInDebug(() => console.log('Should not show up in prod')); // $ExpectType void
-
-// Log a warning if we have more than 3 tomsters
-const tomsterCount = 2;
-// @ts-expect-error
-warn('Too many tomsters!');
-warn('Too many tomsters!', { id: 'some-warning' }); // $ExpectType void
-// @ts-expect-error
-warn('Too many tomsters!', tomsterCount <= 3);
-warn('Too many tomsters!', tomsterCount <= 3, { id: 'some-warning' }); // $ExpectType void
-warn('Too many tomsters!', tomsterCount <= 3, {
-  // $ExpectType void
-  id: 'ember-debug.too-many-tomsters',
-});
-
-// @ts-expect-error
-debug();
-debug('Too many tomsters!'); // $ExpectType void
-// @ts-expect-error
-debug('Too many tomsters!', 'foo');
-
-// Test for truthiness
-const str: unknown = 'hello';
-assert('Must pass a string', typeof str === 'string'); // $ExpectType void
-str; // $ExpectType string
-
-const anObject = {};
-assert('Must pass an object', anObject); // $ExpectType void
-
-// Test with null and undefined
-assert('Can handle falsiness', null); // $ExpectType void
-assert('Can handle falsiness', undefined); // $ExpectType void
-
-// Fail unconditionally
-assert('This code path should never be run'); // $ExpectType never
-
-// Require first argument
-// @ts-expect-error
-assert();
-
-// next is not called, so no warnings get the default behavior
-// @ts-expect-error
-registerWarnHandler();
-registerWarnHandler(() => {}); // $ExpectType void
-registerWarnHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; } | undefined
-  next; // $ExpectType (message: string, options?: { id: string; } | undefined) => void
-});
-registerWarnHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; } | undefined
-  // @ts-expect-error
-  next();
-});
-registerWarnHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; } | undefined
-  next(message); // $ExpectType void
-});
-registerWarnHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; } | undefined
-  next(message, options); // $ExpectType void
-});
-
-// next is not called, so no warnings get the default behavior
-// @ts-expect-error
-registerDeprecationHandler();
-registerDeprecationHandler(() => {}); // $ExpectType void
-registerDeprecationHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; until: string; } | undefined
-  next; // $ExpectType (message: string, options?: { id: string; until: string; } | undefined) => void
-});
-registerDeprecationHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; until: string; } | undefined
-  // @ts-expect-error
-  next();
-});
-registerDeprecationHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; until: string; } | undefined
-  next(message); // $ExpectType void
-});
-registerDeprecationHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; until: string; } | undefined
-  next(message, options); // $ExpectType void
-});
-
-// @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' });
-deprecate('a valid deprecation without `url`', true, {
-  // $ExpectType void
-  id: 'some.deprecation',
-  until: 'v4.0.0',
-  for: 'some.namespace',
-  since: {
-    available: 'some.early.version',
-    enabled: 'some.version',
-  },
-});
-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',
-  },
-});
-deprecate('a valid deprecation with `url`', true, {
-  // $ExpectType void
-  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',
-  },
-});
-deprecate('a valid deprecation with `for`', true, {
-  // $ExpectType void
-  id: 'some.deprecation',
-  until: 'v4.0.0',
-  for: 'some.namespace',
-  since: {
-    available: 'some.earlier.version',
-    enabled: 'some.version',
-  },
-});
-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',
-  },
-});
-deprecate('a valid deprecation with `since`', true, {
-  // $ExpectType void
-  id: 'some.deprecation',
-  until: 'v4.0.0',
-  for: 'some.namespace',
-  since: {
-    available: 'some.version',
-  },
-});
-deprecate('a valid deprecation with `since`', true, {
-  // $ExpectType void
-  id: 'some.deprecation',
-  until: 'v4.0.0',
-  for: 'some.namespace',
-  since: {
-    available: 'some.version',
-    enabled: 'some.version',
-  },
-});
-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',
-  },
-});
diff --git a/types/preview/@ember/debug/index.d.ts b/types/preview/@ember/debug/index.d.ts
index 6554a0d082b..6febb97a22d 100644
--- a/types/preview/@ember/debug/index.d.ts
+++ b/types/preview/@ember/debug/index.d.ts
@@ -1,96 +1,98 @@
-/**
- * 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;
+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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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 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;
+  /**
+   * 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;
+  export interface Available {
+    available: string;
+  }
+  export interface Enabled extends Available {
+    enabled: string;
+  }
 }
diff --git a/types/preview/@ember/destroyable/index.d.ts b/types/preview/@ember/destroyable/index.d.ts
index e8dfee90dd9..302dd6d4240 100644
--- a/types/preview/@ember/destroyable/index.d.ts
+++ b/types/preview/@ember/destroyable/index.d.ts
@@ -1,21 +1,23 @@
-export function associateDestroyableChild<T extends object>(parent: object, child: T): T;
+declare module '@ember/destroyable' {
+  export function associateDestroyableChild<T extends object>(parent: object, child: T): T;
 
-export function isDestroying(destroyable: object): boolean;
+  export function isDestroying(destroyable: object): boolean;
 
-export function isDestroyed(destroyable: object): boolean;
+  export function isDestroyed(destroyable: object): boolean;
 
-export function destroy(destroyable: object): void;
+  export function destroy(destroyable: object): void;
 
-export function assertDestroyablesDestroyed(): void;
+  export function assertDestroyablesDestroyed(): void;
 
-export function enableDestroyableTracking(): void;
+  export function enableDestroyableTracking(): void;
 
-export function registerDestructor<T extends object>(
-  destroyable: T,
-  destructor: (destroyable: T) => void
-): (destroyable: T) => 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;
+  export function unregisterDestructor<T extends object>(
+    destroyable: T,
+    destructor: (destroyable: T) => void
+  ): void;
+}
diff --git a/types/preview/@ember/destroyable/test/lib/assert.ts b/types/preview/@ember/destroyable/test/lib/assert.ts
deleted file mode 100644
index dad227ab5e9..00000000000
--- a/types/preview/@ember/destroyable/test/lib/assert.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-/** Static assertion that `value` has type `T` */
-export declare function assertType<T>(value: T): T;
diff --git a/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts b/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts
index d281c67be69..fbedd3127a9 100644
--- a/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts
+++ b/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts
@@ -1,15 +1,17 @@
-import Owner from '@ember/owner';
-import Mixin from '@ember/object/mixin';
+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.
+   * Given a fullName return a factory manager.
    */
-  ownerInjection(): {};
+  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;
 }
-declare 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
index 801abf8b0cf..a9f9599f8f3 100644
--- a/types/preview/@ember/engine/-private/registry-proxy-mixin.d.ts
+++ b/types/preview/@ember/engine/-private/registry-proxy-mixin.d.ts
@@ -1,52 +1,54 @@
-import Owner from '@ember/owner';
-import Mixin from '@ember/object/mixin';
+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;
+   * 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;
 }
-declare 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
index 2a7f29ccb85..25953dee71b 100644
--- a/types/preview/@ember/engine/-private/types/initializer.d.ts
+++ b/types/preview/@ember/engine/-private/types/initializer.d.ts
@@ -1,6 +1,8 @@
-export default interface Initializer<T> {
-  name: string;
-  before?: string[] | undefined;
-  after?: string[] | undefined;
-  initialize(application: T): void;
+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
index 6cae348a092..561e251d620 100644
--- a/types/preview/@ember/engine/index.d.ts
+++ b/types/preview/@ember/engine/index.d.ts
@@ -1,43 +1,45 @@
-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';
+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.
+   * The `Engine` class contains core functionality for both applications and
+   * engines.
    */
-  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;
+  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 {}
+
   /**
-   * Create an EngineInstance for this Engine.
+   * `getEngineParent` retrieves an engine instance's parent instance.
    */
-  buildInstance(options?: object): EngineInstance;
+  export function getEngineParent(engine: EngineInstance): 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
index 482e66b6caa..2f8c03015da 100644
--- a/types/preview/@ember/engine/instance.d.ts
+++ b/types/preview/@ember/engine/instance.d.ts
@@ -1,22 +1,24 @@
-import ContainerProxyMixin from '@ember/engine/-private/container-proxy-mixin';
-import RegistryProxyMixin from '@ember/engine/-private/registry-proxy-mixin';
-import EmberObject from '@ember/object';
+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.
+   * The `EngineInstance` encapsulates all of the stateful aspects of a
+   * running `Engine`.
    */
-  unregister(fullName: string): unknown;
+  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>;
-}
+    /**
+     *  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 {}
+  export default interface EngineInstance extends RegistryProxyMixin, ContainerProxyMixin {}
+}
diff --git a/types/preview/@ember/error/index.d.ts b/types/preview/@ember/error/index.d.ts
index 8d13769d1f2..6a8636372b6 100644
--- a/types/preview/@ember/error/index.d.ts
+++ b/types/preview/@ember/error/index.d.ts
@@ -1,4 +1,6 @@
-/**
- * A subclass of the JavaScript Error object for use in Ember.
- */
-export default class EmberError extends Error {}
+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/helper/ember__helper-tests.ts b/types/preview/@ember/helper/ember__helper-tests.ts
deleted file mode 100644
index 56b0f5743f8..00000000000
--- a/types/preview/@ember/helper/ember__helper-tests.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { array, concat, fn, get, hash } from '@ember/helper';
-
-array; // $ExpectType ArrayHelper
-concat; // $ExpectType ConcatHelper
-fn; // $ExpectType FnHelper
-get; // $ExpectType GetHelper
-hash; // $ExpectType HashHelper
diff --git a/types/preview/@ember/helper/index.d.ts b/types/preview/@ember/helper/index.d.ts
index 8b6f38d351f..01977dc729c 100644
--- a/types/preview/@ember/helper/index.d.ts
+++ b/types/preview/@ember/helper/index.d.ts
@@ -1,47 +1,49 @@
-import type { Opaque } from 'ember/-private/type-utils';
+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'> {}
+  // 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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/modifier/ember__modifier-tests.ts b/types/preview/@ember/modifier/ember__modifier-tests.ts
deleted file mode 100644
index 3dc6865fb40..00000000000
--- a/types/preview/@ember/modifier/ember__modifier-tests.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { setModifierManager, capabilities, on } from '@ember/modifier';
-import Owner from '@ember/owner';
-
-declare let owner: Owner;
-
-on; // $ExpectType OnModifier
-setModifierManager((owner) => {}, {}); // $ExpectType {}
-capabilities('3.24'); // $ExpectType unknown
diff --git a/types/preview/@ember/modifier/index.d.ts b/types/preview/@ember/modifier/index.d.ts
index 2281a7ea20e..5a4f782b24d 100644
--- a/types/preview/@ember/modifier/index.d.ts
+++ b/types/preview/@ember/modifier/index.d.ts
@@ -1,31 +1,33 @@
-import type Owner from '@ember/owner';
-import type { Opaque } from 'ember/-private/type-utils';
+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'> {}
+  // 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;
+  /**
+   * 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 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;
+  /**
+   * 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/object/-private/action-handler.d.ts b/types/preview/@ember/object/-private/action-handler.d.ts
index ab1f89e9119..331207994f7 100644
--- a/types/preview/@ember/object/-private/action-handler.d.ts
+++ b/types/preview/@ember/object/-private/action-handler.d.ts
@@ -1,29 +1,31 @@
-import { AnyFn } from 'ember/-private/type-utils';
-import type Mixin from '../mixin';
+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;
-}
+  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.
+   * 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.)
    */
-  actions: ActionsHash;
+  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;
 }
-declare 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
index 5945629ca89..efe9bb7a7b9 100644
--- a/types/preview/@ember/object/-private/types.d.ts
+++ b/types/preview/@ember/object/-private/types.d.ts
@@ -1,61 +1,63 @@
-import type Mixin from '../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;
+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;
 }
-
-/**
- * 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
index 291097ab67a..fbc5605ec02 100644
--- a/types/preview/@ember/object/compat.d.ts
+++ b/types/preview/@ember/object/compat.d.ts
@@ -1,7 +1,9 @@
-/**
- * `@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;
+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
index c283b1bf86e..30fa4938739 100644
--- a/types/preview/@ember/object/computed.d.ts
+++ b/types/preview/@ember/object/computed.d.ts
@@ -1,261 +1,263 @@
-/**
- * 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>;
-}
+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;
+  // 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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.
+   */
+  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 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;
+  /**
+   * 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 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 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;
+  /**
+   * 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 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;
+  /**
+   * 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 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 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 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 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 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.
+   *
+   * 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 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 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 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 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;
+  /**
+   * 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
index f9ecbbb256a..ea8506f9b01 100644
--- a/types/preview/@ember/object/core.d.ts
+++ b/types/preview/@ember/object/core.d.ts
@@ -1,87 +1,89 @@
-import type { EmberClassConstructor, Objectify } from './-private/types';
-import type Mixin from './mixin';
+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);
+  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;
+    _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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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 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 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 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 reopenClass<Statics>(
+      this: Statics,
+      ...extraStatics: Array<Mixin | Record<string, unknown>>
+    ): Statics;
 
-  static isClass: boolean;
-  static isMethod: boolean;
-}
+    static isClass: boolean;
+    static isMethod: boolean;
+  }
 
-type MembersOf<Class extends typeof CoreObject> = {
-  [Key in keyof InstanceType<Class>]?: InstanceType<Class>[Key];
-};
+  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
index f3be2682036..d60f3524b00 100644
--- a/types/preview/@ember/object/evented.d.ts
+++ b/types/preview/@ember/object/evented.d.ts
@@ -1,43 +1,45 @@
-import Mixin from '@ember/object/mixin';
-import { AnyFn, EmberMethod } from 'ember/-private/type-utils';
+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.
+   * This mixin allows for Ember objects to subscribe to and emit events.
    */
-  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[]): any;
-  /**
-   * 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;
+  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;
+
   /**
-   * Checks to see if object has any subscriptions for named event.
+   * Define a property as a function that should be executed when
+   * a specified event or events are triggered.
    */
-  has(name: string): boolean;
+  export function on<F extends AnyFn>(...args: [...eventNames: string[], func: F]): F;
 }
-declare 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
index 17d6df2cbf3..281ec80aab4 100644
--- a/types/preview/@ember/object/events.d.ts
+++ b/types/preview/@ember/object/events.d.ts
@@ -1,45 +1,47 @@
-import { AnyFunction } from '@ember/object/-private/types';
+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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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
index 05a3cbb5129..5eb4d03ce46 100644
--- a/types/preview/@ember/object/index.d.ts
+++ b/types/preview/@ember/object/index.d.ts
@@ -1,114 +1,124 @@
-import CoreObject from './core';
-import type Observable from './observable';
-import type ComputedProperty from './computed';
-import type { BasicComputedProperty } from './computed';
-import type { AnyFunction } from './-private/types';
+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 {}
+  /**
+   * `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;
+  /**
+   * 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;
+  export function computed(
+    ...args: [...dependentKeys: string[], callback: AnyFunction]
+  ): BasicComputedProperty;
 
-/**
- * Specify a method that observes property changes.
- */
-export function observer<Fn extends (target: any, key: string) => void>(
-  ...args: [...propertyNames: string[], func: Fn]
-): Fn;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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>;
+  /**
+   * 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>;
+  /**
+   * 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;
+  /**
+   * 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 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;
+  /**
+   * 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 function notifyPropertyChange(obj: object, keyName: string): void;
 
-export const action: MethodDecorator;
+  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
index bb9ccc5be99..9d9ea53784b 100644
--- a/types/preview/@ember/object/internals.d.ts
+++ b/types/preview/@ember/object/internals.d.ts
@@ -1,15 +1,17 @@
-/**
- * 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;
+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;
+  /**
+   * 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
index 4ddb16700f7..af3475c7bfc 100644
--- a/types/preview/@ember/object/mixin.d.ts
+++ b/types/preview/@ember/object/mixin.d.ts
@@ -1,17 +1,19 @@
-declare const __ember_mixin__: unique symbol;
+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?
+   * The `Ember.Mixin` class allows you to create mixins, whose properties can be
+   * added to other classes.
    */
-  [__ember_mixin__]: never;
+  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;
+    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
index 74ed10570dd..e64774959c7 100644
--- a/types/preview/@ember/object/observable.d.ts
+++ b/types/preview/@ember/object/observable.d.ts
@@ -1,83 +1,89 @@
-import { ObserverMethod } from './-private/types';
-import Mixin from './mixin';
-import CoreObject from './core';
+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.
+   * This mixin provides properties and property observing functionality, core features of the Ember object model.
    */
-  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;
+  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;
 }
-declare const Observable: Mixin;
-export default Observable;
diff --git a/types/preview/@ember/object/observers.d.ts b/types/preview/@ember/object/observers.d.ts
index bbf57e4b3fa..36fb7de3325 100644
--- a/types/preview/@ember/object/observers.d.ts
+++ b/types/preview/@ember/object/observers.d.ts
@@ -1,32 +1,34 @@
-import { ObserverMethod } from '@ember/object/-private/types';
+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;
+  /**
+   * 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
index 2ccc0ca5694..a834447639f 100644
--- a/types/preview/@ember/object/promise-proxy-mixin.d.ts
+++ b/types/preview/@ember/object/promise-proxy-mixin.d.ts
@@ -1,35 +1,37 @@
-import Mixin from '@ember/object/mixin';
-import RSVP from 'rsvp';
+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.
+   * A low level mixin making ObjectProxy promise-aware.
    */
-  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>;
+  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;
 }
-declare const PromiseProxyMixin: Mixin;
-export default PromiseProxyMixin;
diff --git a/types/preview/@ember/object/proxy.d.ts b/types/preview/@ember/object/proxy.d.ts
index 266b34d3c81..a28ec6ebbda 100644
--- a/types/preview/@ember/object/proxy.d.ts
+++ b/types/preview/@ember/object/proxy.d.ts
@@ -1,25 +1,27 @@
-import EmberObject from './index';
+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.
+   * `Ember.ObjectProxy` forwards all properties not defined by the proxy itself
+   * to a proxied `content` object.
    */
-  content: T | undefined;
+  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;
+    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>;
+    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];
+    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>;
+    setProperties<K extends keyof this | keyof T>(hash: Pick<this & T, K>): Pick<this & T, K>;
+  }
 }
diff --git a/types/preview/@ember/object/test/access-modifier.ts b/types/preview/@ember/object/test/access-modifier.ts
deleted file mode 100644
index 04e6dc510b5..00000000000
--- a/types/preview/@ember/object/test/access-modifier.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { assertType } from './lib/assert';
-import EmberObject from '@ember/object';
-
-class Foo extends EmberObject {
-  hello() {
-    return 'world';
-  }
-  protected bar() {
-    return 'bar';
-  }
-  private baz() {
-    return 'baz';
-  }
-}
-const f = new Foo();
-assertType<string>(f.hello());
-// @ts-expect-error
-assertType<string>(f.bar());
-// @ts-expect-error
-assertType<string>(f.baz());
-
-// TODO: enable after TS 3.0 https://github.com/typed-ember/ember-cli-typescript/issues/291
-// class Foo2 extends EmberObject.extend({
-//     bar: ''
-// }) {
-//     hello() { return 'world'; }
-//     protected bar() { return 'bar'; } // @ts-expect-error
-//     private baz() { return 'baz'; }
-// }
diff --git a/types/preview/@ember/object/test/get-set.ts b/types/preview/@ember/object/test/get-set.ts
deleted file mode 100644
index 86c801e7b63..00000000000
--- a/types/preview/@ember/object/test/get-set.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { get, set } from '@ember/object';
-
-const basicPojo = { greeting: 'hello' };
-
-get(basicPojo, 'greeting'); // $ExpectType string
-get(basicPojo, 'salutation'); // $ExpectType unknown
-set(basicPojo, 'greeting', 'ahoy'); // $ExpectType string
-// @ts-expect-error
-set(basicPojo, 'salutation', 'heyo');
-
-declare let whoKnows: unknown;
-get(whoKnows, 'any-string'); // $ExpectType unknown
-// @ts-expect-error
-set(whoKnows, 'any-string', 123);
diff --git a/types/preview/@ember/object/test/internals.ts b/types/preview/@ember/object/test/internals.ts
deleted file mode 100644
index fcfb55c2bcb..00000000000
--- a/types/preview/@ember/object/test/internals.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { guidFor } from '@ember/object/internals';
-
-// $ExpectType string
-const strGuid = guidFor('a string');
-// $ExpectType string
-const numGuid = guidFor(123);
-// $ExpectType string
-const objGuid = guidFor({ hello: 'world' });
-// $ExpectType string
-const arrGuid = guidFor([1, 2, 3]);
diff --git a/types/preview/@ember/object/test/lib/assert.ts b/types/preview/@ember/object/test/lib/assert.ts
deleted file mode 100644
index dad227ab5e9..00000000000
--- a/types/preview/@ember/object/test/lib/assert.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-/** Static assertion that `value` has type `T` */
-export declare function assertType<T>(value: T): T;
diff --git a/types/preview/@ember/owner/index.d.ts b/types/preview/@ember/owner/index.d.ts
index 414de7abe1c..31ca3476d4c 100644
--- a/types/preview/@ember/owner/index.d.ts
+++ b/types/preview/@ember/owner/index.d.ts
@@ -1,96 +1,102 @@
-/**
- * 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 {
+declare module '@ember/owner' {
   /**
-   * Given a {@linkcode FullName} return a corresponding instance.
+   * The name for a factory consists of a namespace and the name of a specific
+   * type within that namespace, like `'service:session'`.
    */
-  lookup(fullName: FullName): unknown;
+  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.
   /**
-   * 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.
+   * 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.
    */
-  // 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;
+  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;
+  }
 
   /**
-   * Given a fullName of the form `'type:name'`, like `'route:application'`,
-   * return a corresponding factory manager.
+   * 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.
    *
-   * 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.
+   * However, that behavior can be modified with the `instantiate` and `singleton`
+   * options to the {@linkcode Owner.register} method.
    */
-  factoryFor(fullName: FullName): FactoryManager<unknown> | undefined;
-}
+  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;
+  }
 
-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.
+   * 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.
    *
-   * @param initialValues Any values to set on an instance of the class
+   * @note `FactoryManager` is *not* user-constructible; the only legal way to get
+   *   a `FactoryManager` is via {@linkcode Owner.factoryFor}.
    */
-  create(initialValues?: Partial<T>): T;
-}
+  export interface FactoryManager<T> extends Factory<T> {
+    /** The registered or resolved class. */
+    readonly class: Factory<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 {};
 }
-
-// Don't export things unless we *intend* to.
-export {};
diff --git a/types/preview/@ember/polyfills/ember__polyfills-tests.ts b/types/preview/@ember/polyfills/ember__polyfills-tests.ts
deleted file mode 100644
index 06f1261b6e6..00000000000
--- a/types/preview/@ember/polyfills/ember__polyfills-tests.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { assign } from '@ember/polyfills';
-
-(() => {
-  /* assign */
-  assign({}, { a: 'b' });
-  assign({}, { a: 'b' }).a; // $ExpectType string
-  assign({ a: 6 }, { a: 'b' }).a; // $ExpectType string
-  assign({ a: 6 }, {}).a; // $ExpectType number
-  // @ts-expect-error
-  assign({ b: 6 }, {}).a;
-  assign({}, { b: 6 }, {}).b; // $ExpectType number
-  assign({ a: 'hello' }, { b: 6 }, {}).a; // $ExpectType string
-  assign({ a: 'hello' }, { b: 6 }, { a: true }).a; // $ExpectType boolean
-  // @ts-expect-error
-  assign({ a: 'hello' }, '', { a: true }).a;
-  assign({ d: ['gobias industries'] }, { a: 'hello' }, { b: 6 }, { a: true }).d; // $ExpectType string[]
-  // @ts-expect-error
-  assign({}, { a: 0 }, { b: 1 }, { c: 2 }, { d: 3 }).a;
-
-  // matches Object.assign
-  assign({}, null); // $ExpectType never
-  assign({}, undefined); // $ExpectType never
-})();
diff --git a/types/preview/@ember/polyfills/index.d.ts b/types/preview/@ember/polyfills/index.d.ts
index 8bc9e03dd30..4fbe04bcaa9 100644
--- a/types/preview/@ember/polyfills/index.d.ts
+++ b/types/preview/@ember/polyfills/index.d.ts
@@ -1,21 +1,23 @@
-import type { Mix, Mix3, Mix4 } from './types';
+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;
+  /**
+   * 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/types.d.ts b/types/preview/@ember/polyfills/types.d.ts
index d1c8cf23063..be2a75c4ccc 100644
--- a/types/preview/@ember/polyfills/types.d.ts
+++ b/types/preview/@ember/polyfills/types.d.ts
@@ -1,4 +1,6 @@
-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;
+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/route-info-with-attributes.d.ts b/types/preview/@ember/routing/-private/route-info-with-attributes.d.ts
index 4977630e2ef..eccb9e34b6b 100644
--- a/types/preview/@ember/routing/-private/route-info-with-attributes.d.ts
+++ b/types/preview/@ember/routing/-private/route-info-with-attributes.d.ts
@@ -1 +1,3 @@
-export { RouteInfoWithAttributes as default } from '../route-info';
+declare module '@ember/routing/-private/route-info-with-attributes' {
+  export { RouteInfoWithAttributes as default } from '@ember/routing/route-info';
+}
diff --git a/types/preview/@ember/routing/-private/route-info.d.ts b/types/preview/@ember/routing/-private/route-info.d.ts
index 8c186376518..6174f5896a8 100644
--- a/types/preview/@ember/routing/-private/route-info.d.ts
+++ b/types/preview/@ember/routing/-private/route-info.d.ts
@@ -1 +1,3 @@
-export { default as default } from '../route-info';
+declare module '@ember/routing/-private/route-info' {
+  export { default as default } from '@ember/routing/route-info';
+}
diff --git a/types/preview/@ember/routing/-private/router-dsl.d.ts b/types/preview/@ember/routing/-private/router-dsl.d.ts
index 00c91f826df..8499aec45c8 100644
--- a/types/preview/@ember/routing/-private/router-dsl.d.ts
+++ b/types/preview/@ember/routing/-private/router-dsl.d.ts
@@ -1,18 +1,20 @@
-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;
+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/-private/transition.d.ts b/types/preview/@ember/routing/-private/transition.d.ts
index b825aaed5a7..bfaa3add03f 100644
--- a/types/preview/@ember/routing/-private/transition.d.ts
+++ b/types/preview/@ember/routing/-private/transition.d.ts
@@ -1 +1,3 @@
-export { default as default } from '../transition';
+declare module '@ember/routing/-private/transition' {
+  export { default as default } from '@ember/routing/transition';
+}
diff --git a/types/preview/@ember/routing/auto-location.d.ts b/types/preview/@ember/routing/auto-location.d.ts
index eb17614eb76..ef226556850 100644
--- a/types/preview/@ember/routing/auto-location.d.ts
+++ b/types/preview/@ember/routing/auto-location.d.ts
@@ -1,6 +1,8 @@
-import EmberObject from '@ember/object';
+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 {}
+  /**
+   * 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
index 55b92d265ee..ce78e1d4ada 100644
--- a/types/preview/@ember/routing/hash-location.d.ts
+++ b/types/preview/@ember/routing/hash-location.d.ts
@@ -1,8 +1,10 @@
-import EmberObject from '@ember/object';
+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 {}
+  /**
+   * `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
index 67d4399f038..71b2c015298 100644
--- a/types/preview/@ember/routing/history-location.d.ts
+++ b/types/preview/@ember/routing/history-location.d.ts
@@ -1,7 +1,9 @@
-import EmberObject from '@ember/object';
+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 {}
+  /**
+   * 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
index bc33c70dae5..1fc19e3d27b 100644
--- a/types/preview/@ember/routing/index.d.ts
+++ b/types/preview/@ember/routing/index.d.ts
@@ -1,18 +1,20 @@
-export { default as Route } from '@ember/routing/route';
-export { default as Router } from '@ember/routing/router';
+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';
+  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'> {}
+  // 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;
+  /**
+   * 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
index 286860db69f..8fface47a39 100644
--- a/types/preview/@ember/routing/none-location.d.ts
+++ b/types/preview/@ember/routing/none-location.d.ts
@@ -1,9 +1,11 @@
-import EmberObject from '@ember/object';
+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 {}
+  /**
+   * 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
index acc8095ed2e..ead7d39900b 100644
--- a/types/preview/@ember/routing/route-info.d.ts
+++ b/types/preview/@ember/routing/route-info.d.ts
@@ -1,72 +1,74 @@
-// 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 {
+declare module '@ember/routing/route-info' {
+  // https://api.emberjs.com/ember/4.0/classes/RouteInfo
   /**
-   * A reference to the childe route's `RouteInfo`.
-   * This can be used to traverse downward to the leafmost `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.
    */
-  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;
-}
+  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 {
+  // https://api.emberjs.com/ember/4.0/classes/RouteInfoWithAttributes
   /**
-   * This is the resolved return value from the
-   * route's model hook.
+   * 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.
    */
-  readonly attributes: unknown;
+  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
index 7735a954299..93ff84ea54e 100644
--- a/types/preview/@ember/routing/route.d.ts
+++ b/types/preview/@ember/routing/route.d.ts
@@ -1,532 +1,534 @@
-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 { RenderOptions, RouteQueryParam } from '@ember/routing/types';
-import Controller from '@ember/controller';
+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';
 
-// tslint:disable-next-line:strict-export-declare-modifiers
-type RouteModel = object | string | number;
+  // tslint:disable-next-line:strict-export-declare-modifiers
+  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.
+   * The `Ember.Route` class is used to define individual routes. Refer to
+   * the [routing guide](http://emberjs.com/guides/routing/) for documentation.
    */
-  afterModel(resolvedModel: Model, transition: Transition): Promise<unknown> | void;
+  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;
+    /**
+     * 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;
+    /**
+     * 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>;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    // 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;
+    // 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 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;
+    /**
+     * 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 };
+    /**
+     * Configuration hash for this route's queryParams.
+     */
+    queryParams: { [key: string]: RouteQueryParam };
 
-  /**
-   * The name of the route, dot-delimited
-   */
-  routeName: string;
+    /**
+     * 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;
+    /**
+     * 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;
+    // 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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 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;
+    /**
+     * 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;
+    /**
+     * 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
index 2d8ff069df9..1aceaf2a0b4 100644
--- a/types/preview/@ember/routing/router-service.d.ts
+++ b/types/preview/@ember/routing/router-service.d.ts
@@ -1,350 +1,352 @@
-import RouteInfo, { RouteInfoWithAttributes } from '@ember/routing/route-info';
-import Transition from '@ember/routing/transition';
-import Service from '@ember/service';
+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';
 
-// tslint:disable-next-line:strict-export-declare-modifiers
-type RouteModel = object | string | number;
+  // tslint:disable-next-line:strict-export-declare-modifiers
+  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 {
-  //
+  // https://emberjs.com/api/ember/release/classes/RouterService
   /**
-   * 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)
+   * The Router service is the public API that provides component/view layer access to the router.
    */
-  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;
+  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;
+    /**
+     * 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;
+    /**
+     * 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/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/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://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.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=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=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=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;
+    /**
+     * 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 `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;
+    /**
+     * 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;
+    /**
+     * 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
index 348c410a0b6..299dc3f43df 100644
--- a/types/preview/@ember/routing/router.d.ts
+++ b/types/preview/@ember/routing/router.d.ts
@@ -1,42 +1,48 @@
-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';
-import RouterService from '@ember/routing/router-service';
+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.extend(Evented) {
   /**
-   * 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`.
+   * The `Ember.Router` class manages the application state and URLs. Refer to
+   * the [routing guide](http://emberjs.com/guides/routing/) for documentation.
    */
-  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;
-  transitionTo(name: string, ...models: any[]): Transition;
-  transitionTo(name: string, options: {}): Transition;
+  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/test/built-ins.ts b/types/preview/@ember/routing/test/built-ins.ts
deleted file mode 100644
index 40db98e07cf..00000000000
--- a/types/preview/@ember/routing/test/built-ins.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import { LinkTo } from '@ember/routing';
-
-LinkTo; // $ExpectType LinkTo
diff --git a/types/preview/@ember/routing/test/lib/assert.ts b/types/preview/@ember/routing/test/lib/assert.ts
deleted file mode 100755
index dad227ab5e9..00000000000
--- a/types/preview/@ember/routing/test/lib/assert.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-/** Static assertion that `value` has type `T` */
-export declare function assertType<T>(value: T): T;
diff --git a/types/preview/@ember/routing/test/router-service.ts b/types/preview/@ember/routing/test/router-service.ts
deleted file mode 100644
index 5abf1b622e6..00000000000
--- a/types/preview/@ember/routing/test/router-service.ts
+++ /dev/null
@@ -1,120 +0,0 @@
-import RouterService from '@ember/routing/router-service';
-
-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 = () => {};
-
-// $ExpectType RouterService
-router.on('routeWillChange', routeWillChangeHandler);
-
-// $ExpectType boolean
-router.has('routeWillChange');
-
-// $ExpectType RouterService
-router.off('routeWillChange', routeWillChangeHandler);
-
-// $ExpectType RouterService
-router.one('routeWillChange', routeWillChangeHandler);
-
-// $ExpectType void
-router.trigger('routeWillChange', 'boo');
-
-const transition = router.transitionTo('someRoute');
-
-// $ExpectType Transition<unknown>
-transition.abort();
-
-// $ExpectType Promise<unknown>
-transition.catch();
-transition.catch((err) => console.log(err), 'label');
-
-// $ExpectType Promise<unknown>
-transition.finally();
-transition.finally(() => console.log('finally!'));
-transition.finally(() => console.log('finally!'), 'label');
-
-// $ExpectType Promise<unknown>
-transition.followRedirects();
-
-// $ExpectType Transition<unknown>
-transition.method();
-transition.method('replace');
-
-// $ExpectType Transition<unknown>
-transition.retry();
-
-// $ExpectType Promise<unknown>
-transition.then();
-transition.then(
-  (result) => console.log(result),
-  (err) => console.log(err),
-  'label'
-);
-
-// $ExpectType void
-transition.trigger(false, 'error');
-
-// $ExpectType void
-transition.send(false, 'error');
-
-transition.data = { some: 'data' };
-
-// $ExpectType RouteInfoWithAttributes | null
-transition.from;
-// @ts-expect-error
-transition.from = 'from';
-
-// $ExpectType Promise<unknown>
-transition.promise;
-// @ts-expect-error
-transition.promise = 'promise';
-
-// $ExpectType RouteInfo | RouteInfoWithAttributes
-transition.to;
-// @ts-expect-error
-transition.to = 'to';
-
-// $ExpectType unknown
-transition.to.metadata;
-// @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.
-// $ExpectType Transition<unknown>
-router.transitionTo('someRoute', { queryParams: { shouldWork: true } });
-// $ExpectType Transition<unknown>
-router.transitionTo({ queryParams: { areSupported: true } });
-// @ts-expect-error
-router.transitionTo({ queryParams: 'potato' });
-// $ExpectType Transition<unknown>
-router.transitionTo('someRoute', 1);
-// $ExpectType Transition<unknown>
-router.transitionTo('someRoute', 1, { queryParams: { areSupported: true } });
-// $ExpectType Transition<unknown>
-router.transitionTo('someRoute', 1, '13');
-// $ExpectType Transition<unknown>
-router.transitionTo('someRoute', 1, '13', { queryParams: { areSupported: true } });
-
-router.recognize('foo/bar'); // $ExpectType RouteInfo
-
-router.recognizeAndLoad('foo/bar'); // $ExpectType RouteInfoWithAttributes
-
-router.rootURL; // $ExpectType string
-// @ts-expect-error
-router.rootURL = 'foo';
-
-router.refresh(); // $ExpectType Transition<unknown>
-router.refresh('my-route'); // $ExpectType Transition<unknown>
diff --git a/types/preview/@ember/routing/transition.d.ts b/types/preview/@ember/routing/transition.d.ts
index f575b9da974..0d36e8437d8 100644
--- a/types/preview/@ember/routing/transition.d.ts
+++ b/types/preview/@ember/routing/transition.d.ts
@@ -1,124 +1,126 @@
-import RouteInfo, { RouteInfoWithAttributes } from './route-info';
+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
+   * 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.
    *
-   * @param  ignoreFailure a boolean specifying whether unhandled events throw an error
-   * @param  name          the name of the event to fire
+   * @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.
    */
-  trigger(ignoreFailure: boolean, name: string): void;
+  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/types.d.ts b/types/preview/@ember/routing/types.d.ts
index 0895070ec9a..c8483e79e47 100644
--- a/types/preview/@ember/routing/types.d.ts
+++ b/types/preview/@ember/routing/types.d.ts
@@ -1,13 +1,15 @@
-export interface RenderOptions {
-  into?: string | undefined;
-  controller?: string | undefined;
-  model?: unknown;
-  outlet?: string | undefined;
-  view?: string | undefined;
-}
+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;
+  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
index 146cdcb611c..20fc9cff668 100644
--- a/types/preview/@ember/runloop/-private/backburner.d.ts
+++ b/types/preview/@ember/runloop/-private/backburner.d.ts
@@ -1,41 +1,43 @@
-import { EmberMethod, EmberMethodParams } from 'ember/-private/type-utils';
+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 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 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 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;
+  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
index 5bdf61ef241..8fa9ccf9bf2 100644
--- a/types/preview/@ember/runloop/-private/types.d.ts
+++ b/types/preview/@ember/runloop/-private/types.d.ts
@@ -1,7 +1,9 @@
-export type EmberRunQueues =
-  | 'sync'
-  | 'actions'
-  | 'routerTransitions'
-  | 'render'
-  | 'afterRender'
-  | 'destroy';
+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
index 372df3a5fa4..160276e858c 100644
--- a/types/preview/@ember/runloop/index.d.ts
+++ b/types/preview/@ember/runloop/index.d.ts
@@ -1,171 +1,175 @@
-import {
-  EmberMethod,
-  EmberMethodParams,
-  AnyFn,
-  EmberMethodReturn,
-  AnyMethod,
-} from 'ember/-private/type-utils';
-import { EmberRunQueues } from './-private/types';
-import { EmberRunTimer } from '@ember/runloop/types';
-import '@ember/runloop/-private/backburner';
+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;
+  /**
+   * 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>;
 
-/**
- * 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;
+  /**
+   * 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;
 
-/**
- * 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;
+  /**
+   * 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>;
 
-/**
- * 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;
+  /**
+   * 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;
 
-/**
- * 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;
+  /**
+   * 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;
 
-export function once<T, M extends keyof T>(
-  target: T,
-  method: M,
-  ...args: EmberMethodParams<T, M>
-): EmberRunTimer;
+  /**
+   * 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;
 
-/**
- * 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;
+  /**
+   * 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;
 
-/**
- * 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;
+  /**
+   * 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;
 
-/**
- * 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;
+  export function once<T, M extends keyof T>(
+    target: T,
+    method: M,
+    ...args: EmberMethodParams<T, M>
+  ): EmberRunTimer;
 
-/**
- * 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,
+  /**
+   * 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<Target, M>,
-    wait: number,
-    immediate?: boolean
-  ]
-): EmberRunTimer;
+    ...args: EmberMethodParams<T, M>
+  ): 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: [
+  /**
+   * 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,
-    ...methodArgs: EmberMethodParams<T, M>,
-    spacing: number,
-    immediate?: boolean
-  ]
-): EmberRunTimer;
+    ...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/types.d.ts b/types/preview/@ember/runloop/types.d.ts
index 0ba5585ad72..f1c79f14c6c 100644
--- a/types/preview/@ember/runloop/types.d.ts
+++ b/types/preview/@ember/runloop/types.d.ts
@@ -1,3 +1,5 @@
-export interface EmberRunTimer {
-  __ember_run_timer_brand__: boolean;
+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
index a9fe6f68536..8a3828ed837 100644
--- a/types/preview/@ember/service/index.d.ts
+++ b/types/preview/@ember/service/index.d.ts
@@ -1,24 +1,26 @@
-import EmberObject from '@ember/object';
-import type { BasicComputedProperty } from '@ember/object/computed';
+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
+  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
+  /**
+   * 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.
-// tslint:disable-next-line no-empty-interface strict-export-declare-modifiers
-interface Registry {}
+  // A type registry for Ember `Service`s. Meant to be declaration-merged so
+  // string lookups resolve to the correct type.
+  // tslint:disable-next-line no-empty-interface strict-export-declare-modifiers
+  interface Registry {}
+}
diff --git a/types/preview/@ember/string/index.d.ts b/types/preview/@ember/string/index.d.ts
index 6a6f95b8ed5..965bfd7b842 100644
--- a/types/preview/@ember/string/index.d.ts
+++ b/types/preview/@ember/string/index.d.ts
@@ -1,7 +1,9 @@
-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[];
+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/template/-private/handlebars.d.ts b/types/preview/@ember/template/-private/handlebars.d.ts
index ac9a7eb6fb3..6b4d0985f92 100644
--- a/types/preview/@ember/template/-private/handlebars.d.ts
+++ b/types/preview/@ember/template/-private/handlebars.d.ts
@@ -1,5 +1,7 @@
-export class SafeString {
-  constructor(str: string);
-  toString(): string;
-  toHTML(): string;
+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
index 9079f7a96f4..32b7d70da6f 100644
--- a/types/preview/@ember/template/index.d.ts
+++ b/types/preview/@ember/template/index.d.ts
@@ -1,3 +1,5 @@
-import { SafeString } from './-private/handlebars';
-export function htmlSafe(str: string): SafeString;
-export function isHTMLSafe(str: unknown): str is SafeString;
+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/test/adapter.d.ts b/types/preview/@ember/test/adapter.d.ts
index a1573f0d416..ac38cd059ba 100644
--- a/types/preview/@ember/test/adapter.d.ts
+++ b/types/preview/@ember/test/adapter.d.ts
@@ -1,20 +1,22 @@
-/**
- * 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 {
+declare module '@ember/test/adapter' {
   /**
-   * This callback will be called whenever an async operation is about to start.
+   * The primary purpose of this class is to create hooks that can be implemented
+   * by an adapter for various test frameworks.
    */
-  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;
+  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
index 7e78f264120..8d754a27286 100644
--- a/types/preview/@ember/test/index.d.ts
+++ b/types/preview/@ember/test/index.d.ts
@@ -1,47 +1,49 @@
-import Application from '@ember/application';
+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;
+  /**
+   * `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;
+  /**
+   * 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;
+  /**
+   * 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/utils/-private/types.d.ts b/types/preview/@ember/utils/-private/types.d.ts
index a09307c2c40..de5bf83173a 100644
--- a/types/preview/@ember/utils/-private/types.d.ts
+++ b/types/preview/@ember/utils/-private/types.d.ts
@@ -1,7 +1,9 @@
-import type { AnyFn } from 'ember/-private/type-utils';
+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> =
+  // 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 :
@@ -9,28 +11,29 @@ type _KeysOfType<Key extends keyof TypeLookup, Type> =
     // using a const-valued function like `const x = () => 4 as const`.
     Type extends TypeLookup[Key] ? Key : never;
 
-// prettier-ignore
-type KeysOfType<Type> =
+  // 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>;
+  // 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: unknown[];
-  error: Error;
-  filelist: FileList;
-  date: Date;
-  null: null;
-  undefined: undefined;
-}
+  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 {};
+  // 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
index d28098e176b..be432898ad4 100644
--- a/types/preview/@ember/utils/index.d.ts
+++ b/types/preview/@ember/utils/index.d.ts
@@ -1,41 +1,42 @@
-import type { TypeOf } from './-private/types';
+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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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';
-export function typeOf(item: unknown): string;
+  /**
+   * 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/-private/type-utils.d.ts b/types/preview/ember/-private/type-utils.d.ts
index a40275e657b..f0dca1fab68 100644
--- a/types/preview/ember/-private/type-utils.d.ts
+++ b/types/preview/ember/-private/type-utils.d.ts
@@ -1,52 +1,54 @@
-// These are utility types used throughout the Ember type definitions. They
-// should *never* be used in end user code.
+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;
+  /** A safe-ish type representing any function. */
+  export type AnyFn = (...args: any[]) => unknown;
 
-export type AnyMethod<Target> = (this: Target, ...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;
-};
+  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];
+  // 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 MethodParams<T, M extends MethodNamesOf<T>> = Parameters<MethodsOf<T>[M]>;
 
-export type MethodReturns<T, M extends MethodNamesOf<T>> = ReturnType<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>> =
+  // 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>> =
+  // 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).
-declare const Data: unique symbol;
-export class Opaque<Data> {
-  private declare [Data]: Data;
+  /**
+   * 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 {};
 }
-
-export {};
diff --git a/types/preview/ember/index.d.ts b/types/preview/ember/index.d.ts
index 81f76ca76f1..285250f392a 100755
--- a/types/preview/ember/index.d.ts
+++ b/types/preview/ember/index.d.ts
@@ -1,382 +1,382 @@
-// Capitalization is intentional: this makes it much easier to re-export RSVP on
-// the Ember namespace.
-import Rsvp from 'rsvp';
+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';
-// tslint:disable-next-line:no-duplicate-imports
-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';
-// tslint:disable-next-line:no-duplicate-imports
-import * as EmberControllerNs from '@ember/controller';
-// tslint:disable-next-line:no-duplicate-imports
-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';
-import type EmberArrayProtoExtensions from '@ember/array/types/prototype-extensions';
-// @ember/error
-import type EmberError from '@ember/error';
+  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';
+  // tslint:disable-next-line:no-duplicate-imports
+  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';
+  // tslint:disable-next-line:no-duplicate-imports
+  import * as EmberControllerNs from '@ember/controller';
+  // tslint:disable-next-line:no-duplicate-imports
+  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';
+  import type EmberArrayProtoExtensions from '@ember/array/types/prototype-extensions';
+  // @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';
+  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';
 
-export namespace Ember {
-  export const A: typeof EmberArrayNs.A;
-  export const isArray: typeof EmberArrayNs.isArray;
-  export type Enumerable<T> = EmberEnumerable<T>;
-  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<T> = EmberMutableEnumerable<T>;
-  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 {}
+  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 {}
-  export interface ArrayPrototypeExtensions<T> extends EmberArrayProtoExtensions<T> {}
+    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 {}
+    export interface ArrayPrototypeExtensions<T> extends EmberArrayProtoExtensions<T> {}
 
-  /**
-   * 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.
+     * Implements some standard methods for comparing objects. Add this mixin to
+     * any class you create that can compare its instances.
      */
-    factoryFor(fullName: string, options?: {}): unknown;
-  }
-  class ContainerDebugAdapter extends _ContainerDebugAdapter {}
-
-  // TODO: replace with a proper ES6 reexport once we remove declare module 'ember' {}
-  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 {}
+    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 Mixin extends EmberMixin {}
+    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 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 {}
+    /**
+     * A subclass of the JavaScript Error object for use in Ember.
+     */
+    const Error: typeof EmberError;
 
-  class Service extends Object {}
+    const Evented: typeof EmberObjectEventedNs.default;
+    interface Evented extends EmberObjectEventedNs.default {}
 
-  interface ViewTargetActionSupport {
-    target: unknown;
-    actionContext: unknown;
-  }
-  const ViewTargetActionSupport: Mixin;
-  const ViewUtils: {
-    isSimpleClick(event: Event): boolean;
-  };
+    class Mixin extends EmberMixin {}
 
-  // 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.
+     * 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.
      */
-    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>;
+    class Namespace extends Object {}
 
-    /**
-     * 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;
+    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 class implements the methods defined by Ember.Test.Adapter for the
-     * QUnit testing framework.
+     * This is a container for an assortment of testing related functionality
      */
-    class QUnitAdapter extends EmberTestAdapter {}
-    class Promise<T> extends Rsvp.Promise<T> {
-      constructor(
-        executor: (
+    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
-      );
+        ) => 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.
+     * Namespace for injection helper methods.
      */
-    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;
+    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;
+    // 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;
-  };
+    const platform: {
+      defineProperty: boolean;
+      hasPropertyAccessors: boolean;
+    };
 
-  /**
-   * `getEngineParent` retrieves an engine instance's parent instance.
-   */
-  function getEngineParent(engine: EngineInstance): EngineInstance;
+    /**
+     * `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 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 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 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 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;
-  // TODO: replace with an es6 reexport when declare module 'ember' is removed
-  /**
-   * 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;
+    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;
+    /**
+     * 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;
+    /**
+     * 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;
-}
+    const expandProperties: typeof EmberObjectComputedNs.expandProperties;
+  }
 
-export default Ember;
+  export default Ember;
+}
 
 declare module 'htmlbars-inline-precompile' {
   interface TemplateFactory {
diff --git a/types/preview/ember/test/array-ext.ts b/types/preview/ember/test/array-ext.ts
deleted file mode 100755
index 0b87d139900..00000000000
--- a/types/preview/ember/test/array-ext.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import Ember from 'ember';
-import { assertType } from './lib/assert';
-
-declare global {
-  interface Array<T> extends Ember.ArrayPrototypeExtensions<T> {}
-}
-
-class Person extends Ember.Object {
-  declare name: string;
-}
-
-const person = Person.create({ name: 'Joe' });
-const array = [person];
-
-assertType<number>(array.get('length'));
-assertType<Person | undefined>(array.get('firstObject'));
-assertType<string[]>(array.mapBy('name'));
-assertType<string[]>(array.map((p) => p.get('name')));
-assertType<Person[]>(array.sortBy('name'));
-assertType<Person[]>(array.uniq());
-assertType<Person[]>(array.uniqBy('name'));
diff --git a/types/preview/ember/test/data-adapter.ts b/types/preview/ember/test/data-adapter.ts
deleted file mode 100644
index e7a42b6a5cd..00000000000
--- a/types/preview/ember/test/data-adapter.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-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>();
-
-// $ExpectType () => void
-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>();
-  }
-);
-// @ts-expect-error
-da.watchModelTypes(() => {});
-
-// $ExpectType () => void
-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) {
-    idx; // $ExpectType number
-    count; // $ExpectType number
-  }
-);
-// @ts-expect-error
-da.watchRecords(() => {});
-
-da.acceptsModelName; // $ExpectType boolean
-da.containerDebugAdapter; // $ExpectType ContainerDebugAdapter
-
-const ca: Ember.ContainerDebugAdapter = da.containerDebugAdapter;
-ca.canCatalogEntriesByType('controller'); // $ExpectType boolean
-ca.catalogEntriesByType('controller'); // $ExpectType string[]
diff --git a/types/preview/ember/test/debug.ts b/types/preview/ember/test/debug.ts
deleted file mode 100644
index 69396503e07..00000000000
--- a/types/preview/ember/test/debug.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-import Ember from 'ember';
-
-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();
-runInDebug(() => console.log('Should not show up in prod')); // $ExpectType void
-
-// Log a warning if we have more than 3 tomsters
-const tomsterCount = 2;
-// @ts-expect-error
-warn('Too many tomsters!');
-warn('Too many tomsters!', { id: 'some-warning' }); // $ExpectType void
-// @ts-expect-error
-warn('Too many tomsters!', tomsterCount <= 3);
-warn('Too many tomsters!', tomsterCount <= 3, { id: 'some-warning' }); // $ExpectType void
-// $ExpectType void
-warn('Too many tomsters!', tomsterCount <= 3, {
-  id: 'ember-debug.too-many-tomsters',
-});
-
-// @ts-expect-error
-debug();
-debug('Too many tomsters!'); // $ExpectType void
-// @ts-expect-error
-debug('Too many tomsters!', 'foo');
-
-// next is not called, so no warnings get the default behavior
-// @ts-expect-error
-registerWarnHandler();
-registerWarnHandler(() => {}); // $ExpectType void
-registerWarnHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; } | undefined
-  next; // $ExpectType (message: string, options?: { id: string; } | undefined) => void
-});
-registerWarnHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; } | undefined
-  // @ts-expect-error
-  next();
-});
-registerWarnHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; } | undefined
-  next(message); // $ExpectType void
-});
-registerWarnHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; } | undefined
-  next(message, options); // $ExpectType void
-});
-
-// next is not called, so no warnings get the default behavior
-// @ts-expect-error
-registerDeprecationHandler();
-registerDeprecationHandler(() => {}); // $ExpectType void
-registerDeprecationHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; until: string; } | undefined
-  next; // $ExpectType (message: string, options?: { id: string; until: string; } | undefined) => void
-});
-registerDeprecationHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; until: string; } | undefined
-  // @ts-expect-error
-  next();
-});
-registerDeprecationHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; until: string; } | undefined
-  next(message); // $ExpectType void
-});
-registerDeprecationHandler((message, options, next) => {
-  // $ExpectType void
-  message; // $ExpectType string
-  options; // $ExpectType { id: string; until: string; } | undefined
-  next(message, options); // $ExpectType void
-});
-
-// Test for truthiness
-const str: unknown = 'hello';
-assert('Must pass a string', typeof str === 'string');
-str; // $ExpectType string
-
-// Fail unconditionally
-// This has to be last because `assert never` will raise TS's checks for
-// unreachable code.
-assert('This code path should never be run'); // $ExpectType never
diff --git a/types/preview/ember/test/error.ts b/types/preview/ember/test/error.ts
deleted file mode 100644
index 3e8de002ad9..00000000000
--- a/types/preview/ember/test/error.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { assertType } from './lib/assert';
-
-import Ember from 'ember';
-
-assertType<typeof Ember.Error>(Ember.Error);
diff --git a/types/preview/ember/test/lib/assert.ts b/types/preview/ember/test/lib/assert.ts
deleted file mode 100755
index dad227ab5e9..00000000000
--- a/types/preview/ember/test/lib/assert.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-/** Static assertion that `value` has type `T` */
-export declare function assertType<T>(value: T): T;
diff --git a/types/preview/ember/test/private/computed-tests.ts b/types/preview/ember/test/private/computed-tests.ts
deleted file mode 100644
index a3f61025ac2..00000000000
--- a/types/preview/ember/test/private/computed-tests.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import Ember from 'ember';
-
-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() {
-    this.fullName; // $ExpectType ComputedProperty<string, string>
-    this.allNames; // $ExpectType ComputedProperty<string[], string[]>
-    this.firstName; // $ExpectType string
-    this.lastName; // $ExpectType string
-
-    this.get('fullName').split(','); // $ExpectType string[]
-    this.get('allNames')[0]; // $ExpectType string
-    this.get('firstName').split(','); // $ExpectType string[]
-    this.get('lastName').split(','); // $ExpectType string[]
-  }
-}
diff --git a/types/preview/ember/test/utils.ts b/types/preview/ember/test/utils.ts
deleted file mode 100755
index 91796516054..00000000000
--- a/types/preview/ember/test/utils.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-import Ember from 'ember';
-import { expectTypeOf } from 'expect-type';
-import { assertType } from './lib/assert';
-
-function testTypeOf() {
-  Ember.typeOf(); // $ExpectType "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';
-  Ember.isNone(); // $ExpectType boolean
-}
-
-function testIsBlank() {
-  Ember.isBlank(); // $ExpectType boolean
-  Ember.isBlank(''); // $ExpectType boolean
-  // @ts-expect-error
-  Ember.isBlank('', '');
-}
-
-function testIsEmpty() {
-  Ember.isEmpty(); // $ExpectType boolean
-  Ember.isEmpty(''); // $ExpectType boolean
-  // @ts-expect-error
-  Ember.isEmpty('', '');
-}
-
-function testIsPresent() {
-  Ember.isPresent(); // $ExpectType boolean
-  Ember.isPresent(''); // $ExpectType boolean
-  // @ts-expect-error
-  Ember.isPresent('', '');
-}
-
-function testIsNone() {
-  Ember.isNone(); // $ExpectType boolean
-  Ember.isNone(''); // $ExpectType boolean
-  // @ts-expect-error
-  Ember.isNone('', '');
-}
-
-function testAssign() {
-  assertType<{ first: string; middle: string; last: string }>(
-    Ember.assign({ first: 'Tom' }, { middle: 'M' }, { last: 'Dale' })
-  );
-}
-
-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 */
-  Ember.typeOf(); // $ExpectType "undefined"
-  Ember.typeOf(null); // $ExpectType "null"
-  Ember.typeOf(undefined); // $ExpectType "undefined"
-  Ember.typeOf('michael'); // $ExpectType "string"
-  // tslint:disable-next-line:no-construct
-  Ember.typeOf(new String('michael')); // $ExpectType "string"
-  Ember.typeOf(101); // $ExpectType "number"
-  // tslint:disable-next-line:no-construct
-  Ember.typeOf(new Number(101)); // $ExpectType "number"
-  Ember.typeOf(true); // $ExpectType "boolean"
-  // tslint:disable-next-line:no-construct
-  Ember.typeOf(new Boolean(true)); // $ExpectType "boolean"
-  Ember.typeOf(() => 4); // $ExpectType "function"
-  Ember.typeOf([1, 2, 90]); // $ExpectType "array"
-  Ember.typeOf(/abc/); // $ExpectType "regexp"
-  Ember.typeOf(new Date()); // $ExpectType "date"
-  Ember.typeOf(fileList); // $ExpectType "filelist"
-  Ember.typeOf(Ember.Object.extend()); // $ExpectType "class"
-  Ember.typeOf(Ember.Object.create()); // $ExpectType "instance"
-  Ember.typeOf(new Error('teamocil')); // $ExpectType "error"
-  Ember.typeOf(new Date() as RegExp | Date); // "regexp" | "date"
-  Ember.typeOf({ randomObject: true }); // $ExpectType "object"
-})();
-
-(() => {
-  /* assign */
-  Ember.assign({}, { a: 'b' });
-  Ember.assign({}, { a: 'b' }).a; // $ExpectType string
-  Ember.assign({ a: 6 }, { a: 'b' }).a; // $ExpectType string
-  Ember.assign({ a: 6 }, {}).a; // $ExpectType number
-  // @ts-expect-error
-  Ember.assign({ b: 6 }, {}).a;
-  Ember.assign({}, { b: 6 }, {}).b; // $ExpectType number
-  Ember.assign({ a: 'hello' }, { b: 6 }, {}).a; // $ExpectType string
-  Ember.assign({ a: 'hello' }, { b: 6 }, { a: true }).a; // $ExpectType boolean
-  // @ts-expect-error
-  Ember.assign({ a: 'hello' }, '', { a: true }).a;
-  Ember.assign({ d: ['gobias industries'] }, { a: 'hello' }, { b: 6 }, { a: true }).d; // $ExpectType string[]
-})();
diff --git a/types/preview/ember/test/view-utils.ts b/types/preview/ember/test/view-utils.ts
deleted file mode 100644
index 7cce69bc61f..00000000000
--- a/types/preview/ember/test/view-utils.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import Ember from 'ember';
-import { assertType } from './lib/assert';
-
-const {
-  ViewUtils: { isSimpleClick },
-} = Ember;
-assertType<boolean>(isSimpleClick(new Event('wat')));
diff --git a/types/preview/index.d.ts b/types/preview/index.d.ts
new file mode 100644
index 00000000000..5d15af6d833
--- /dev/null
+++ b/types/preview/index.d.ts
@@ -0,0 +1,121 @@
+/**
+  @module
+  Makes Ember's types for the packages it publishes available by importing this
+  path from `ember-source`:
+
+  ```ts
+  import 'ember-source/types/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.
+//
+// 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/array/types/prototype-extensions';
+
+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/route-info'; // TODO: remove
+import './@ember/routing/-private/route-info-with-attributes'; // TODO: remove
+import './@ember/routing/-private/router-dsl';
+import './@ember/routing/-private/transition'; // TODO: remove
+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';

From dc1d4fda38f1083551796de9263fa7fff9848772 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Wed, 31 Aug 2022 17:54:22 -0600
Subject: [PATCH 32/39] Add type checking for preview types to package scripts

---
 package.json | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 771014a287e..03269bb0815 100644
--- a/package.json
+++ b/package.json
@@ -41,7 +41,10 @@
     "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 && tsc --noEmit --project types/preview",
+    "lint:tsc:stable": "tsc --noEmit",
+    "lint:tsc:preview": "tsc --noEmit --project type-tests/preview",
+    "lint:tsc:preview-array-ext": "tsc --noEmit --project type-tests/preview-prototype-extensions",
+    "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",

From 434c714506a1159db0498f93ebecd3cb69b60dc4 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Wed, 31 Aug 2022 17:59:52 -0600
Subject: [PATCH 33/39] Add array prototype extension preview types

These *do not work*. They will be removed in the next commit, but are
added here for historical purposes.

They do not work specifically because they introduce a circularity in
the definition of `NativeArray`: `NativeArray` must extends from a
*subset* of `Array` to correctly represent its public API and behavior,
but introducing the `Array` prototype extension in turn must extend from
`NativeArray`, which results in type errors because `NativeArray`
extends from the subset rather than the full API of `Array`.

This "worked" in the DefinitelyTyped version for two reasons:

1.  All of our type tests actually just assumed the array prototype
    extensions were enabled (as discussed in the previous commit).

2.  The type definition for `NativeArray` was *wrong*: at minimum it was
    substantially out of date; possibly it has always been incorrect.
    (It may have been incorrect *intentionally*, precisely to allow the
    prototype extension to work. The details are lost to time.)

In any case, these type tests represent the "correct" APIs for the
prototype extensions, so are committed here and removed in the next
commit for historical purposes.
---
 .../preview-prototype-extensions/README.md    |  1 +
 .../array-module-ext.ts                       | 21 +++++++++++++++++++
 .../ember-namespace-array-ext.ts              | 18 ++++++++++++++++
 .../preview-prototype-extensions/index.d.ts   |  6 ++++++
 .../tsconfig.json                             |  3 +++
 5 files changed, 49 insertions(+)
 create mode 100644 type-tests/preview-prototype-extensions/README.md
 create mode 100755 type-tests/preview-prototype-extensions/array-module-ext.ts
 create mode 100755 type-tests/preview-prototype-extensions/ember-namespace-array-ext.ts
 create mode 100644 type-tests/preview-prototype-extensions/index.d.ts
 create mode 100644 type-tests/preview-prototype-extensions/tsconfig.json

diff --git a/type-tests/preview-prototype-extensions/README.md b/type-tests/preview-prototype-extensions/README.md
new file mode 100644
index 00000000000..5a47b7822eb
--- /dev/null
+++ b/type-tests/preview-prototype-extensions/README.md
@@ -0,0 +1 @@
+This exists so we can test the *rest* of the system *without* pulling in Array prototype extensions.
diff --git a/type-tests/preview-prototype-extensions/array-module-ext.ts b/type-tests/preview-prototype-extensions/array-module-ext.ts
new file mode 100755
index 00000000000..f97cb41be1f
--- /dev/null
+++ b/type-tests/preview-prototype-extensions/array-module-ext.ts
@@ -0,0 +1,21 @@
+import EmberObject from '@ember/object';
+import { expectTypeOf } from 'expect-type';
+import type NativeArray from '@ember/array/-private/native-array';
+
+class Person extends EmberObject {
+  declare name: string;
+}
+
+const person = Person.create({ name: 'Joe' });
+const array = [person];
+
+expectTypeOf(array.get('length')).toBeNumber();
+expectTypeOf(array.get('firstObject')).toEqualTypeOf<Person | undefined>();
+expectTypeOf(array.mapBy('name')).toEqualTypeOf<NativeArray<string>>();
+expectTypeOf(array.map((p) => p.get('name'))).toEqualTypeOf<string[]>();
+// These use `toMatchTypeOf` instead of `toEqualTypeOf` because they are not
+// actually returning `Array`; they return `Ember.NativeArray`
+expectTypeOf(array.sortBy('name')).toMatchTypeOf<Person[]>();
+expectTypeOf(array.uniq()).toMatchTypeOf<Person[]>();
+expectTypeOf(array.uniqBy('name')).toMatchTypeOf<Person[]>();
+expectTypeOf(array.uniqBy((p) => p.get('name'))).toMatchTypeOf<Person[]>();
diff --git a/type-tests/preview-prototype-extensions/ember-namespace-array-ext.ts b/type-tests/preview-prototype-extensions/ember-namespace-array-ext.ts
new file mode 100755
index 00000000000..59a5bf256c2
--- /dev/null
+++ b/type-tests/preview-prototype-extensions/ember-namespace-array-ext.ts
@@ -0,0 +1,18 @@
+import Ember from 'ember';
+import { expectTypeOf } from 'expect-type';
+
+class Person extends Ember.Object {
+  declare name: string;
+}
+
+const person = Person.create({ name: 'Joe' });
+const array = [person];
+
+expectTypeOf(array.get('length')).toBeNumber();
+expectTypeOf(array.get('firstObject')).toEqualTypeOf<Person | undefined>();
+expectTypeOf(array.mapBy('name')).toMatchTypeOf<string[]>();
+expectTypeOf(array.map((p) => p.get('name'))).toEqualTypeOf<string[]>();
+// These return `Ember.NativeArray` so use `toMatchTypeOf`
+expectTypeOf(array.sortBy('name')).toMatchTypeOf<Person[]>();
+expectTypeOf(array.uniq()).toMatchTypeOf<Person[]>();
+expectTypeOf(array.uniqBy('name')).toMatchTypeOf<Person[]>();
diff --git a/type-tests/preview-prototype-extensions/index.d.ts b/type-tests/preview-prototype-extensions/index.d.ts
new file mode 100644
index 00000000000..5d36bbf9924
--- /dev/null
+++ b/type-tests/preview-prototype-extensions/index.d.ts
@@ -0,0 +1,6 @@
+import '../../types/preview';
+import type ArrayPrototypeExtensions from '@ember/array/types/prototype-extensions';
+
+declare global {
+  interface Array<T> extends ArrayPrototypeExtensions<T> {}
+}
diff --git a/type-tests/preview-prototype-extensions/tsconfig.json b/type-tests/preview-prototype-extensions/tsconfig.json
new file mode 100644
index 00000000000..a205f6579ab
--- /dev/null
+++ b/type-tests/preview-prototype-extensions/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "extends": "@tsconfig/ember/tsconfig.json",
+}

From 17df5a1fed5cc42dfe511b2f6a2cd94f7ee03832 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Wed, 31 Aug 2022 18:03:24 -0600
Subject: [PATCH 34/39] Remove types for array prototype extensions

See previous commit message for discussion of *why* these are being
removed. If we decide to re-introduce these types later, it will require
not only adding back in these tests but also taking some fairly distinct
approach to their inclusion, given the problems with the way they work.
---
 package.json                                  |  1 -
 .../preview-prototype-extensions/README.md    |  1 -
 .../array-module-ext.ts                       | 21 -------------------
 .../ember-namespace-array-ext.ts              | 18 ----------------
 .../preview-prototype-extensions/index.d.ts   |  6 ------
 .../tsconfig.json                             |  3 ---
 .../array/types/prototype-extensions.d.ts     |  6 ------
 types/preview/ember/index.d.ts                |  2 --
 types/preview/index.d.ts                      |  1 -
 9 files changed, 59 deletions(-)
 delete mode 100644 type-tests/preview-prototype-extensions/README.md
 delete mode 100755 type-tests/preview-prototype-extensions/array-module-ext.ts
 delete mode 100755 type-tests/preview-prototype-extensions/ember-namespace-array-ext.ts
 delete mode 100644 type-tests/preview-prototype-extensions/index.d.ts
 delete mode 100644 type-tests/preview-prototype-extensions/tsconfig.json
 delete mode 100644 types/preview/@ember/array/types/prototype-extensions.d.ts

diff --git a/package.json b/package.json
index 03269bb0815..778df1e0bac 100644
--- a/package.json
+++ b/package.json
@@ -43,7 +43,6 @@
     "lint:eslint:fix": "npm-run-all \"lint:eslint --fix\"",
     "lint:tsc:stable": "tsc --noEmit",
     "lint:tsc:preview": "tsc --noEmit --project type-tests/preview",
-    "lint:tsc:preview-array-ext": "tsc --noEmit --project type-tests/preview-prototype-extensions",
     "lint:tsc": "npm-run-all lint:tsc:*",
     "lint:fix": "npm-run-all lint:*:fix",
     "test": "node bin/run-tests.js",
diff --git a/type-tests/preview-prototype-extensions/README.md b/type-tests/preview-prototype-extensions/README.md
deleted file mode 100644
index 5a47b7822eb..00000000000
--- a/type-tests/preview-prototype-extensions/README.md
+++ /dev/null
@@ -1 +0,0 @@
-This exists so we can test the *rest* of the system *without* pulling in Array prototype extensions.
diff --git a/type-tests/preview-prototype-extensions/array-module-ext.ts b/type-tests/preview-prototype-extensions/array-module-ext.ts
deleted file mode 100755
index f97cb41be1f..00000000000
--- a/type-tests/preview-prototype-extensions/array-module-ext.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import EmberObject from '@ember/object';
-import { expectTypeOf } from 'expect-type';
-import type NativeArray from '@ember/array/-private/native-array';
-
-class Person extends EmberObject {
-  declare name: string;
-}
-
-const person = Person.create({ name: 'Joe' });
-const array = [person];
-
-expectTypeOf(array.get('length')).toBeNumber();
-expectTypeOf(array.get('firstObject')).toEqualTypeOf<Person | undefined>();
-expectTypeOf(array.mapBy('name')).toEqualTypeOf<NativeArray<string>>();
-expectTypeOf(array.map((p) => p.get('name'))).toEqualTypeOf<string[]>();
-// These use `toMatchTypeOf` instead of `toEqualTypeOf` because they are not
-// actually returning `Array`; they return `Ember.NativeArray`
-expectTypeOf(array.sortBy('name')).toMatchTypeOf<Person[]>();
-expectTypeOf(array.uniq()).toMatchTypeOf<Person[]>();
-expectTypeOf(array.uniqBy('name')).toMatchTypeOf<Person[]>();
-expectTypeOf(array.uniqBy((p) => p.get('name'))).toMatchTypeOf<Person[]>();
diff --git a/type-tests/preview-prototype-extensions/ember-namespace-array-ext.ts b/type-tests/preview-prototype-extensions/ember-namespace-array-ext.ts
deleted file mode 100755
index 59a5bf256c2..00000000000
--- a/type-tests/preview-prototype-extensions/ember-namespace-array-ext.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import Ember from 'ember';
-import { expectTypeOf } from 'expect-type';
-
-class Person extends Ember.Object {
-  declare name: string;
-}
-
-const person = Person.create({ name: 'Joe' });
-const array = [person];
-
-expectTypeOf(array.get('length')).toBeNumber();
-expectTypeOf(array.get('firstObject')).toEqualTypeOf<Person | undefined>();
-expectTypeOf(array.mapBy('name')).toMatchTypeOf<string[]>();
-expectTypeOf(array.map((p) => p.get('name'))).toEqualTypeOf<string[]>();
-// These return `Ember.NativeArray` so use `toMatchTypeOf`
-expectTypeOf(array.sortBy('name')).toMatchTypeOf<Person[]>();
-expectTypeOf(array.uniq()).toMatchTypeOf<Person[]>();
-expectTypeOf(array.uniqBy('name')).toMatchTypeOf<Person[]>();
diff --git a/type-tests/preview-prototype-extensions/index.d.ts b/type-tests/preview-prototype-extensions/index.d.ts
deleted file mode 100644
index 5d36bbf9924..00000000000
--- a/type-tests/preview-prototype-extensions/index.d.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-import '../../types/preview';
-import type ArrayPrototypeExtensions from '@ember/array/types/prototype-extensions';
-
-declare global {
-  interface Array<T> extends ArrayPrototypeExtensions<T> {}
-}
diff --git a/type-tests/preview-prototype-extensions/tsconfig.json b/type-tests/preview-prototype-extensions/tsconfig.json
deleted file mode 100644
index a205f6579ab..00000000000
--- a/type-tests/preview-prototype-extensions/tsconfig.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-  "extends": "@tsconfig/ember/tsconfig.json",
-}
diff --git a/types/preview/@ember/array/types/prototype-extensions.d.ts b/types/preview/@ember/array/types/prototype-extensions.d.ts
deleted file mode 100644
index 20db9620ebd..00000000000
--- a/types/preview/@ember/array/types/prototype-extensions.d.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-declare module '@ember/array/types/prototype-extensions' {
-  import Observable from '@ember/object/observable';
-  import MutableArray from '@ember/array/mutable';
-
-  export default interface ArrayPrototypeExtensions<T> extends MutableArray<T>, Observable {}
-}
diff --git a/types/preview/ember/index.d.ts b/types/preview/ember/index.d.ts
index 285250f392a..e0511e6bbf2 100755
--- a/types/preview/ember/index.d.ts
+++ b/types/preview/ember/index.d.ts
@@ -44,7 +44,6 @@ declare module 'ember' {
   import EmberArrayProxy from '@ember/array/proxy';
   import type EmberEnumerable from '@ember/array/-private/enumerable';
   import type EmberMutableEnumerable from '@ember/array/-private/mutable-enumerable';
-  import type EmberArrayProtoExtensions from '@ember/array/types/prototype-extensions';
   // @ember/error
   import type EmberError from '@ember/error';
 
@@ -94,7 +93,6 @@ declare module 'ember' {
     export const setOwner: typeof EmberApplicationNs.setOwner;
     export class EventDispatcher extends EmberEventDispatcher {}
     export class Registry extends EmberRegistry {}
-    export interface ArrayPrototypeExtensions<T> extends EmberArrayProtoExtensions<T> {}
 
     /**
      * Implements some standard methods for comparing objects. Add this mixin to
diff --git a/types/preview/index.d.ts b/types/preview/index.d.ts
index 5d15af6d833..7ec202b1068 100644
--- a/types/preview/index.d.ts
+++ b/types/preview/index.d.ts
@@ -35,7 +35,6 @@ import './@ember/array/-private/mutable-enumerable';
 import './@ember/array/-private/native-array';
 import './@ember/array/mutable';
 import './@ember/array/proxy';
-import './@ember/array/types/prototype-extensions';
 
 import './@ember/component';
 import './@ember/component/-private/class-names-support';

From 121ab1c67c2eda3d85a13c8e5b627e3e4b8c272e Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Wed, 31 Aug 2022 19:57:50 -0600
Subject: [PATCH 35/39] Types preview: prettier and remove tslint references

---
 types/preview/@ember/array/index.d.ts                    | 1 -
 .../@ember/component/-private/glimmer-interfaces.d.ts    | 1 -
 types/preview/@ember/component/index.d.ts                | 9 ++++-----
 types/preview/@ember/controller/index.d.ts               | 1 -
 types/preview/@ember/routing/route.d.ts                  | 1 -
 types/preview/@ember/routing/router-service.d.ts         | 1 -
 types/preview/@ember/service/index.d.ts                  | 1 -
 types/preview/ember/index.d.ts                           | 3 ---
 8 files changed, 4 insertions(+), 14 deletions(-)

diff --git a/types/preview/@ember/array/index.d.ts b/types/preview/@ember/array/index.d.ts
index 2667e7289f1..cd149da2d1b 100644
--- a/types/preview/@ember/array/index.d.ts
+++ b/types/preview/@ember/array/index.d.ts
@@ -21,7 +21,6 @@ declare module '@ember/array' {
     /**
      * This returns the objects at the specified indexes, using `objectAt`.
      */
-    // tslint:disable-next-line:array-type
     objectsAt(indexes: number[]): Array<T | undefined>;
     /**
      * Helper method returns the first object from a collection. This is usually
diff --git a/types/preview/@ember/component/-private/glimmer-interfaces.d.ts b/types/preview/@ember/component/-private/glimmer-interfaces.d.ts
index e77e6f1eb89..f5412750c3a 100644
--- a/types/preview/@ember/component/-private/glimmer-interfaces.d.ts
+++ b/types/preview/@ember/component/-private/glimmer-interfaces.d.ts
@@ -7,7 +7,6 @@ declare module '@ember/component/-private/glimmer-interfaces' {
   // 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
-  // tslint:disable-next-line:strict-export-declare-modifiers
   const CAPABILITIES: unique symbol;
 
   export interface Capabilities {
diff --git a/types/preview/@ember/component/index.d.ts b/types/preview/@ember/component/index.d.ts
index c78cb25c62a..ced33f71e48 100644
--- a/types/preview/@ember/component/index.d.ts
+++ b/types/preview/@ember/component/index.d.ts
@@ -17,8 +17,7 @@ declare module '@ember/component' {
   // 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.
-  // tslint:disable-next-line:no-unnecessary-generics
-  export default interface Component<S = unknown> extends ViewMixin, ClassNamesSupport, Opaque<S> { }
+  export default interface Component<S = unknown> extends ViewMixin, ClassNamesSupport, Opaque<S> {}
   export default class Component<S = unknown> extends CoreView {
     // methods
     readDOMAttr(name: string): string;
@@ -111,8 +110,8 @@ declare module '@ember/component' {
   // 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'> { }
+  export interface Input extends Opaque<'component:input'> {}
+  export interface Textarea extends Opaque<'component:textarea'> {}
 
   /**
    * The `Input` component lets you create an HTML `<input>` element.
@@ -129,5 +128,5 @@ declare module '@ember/component' {
   export const Textarea: Textarea;
 
   // Do not export anything but what we *explicitly* say to export.
-  export { };
+  export {};
 }
diff --git a/types/preview/@ember/controller/index.d.ts b/types/preview/@ember/controller/index.d.ts
index d270a29ecee..5d7dcbc4d2b 100644
--- a/types/preview/@ember/controller/index.d.ts
+++ b/types/preview/@ember/controller/index.d.ts
@@ -44,6 +44,5 @@ declare module '@ember/controller' {
 
   // A type registry for Ember `Controller`s. Meant to be declaration-merged
   // so string lookups resolve to the correct type.
-  // tslint:disable-next-line no-empty-interface
   export interface Registry {}
 }
diff --git a/types/preview/@ember/routing/route.d.ts b/types/preview/@ember/routing/route.d.ts
index 93ff84ea54e..c2005e66153 100644
--- a/types/preview/@ember/routing/route.d.ts
+++ b/types/preview/@ember/routing/route.d.ts
@@ -6,7 +6,6 @@ declare module '@ember/routing/route' {
   import { RouteQueryParam } from '@ember/routing/types';
   import Controller from '@ember/controller';
 
-  // tslint:disable-next-line:strict-export-declare-modifiers
   type RouteModel = object | string | number;
 
   /**
diff --git a/types/preview/@ember/routing/router-service.d.ts b/types/preview/@ember/routing/router-service.d.ts
index 1aceaf2a0b4..35b16927e85 100644
--- a/types/preview/@ember/routing/router-service.d.ts
+++ b/types/preview/@ember/routing/router-service.d.ts
@@ -3,7 +3,6 @@ declare module '@ember/routing/router-service' {
   import Transition from '@ember/routing/transition';
   import Service from '@ember/service';
 
-  // tslint:disable-next-line:strict-export-declare-modifiers
   type RouteModel = object | string | number;
 
   // https://emberjs.com/api/ember/release/classes/RouterService
diff --git a/types/preview/@ember/service/index.d.ts b/types/preview/@ember/service/index.d.ts
index 8a3828ed837..323494f3b35 100644
--- a/types/preview/@ember/service/index.d.ts
+++ b/types/preview/@ember/service/index.d.ts
@@ -21,6 +21,5 @@ declare module '@ember/service' {
 
   // A type registry for Ember `Service`s. Meant to be declaration-merged so
   // string lookups resolve to the correct type.
-  // tslint:disable-next-line no-empty-interface strict-export-declare-modifiers
   interface Registry {}
 }
diff --git a/types/preview/ember/index.d.ts b/types/preview/ember/index.d.ts
index e0511e6bbf2..59270bbcbb8 100755
--- a/types/preview/ember/index.d.ts
+++ b/types/preview/ember/index.d.ts
@@ -7,7 +7,6 @@ declare module 'ember' {
   import type * as EmberStringNs from '@ember/string';
   import type * as EmberTemplateNs from '@ember/template';
   import * as EmberTemplateHandlebarsNs from '@ember/template/-private/handlebars';
-  // tslint:disable-next-line:no-duplicate-imports
   import type * as EmberServiceNs from '@ember/service';
   import type * as EmberPolyfillsNs from '@ember/polyfills';
   import type * as EmberUtilsNs from '@ember/utils';
@@ -32,9 +31,7 @@ declare module 'ember' {
   import * as EmberApplicationInstanceNs from '@ember/application/instance';
   import type * as EmberApplicationDeprecateNs from '@ember/application/deprecations';
   import type * as EmberTestNs from '@ember/test';
-  // tslint:disable-next-line:no-duplicate-imports
   import * as EmberControllerNs from '@ember/controller';
-  // tslint:disable-next-line:no-duplicate-imports
   import EmberMixin from '@ember/object/mixin';
   import type EmberObservable from '@ember/object/observable';
   // @ember/array

From 303505ac07ccea48e43e86bc324acfcbfcab3b22 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Wed, 31 Aug 2022 21:12:28 -0600
Subject: [PATCH 36/39] Types preview: import from 'ember-source/preview'

Use `typesVersions` to resolve `preview` to `types/preview`; we can use
`types` for stable and more `typesVersions` (or, eventually, `exports`)
for other similar schemes in the future.
---
 package.json             | 7 +++++++
 types/preview/index.d.ts | 5 ++++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 778df1e0bac..1139694c356 100644
--- a/package.json
+++ b/package.json
@@ -167,5 +167,12 @@
   },
   "ember-addon": {
     "after": "ember-cli-legacy-blueprints"
+  },
+  "typesVersions": {
+    "*": {
+      "preview": [
+        "./types/preview"
+      ]
+    }
   }
 }
diff --git a/types/preview/index.d.ts b/types/preview/index.d.ts
index 7ec202b1068..858356c29db 100644
--- a/types/preview/index.d.ts
+++ b/types/preview/index.d.ts
@@ -4,13 +4,16 @@
   path from `ember-source`:
 
   ```ts
-  import 'ember-source/types/preview';
+  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

From f8a9e83492957d2dd777de0bd4fd143ae162b37b Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Wed, 31 Aug 2022 21:20:36 -0600
Subject: [PATCH 37/39] Types preview: remove private DT route types

We continue to maintain support for these import locations in the types
on DefinitelyTyped, but remove them here so that users trying the
preview types do not accidentally depend on them.
---
 .../preview/@ember/routing-test/route.ts      | 25 +------------------
 .../-private/route-info-with-attributes.d.ts  |  3 ---
 .../@ember/routing/-private/route-info.d.ts   |  3 ---
 .../@ember/routing/-private/transition.d.ts   |  3 ---
 4 files changed, 1 insertion(+), 33 deletions(-)
 delete mode 100644 types/preview/@ember/routing/-private/route-info-with-attributes.d.ts
 delete mode 100644 types/preview/@ember/routing/-private/route-info.d.ts
 delete mode 100644 types/preview/@ember/routing/-private/transition.d.ts

diff --git a/type-tests/preview/@ember/routing-test/route.ts b/type-tests/preview/@ember/routing-test/route.ts
index b550e7180f6..2ce642ec79d 100755
--- a/type-tests/preview/@ember/routing-test/route.ts
+++ b/type-tests/preview/@ember/routing-test/route.ts
@@ -5,8 +5,7 @@ import type Array from '@ember/array';
 import EmberObject from '@ember/object';
 import Controller from '@ember/controller';
 import type Transition from '@ember/routing/transition';
-import type { RouteInfoWithAttributes } from '@ember/routing/route-info';
-import type RouteInfo from '@ember/routing/route-info';
+import { expectTypeOf } from 'expect-type';
 
 class Post extends EmberObject {}
 
@@ -207,25 +206,3 @@ class WithImplicitParams extends Route {
 
 type ImplicitParams = WithImplicitParams extends Route<any, infer T> ? T : never;
 expectTypeOf<ImplicitParams>().toEqualTypeOf<RouteParams>();
-
-// back-compat for existing users of these
-// NOTE: we will *not* migrate the private import locations when moving to
-// publish from Ember itself.
-import type PrivateTransition from '@ember/routing/-private/transition';
-declare let publicTransition: Transition;
-declare let oldPrivateTransition: PrivateTransition;
-publicTransition = oldPrivateTransition;
-oldPrivateTransition = publicTransition;
-
-import type PrivateRouteInfo from '@ember/routing/-private/route-info';
-declare let publicRouteInfo: RouteInfo;
-declare let privateRouteInfo: PrivateRouteInfo;
-publicRouteInfo = privateRouteInfo;
-privateRouteInfo = publicRouteInfo;
-
-import type PrivateRouteInfoWithAttributes from '@ember/routing/-private/route-info-with-attributes';
-import { expectTypeOf } from 'expect-type';
-declare let publicRouteInfoWithAttributes: RouteInfoWithAttributes;
-declare let privateRouteInfoWithAttributes: PrivateRouteInfoWithAttributes;
-publicRouteInfoWithAttributes = privateRouteInfoWithAttributes;
-privateRouteInfoWithAttributes = publicRouteInfoWithAttributes;
diff --git a/types/preview/@ember/routing/-private/route-info-with-attributes.d.ts b/types/preview/@ember/routing/-private/route-info-with-attributes.d.ts
deleted file mode 100644
index eccb9e34b6b..00000000000
--- a/types/preview/@ember/routing/-private/route-info-with-attributes.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-declare module '@ember/routing/-private/route-info-with-attributes' {
-  export { RouteInfoWithAttributes as default } from '@ember/routing/route-info';
-}
diff --git a/types/preview/@ember/routing/-private/route-info.d.ts b/types/preview/@ember/routing/-private/route-info.d.ts
deleted file mode 100644
index 6174f5896a8..00000000000
--- a/types/preview/@ember/routing/-private/route-info.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-declare module '@ember/routing/-private/route-info' {
-  export { default as default } from '@ember/routing/route-info';
-}
diff --git a/types/preview/@ember/routing/-private/transition.d.ts b/types/preview/@ember/routing/-private/transition.d.ts
deleted file mode 100644
index bfaa3add03f..00000000000
--- a/types/preview/@ember/routing/-private/transition.d.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-declare module '@ember/routing/-private/transition' {
-  export { default as default } from '@ember/routing/transition';
-}

From 45a03dfb82665ce82af7742304ca1e642b67e434 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Thu, 1 Sep 2022 07:12:42 -0600
Subject: [PATCH 38/39] Types: exclude from ESLint

While having some guidance for the ambient types here would be needful
for the long term, we do not intend to *keep* these all that long; this
is intended as transitional. If we end up maintaining the ambient types
for a long time, we can of course revisit this. In any case, we will
want to run linting on any type tests we introduce for *stable* types
(at a future `type-tests/stable` location). Net, exclude everything in
`types` and the tests in `type-tests/preview`.
---
 .eslintignore |  2 ++
 .eslintrc.js  | 48 ------------------------------------------------
 2 files changed, 2 insertions(+), 48 deletions(-)

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/.eslintrc.js b/.eslintrc.js
index a768459eaee..921dc164dd6 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -65,54 +65,6 @@ module.exports = {
         'prefer-rest-params': 'off',
       },
     },
-    {
-      files: ['types/preview/**/*.ts'],
-
-      extends: ['plugin:@typescript-eslint/recommended'],
-
-      parserOptions: {
-        sourceType: 'module',
-        project: './types/preview/tsconfig.json',
-        tsconfigRootDir: __dirname,
-      },
-
-      rules: {
-        'import/export': 'off',
-        'disable-features/disable-async-await': 'off',
-        '@typescript-eslint/ban-ts-comment': 'off',
-        '@typescript-eslint/ban-types': 'off',
-        '@typescript-eslint/no-empty-interface': 'off',
-        'import/no-unresolved': 'off',
-        '@typescript-eslint/no-this-alias': 'off',
-        '@typescript-eslint/consistent-type-imports': 'off',
-        '@typescript-eslint/no-empty-function': 'off',
-        'no-console': 'off',
-      },
-    },
-    {
-      files: ['type-tests/preview/**/*.ts'],
-      parserOptions: {
-        sourceType: 'module',
-        project: './type-tests/preview/tsconfig.json',
-        tsconfigRootDir: __dirname,
-      },
-      rules: {
-        'no-console': 'off',
-        '@typescript-eslint/no-empty-interface': 'off',
-      },
-    },
-    {
-      files: ['type-tests/preview-prototype-extensions/**/*.ts'],
-      parserOptions: {
-        sourceType: 'module',
-        project: './type-tests/preview-prototype-extensions/tsconfig.json',
-        tsconfigRootDir: __dirname,
-      },
-      rules: {
-        'no-console': 'off',
-        '@typescript-eslint/no-empty-interface': 'off',
-      },
-    },
     {
       // TODO: files: ['packages/**/*.[jt]s'],
       files: ['packages/**/*.js'],

From 119b42cf214ff9c2bb5855787df68629b32afb16 Mon Sep 17 00:00:00 2001
From: Chris Krycho <hello@chriskrycho.com>
Date: Tue, 6 Sep 2022 14:10:15 -0600
Subject: [PATCH 39/39] Types preview: remove dead imports

The corresponding module declarations were removed earlier; this simply
drops the 'side-effect' imports from `types/preview/index.d.ts`.
---
 types/preview/index.d.ts | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/types/preview/index.d.ts b/types/preview/index.d.ts
index 858356c29db..e887be9736a 100644
--- a/types/preview/index.d.ts
+++ b/types/preview/index.d.ts
@@ -89,10 +89,7 @@ import './@ember/polyfills';
 import './@ember/polyfills/types';
 
 import './@ember/routing';
-import './@ember/routing/-private/route-info'; // TODO: remove
-import './@ember/routing/-private/route-info-with-attributes'; // TODO: remove
 import './@ember/routing/-private/router-dsl';
-import './@ember/routing/-private/transition'; // TODO: remove
 import './@ember/routing/auto-location';
 import './@ember/routing/hash-location';
 import './@ember/routing/history-location';