diff --git a/broccoli/packages.js b/broccoli/packages.js
index 7c19582105f..e6e77d329f0 100644
--- a/broccoli/packages.js
+++ b/broccoli/packages.js
@@ -140,6 +140,12 @@ module.exports.backburnerES = function _backburnerES() {
   return funnelLib('backburner.js', 'dist/es6', {
     files: ['backburner.js'],
     annotation: 'backburner es',
+    // This writes the "output" to `backburner.js.js` in the funnel, which means
+    // that when it gets fed into the Babel AMD transform, which (implicitly)
+    // pulls off the trailing `.js`, the result is just `backburner.js`, which
+    // is the actual Node-resolve-able (and therefore TS-resolve-able) ES module
+    // on disk.
+    getDestinationPath: (relativePath) => relativePath + '.js',
   });
 };
 
diff --git a/package.json b/package.json
index 9d1ed2a78ac..47148148079 100644
--- a/package.json
+++ b/package.json
@@ -58,9 +58,24 @@
     "@babel/helper-module-imports": "^7.16.7",
     "@babel/plugin-transform-block-scoping": "^7.20.5",
     "@ember/edition-utils": "^1.2.0",
+    "@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",
+    "@glimmer/interfaces": "0.84.2",
+    "@glimmer/manager": "0.84.2",
+    "@glimmer/node": "0.84.2",
+    "@glimmer/opcode-compiler": "0.84.2",
+    "@glimmer/owner": "0.84.2",
+    "@glimmer/program": "0.84.2",
+    "@glimmer/reference": "0.84.2",
+    "@glimmer/runtime": "0.84.2",
+    "@glimmer/validator": "0.84.2",
     "@glimmer/vm-babel-plugins": "0.84.2",
     "babel-plugin-debug-macros": "^0.3.4",
     "babel-plugin-filter-imports": "^4.0.0",
+    "backburner.js": "^2.7.0",
     "broccoli-concat": "^4.2.5",
     "broccoli-debug": "^0.6.4",
     "broccoli-file-creator": "^2.1.1",
@@ -79,26 +94,14 @@
     "ember-router-generator": "^2.0.0",
     "inflection": "^1.13.2",
     "resolve": "^1.22.0",
+    "route-recognizer": "^0.3.4",
+    "router_js": "^8.0.3",
     "semver": "^7.3.8",
     "silent-error": "^1.1.1"
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.321.1",
     "@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",
-    "@glimmer/interfaces": "0.84.2",
-    "@glimmer/manager": "0.84.2",
-    "@glimmer/node": "0.84.2",
-    "@glimmer/opcode-compiler": "0.84.2",
-    "@glimmer/owner": "0.84.2",
-    "@glimmer/program": "0.84.2",
-    "@glimmer/reference": "0.84.2",
-    "@glimmer/runtime": "0.84.2",
-    "@glimmer/validator": "0.84.2",
     "@simple-dom/document": "^1.4.0",
     "@tsconfig/ember": "^2.0.0",
     "@types/node": "^18.11.11",
@@ -110,7 +113,6 @@
     "auto-dist-tag": "^2.1.1",
     "aws-sdk": "^2.1325.0",
     "babel-template": "^6.26.0",
-    "backburner.js": "^2.7.0",
     "broccoli-babel-transpiler": "^7.8.1",
     "broccoli-persistent-filter": "^2.3.1",
     "broccoli-plugin": "^4.0.3",
@@ -152,8 +154,6 @@
     "puppeteer": "^19.4.1",
     "qunit": "^2.19.4",
     "recast": "^0.22.0",
-    "route-recognizer": "^0.3.4",
-    "router_js": "^8.0.3",
     "rsvp": "^4.8.5",
     "serve-static": "^1.14.2",
     "simple-dom": "^1.4.0",
diff --git a/packages/@ember/-internals/glimmer/index.ts b/packages/@ember/-internals/glimmer/index.ts
index 2149bb8d49b..7a6ab6937cd 100644
--- a/packages/@ember/-internals/glimmer/index.ts
+++ b/packages/@ember/-internals/glimmer/index.ts
@@ -450,7 +450,12 @@ export { default as Input } from './lib/components/input';
 export { default as LinkTo } from './lib/components/link-to';
 export { default as Textarea } from './lib/components/textarea';
 export { default as Component } from './lib/component';
-export { default as Helper, helper } from './lib/helper';
+export {
+  default as Helper,
+  helper,
+  type FunctionBasedHelper,
+  type FunctionBasedHelperInstance,
+} from './lib/helper';
 export { SafeString, escapeExpression, htmlSafe, isHTMLSafe } from './lib/utils/string';
 export { Renderer, _resetRenderers, renderSettled } from './lib/renderer';
 export {
diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts b/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
index 3845e5f526a..dc6d04ef544 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
@@ -219,7 +219,7 @@ export default class CurlyComponentManager
       Object.assign(named, args.named.capture());
 
       for (let i = 0; i < count; i++) {
-        let name = positionalParams[i];
+        let name: string | undefined = positionalParams[i];
         assert('Expected at least one positional param', name);
 
         assert(
diff --git a/packages/@ember/-internals/glimmer/lib/component.ts b/packages/@ember/-internals/glimmer/lib/component.ts
index 12c2ca543e6..4b2f7ce2165 100644
--- a/packages/@ember/-internals/glimmer/lib/component.ts
+++ b/packages/@ember/-internals/glimmer/lib/component.ts
@@ -36,6 +36,154 @@ let lazyEventsProcessed = new WeakMap<EventDispatcher, WeakSet<object>>();
 @module @ember/component
 */
 
+interface ComponentMethods {
+  // Overrideable methods are defined here since you can't `declare` a method in a class
+
+  /**
+   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.
+    @method didReceiveAttrs
+    @public
+    @since 1.13.0
+    */
+  didReceiveAttrs(): void;
+
+  /**
+   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.
+    @event didReceiveAttrs
+    @public
+    @since 1.13.0
+    */
+
+  /**
+   Called after a component has been rendered, both on initial render and
+    in subsequent rerenders.
+    @method didRender
+    @public
+    @since 1.13.0
+    */
+  didRender(): void;
+
+  /**
+   Called after a component has been rendered, both on initial render and
+    in subsequent rerenders.
+    @event didRender
+    @public
+    @since 1.13.0
+    */
+
+  /**
+   Called before a component has been rendered, both on initial render and
+    in subsequent rerenders.
+    @method willRender
+    @public
+    @since 1.13.0
+    */
+  willRender(): void;
+
+  /**
+   Called before a component has been rendered, both on initial render and
+    in subsequent rerenders.
+    @event willRender
+    @public
+    @since 1.13.0
+    */
+
+  /**
+   Called when the attributes passed into the component have been changed.
+    Called only during a rerender, not during an initial render.
+    @method didUpdateAttrs
+    @public
+    @since 1.13.0
+    */
+  didUpdateAttrs(): void;
+
+  /**
+   Called when the attributes passed into the component have been changed.
+    Called only during a rerender, not during an initial render.
+    @event didUpdateAttrs
+    @public
+    @since 1.13.0
+    */
+
+  /**
+   Called when the component is about to update and rerender itself.
+    Called only during a rerender, not during an initial render.
+    @method willUpdate
+    @public
+    @since 1.13.0
+    */
+  willUpdate(): void;
+
+  /**
+   Called when the component is about to update and rerender itself.
+    Called only during a rerender, not during an initial render.
+    @event willUpdate
+    @public
+    @since 1.13.0
+    */
+
+  /**
+   Called when the component has updated and rerendered itself.
+    Called only during a rerender, not during an initial render.
+    @method didUpdate
+    @public
+    @since 1.13.0
+    */
+  didUpdate(): void;
+
+  /**
+   Called when the component has updated and rerendered itself.
+    Called only during a rerender, not during an initial render.
+    @event didUpdate
+    @public
+    @since 1.13.0
+    */
+
+  /**
+    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):
+
+    ```handlebars
+    {{my-component elementId="a-really-cool-id"}}
+    ```
+
+    ```handlebars
+    <MyComponent @elementId="a-really-cool-id" />
+    ```
+    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:
+
+    ```javascript
+    export default Component.extend({
+      init() {
+        this._super(...arguments);
+
+        var index = this.get('index');
+        this.set('elementId', `component-id${index}`);
+      }
+    });
+    ```
+
+    @property elementId
+    @type String
+    @public
+  */
+  layoutName?: string;
+}
+
+// A zero-runtime-overhead private symbol to use in branding the component to
+// preserve its type parameter.
+declare const SIGNATURE: unique symbol;
+
 /**
   A component is a reusable UI element that consists of a `.hbs` template and an
   optional JavaScript class that defines its behavior. For example, someone
@@ -650,150 +798,9 @@ let lazyEventsProcessed = new WeakMap<EventDispatcher, WeakSet<object>>();
   @uses Ember.ViewStateSupport
   @public
 */
-interface ComponentMethods {
-  // Overrideable methods are defined here since you can't `declare` a method in a class
-
-  /**
-   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.
-    @method didReceiveAttrs
-    @public
-    @since 1.13.0
-    */
-  didReceiveAttrs(): void;
-
-  /**
-   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.
-    @event didReceiveAttrs
-    @public
-    @since 1.13.0
-    */
-
-  /**
-   Called after a component has been rendered, both on initial render and
-    in subsequent rerenders.
-    @method didRender
-    @public
-    @since 1.13.0
-    */
-  didRender(): void;
-
-  /**
-   Called after a component has been rendered, both on initial render and
-    in subsequent rerenders.
-    @event didRender
-    @public
-    @since 1.13.0
-    */
-
-  /**
-   Called before a component has been rendered, both on initial render and
-    in subsequent rerenders.
-    @method willRender
-    @public
-    @since 1.13.0
-    */
-  willRender(): void;
-
-  /**
-   Called before a component has been rendered, both on initial render and
-    in subsequent rerenders.
-    @event willRender
-    @public
-    @since 1.13.0
-    */
-
-  /**
-   Called when the attributes passed into the component have been changed.
-    Called only during a rerender, not during an initial render.
-    @method didUpdateAttrs
-    @public
-    @since 1.13.0
-    */
-  didUpdateAttrs(): void;
-
-  /**
-   Called when the attributes passed into the component have been changed.
-    Called only during a rerender, not during an initial render.
-    @event didUpdateAttrs
-    @public
-    @since 1.13.0
-    */
-
-  /**
-   Called when the component is about to update and rerender itself.
-    Called only during a rerender, not during an initial render.
-    @method willUpdate
-    @public
-    @since 1.13.0
-    */
-  willUpdate(): void;
-
-  /**
-   Called when the component is about to update and rerender itself.
-    Called only during a rerender, not during an initial render.
-    @event willUpdate
-    @public
-    @since 1.13.0
-    */
-
-  /**
-   Called when the component has updated and rerendered itself.
-    Called only during a rerender, not during an initial render.
-    @method didUpdate
-    @public
-    @since 1.13.0
-    */
-  didUpdate(): void;
-
-  /**
-   Called when the component has updated and rerendered itself.
-    Called only during a rerender, not during an initial render.
-    @event didUpdate
-    @public
-    @since 1.13.0
-    */
-
-  /**
-    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):
-
-    ```handlebars
-    {{my-component elementId="a-really-cool-id"}}
-    ```
-
-    ```handlebars
-    <MyComponent @elementId="a-really-cool-id" />
-    ```
-    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:
-
-    ```javascript
-    export default Component.extend({
-      init() {
-        this._super(...arguments);
-
-        var index = this.get('index');
-        this.set('elementId', `component-id${index}`);
-      }
-    });
-    ```
-
-    @property elementId
-    @type String
-    @public
-  */
-  layoutName?: string;
-}
-interface Component
+// This type param is used in the class, so must appear here.
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+interface Component<S = unknown>
   extends CoreView,
     ChildViewsSupport,
     ViewStateSupport,
@@ -803,7 +810,7 @@ interface Component
     ViewMixin,
     ComponentMethods {}
 
-class Component
+class Component<S = unknown>
   extends CoreView.extend(
     ChildViewsSupport,
     ViewStateSupport,
@@ -826,6 +833,10 @@ class Component
 {
   isComponent = true;
 
+  // SAFETY: this has no runtime existence whatsoever; it is a "phantom type"
+  // here to preserve the type param.
+  private declare [SIGNATURE]: S;
+
   // SAFTEY: This is set in `init`.
   declare _superRerender: ViewMixin['rerender'];
 
@@ -1009,50 +1020,65 @@ class Component
   declare attributeBindings?: string[];
 
   /**
-    Layout can be used to wrap content in a component.
-    @property layout
-    @type Function
-    @public
-  */
-  declare layout?: TemplateFactory | Template;
+   Enables components to take a list of parameters as arguments.
+    For example, a component that takes two parameters with the names
+    `name` and `age`:
 
-  /**
-    The name of the layout to lookup if no layout is provided.
-    By default `Component` will lookup a template with this name in
-    `Ember.TEMPLATES` (a shared global object).
-    @property layoutName
-    @type String
-    @default undefined
-    @private
-  */
-  declare layoutName?: string;
+    ```app/components/my-component.js
+    import Component from '@ember/component';
 
-  /**
-   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.
+    let MyComponent = Component.extend();
 
-    The full list of valid WAI-ARIA roles is available at:
-    [https://www.w3.org/TR/wai-aria/#roles_categorization](https://www.w3.org/TR/wai-aria/#roles_categorization)
+    MyComponent.reopenClass({
+      positionalParams: ['name', 'age']
+    });
 
-    @property ariaRole
-    @type String
-    @default undefined
-    @public
-    */
-  declare ariaRole?: string;
+    export default MyComponent;
+    ```
 
-  static isComponentFactory = true;
+    It can then be invoked like this:
 
-  static toString() {
-    return '@ember/component';
-  }
-}
+    ```hbs
+    {{my-component "John" 38}}
+    ```
 
-// We continue to use reopenClass here so that positionalParams can be overridden with reopenClass in subclasses.
-Component.reopenClass({
-  /**
+    The parameters can be referred to just like named parameters:
+
+    ```hbs
+    Name: {{name}}, Age: {{age}}.
+    ```
+
+    Using a string instead of an array allows for an arbitrary number of
+    parameters:
+
+    ```app/components/my-component.js
+    import Component from '@ember/component';
+
+    let MyComponent = Component.extend();
+
+    MyComponent.reopenClass({
+      positionalParams: 'names'
+    });
+
+    export default MyComponent;
+    ```
+
+    It can then be invoked like this:
+
+    ```hbs
+    {{my-component "John" "Michael" "Scott"}}
+    ```
+    The parameters can then be referred to by enumerating over the list:
+
+    ```hbs
+    {{#each names as |name|}}{{name}}{{/each}}
+    ```
+
+    @static
+    @public
+    @property positionalParams
+    @since 1.13.0
+    */ /**
    Enables components to take a list of parameters as arguments.
     For example, a component that takes two parameters with the names
     `name` and `age`:
@@ -1112,6 +1138,52 @@ Component.reopenClass({
     @property positionalParams
     @since 1.13.0
     */
+  declare static positionalParams: string | string[];
+
+  /**
+    Layout can be used to wrap content in a component.
+    @property layout
+    @type Function
+    @public
+  */
+  declare layout?: TemplateFactory | Template;
+
+  /**
+    The name of the layout to lookup if no layout is provided.
+    By default `Component` will lookup a template with this name in
+    `Ember.TEMPLATES` (a shared global object).
+    @property layoutName
+    @type String
+    @default undefined
+    @private
+  */
+  declare layoutName?: string;
+
+  /**
+   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.
+
+    The full list of valid WAI-ARIA roles is available at:
+    [https://www.w3.org/TR/wai-aria/#roles_categorization](https://www.w3.org/TR/wai-aria/#roles_categorization)
+
+    @property ariaRole
+    @type String
+    @default undefined
+    @public
+    */
+  declare ariaRole?: string;
+
+  static isComponentFactory = true;
+
+  static toString() {
+    return '@ember/component';
+  }
+}
+
+// We continue to use reopenClass here so that positionalParams can be overridden with reopenClass in subclasses.
+Component.reopenClass({
   positionalParams: [],
 });
 
diff --git a/packages/@ember/-internals/glimmer/lib/components/input.ts b/packages/@ember/-internals/glimmer/lib/components/input.ts
index e22e6a35879..94d2fd706b9 100644
--- a/packages/@ember/-internals/glimmer/lib/components/input.ts
+++ b/packages/@ember/-internals/glimmer/lib/components/input.ts
@@ -2,13 +2,14 @@
 @module @ember/component
 */
 import { hasDOM } from '@ember/-internals/browser-environment';
+import { type Opaque } from '@ember/-internals/utility-types';
 import { assert, warn } from '@ember/debug';
 import { action } from '@ember/object';
 import { valueForRef } from '@glimmer/reference';
 import { untrack } from '@glimmer/validator';
 import InputTemplate from '../templates/input';
 import AbstractInput, { valueFrom } from './abstract-input';
-import { opaquify } from './internal';
+import { type OpaqueInternalComponentConstructor, opaquify } from './internal';
 
 let isValidInputType: (type: string) => boolean;
 
@@ -158,7 +159,7 @@ if (hasDOM) {
   @param {Hash} options
   @public
 */
-class Input extends AbstractInput {
+class _Input extends AbstractInput {
   static toString(): string {
     return 'Input';
   }
@@ -270,4 +271,6 @@ class Input extends AbstractInput {
   }
 }
 
-export default opaquify(Input, InputTemplate);
+const Input = opaquify(_Input, InputTemplate) as Input;
+interface Input extends Opaque<'component:input'>, OpaqueInternalComponentConstructor {}
+export default Input;
diff --git a/packages/@ember/-internals/glimmer/lib/components/link-to.ts b/packages/@ember/-internals/glimmer/lib/components/link-to.ts
index f90bcfc951c..97c119a10f2 100644
--- a/packages/@ember/-internals/glimmer/lib/components/link-to.ts
+++ b/packages/@ember/-internals/glimmer/lib/components/link-to.ts
@@ -12,7 +12,8 @@ import type { Maybe, Option } from '@glimmer/interfaces';
 import { consumeTag, createCache, getValue, tagFor, untrack } from '@glimmer/validator';
 import type { Transition } from 'router_js';
 import LinkToTemplate from '../templates/link-to';
-import InternalComponent, { opaquify } from './internal';
+import InternalComponent, { type OpaqueInternalComponentConstructor, opaquify } from './internal';
+import { type Opaque } from '@ember/-internals/utility-types';
 
 const EMPTY_ARRAY: {}[] = [];
 const EMPTY_QUERY_PARAMS = {};
@@ -272,7 +273,7 @@ function isQueryParams(value: unknown): value is QueryParams {
   @public
 **/
 
-class LinkTo extends InternalComponent {
+class _LinkTo extends InternalComponent {
   static toString(): string {
     return 'LinkTo';
   }
@@ -469,12 +470,12 @@ class LinkTo extends InternalComponent {
   }
 
   private get isActive(): boolean {
-    return this.isActiveForState(this.routing.currentState as Maybe<RouterState<Route>>);
+    return this.isActiveForState(this.routing.currentState as Maybe<RouterState>);
   }
 
   private get willBeActive(): Option<boolean> {
-    let current = this.routing.currentState as Maybe<RouterState<Route>>;
-    let target = this.routing.targetState as Maybe<RouterState<Route>>;
+    let current = this.routing.currentState;
+    let target = this.routing.targetState;
 
     if (current === target) {
       return null;
@@ -530,7 +531,7 @@ class LinkTo extends InternalComponent {
     }
   }
 
-  private isActiveForState(state: Maybe<RouterState<Route>>): boolean {
+  private isActiveForState(state: Maybe<RouterState>): boolean {
     if (!isPresent(state)) {
       return false;
     }
@@ -582,7 +583,7 @@ class LinkTo extends InternalComponent {
   }
 }
 
-let { prototype } = LinkTo;
+let { prototype } = _LinkTo;
 
 let descriptorFor = (target: object, property: string): Option<PropertyDescriptor> => {
   if (target) {
@@ -602,7 +603,7 @@ let descriptorFor = (target: object, property: string): Option<PropertyDescripto
   Object.defineProperty(prototype, 'onUnsupportedArgument', {
     configurable: true,
     enumerable: false,
-    value: function onUnsupportedArgument(this: LinkTo, name: string): void {
+    value: function onUnsupportedArgument(this: _LinkTo, name: string): void {
       if (name === 'href') {
         assert(`Passing the \`@href\` argument to <LinkTo> is not supported.`);
       } else {
@@ -621,12 +622,12 @@ let descriptorFor = (target: object, property: string): Option<PropertyDescripto
     superModelsDescriptor && typeof superModelsDescriptor.get === 'function'
   );
 
-  let superModelsGetter = superModelsDescriptor.get as (this: LinkTo) => {}[];
+  let superModelsGetter = superModelsDescriptor.get as (this: _LinkTo) => {}[];
 
   Object.defineProperty(prototype, 'models', {
     configurable: true,
     enumerable: false,
-    get: function models(this: LinkTo): {}[] {
+    get: function models(this: _LinkTo): {}[] {
       let models = superModelsGetter.call(this);
 
       if (models.length > 0 && !('query' in this.args.named)) {
@@ -646,12 +647,12 @@ let descriptorFor = (target: object, property: string): Option<PropertyDescripto
     superQueryDescriptor && typeof superQueryDescriptor.get === 'function'
   );
 
-  let superQueryGetter = superQueryDescriptor.get as (this: LinkTo) => {};
+  let superQueryGetter = superQueryDescriptor.get as (this: _LinkTo) => {};
 
   Object.defineProperty(prototype, 'query', {
     configurable: true,
     enumerable: false,
-    get: function query(this: LinkTo): {} {
+    get: function query(this: _LinkTo): {} {
       if ('query' in this.args.named) {
         let qp = superQueryGetter.call(this);
 
@@ -684,7 +685,7 @@ let descriptorFor = (target: object, property: string): Option<PropertyDescripto
   Object.defineProperty(prototype, 'onUnsupportedArgument', {
     configurable: true,
     enumerable: false,
-    value: function onUnsupportedArgument(this: LinkTo, name: string): void {
+    value: function onUnsupportedArgument(this: _LinkTo, name: string): void {
       if (name !== 'params') {
         superOnUnsupportedArgument.call(this, name);
       }
@@ -692,4 +693,6 @@ let descriptorFor = (target: object, property: string): Option<PropertyDescripto
   });
 }
 
-export default opaquify(LinkTo, LinkToTemplate);
+const LinkTo = opaquify(_LinkTo, LinkToTemplate) as LinkTo;
+interface LinkTo extends Opaque<'component:link-to'>, OpaqueInternalComponentConstructor {}
+export default LinkTo;
diff --git a/packages/@ember/-internals/glimmer/lib/components/textarea.ts b/packages/@ember/-internals/glimmer/lib/components/textarea.ts
index 8f3e3c32d71..9d0d4178753 100644
--- a/packages/@ember/-internals/glimmer/lib/components/textarea.ts
+++ b/packages/@ember/-internals/glimmer/lib/components/textarea.ts
@@ -1,10 +1,11 @@
 /**
 @module @ember/component
 */
+import { type Opaque } from '@ember/-internals/utility-types';
 import { action } from '@ember/object';
 import TextareaTemplate from '../templates/textarea';
 import AbstractInput from './abstract-input';
-import { opaquify } from './internal';
+import { type OpaqueInternalComponentConstructor, opaquify } from './internal';
 
 /**
   The `Textarea` component inserts a new instance of `<textarea>` tag into the template.
@@ -139,7 +140,7 @@ import { opaquify } from './internal';
   @see {Ember.Templates.components.Textarea}
   @public
 **/
-class Textarea extends AbstractInput {
+class _Textarea extends AbstractInput {
   static toString(): string {
     return 'Textarea';
   }
@@ -164,4 +165,6 @@ class Textarea extends AbstractInput {
   }
 }
 
-export default opaquify(Textarea, TextareaTemplate);
+const Textarea = opaquify(_Textarea, TextareaTemplate) as Textarea;
+interface Textarea extends Opaque<'component:textarea'>, OpaqueInternalComponentConstructor {}
+export default Textarea;
diff --git a/packages/@ember/-internals/glimmer/lib/helper.ts b/packages/@ember/-internals/glimmer/lib/helper.ts
index 148d81c49c8..0ee8b57d687 100644
--- a/packages/@ember/-internals/glimmer/lib/helper.ts
+++ b/packages/@ember/-internals/glimmer/lib/helper.ts
@@ -9,66 +9,46 @@ import { FrameworkObject } from '@ember/object/-internals';
 import { getDebugName } from '@ember/-internals/utils';
 import { assert } from '@ember/debug';
 import { join } from '@ember/runloop';
-import type { Arguments, Dict, HelperManager } from '@glimmer/interfaces';
+import type { Arguments, HelperManager } from '@glimmer/interfaces';
 import { getInternalHelperManager, helperCapabilities, setHelperManager } from '@glimmer/manager';
 import type { DirtyableTag } from '@glimmer/validator';
 import { consumeTag, createTag, dirtyTag } from '@glimmer/validator';
 
 export const RECOMPUTE_TAG = Symbol('RECOMPUTE_TAG');
 
-export type HelperFunction<T, P extends unknown[], N extends Dict<unknown>> = (
-  positional: P,
-  named: N
-) => T;
+// Signature type utilities
+type GetOr<T, K, Else> = K extends keyof T ? T[K] : Else;
 
-export type SimpleHelperFactory<T, P extends unknown[], N extends Dict<unknown>> = InternalFactory<
-  SimpleHelper<T, P, N>,
-  HelperFactory<SimpleHelper<T, P, N>>
->;
-export type ClassHelperFactory = InternalFactory<HelperInstance, HelperFactory<HelperInstance>>;
+type Args<S> = GetOr<S, 'Args', {}>;
+
+type DefaultPositional = unknown[];
+type Positional<S> = GetOr<Args<S>, 'Positional', DefaultPositional>;
+
+type Named<S> = GetOr<Args<S>, 'Named', object>;
+
+type Return<S> = GetOr<S, 'Return', unknown>;
 
+// Implements Ember's `Factory` interface and tags it for narrowing/checking.
 export interface HelperFactory<T> {
   isHelperFactory: true;
   create(): T;
 }
 
-export interface HelperInstance<T = unknown> {
-  compute(positional: unknown[], named: Dict<unknown>): T;
+export interface HelperInstance<S> {
+  compute(positional: Positional<S>, named: Named<S>): Return<S>;
   destroy(): void;
   [RECOMPUTE_TAG]: DirtyableTag;
 }
 
 const IS_CLASSIC_HELPER: unique symbol = Symbol('IS_CLASSIC_HELPER');
 
-export interface SimpleHelper<T, P extends unknown[], N extends Dict<unknown>> {
-  compute: HelperFunction<T, P, N>;
+export interface SimpleHelper<S> {
+  compute: (positional: Positional<S>, named: Named<S>) => Return<S>;
 }
 
-/**
-  In many cases it is not necessary to use the full `Helper` class.
-  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([cents], {currency}) {
-    return `${currency}${cents * 0.01}`;
-  });
-  ```
-
-  @static
-  @param {Function} helper The helper function
-  @method helper
-  @for @ember/component/helper
-  @public
-  @since 1.13.0
-*/
-export function helper<T, P extends unknown[], N extends Dict<unknown>>(
-  helperFn: HelperFunction<T, P, N>
-): HelperFactory<SimpleHelper<T, P, N>> {
-  return new Wrapper(helperFn);
-}
+// A zero-runtime-overhead private symbol to use in branding the component to
+// preserve its type parameter.
+declare const SIGNATURE: unique symbol;
 
 /**
   Ember Helpers are functions that can compute values, and are used in templates.
@@ -115,19 +95,21 @@ export function helper<T, P extends unknown[], N extends Dict<unknown>>(
   @public
   @since 1.13.0
 */
-interface Helper {
+// ESLint doesn't understand declaration merging.
+/* eslint-disable import/export */
+export default interface Helper<S = unknown> {
   /**
     Override this function when writing a class-based helper.
 
     @method compute
-    @param {Array} params The positional arguments to the helper
-    @param {Object} hash The named arguments to the helper
+    @param {Array} positional The positional arguments to the helper
+    @param {Object} named The named arguments to the helper
     @public
     @since 1.13.0
   */
-  compute(params: unknown[], hash: Dict<unknown>): unknown;
+  compute(positional: Positional<S>, named: Named<S>): Return<S>;
 }
-class Helper extends FrameworkObject {
+export default class Helper<S = unknown> extends FrameworkObject {
   static isHelperFactory = true;
   static [IS_CLASSIC_HELPER] = true;
 
@@ -142,6 +124,10 @@ class Helper extends FrameworkObject {
   // directly in this class, since nothing else can run before `init`.
   declare [RECOMPUTE_TAG]: DirtyableTag;
 
+  // SAFETY: this has no runtime existence whatsoever; it is a "phantom type"
+  // here to preserve the type param.
+  private declare [SIGNATURE]: S;
+
   init(properties: object | undefined) {
     super.init(properties);
     this[RECOMPUTE_TAG] = createTag();
@@ -182,32 +168,38 @@ class Helper extends FrameworkObject {
     join(() => dirtyTag(this[RECOMPUTE_TAG]));
   }
 }
+/* eslint-enable import/export */
 
 export function isClassicHelper(obj: object): boolean {
   return (obj as any)[IS_CLASSIC_HELPER] === true;
 }
 
 interface ClassicHelperStateBucket {
-  instance: HelperInstance;
+  instance: HelperInstance<unknown>;
   args: Arguments;
 }
 
+type ClassHelperFactory = InternalFactory<
+  HelperInstance<unknown>,
+  HelperFactory<HelperInstance<unknown>>
+>;
+
 class ClassicHelperManager implements HelperManager<ClassicHelperStateBucket> {
   capabilities = helperCapabilities('3.23', {
     hasValue: true,
     hasDestroyable: true,
   });
 
-  private ownerInjection: object;
+  private ownerInjection: Record<string, unknown>;
 
   constructor(owner: InternalOwner | undefined) {
-    let ownerInjection = {};
+    let ownerInjection: Record<string, unknown> = {};
     setOwner(ownerInjection, owner!);
     this.ownerInjection = ownerInjection;
   }
 
   createHelper(
-    definition: typeof Helper | InternalFactoryManager<object>,
+    definition: typeof Helper | InternalFactoryManager<Helper>,
     args: Arguments
   ): ClassicHelperStateBucket {
     let instance = isFactoryManager(definition)
@@ -216,9 +208,9 @@ class ClassicHelperManager implements HelperManager<ClassicHelperStateBucket> {
 
     assert(
       'expected HelperInstance',
-      (function (instance: unknown): instance is HelperInstance {
+      (function (instance: unknown): instance is HelperInstance<unknown> {
         if (instance !== null && typeof instance === 'object') {
-          let cast = instance as HelperInstance;
+          let cast = instance as HelperInstance<unknown>;
           return typeof cast.compute === 'function' && typeof cast.destroy === 'function';
         }
         return false;
@@ -238,7 +230,7 @@ class ClassicHelperManager implements HelperManager<ClassicHelperStateBucket> {
   getValue({ instance, args }: ClassicHelperStateBucket) {
     let { positional, named } = args;
 
-    let ret = instance.compute(positional as unknown[], named);
+    let ret = instance.compute(positional as DefaultPositional, named);
 
     consumeTag(instance[RECOMPUTE_TAG]);
 
@@ -262,14 +254,12 @@ export const CLASSIC_HELPER_MANAGER = getInternalHelperManager(Helper);
 
 ///////////
 
-class Wrapper<T = unknown, P extends unknown[] = unknown[], N extends Dict<unknown> = Dict<unknown>>
-  implements HelperFactory<SimpleHelper<T, P, N>>
-{
+class Wrapper<S = unknown> implements HelperFactory<SimpleHelper<S>> {
   readonly isHelperFactory = true;
 
-  constructor(public compute: HelperFunction<T, P, N>) {}
+  constructor(public compute: (positional: Positional<S>, named: Named<S>) => Return<S>) {}
 
-  create() {
+  create(): SimpleHelper<S> {
     // needs new instance or will leak containers
     return {
       compute: this.compute,
@@ -283,9 +273,7 @@ class SimpleClassicHelperManager implements HelperManager<() => unknown> {
   });
 
   createHelper(definition: Wrapper, args: Arguments) {
-    let { compute } = definition;
-
-    return () => compute.call(null, args.positional as unknown[], args.named);
+    return () => definition.compute.call(null, args.positional as [], args.named);
   }
 
   getValue(fn: () => unknown) {
@@ -301,4 +289,106 @@ export const SIMPLE_CLASSIC_HELPER_MANAGER = new SimpleClassicHelperManager();
 
 setHelperManager(() => SIMPLE_CLASSIC_HELPER_MANAGER, Wrapper.prototype);
 
-export default Helper;
+/*
+  Function-based helpers need to present with a constructor signature so that
+  type parameters can be preserved when `helper()` is passed a generic function
+  (this is particularly key for checking helper invocations with Glint).
+  Accordingly, we define an abstract class and declaration merge it with the
+  interface; this inherently provides an `abstract` constructor. Since it is
+  `abstract`, it is not callable, which is important since end users should not
+  be able to do `let myHelper = helper(someFn); new myHelper()`.
+ */
+
+/**
+ * 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` an alias this way allows callers to name it in
+// terms meaningful to *them*, while preserving the type behavior described on
+// the `abstract class FunctionBasedHelperInstance` below.
+export type FunctionBasedHelper<S> = abstract new () => FunctionBasedHelperInstance<S>;
+
+// This abstract class -- specifically, its `protected abstract __concrete__`
+// member -- prevents subclasses from doing `class X extends helper(..)`, since
+// that is an error at runtime. While it is rare that people would type that, it
+// is not impossible and we use this to give them early signal via the types for
+// a behavior which will break (and in a somewhat inscrutable way!) at runtime.
+//
+// This is needful because we lie about what this actually is for Glint's sake:
+// a function-based helper returns a `Factory<SimpleHelper>`, which is designed
+// to be "opaque" from a consumer's POV, i.e. not user-callable or constructible
+// but only useable in a template (or via `invokeHelper()` which also treats it
+// as a fully opaque `object` from a type POV). But Glint needs a `Helper<S>` to
+// make it work the same way as class-based helpers. (Note that this does not
+// hold for plain functions as helpers, which it can handle distinctly.) This
+// signature thus makes it so that the item is usable *as* a `Helper` in Glint,
+// but without letting end users treat it as a helper class instance.
+export declare abstract class FunctionBasedHelperInstance<S> extends Helper<S> {
+  protected abstract __concrete__: never;
+}
+
+/**
+  In many cases it is not necessary to use the full `Helper` class.
+  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([cents], {currency}) {
+    return `${currency}${cents * 0.01}`;
+  });
+  ```
+
+  @static
+  @param {Function} helper The helper function
+  @method helper
+  @for @ember/component/helper
+  @public
+  @since 1.13.0
+*/
+// 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 extends object, 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: Positional<S>, named: Named<S>) => Return<S>
+): FunctionBasedHelper<S>;
+export function helper(
+  helperFn: (positional: unknown[], named: object) => unknown
+  // At the implementation site, we don't care about the actual underlying type
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+): FunctionBasedHelper<any> {
+  // SAFETY: this is completely lies, in two ways:
+  //
+  // 1. `Wrapper` is a `Factory<SimpleHelper<S>>`, but from the perspective of
+  //    any external callers (i.e. Ember *users*), it is quite important that
+  //    the `Factory` relationship be hidden, because it is not public API for
+  //    an end user to call `.create()` on a helper created this way. Instead,
+  //    we provide them an `abstract new` signature (which means it cannot be
+  //    directly constructed by calling `new` on it) and which does not have the
+  //    `.create()` signature on it anymore.
+  //
+  // 2. The produced type here ends up being a subtype of `Helper`, which is not
+  //    strictly true. This is necessary for the sake of Glint, which provides
+  //    its information by way of a "declaration merge" with `Helper<S>` in the
+  //    case of items produced by `helper()`.
+  //
+  // Long-term, this entire construct can go away in favor of deprecating the
+  // `helper()` invocation in favor of using plain functions.
+  return new Wrapper(helperFn) as unknown as FunctionBasedHelper<any>;
+}
diff --git a/packages/@ember/-internals/metal/lib/computed.ts b/packages/@ember/-internals/metal/lib/computed.ts
index 2aa2ee2fcd9..aac84147b84 100644
--- a/packages/@ember/-internals/metal/lib/computed.ts
+++ b/packages/@ember/-internals/metal/lib/computed.ts
@@ -699,7 +699,9 @@ class ComputedDecoratorImpl extends Function {
     @chainable
     @public
   */
-  meta(this: ExtendedMethodDecorator, meta?: unknown): unknown {
+  meta(): unknown;
+  meta(meta: unknown): ComputedDecorator;
+  meta(meta?: unknown): unknown {
     let prop = descriptorForDecorator(this) as ComputedProperty;
 
     if (arguments.length === 0) {
diff --git a/packages/@ember/-internals/metal/lib/computed_cache.ts b/packages/@ember/-internals/metal/lib/computed_cache.ts
index f6bc37b3ce4..31a856ebc9f 100644
--- a/packages/@ember/-internals/metal/lib/computed_cache.ts
+++ b/packages/@ember/-internals/metal/lib/computed_cache.ts
@@ -1,5 +1,7 @@
 import { peekMeta } from '@ember/-internals/meta';
 
+export function getCachedValueFor<T, K extends keyof T>(obj: T, key: K): T[K] | undefined;
+export function getCachedValueFor(obj: object, key: string): unknown;
 export function getCachedValueFor(obj: object, key: string): unknown {
   let meta = peekMeta(obj);
 
diff --git a/packages/@ember/-internals/metal/lib/get_properties.ts b/packages/@ember/-internals/metal/lib/get_properties.ts
index c2b54ca0c36..2e7f0af46ce 100644
--- a/packages/@ember/-internals/metal/lib/get_properties.ts
+++ b/packages/@ember/-internals/metal/lib/get_properties.ts
@@ -31,14 +31,17 @@ import { get } from './property_get';
   @return {Object}
   @public
 */
-function getProperties<L extends string[]>(obj: unknown, list: L): Record<L[number], unknown>;
-function getProperties<L extends string[]>(obj: unknown, ...list: L): Record<L[number], unknown>;
-function getProperties<L extends string[]>(
+
+function getProperties<T, K extends keyof T>(obj: T, list: K[]): Pick<T, K>;
+function getProperties<T, K extends keyof T>(obj: T, ...list: K[]): Pick<T, K>;
+function getProperties<K extends string>(obj: unknown, list: K[]): Record<K, unknown>;
+function getProperties<K extends string>(obj: unknown, ...list: K[]): Record<K, unknown>;
+function getProperties<K extends string>(
   obj: unknown,
-  keys?: L | [L]
-): Record<L[number], unknown> {
-  let ret = {} as Record<L[number], unknown>;
-  let propertyNames: string[];
+  keys?: Array<K> | Array<Array<K>>
+): Record<K, unknown> {
+  let ret = {} as Record<K, unknown>;
+  let propertyNames: K[];
   let i = 1;
 
   if (arguments.length === 2 && Array.isArray(keys)) {
@@ -49,7 +52,10 @@ function getProperties<L extends string[]>(
   }
 
   for (; i < propertyNames.length; i++) {
-    ret[propertyNames[i] as L[number]] = get(obj, propertyNames[i]!);
+    // SAFETY: we are just walking the list of property names, so we know the
+    // index access never produces `undefined`.
+    let name = propertyNames[i] as K;
+    ret[name] = get(obj, name);
   }
   return ret;
 }
diff --git a/packages/@ember/-internals/metal/lib/set_properties.ts b/packages/@ember/-internals/metal/lib/set_properties.ts
index 932ea8cde3a..97683a1aaec 100644
--- a/packages/@ember/-internals/metal/lib/set_properties.ts
+++ b/packages/@ember/-internals/metal/lib/set_properties.ts
@@ -27,10 +27,12 @@ import { set } from './property_set';
   @return properties
   @public
 */
-export default function setProperties<TProperties extends { [key: string]: any }>(
+function setProperties<T, K extends keyof T>(obj: T, properties: Pick<T, K>): Pick<T, K>;
+function setProperties<T extends Record<string, unknown>>(obj: object, properties: T): T;
+function setProperties<K extends string, Hash extends Record<K, unknown>>(
   obj: object,
-  properties: TProperties
-): TProperties {
+  properties: Hash
+): Hash {
   if (properties === null || typeof properties !== 'object') {
     return properties;
   }
@@ -38,8 +40,13 @@ export default function setProperties<TProperties extends { [key: string]: any }
     let props = Object.keys(properties);
 
     for (let propertyName of props) {
-      set(obj, propertyName, properties[propertyName]);
+      // SAFETY: casting `properties` this way is safe because any object in JS
+      // can be indexed this way, and the result will be `unknown`, making it
+      // safe for callers.
+      set(obj, propertyName, (properties as Record<string, unknown>)[propertyName]);
     }
   });
   return properties;
 }
+
+export default setProperties;
diff --git a/packages/@ember/-internals/utility-types/index.ts b/packages/@ember/-internals/utility-types/index.ts
index 0c759a1e037..f03be1a0b57 100644
--- a/packages/@ember/-internals/utility-types/index.ts
+++ b/packages/@ember/-internals/utility-types/index.ts
@@ -19,3 +19,12 @@ export type MethodParams<T, M extends MethodNamesOf<T>> = Parameters<MethodsOf<T
 export type MethodReturns<T, M extends MethodNamesOf<T>> = ReturnType<MethodsOf<T>[M]>;
 
 export type OmitFirst<F> = F extends [any, ...infer R] ? R : [];
+
+// A way of representing non-user-constructible types. You can conveniently use
+// this by doing `interface Type extends Opaque<'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;
+}
diff --git a/packages/@ember/-internals/views/lib/mixins/view_support.ts b/packages/@ember/-internals/views/lib/mixins/view_support.ts
index 1e84ef34066..6458542e00a 100644
--- a/packages/@ember/-internals/views/lib/mixins/view_support.ts
+++ b/packages/@ember/-internals/views/lib/mixins/view_support.ts
@@ -4,9 +4,9 @@ import Mixin from '@ember/object/mixin';
 import { assert } from '@ember/debug';
 import { hasDOM } from '@ember/-internals/browser-environment';
 import { matches } from '../system/utils';
-import type Component from '@ember/component';
 import type { View } from '@ember/-internals/glimmer/lib/renderer';
 import type { SimpleElement } from '@simple-dom/interface';
+import type CoreView from '../views/core_view';
 
 function K(this: unknown) {
   return this;
@@ -101,7 +101,7 @@ const ViewMixin = Mixin.create({
    @deprecated use `yield` and contextual components for composition instead.
    @private
    */
-  nearestOfType(this: Component, klass: any) {
+  nearestOfType(klass: any) {
     let view = this.parentView;
     let isOfType =
       klass instanceof Mixin
@@ -173,7 +173,7 @@ const ViewMixin = Mixin.create({
   element: nativeDescDecorator({
     configurable: false,
     enumerable: false,
-    get(this: Component) {
+    get(this: CoreView) {
       return this.renderer.getElement(this);
     },
   }),
@@ -195,7 +195,7 @@ const ViewMixin = Mixin.create({
    @return {Ember.View} receiver
    @private
    */
-  appendTo(this: Component, selector: string | Element | SimpleElement) {
+  appendTo(selector: string | Element | SimpleElement) {
     let target;
 
     if (hasDOM) {
@@ -444,7 +444,7 @@ const ViewMixin = Mixin.create({
    @param evt {Event}
    @private
    */
-  handleEvent(this: Component, eventName: string, evt: Event) {
+  handleEvent(eventName: string, evt: Event) {
     return this._currentState.handleEvent(this, eventName, evt);
   },
 });
diff --git a/packages/@ember/-internals/views/lib/views/core_view.ts b/packages/@ember/-internals/views/lib/views/core_view.ts
index 1eefce9682d..c6a7529cf44 100644
--- a/packages/@ember/-internals/views/lib/views/core_view.ts
+++ b/packages/@ember/-internals/views/lib/views/core_view.ts
@@ -23,7 +23,7 @@ import states from './states';
   @private
 */
 
-interface CoreView extends FrameworkObject, Evented, ActionHandler, View {}
+interface CoreView extends Evented, ActionHandler, View {}
 class CoreView extends FrameworkObject.extend(Evented, ActionHandler) {
   isView = true;
 
diff --git a/packages/@ember/application/type-tests/instance.test.ts b/packages/@ember/application/type-tests/instance.test.ts
index 49a750e1057..65fac1fc6b6 100644
--- a/packages/@ember/application/type-tests/instance.test.ts
+++ b/packages/@ember/application/type-tests/instance.test.ts
@@ -24,10 +24,11 @@ expectTypeOf(
   instance.register('service:store-singleton', Store, { singleton: true, instantiate: true })
 ).toEqualTypeOf<void>();
 
-expectTypeOf(instance.lookup('service:store')).toBeUnknown();
+// We do not have a registry entry, so we will not get back the `Store` class.
+expectTypeOf(instance.lookup('service:store')).toEqualTypeOf<object | undefined>();
 expectTypeOf(
   instance.lookup('service:store', { singleton: true, instantiate: true })
-).toBeUnknown();
+).toEqualTypeOf<object | undefined>();
 
 expectTypeOf(instance.hasRegistration('service:store')).toEqualTypeOf<boolean>();
 // @ts-expect-error requires name
diff --git a/packages/@ember/application/type-tests/namespace.test.ts b/packages/@ember/application/type-tests/namespace.test.ts
index 46332e2701c..bf53e5d5c1e 100644
--- a/packages/@ember/application/type-tests/namespace.test.ts
+++ b/packages/@ember/application/type-tests/namespace.test.ts
@@ -2,6 +2,7 @@ import Namespace from '@ember/application/namespace';
 
 import { expectTypeOf } from 'expect-type';
 
+// @ts-expect-error: VERSION is a static property.
 const namespace = Namespace.create({ VERSION: '1.0.0' });
 
 expectTypeOf(namespace).toMatchTypeOf<Namespace>();
diff --git a/packages/@ember/array/index.ts b/packages/@ember/array/index.ts
index 53495e9d11a..65a649e5a8b 100644
--- a/packages/@ember/array/index.ts
+++ b/packages/@ember/array/index.ts
@@ -1146,7 +1146,7 @@ interface EmberArray<T> extends Enumerable {
     @since 1.2.0
     @public
   */
-  sortBy(key: string): T[];
+  sortBy(...keys: string[]): T[];
   /**
     Returns a new array that contains only unique values. The default
     implementation returns an array regardless of the receiver type.
diff --git a/packages/@ember/array/proxy.ts b/packages/@ember/array/proxy.ts
index 599cb6bab69..a153a9d193d 100644
--- a/packages/@ember/array/proxy.ts
+++ b/packages/@ember/array/proxy.ts
@@ -17,7 +17,7 @@ import { get } from '@ember/object';
 import type { PropertyDidChange } from '@ember/-internals/metal';
 import { isObject } from '@ember/-internals/utils';
 import EmberObject from '@ember/object';
-import EmberArray from '@ember/array';
+import EmberArray, { type NativeArray } from '@ember/array';
 import MutableArray from '@ember/array/mutable';
 import { assert } from '@ember/debug';
 import { setCustomTagFor } from '@glimmer/manager';
@@ -116,7 +116,7 @@ function customTagForArrayProxy(proxy: object, key: string) {
   @uses MutableArray
   @public
 */
-interface ArrayProxy<T, C extends EmberArray<T> | T[] = T[]> extends MutableArray<T> {
+interface ArrayProxy<T> extends MutableArray<T> {
   /**
     The content array. Must be an object that implements `Array` and/or
     `MutableArray.`
@@ -125,7 +125,7 @@ interface ArrayProxy<T, C extends EmberArray<T> | T[] = T[]> extends MutableArra
     @type EmberArray
     @public
   */
-  content: C | null;
+  content: EmberArray<T> | NativeArray<T> | null;
   /**
     The array that the proxy pretends to be. In the default `ArrayProxy`
     implementation, this and `content` are the same. Subclasses of `ArrayProxy`
@@ -134,7 +134,7 @@ interface ArrayProxy<T, C extends EmberArray<T> | T[] = T[]> extends MutableArra
     @property arrangedContent
     @public
   */
-  arrangedContent: C | null;
+  arrangedContent: EmberArray<T> | null;
   /**
     Should actually retrieve the object at the specified index from the
     content. You can override this method in subclasses to transform the
@@ -163,11 +163,10 @@ interface ArrayProxy<T, C extends EmberArray<T> | T[] = T[]> extends MutableArra
     @public
   */
   replaceContent(idx: number, amt: number, objects?: T[]): void;
+
+  create(init: { content: Array<T> }): ArrayProxy<T>;
 }
-class ArrayProxy<T, C extends EmberArray<T> | T[] = T[]>
-  extends EmberObject
-  implements PropertyDidChange
-{
+class ArrayProxy<T> extends EmberObject implements PropertyDidChange {
   /*
     `this._objectsDirtyIndex` determines which indexes in the `this._objects`
     cache are dirty.
@@ -189,7 +188,7 @@ class ArrayProxy<T, C extends EmberArray<T> | T[] = T[]>
   _length = 0;
 
   /** @internal */
-  _arrangedContent: C | null = null;
+  _arrangedContent: EmberArray<T> | null = null;
   /** @internal */
   _arrangedContentIsUpdating = false;
   /** @internal */
@@ -215,9 +214,9 @@ class ArrayProxy<T, C extends EmberArray<T> | T[] = T[]>
     this._removeArrangedContentArrayObserver();
   }
 
-  declare content: C | null;
+  declare content: EmberArray<T> | NativeArray<T> | null;
 
-  declare arrangedContent: C | null;
+  declare arrangedContent: EmberArray<T> | null;
 
   objectAtContent(idx: number) {
     let arrangedContent = get(this, 'arrangedContent');
@@ -251,7 +250,7 @@ class ArrayProxy<T, C extends EmberArray<T> | T[] = T[]>
     }
 
     if (this._objectsDirtyIndex !== -1 && idx >= this._objectsDirtyIndex) {
-      let arrangedContent = get(this, 'arrangedContent') as C | null;
+      let arrangedContent = get(this, 'arrangedContent');
       if (arrangedContent) {
         let length = (this._objects.length = get(arrangedContent, 'length'));
 
@@ -275,7 +274,7 @@ class ArrayProxy<T, C extends EmberArray<T> | T[] = T[]>
     this._revalidate();
 
     if (this._lengthDirty) {
-      let arrangedContent = get(this, 'arrangedContent') as C | null;
+      let arrangedContent = get(this, 'arrangedContent');
       this._length = arrangedContent ? get(arrangedContent, 'length') : 0;
       this._lengthDirty = false;
     }
@@ -298,7 +297,7 @@ class ArrayProxy<T, C extends EmberArray<T> | T[] = T[]>
       removedCount = 0;
     }
 
-    let content = get(this, 'content') as C | null;
+    let content = get(this, 'content');
     if (content) {
       assert('Mutating a non-mutable array is not allowed', isMutable(content));
       replace<T>(content, value, removedCount, added);
@@ -307,7 +306,7 @@ class ArrayProxy<T, C extends EmberArray<T> | T[] = T[]>
     }
   }
 
-  _updateArrangedContentArray(arrangedContent: C | null) {
+  _updateArrangedContentArray(arrangedContent: EmberArray<T> | null) {
     let oldLength = this._objects === null ? 0 : this._objects.length;
     let newLength = arrangedContent ? get(arrangedContent, 'length') : 0;
 
@@ -320,9 +319,8 @@ class ArrayProxy<T, C extends EmberArray<T> | T[] = T[]>
     this._addArrangedContentArrayObserver(arrangedContent);
   }
 
-  _addArrangedContentArrayObserver(arrangedContent: C | null) {
+  _addArrangedContentArrayObserver(arrangedContent: EmberArray<T> | null) {
     if (arrangedContent && !(arrangedContent as any).isDestroyed) {
-      // @ts-expect-error This check is still good for ensuring correctness
       assert("Can't set ArrayProxy's content to itself", arrangedContent !== this);
       assert(
         `ArrayProxy expects a native Array, EmberArray, or ArrayProxy, but you passed ${typeof arrangedContent}`,
@@ -384,7 +382,7 @@ class ArrayProxy<T, C extends EmberArray<T> | T[] = T[]>
       this._arrangedContentTag === null ||
       !validateTag(this._arrangedContentTag, this._arrangedContentRevision!)
     ) {
-      let arrangedContent = this.get('arrangedContent') as C | null;
+      let arrangedContent = this.get('arrangedContent');
 
       if (this._arrangedContentTag === null) {
         // This is the first time the proxy has been setup, only add the observer
diff --git a/packages/@ember/array/type-tests/proxy.test.ts b/packages/@ember/array/type-tests/proxy.test.ts
index 6821586a073..c7f74be1cd6 100644
--- a/packages/@ember/array/type-tests/proxy.test.ts
+++ b/packages/@ember/array/type-tests/proxy.test.ts
@@ -1,6 +1,5 @@
-import type { NativeArray } from '@ember/array';
 import type EmberArray from '@ember/array';
-import { A } from '@ember/array';
+import { A, NativeArray } from '@ember/array';
 import ArrayProxy from '@ember/array/proxy';
 import type MutableArray from '@ember/array/mutable';
 
@@ -13,10 +12,10 @@ let foo = new Foo();
 let content = A([foo]);
 
 // We can't infer the correct type through `create`;
-let proxy = ArrayProxy.create({ content }) as ArrayProxy<Foo, NativeArray<Foo>>;
+let proxy = ArrayProxy.create({ content }) as ArrayProxy<Foo>;
 
 expectTypeOf(proxy).toMatchTypeOf<EmberArray<Foo>>();
 expectTypeOf(proxy).toMatchTypeOf<MutableArray<Foo>>();
 
-expectTypeOf(proxy.content).toEqualTypeOf<NativeArray<Foo> | null>();
-expectTypeOf(proxy.arrangedContent).toEqualTypeOf<NativeArray<Foo> | null>();
+expectTypeOf(proxy.content).toEqualTypeOf<EmberArray<Foo> | NativeArray<Foo> | null>();
+expectTypeOf(proxy.arrangedContent).toEqualTypeOf<EmberArray<Foo> | null>();
diff --git a/packages/@ember/component/helper.ts b/packages/@ember/component/helper.ts
index 616baeeb9e5..c1aa1427027 100644
--- a/packages/@ember/component/helper.ts
+++ b/packages/@ember/component/helper.ts
@@ -1 +1,6 @@
-export { Helper as default, helper } from '@ember/-internals/glimmer';
+export {
+  Helper as default,
+  helper,
+  type FunctionBasedHelper,
+  type FunctionBasedHelperInstance,
+} from '@ember/-internals/glimmer';
diff --git a/packages/@ember/component/template-only.ts b/packages/@ember/component/template-only.ts
index 509390074fb..6bae8223e26 100644
--- a/packages/@ember/component/template-only.ts
+++ b/packages/@ember/component/template-only.ts
@@ -29,4 +29,58 @@
   @for @ember/component/template-only
   @category EMBER_GLIMMER_SET_COMPONENT_TEMPLATE
 */
-export { templateOnlyComponent as default } from '@glimmer/runtime';
+import { type Opaque } from '@ember/-internals/utility-types';
+import { templateOnlyComponent as glimmerTemplateOnlyComponent } from '@glimmer/runtime';
+
+/**
+ * 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.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface TemplateOnlyComponent<S = unknown> extends Opaque<S> {}
+
+/**
+ * A convenience alias for {@link TemplateOnlyComponent}
+ */
+export type TOC<S> = TemplateOnlyComponent<S>;
+
+// NOTES:
+//
+// 1. 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.
+// 2. SAFETY: this cast is *throwing away* information that is not part of the
+//    public API and replacing it with something which has the same calling
+//    contract, but much less information (since we do not want to expose the
+//    internal APIs like `moduleName` etc.).
+// prettier-ignore
+const templateOnly =
+  glimmerTemplateOnlyComponent as unknown as
+    <S>(moduleName?: string, name?: string) => TemplateOnlyComponent<S>;
+export default templateOnly;
diff --git a/packages/@ember/component/type-tests/helper/helper.test.ts b/packages/@ember/component/type-tests/helper/helper.test.ts
index cdd73f4eedd..27413a641d1 100644
--- a/packages/@ember/component/type-tests/helper/helper.test.ts
+++ b/packages/@ember/component/type-tests/helper/helper.test.ts
@@ -1,4 +1,4 @@
-import type { HelperFactory, SimpleHelper } from '@ember/-internals/glimmer/lib/helper';
+import type { FunctionBasedHelper } from '@ember/-internals/glimmer/lib/helper';
 import { helper } from '@ember/component/helper';
 import { expectTypeOf } from 'expect-type';
 
@@ -8,7 +8,10 @@ let myHelper = helper(function ([cents]: [number], { currency }: { currency: str
   return `${currency}${cents * 0.01}`;
 });
 expectTypeOf(myHelper).toEqualTypeOf<
-  HelperFactory<SimpleHelper<string, [number], { currency: string }>>
+  FunctionBasedHelper<{
+    Args: { Positional: [number]; Named: { currency: string } };
+    Return: string;
+  }>
 >();
 
 // @ts-expect-error invalid named params
diff --git a/packages/@ember/component/type-tests/template-only.test.ts b/packages/@ember/component/type-tests/template-only.test.ts
index 77cfa79575d..3e82523a98a 100644
--- a/packages/@ember/component/type-tests/template-only.test.ts
+++ b/packages/@ember/component/type-tests/template-only.test.ts
@@ -1,8 +1,7 @@
-import templateOnlyComponent from '@ember/component/template-only';
-import type { TemplateOnlyComponentDefinition } from '@glimmer/runtime/dist/types/lib/component/template-only';
+import templateOnlyComponent, { type TemplateOnlyComponent } from '@ember/component/template-only';
 import { expectTypeOf } from 'expect-type';
 
-expectTypeOf(templateOnlyComponent()).toEqualTypeOf<TemplateOnlyComponentDefinition>();
+expectTypeOf(templateOnlyComponent()).toEqualTypeOf<TemplateOnlyComponent<unknown>>();
 
 templateOnlyComponent('myModule');
 templateOnlyComponent('myModule', 'myName');
diff --git a/packages/@ember/controller/index.ts b/packages/@ember/controller/index.ts
index 5edc7eca9ab..c45babc0ada 100644
--- a/packages/@ember/controller/index.ts
+++ b/packages/@ember/controller/index.ts
@@ -7,11 +7,13 @@ import Mixin from '@ember/object/mixin';
 import type { RouteArgs } from '@ember/routing/-internals';
 import { ActionHandler } from '@ember/-internals/runtime';
 import { symbol } from '@ember/-internals/utils';
-import type Route from '@ember/routing/route';
 import type { Transition } from 'router_js';
 
 export type ControllerQueryParamType = 'boolean' | 'number' | 'array' | 'string';
-export type ControllerQueryParam = string | Record<string, { type: ControllerQueryParamType }>;
+export type ControllerQueryParam =
+  | string
+  | Record<string, { type: ControllerQueryParamType }>
+  | Record<string, string>;
 
 const MODEL = symbol('MODEL');
 
@@ -162,7 +164,7 @@ interface ControllerMixin<T> extends ActionHandler {
       attempted transition
     @public
   */
-  transitionToRoute(...args: RouteArgs<Route>): Transition;
+  transitionToRoute(...args: RouteArgs): Transition;
 
   /**
     Transition into another route while replacing the current URL, if possible.
@@ -226,7 +228,7 @@ interface ControllerMixin<T> extends ActionHandler {
       attempted transition
     @public
   */
-  replaceRoute(...args: RouteArgs<Route>): Transition;
+  replaceRoute(...args: RouteArgs): Transition;
 }
 const ControllerMixin = Mixin.create(ActionHandler, {
   /* ducktype as a controller */
diff --git a/packages/@ember/controller/type-tests/index.test.ts b/packages/@ember/controller/type-tests/index.test.ts
index 539170513ea..fdcca149715 100644
--- a/packages/@ember/controller/type-tests/index.test.ts
+++ b/packages/@ember/controller/type-tests/index.test.ts
@@ -26,7 +26,13 @@ expectTypeOf(controller.model).toEqualTypeOf<Foo>();
 expectTypeOf(controller.concatenatedProperties).toEqualTypeOf<string[] | string | undefined>();
 
 expectTypeOf(controller.queryParams).toEqualTypeOf<
-  Readonly<Array<string | Record<string, { type: 'boolean' | 'number' | 'array' | 'string' }>>>
+  Readonly<
+    Array<
+      | string
+      | Record<string, string>
+      | Record<string, { type: 'boolean' | 'number' | 'array' | 'string' }>
+    >
+  >
 >();
 
 controller.transitionToRoute('blogPosts');
diff --git a/packages/@ember/debug/data-adapter.ts b/packages/@ember/debug/data-adapter.ts
index c8d4af0a1f9..150921046ad 100644
--- a/packages/@ember/debug/data-adapter.ts
+++ b/packages/@ember/debug/data-adapter.ts
@@ -18,10 +18,15 @@ import { assert } from '.';
 
 type RecordColor = 'black' | 'red' | 'blue' | 'green';
 
+type Column = {
+  name: string;
+  desc: string;
+};
+
 type WrappedType<N extends string = string> = {
   name: N;
   count: number;
-  columns: unknown[];
+  columns: Column[];
   object: unknown;
 };
 
@@ -307,7 +312,10 @@ export default class DataAdapter<T> extends EmberObject {
     @return {Array} List of objects defining filters.
      The object should have a `name` and `desc` property.
   */
-  getFilters() {
+  getFilters(): Array<{
+    name: string;
+    desc: string;
+  }> {
     return emberA();
   }
 
@@ -472,7 +480,7 @@ export default class DataAdapter<T> extends EmberObject {
      name: {String} The name of the column.
      desc: {String} Humanized description (what would show in a table column name).
   */
-  columnsForType(_klass: unknown) {
+  columnsForType(_klass: unknown): Column[] {
     return emberA();
   }
 
diff --git a/packages/@ember/debug/index.ts b/packages/@ember/debug/index.ts
index 81e23ab2276..cb7fc8fb6fa 100644
--- a/packages/@ember/debug/index.ts
+++ b/packages/@ember/debug/index.ts
@@ -24,7 +24,10 @@ export type DebugFunctionType =
   | 'runInDebug'
   | 'deprecateFunc';
 
-export type AssertFunc = (desc: string, condition?: unknown) => asserts condition;
+export interface AssertFunc {
+  (desc: string, condition: unknown): asserts condition;
+  (desc: string): never;
+}
 export type DebugFunc = (message: string) => void;
 export type DebugSealFunc = (obj: object) => void;
 export type DebugFreezeFunc = (obj: object) => void;
@@ -63,7 +66,9 @@ export type SetDebugFunction = {
 // These are the default production build versions:
 const noop = () => {};
 
-let assert: AssertFunc = noop;
+// SAFETY: these casts are just straight-up lies, but the point is that they do
+// not do anything in production builds.
+let assert: AssertFunc = noop as unknown as AssertFunc;
 let info: InfoFunc = noop;
 let warn: WarnFunc = noop;
 let debug: DebugFunc = noop;
@@ -71,8 +76,8 @@ let deprecate: DeprecateFunc = noop;
 let debugSeal: DebugSealFunc = noop;
 let debugFreeze: DebugFreezeFunc = noop;
 let runInDebug: RunInDebugFunc = noop;
-let setDebugFunction: SetDebugFunction = noop as any;
-let getDebugFunction: GetDebugFunction = noop as any;
+let setDebugFunction: SetDebugFunction = noop as unknown as SetDebugFunction;
+let getDebugFunction: GetDebugFunction = noop as unknown as GetDebugFunction;
 
 let deprecateFunc: DeprecateFuncFunc = function () {
   return arguments[arguments.length - 1];
@@ -165,11 +170,16 @@ if (DEBUG) {
     @public
     @since 1.0.0
   */
-  setDebugFunction('assert', function assert(desc, test) {
+  function assert(desc: string): never;
+  function assert(desc: string, test: unknown): asserts test;
+  // eslint-disable-next-line no-inner-declarations
+  function assert(desc: string, test?: unknown): asserts test {
     if (!test) {
       throw new Error(`Assertion Failed: ${desc}`);
     }
-  });
+  }
+
+  setDebugFunction('assert', assert);
 
   /**
     Display a debug notice.
diff --git a/packages/@ember/debug/lib/warn.ts b/packages/@ember/debug/lib/warn.ts
index 6c1711ea765..8924a4ba929 100644
--- a/packages/@ember/debug/lib/warn.ts
+++ b/packages/@ember/debug/lib/warn.ts
@@ -9,7 +9,12 @@ export interface WarnOptions {
 }
 
 export type RegisterHandlerFunc = (handler: HandlerCallback<WarnOptions>) => void;
-export type WarnFunc = (message: string, test?: boolean, options?: WarnOptions) => void;
+export interface WarnFunc {
+  (message: string): void;
+  (message: string, test: boolean): void;
+  (message: string, options: WarnOptions): void;
+  (message: string, test: boolean, options: WarnOptions): void;
+}
 
 let registerHandler: RegisterHandlerFunc = () => {};
 let warn: WarnFunc = () => {};
@@ -97,7 +102,7 @@ if (DEBUG) {
     @public
     @since 1.0.0
   */
-  warn = function warn(message, test, options) {
+  warn = function warn(message: string, test?: boolean | WarnOptions, options?: WarnOptions) {
     if (arguments.length === 2 && typeof test === 'object') {
       options = test;
       test = false;
@@ -106,7 +111,8 @@ if (DEBUG) {
     assert(missingOptionsDeprecation, Boolean(options));
     assert(missingOptionsIdDeprecation, Boolean(options && options.id));
 
-    invoke('warn', message, test, options);
+    // SAFETY: we checked this by way of the `arguments` check above.
+    invoke('warn', message, test as boolean, options);
   };
 }
 
diff --git a/packages/@ember/debug/type-tests/assert.test.ts b/packages/@ember/debug/type-tests/assert.test.ts
index ed26bd456f7..7e513dcbbff 100644
--- a/packages/@ember/debug/type-tests/assert.test.ts
+++ b/packages/@ember/debug/type-tests/assert.test.ts
@@ -3,16 +3,19 @@ import { expectTypeOf } from 'expect-type';
 
 let str: unknown;
 assert('Must pass a string', typeof str === 'string');
+expectTypeOf(assert).parameter(0).toBeString();
 
-// Fail unconditionally
-assert('This code path should never be run');
-
-expectTypeOf(assert('foo')).toEqualTypeOf<void>();
+expectTypeOf(assert('foo')).toBeNever();
 
-// @ts-expect-error inverted order
-assert(typeof str === 'string', 'Must pass a string');
+// Narrows
+declare let test: string | undefined;
+assert('desc', !!test);
+expectTypeOf(test).toBeString();
 
 // Functions as a type guard
 let otherStr: unknown;
 assert('Must pass a string', typeof otherStr === 'string');
 expectTypeOf(otherStr).toEqualTypeOf<string>();
+
+// Fail unconditionally
+assert('This code path should never be run');
diff --git a/packages/@ember/helper/index.ts b/packages/@ember/helper/index.ts
index 47f98763171..703a7a46a0b 100644
--- a/packages/@ember/helper/index.ts
+++ b/packages/@ember/helper/index.ts
@@ -2,6 +2,17 @@
 @module @ember/helper
 */
 
+import { setHelperManager as glimmerSetHelperManager, helperCapabilities } from '@glimmer/manager';
+import {
+  invokeHelper as glimmerInvokeHelper,
+  hash as glimmerHash,
+  array as glimmerArray,
+  concat as glimmerConcat,
+  get as glimmerGet,
+  fn as glimmerFn,
+} from '@glimmer/runtime';
+import { type Opaque } from '@ember/-internals/utility-types';
+
 /**
   `capabilities` returns a capabilities configuration which can be used to modify
   the behavior of the manager. Manager capabilities _must_ be provided using the
@@ -54,6 +65,7 @@
   @return {Capabilities} The capabilities object instance
   @public
 */
+export const capabilities = helperCapabilities;
 
 /**
   Sets the helper manager for an object or function.
@@ -247,6 +259,7 @@
   @return {object} The definition passed into setHelperManager
   @public
 */
+export const setHelperManager = glimmerSetHelperManager;
 
 /**
   The `invokeHelper` function can be used to create a helper instance in
@@ -280,7 +293,7 @@
     }
   }
   ```
-  ```hbs
+  ```js
   {{this.value}}
   ```
 
@@ -311,6 +324,148 @@
   @returns
   @public
 */
+export const invokeHelper = glimmerInvokeHelper;
+
+// SAFETY: we need to provide interfaces that Glint can declaration-merge with
+// to provide appropriate completions. In each case, the imported item is
+// currently typed only as `object`, and we are replacing it with a similarly
+// low-information interface type: these are empty objects which are simply able
+// to be distinguished so that Glint can provide the relevant extensions.
+/* eslint-disable @typescript-eslint/no-empty-interface */
+
+/**
+ * Using the `{{hash}}` helper, you can pass objects directly from the template
+ * as an argument to your components.
+ *
+ * ```
+ * import { hash } from '@ember/helper';
+ *
+ * <template>
+ *   {{#each-in (hash givenName='Jen' familyName='Weber') as |key value|}}
+ *     <p>{{key}}: {{value}}</p>
+ *   {{/each-in}}
+ * </template>
+ * ```
+ *
+ * **NOTE:** this example uses the experimental `<template>` feature, which is
+ * the only place you need to import `hash` to use it (it is a built-in when
+ * writing standalone `.hbs` files).
+ */
+export const hash = glimmerHash as HashHelper;
+export interface HashHelper extends Opaque<'helper:hash'> {}
+
+/**
+ * Using the `{{array}}` helper, you can pass arrays directly from the template
+ * as an argument to your components.
+ *
+ * ```js
+ * import { array } from '@ember/helper';
+ *
+ * <template>
+ *   <ul>
+ *   {{#each (array 'Tom Dale' 'Yehuda Katz' @anotherPerson) as |person|}}
+ *     <li>{{person}}</li>
+ *   {{/each}}
+ *   </ul>
+ * </template>
+ *
+ * **NOTE:** this example uses the experimental `<template>` feature, which is
+ * the only place you need to import `array` to use it (it is a built-in when
+ * writing standalone `.hbs` files).
+ * ```
+ */
+export const array = glimmerArray as ArrayHelper;
+export interface ArrayHelper extends Opaque<'helper:array'> {}
+
+/**
+ * The `{{concat}}` helper makes it easy to dynamically send a number of
+ * parameters to a component or helper as a single parameter in the format of a
+ * concatenated string.
+ *
+ * For example:
+ *
+ * ```js
+ * import { concat } from '@ember/helper';
+ *
+ * <template>
+ *   {{get @foo (concat "item" @index)}}
+ * </template>
+ * ```
+ *
+ * This will display the result of `@foo.item1` when `index` is `1`, and
+ * `this.foo.item2` when `index` is `2`, etc.
+ *
+ * **NOTE:** this example uses the experimental `<template>` feature, which is
+ * the only place you need to import `concat` to use it (it is a built-in when
+ * writing standalone `.hbs` files).
+ */
+export const concat = glimmerConcat as ConcatHelper;
+export interface ConcatHelper extends Opaque<'helper:concat'> {}
 
-export { setHelperManager, helperCapabilities as capabilities } from '@glimmer/manager';
-export { invokeHelper, hash, array, concat, get, fn } from '@glimmer/runtime';
+/**
+ * The `{{get}}` helper makes it easy to dynamically look up a property on an
+ * object or an element in an array. The second argument to `{{get}}` can be a
+ * string or a number, depending on the object being accessed.
+ *
+ * To access a property on an object with a string key:
+ *
+ * ```js
+ * import { get } from '@ember/helper';
+ *
+ * <template>
+ *   {{get @someObject "objectKey"}}
+ * </template>
+ * ```
+ *
+ * To access the first element in an array:
+ *
+ * ```js
+ * import { get } from '@ember/helper';
+ *
+ * <template>
+ *   {{get @someArray 0}}
+ * </template>
+ * ```
+ *
+ * To access a property on an object with a dynamic key:
+ *
+ * ```js
+ * import { get } from '@ember/helper';
+ *
+ * <template>
+ *   {{get @address @field}}
+ * </template>
+ * ```
+ *
+ * This will display the result of `@foo.item1` when `index` is `1`, and
+ * `this.foo.item2` when `index` is `2`, etc.
+ *
+ * **NOTE:** this example uses the experimental `<template>` feature, which is
+ * the only place you need to import `concat` to use it (it is a built-in when
+ * writing standalone `.hbs` files).
+ */
+export const get = glimmerGet as GetHelper;
+export interface GetHelper extends Opaque<'helper:get'> {}
+
+/**
+ * `{{fn}}` is a helper that receives a function and some arguments, and returns
+ * a new function that combines. This allows you to pass parameters along to
+ * functions in your templates:
+ *
+ * ```js
+ * import { fn } from '@ember/helper';
+ *
+ * function showAlert(message) {
+ *   alert(`The message is: '${message}'`);
+ * }
+ *
+ * <template>
+ *   <button type="button" {{on "click" (fn showAlert "Hello!")}}>
+ *     Click me!
+ *   </button>
+ * </template>
+ * ```
+ */
+export const fn = glimmerFn as FnHelper;
+export interface FnHelper extends Opaque<'helper:fn'> {}
+/* eslint-enable @typescript-eslint/no-empty-interface */
diff --git a/packages/@ember/helper/type-tests/set-helper-manager.test.ts b/packages/@ember/helper/type-tests/set-helper-manager.test.ts
index f76d49e6ace..c693db3c3db 100644
--- a/packages/@ember/helper/type-tests/set-helper-manager.test.ts
+++ b/packages/@ember/helper/type-tests/set-helper-manager.test.ts
@@ -1,19 +1,24 @@
-import type {
-  HelperFactory,
-  HelperFunction,
-  SimpleHelper,
-} from '@ember/-internals/glimmer/lib/helper';
+import type { HelperFactory, SimpleHelper } from '@ember/-internals/glimmer/lib/helper';
 import { getDebugName } from '@ember/-internals/utils';
 import { capabilities, setHelperManager } from '@ember/helper';
 import type { Arguments, Dict, HelperManager } from '@glimmer/interfaces';
 import { expectTypeOf } from 'expect-type';
 
 class Wrapper<T = unknown, P extends unknown[] = unknown[], N extends Dict<unknown> = Dict<unknown>>
-  implements HelperFactory<SimpleHelper<T, P, N>>
+  implements
+    HelperFactory<
+      SimpleHelper<{
+        Args: {
+          Positional: P;
+          Named: N;
+        };
+        Return: T;
+      }>
+    >
 {
   readonly isHelperFactory = true;
 
-  constructor(public compute: HelperFunction<T, P, N>) {}
+  constructor(public compute: (positional: P, named: N) => T) {}
 
   create() {
     // needs new instance or will leak containers
diff --git a/packages/@ember/modifier/index.ts b/packages/@ember/modifier/index.ts
index cb64d224d38..a24469efad8 100644
--- a/packages/@ember/modifier/index.ts
+++ b/packages/@ember/modifier/index.ts
@@ -1,3 +1,31 @@
-export { setModifierManager } from '@glimmer/manager';
+import { on as glimmerOn } from '@glimmer/runtime';
+import { setModifierManager as glimmerSetModifierManager } from '@glimmer/manager';
+
+import type { Opaque } from '@ember/-internals/utility-types';
+import type Owner from '@ember/owner';
+import type { ModifierManager } from '@glimmer/interfaces';
+
+// 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.
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface OnModifier extends Opaque<'modifier:on'> {}
+
+// SAFETY: at the time of writing, the cast here is from `{}` to `OnModifier`,
+// which makes it strictly safer to use outside this module because it is not
+// usable as "any non-null item", which is what `{}` means, without loss of any
+// information from the type itself.
+export const on = glimmerOn as OnModifier;
+
+// NOTE: this uses assignment to *require* that the `glimmerSetModifierManager`
+// is legally assignable to this type, i.e. that variance is properly upheld.
+export const setModifierManager: <T extends object>(
+  factory: (owner: Owner) => ModifierManager<unknown>,
+  modifier: T
+) => T = glimmerSetModifierManager;
+
+export type { ModifierManager };
+
+export type { ModifierCapabilities } from '@glimmer/interfaces';
 export { modifierCapabilities as capabilities } from '@ember/-internals/glimmer';
-export { on } from '@glimmer/runtime';
diff --git a/packages/@ember/object/core.ts b/packages/@ember/object/core.ts
index 797b1b8dad2..ed18d97d530 100644
--- a/packages/@ember/object/core.ts
+++ b/packages/@ember/object/core.ts
@@ -91,7 +91,10 @@ function initialize(obj: CoreObject, properties?: unknown) {
     let keyNames = Object.keys(properties);
 
     for (let keyName of keyNames) {
-      let value = (properties as any)[keyName];
+      // SAFETY: this cast as a Record is safe because all object types can be
+      // indexed in JS, and we explicitly type it as returning `unknown`, so the
+      // result *must* be checked below.
+      let value: unknown = (properties as Record<string, unknown>)[keyName];
 
       assert(
         'EmberObject.create no longer supports defining computed ' +
@@ -311,7 +314,7 @@ class CoreObject {
     }
   }
 
-  reopen(...args: Array<Mixin | Record<string, unknown>>) {
+  reopen(...args: Array<Mixin | Record<string, unknown>>): this {
     applyMixin(this, args);
     return this;
   }
@@ -709,10 +712,10 @@ class CoreObject {
     @param {Object} [arguments]* Object containing values to use within the new class
     @public
   */
-  static extend<Statics, Instance>(
+  static extend<Statics, Instance, M extends Array<unknown>>(
     this: Statics & EmberClassConstructor<Instance>,
-    ...mixins: any[]
-  ): Readonly<Statics> & EmberClassConstructor<Instance>;
+    ...mixins: M
+  ): Readonly<Statics> & EmberClassConstructor<Instance> & MergeArray<M>;
   static extend(...mixins: any[]) {
     let Class = class extends this {};
     reopen.apply(Class.PrototypeMixin, mixins);
@@ -760,16 +763,17 @@ class CoreObject {
     @param [arguments]*
     @public
   */
-  static create<Class extends typeof CoreObject, Args extends Array<Record<string, any>>>(
-    this: Class,
-    ...args: Args
-  ): InstanceType<Class> & MergeArray<Args>;
-  static create(...args: Record<string, unknown>[]) {
+  static create<
+    C extends typeof CoreObject,
+    I extends InstanceType<C>,
+    K extends keyof I,
+    Args extends Array<Partial<Record<K, I[K]>>>
+  >(this: C, ...args: Args): InstanceType<C> & MergeArray<Args> {
     let props = args[0];
     let instance;
 
     if (props !== undefined) {
-      instance = new this(getOwner(props));
+      instance = new this(getOwner(props)) as InstanceType<C>;
       // TODO(SAFETY): at present, we cannot actually rely on this being set,
       // because a number of acceptance tests are (incorrectly? Unclear!)
       // relying on the ability to run through this path with `factory` being
@@ -782,7 +786,7 @@ class CoreObject {
       // assert(`missing factory when creating object ${instance}`, factory !== undefined);
       setFactoryFor(instance, factory as NonNullable<typeof factory>);
     } else {
-      instance = new this();
+      instance = new this() as InstanceType<C>;
     }
 
     if (args.length <= 1) {
@@ -791,7 +795,9 @@ class CoreObject {
       initialize(instance, flattenProps.apply(this, args));
     }
 
-    return instance;
+    // SAFETY: The `initialize` call is responsible to merge the prototype chain
+    // so that this holds.
+    return instance as InstanceType<C> & MergeArray<Args>;
   }
 
   /**
@@ -828,7 +834,7 @@ class CoreObject {
     @static
     @public
   */
-  static reopen(...args: any[]) {
+  static reopen<C extends typeof CoreObject>(this: C, ...args: any[]): C {
     this.willReopen();
     reopen.apply(this.PrototypeMixin, args);
     return this;
@@ -909,7 +915,10 @@ class CoreObject {
     @static
     @public
   */
-  static reopenClass(...mixins: Array<Mixin | Record<string, unknown>>) {
+  static reopenClass<C extends typeof CoreObject>(
+    this: C,
+    ...mixins: Array<Mixin | Record<string, unknown>>
+  ): C {
     applyMixin(this, mixins);
     return this;
   }
diff --git a/packages/@ember/object/index.ts b/packages/@ember/object/index.ts
index 230471a71e0..8eb36b1b938 100644
--- a/packages/@ember/object/index.ts
+++ b/packages/@ember/object/index.ts
@@ -37,7 +37,8 @@ export {
   @uses Observable
   @public
 */
-interface EmberObject extends CoreObject, Observable {}
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface EmberObject extends Observable {}
 class EmberObject extends CoreObject.extend(Observable) {
   get _debugContainerKey() {
     let factory = getFactoryFor(this);
diff --git a/packages/@ember/object/lib/computed/reduce_computed_macros.ts b/packages/@ember/object/lib/computed/reduce_computed_macros.ts
index 6bb7037e904..525c9611746 100644
--- a/packages/@ember/object/lib/computed/reduce_computed_macros.ts
+++ b/packages/@ember/object/lib/computed/reduce_computed_macros.ts
@@ -1030,7 +1030,11 @@ export function collect(dependentKey: string, ...additionalDependentKeys: string
   );
 }
 
-type SortDefinition = (itemA: unknown, itemB: unknown) => number;
+// (UN)SAFETY: we use `any` here to match how TS defines the sorting for arrays.
+// Additionally, since we're using it with *decorators*, we don't have any way
+// to plumb through the relationship between the types in a way that would be
+// variance-safe.
+type SortDefinition = (itemA: any, itemB: any) => number;
 
 /**
   A computed property which returns a new array with all the properties from the
diff --git a/packages/@ember/object/mixin.ts b/packages/@ember/object/mixin.ts
index 681cb37bcc9..330529045e9 100644
--- a/packages/@ember/object/mixin.ts
+++ b/packages/@ember/object/mixin.ts
@@ -585,10 +585,10 @@ export default class Mixin {
     @param arguments*
     @public
   */
-  static create(...args: any[]): Mixin {
+  static create<M extends typeof Mixin>(...args: any[]): InstanceType<M> {
     setUnprocessedMixins();
     let M = this;
-    return new M(args, undefined);
+    return new M(args, undefined) as InstanceType<M>;
   }
 
   // returns the mixins currently applied to the specified object
@@ -617,9 +617,9 @@ export default class Mixin {
     @private
     @internal
   */
-  reopen(...args: any[]): this | undefined {
+  reopen(...args: Array<Mixin | Record<string, unknown>>): this {
     if (args.length === 0) {
-      return;
+      return this;
     }
 
     if (this.properties) {
diff --git a/packages/@ember/object/observable.ts b/packages/@ember/object/observable.ts
index d71ca3db17c..fb760925efc 100644
--- a/packages/@ember/object/observable.ts
+++ b/packages/@ember/object/observable.ts
@@ -131,6 +131,7 @@ interface Observable {
     @return {Object} The property value or undefined.
     @public
   */
+  get<K extends keyof this>(key: K): this[K];
   get(key: string): unknown;
 
   /**
@@ -154,6 +155,8 @@ interface Observable {
     @return {Object}
     @public
   */
+  getProperties<L extends Array<keyof this>>(list: L): { [Key in L[number]]: this[Key] };
+  getProperties<L extends Array<keyof this>>(...list: L): { [Key in L[number]]: this[Key] };
   getProperties<L extends string[]>(list: L): { [Key in L[number]]: unknown };
   getProperties<L extends string[]>(...list: L): { [Key in L[number]]: unknown };
 
@@ -202,6 +205,7 @@ interface Observable {
     @return {Object} The passed value
     @public
   */
+  set<K extends keyof this, T extends this[K]>(key: K, value: T): T;
   set<T>(key: string, value: T): T;
 
   // NOT TYPE SAFE!
@@ -219,7 +223,8 @@ interface Observable {
     @return {Object} The passed in hash
     @public
   */
-  setProperties<T extends Record<string, any>>(hash: T): T;
+  setProperties<K extends keyof this, P extends { [Key in K]: this[Key] }>(hash: P): P;
+  setProperties<T extends Record<string, unknown>>(hash: T): T;
 
   /**
     Convenience method to call `propertyWillChange` and `propertyDidChange` in
diff --git a/packages/@ember/object/proxy.ts b/packages/@ember/object/proxy.ts
index 9fb314c258d..f8f9a09f575 100644
--- a/packages/@ember/object/proxy.ts
+++ b/packages/@ember/object/proxy.ts
@@ -81,9 +81,45 @@ import { _ProxyMixin } from '@ember/-internals/runtime';
   @uses Ember.ProxyMixin
   @public
 */
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-interface ObjectProxy extends _ProxyMixin {}
-class ObjectProxy extends FrameworkObject {}
+interface ObjectProxy<Content = unknown> extends _ProxyMixin<Content> {
+  // Proxies forward to their content. This behavior *actually* comes from the
+  // ProxyMixin type itself, via its `unknownProperty` implementation, but if we
+  // try to apply it there, `ObjectProxy` does not correctly extend both the
+  // `EmberObject` and `ProxyMixin` types. Instead, we apply it here, and that
+  // gives us the desired behavior for this which actually *use* `ObjectProxy`.
+  get<K extends keyof Content>(keyName: K): Content[K];
+  get<K extends keyof this>(keyname: K): this[K];
+  get(keyName: string): unknown;
+
+  set<K extends keyof Content>(keyName: K, value: Content[K]): Content[K];
+  set<K extends keyof this>(keyName: K, value: this[K]): this[K];
+  set(keyName: string): unknown;
+
+  // These types for `getProperties` and `setProperties` properly merge the
+  // Content and `this` type for the proxy so callers actually get the safe
+  // result.
+  getProperties<K extends keyof Content | keyof this>(
+    list: K[]
+  ): Pick<Content, Exclude<K, keyof this>> & Pick<this, Exclude<K, keyof Content>>;
+  getProperties<K extends keyof Content | keyof this>(
+    ...list: K[]
+  ): Pick<Content, Exclude<K, keyof this>> & Pick<this, Exclude<K, keyof Content>>;
+  getProperties<K extends string>(list: K[]): Record<K, unknown>;
+  getProperties<K extends string>(...list: K[]): Record<K, unknown>;
+
+  setProperties<
+    K extends keyof Content | keyof this,
+    Hash extends Partial<
+      Pick<Content, Exclude<K, keyof this>> & Pick<this, Exclude<K, keyof Content>>
+    >
+  >(
+    hash: Hash
+  ): Hash;
+  setProperties<T extends Record<string, unknown>>(hash: T): T;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+class ObjectProxy<Content = unknown> extends FrameworkObject {}
 ObjectProxy.PrototypeMixin.reopen(_ProxyMixin);
 
 export default ObjectProxy;
diff --git a/packages/@ember/object/type-tests/core/index.test.ts b/packages/@ember/object/type-tests/core/index.test.ts
index 36a4e388ca7..bbff33c33dc 100644
--- a/packages/@ember/object/type-tests/core/index.test.ts
+++ b/packages/@ember/object/type-tests/core/index.test.ts
@@ -26,13 +26,13 @@ expectTypeOf(co2.destroy()).toEqualTypeOf<CoreObject>();
 expectTypeOf(co2.toString()).toEqualTypeOf<string>();
 
 /** .create tests w/ initial instance data passed in */
+// @ts-expect-error: We reject arbitrary properties!
 const co3 = CoreObject.create({ foo: '123', bar: 456 });
 
-expectTypeOf(co3.foo).toEqualTypeOf<string>();
-expectTypeOf(co3.bar).toEqualTypeOf<number>();
-
 // NOTE: This is marked as @internal and will not be publicly available
-CoreObject.extend({ baz: 6 });
+// Note: we don't provide type creation via `.extend`. People should use native
+// classes instead.
+expectTypeOf(CoreObject.extend({ baz: 6 }).create()).not.toHaveProperty('baz');
 
 // NOTE: This is marked as @internal and will not be publicly available
 CoreObject.reopen({ baz: 6 });
diff --git a/packages/@ember/object/type-tests/ember-object.test.ts b/packages/@ember/object/type-tests/ember-object.test.ts
index db9845eaa04..57aef38d3bb 100644
--- a/packages/@ember/object/type-tests/ember-object.test.ts
+++ b/packages/@ember/object/type-tests/ember-object.test.ts
@@ -22,15 +22,11 @@ expectTypeOf(o.isDestroying).toEqualTypeOf<boolean>(); // from instance
 /**
  * One-argument case
  */
+// @ts-expect-error: there are *no* types in common here, so we reject them.
 const o1 = EmberObject.create({ x: 9, y: 'hello', z: false });
-expectTypeOf(o1.x).toEqualTypeOf<number>();
-expectTypeOf(o1.y).toEqualTypeOf<string>();
-expectTypeOf(o1.z).toEqualTypeOf<boolean>();
 
+// @ts-expect-error: there are *no* types in common here, so we reject them.
 const obj = EmberObject.create({ a: 1 }, { b: 2 }, { c: 3 });
-expectTypeOf(obj.b).toEqualTypeOf<number>();
-expectTypeOf(obj.a).toEqualTypeOf<number>();
-expectTypeOf(obj.c).toEqualTypeOf<number>();
 
 export class Person extends EmberObject {
   firstName!: string;
@@ -42,7 +38,7 @@ const p = new Person(owner);
 expectTypeOf(p.firstName).toEqualTypeOf<string>();
 
 // get not preferred for TS only returns unknown
-expectTypeOf(p.get('firstName')).toEqualTypeOf<unknown>();
+expectTypeOf(p.get('firstName')).toBeString();
 // Also returns unknown for invalid properties
 expectTypeOf(p.get('invalid')).toEqualTypeOf<unknown>();
 
@@ -70,7 +66,7 @@ expectTypeOf(getPropertiesResult).toEqualTypeOf<{
 // @ts-expect-error doesn't have unknown properties
 getPropertiesResult.unknown;
 
-expectTypeOf(p.set('firstName', 'Joe')).toEqualTypeOf<string>();
+expectTypeOf(p.set('firstName', 'Joe')).toBeString();
 expectTypeOf(p.set('invalid', 1)).toEqualTypeOf<number>();
 
 const setPropertiesResult = p.setProperties({ firstName: 'Joe', invalid: 1 });
diff --git a/packages/@ember/object/type-tests/internals/cache-for.test.ts b/packages/@ember/object/type-tests/internals/cache-for.test.ts
index fcfcebe7e16..df054107e15 100644
--- a/packages/@ember/object/type-tests/internals/cache-for.test.ts
+++ b/packages/@ember/object/type-tests/internals/cache-for.test.ts
@@ -4,5 +4,5 @@ import { cacheFor } from '@ember/object/-internals';
 
 expectTypeOf(cacheFor).toEqualTypeOf<(obj: object, key: string) => unknown>();
 
-expectTypeOf(cacheFor({ foo: 1 }, 'foo')).toEqualTypeOf<unknown>();
+expectTypeOf(cacheFor({ foo: 1 }, 'foo')).toEqualTypeOf<number | undefined>();
 expectTypeOf(cacheFor({ foo: 1 }, 'other')).toEqualTypeOf<unknown>();
diff --git a/packages/@ember/routing/hash-location.ts b/packages/@ember/routing/hash-location.ts
index 2d73b642916..ce86f98d3fa 100644
--- a/packages/@ember/routing/hash-location.ts
+++ b/packages/@ember/routing/hash-location.ts
@@ -173,9 +173,3 @@ export default class HashLocation extends EmberObject implements EmberLocation {
     }
   }
 }
-
-declare module '@ember/routing/location' {
-  export interface Registry {
-    hash: HashLocation;
-  }
-}
diff --git a/packages/@ember/routing/history-location.ts b/packages/@ember/routing/history-location.ts
index c3622b9d73e..8c819e36e82 100644
--- a/packages/@ember/routing/history-location.ts
+++ b/packages/@ember/routing/history-location.ts
@@ -285,9 +285,3 @@ export default class HistoryLocation extends EmberObject implements EmberLocatio
     }
   }
 }
-
-declare module '@ember/routing/location' {
-  export interface Registry {
-    history: HistoryLocation;
-  }
-}
diff --git a/packages/@ember/routing/lib/controller_for.ts b/packages/@ember/routing/lib/controller_for.ts
index a4c7ada89da..a6557f57e3f 100644
--- a/packages/@ember/routing/lib/controller_for.ts
+++ b/packages/@ember/routing/lib/controller_for.ts
@@ -1,4 +1,5 @@
 import type { Container } from '@ember/-internals/container';
+import type { FactoryClass, InternalFactory } from '@ember/-internals/owner';
 import type { RegisterOptions } from '@ember/owner';
 
 /**
@@ -16,6 +17,6 @@ export default function controllerFor(
   container: Container,
   controllerName: string,
   lookupOptions: RegisterOptions
-) {
+): InternalFactory<object, FactoryClass> | object | undefined {
   return container.lookup(`controller:${controllerName}`, lookupOptions);
 }
diff --git a/packages/@ember/routing/lib/router_state.ts b/packages/@ember/routing/lib/router_state.ts
index 7a5be9eb204..4f9475d9e2d 100644
--- a/packages/@ember/routing/lib/router_state.ts
+++ b/packages/@ember/routing/lib/router_state.ts
@@ -4,11 +4,15 @@ import { shallowEqual } from './utils';
 import type Route from '@ember/routing/route';
 import type EmberRouter from '@ember/routing/router';
 
-export default class RouterState<R extends Route> {
-  router: Router<R>;
-  emberRouter: EmberRouter<R>;
-  routerJsState: TransitionState<R>;
-  constructor(emberRouter: EmberRouter<R>, router: Router<R>, routerJsState: TransitionState<R>) {
+export default class RouterState {
+  router: Router<Route>;
+  emberRouter: EmberRouter;
+  routerJsState: TransitionState<Route>;
+  constructor(
+    emberRouter: EmberRouter,
+    router: Router<Route>,
+    routerJsState: TransitionState<Route>
+  ) {
     this.emberRouter = emberRouter;
     this.router = router;
     this.routerJsState = routerJsState;
@@ -16,7 +20,7 @@ export default class RouterState<R extends Route> {
 
   isActiveIntent(
     routeName: string,
-    models: ModelFor<R>[],
+    models: ModelFor<Route>[],
     queryParams?: Record<string, unknown>
   ): boolean {
     let state = this.routerJsState;
diff --git a/packages/@ember/routing/lib/routing-service.ts b/packages/@ember/routing/lib/routing-service.ts
index 92bb0392cfb..a3d4758bbe5 100644
--- a/packages/@ember/routing/lib/routing-service.ts
+++ b/packages/@ember/routing/lib/routing-service.ts
@@ -28,9 +28,9 @@ export default class RoutingService<R extends Route> extends Service {
   declare currentRouteName: EmberRouter['currentRouteName'];
   declare currentPath: EmberRouter['currentPath'];
 
-  [ROUTER]?: EmberRouter<R>;
+  [ROUTER]?: EmberRouter;
 
-  get router(): EmberRouter<R> {
+  get router(): EmberRouter {
     let router = this[ROUTER];
     if (router !== undefined) {
       return router;
@@ -104,7 +104,7 @@ export default class RoutingService<R extends Route> extends Service {
     contexts: ModelFor<R>[],
     queryParams: Record<string, unknown> | undefined,
     routeName: string,
-    routerState: RouterState<R>
+    routerState: RouterState
   ): boolean {
     let handlers = this.router._routerMicrolib.recognizer.handlersFor(routeName);
     let leafName = handlers[handlers.length - 1].handler;
diff --git a/packages/@ember/routing/lib/utils.ts b/packages/@ember/routing/lib/utils.ts
index f06c95e4988..9c423bbeead 100644
--- a/packages/@ember/routing/lib/utils.ts
+++ b/packages/@ember/routing/lib/utils.ts
@@ -3,7 +3,7 @@ import { getOwner } from '@ember/-internals/owner';
 import type { ControllerQueryParam, ControllerQueryParamType } from '@ember/controller';
 import { assert } from '@ember/debug';
 import EngineInstance from '@ember/engine/instance';
-import type { InternalRouteInfo, ModelFor } from 'router_js';
+import type { InternalRouteInfo } from 'router_js';
 import type Router from 'router_js';
 import { STATE_SYMBOL } from 'router_js';
 import type { ExtendedInternalRouteInfo } from '@ember/routing/route';
@@ -18,28 +18,28 @@ export type ExpandedControllerQueryParam = {
   type?: ControllerQueryParamType;
 };
 
-export type NamedRouteArgs<R extends Route> =
-  | [routeNameOrUrl: string, ...modelsAndOptions: [...ModelFor<R>[], RouteOptions]]
-  | [routeNameOrUrl: string, ...models: ModelFor<R>[]];
+export type NamedRouteArgs =
+  | [routeNameOrUrl: string, ...modelsAndOptions: [...unknown[], RouteOptions]]
+  | [routeNameOrUrl: string, ...models: unknown[]];
 
-export type UnnamedRouteArgs<R extends Route> =
-  | [...modelsAndOptions: [...ModelFor<R>[], RouteOptions]]
-  | [...models: ModelFor<R>[]]
+export type UnnamedRouteArgs =
+  | [...modelsAndOptions: [...unknown[], RouteOptions]]
+  | [...models: unknown[]]
   | [options: RouteOptions];
 
-export type RouteArgs<R extends Route> = NamedRouteArgs<R> | UnnamedRouteArgs<R>;
+export type RouteArgs = NamedRouteArgs | UnnamedRouteArgs;
 
-type ExtractedArgs<R extends Route> = {
+type ExtractedArgs = {
   routeName: string | undefined;
-  models: ModelFor<R>[];
+  models: unknown[];
   queryParams: Record<string, unknown>;
 };
 
 export type RouteOptions = { queryParams: Record<string, unknown> };
 
-export function extractRouteArgs<R extends Route>(args: RouteArgs<R>): ExtractedArgs<R> {
+export function extractRouteArgs(args: RouteArgs): ExtractedArgs {
   // SAFETY: This should just be the same thing
-  args = args.slice() as RouteArgs<R>;
+  args = args.slice() as RouteArgs;
 
   let possibleOptions = args[args.length - 1];
 
@@ -60,7 +60,7 @@ export function extractRouteArgs<R extends Route>(args: RouteArgs<R>): Extracted
   }
 
   // SAFTEY: We removed the name and options if they existed, only models left.
-  let models = args as ModelFor<R>[];
+  let models = args;
 
   return { routeName, models, queryParams };
 }
@@ -74,9 +74,9 @@ export function getActiveTargetName(router: Router<Route>): string {
   return lastRouteInfo.name;
 }
 
-export function stashParamNames<R extends Route>(
-  router: EmberRouter<R>,
-  routeInfos: Array<ExtendedInternalRouteInfo<R>> & { _namesStashed?: boolean }
+export function stashParamNames(
+  router: EmberRouter,
+  routeInfos: Array<ExtendedInternalRouteInfo<Route>> & { _namesStashed?: boolean }
 ): void {
   if (routeInfos['_namesStashed']) {
     return;
@@ -90,7 +90,7 @@ export function stashParamNames<R extends Route>(
   assert('has route info', routeInfo);
   let targetRouteName = routeInfo.name;
   let recogHandlers = router._routerMicrolib.recognizer.handlersFor(targetRouteName);
-  let dynamicParent: InternalRouteInfo<R>;
+  let dynamicParent: InternalRouteInfo<Route>;
 
   for (let i = 0; i < routeInfos.length; ++i) {
     let routeInfo = routeInfos[i];
@@ -104,11 +104,7 @@ export function stashParamNames<R extends Route>(
     routeInfo['_names'] = names;
 
     let route = routeInfo.route!;
-    // SAFETY: This cast should be idential. I don't understand why it is needed.
-    route._stashNames(
-      routeInfo as InternalRouteInfo<NonNullable<R>>,
-      dynamicParent! as InternalRouteInfo<NonNullable<R>>
-    );
+    route._stashNames(routeInfo, dynamicParent!);
   }
 
   routeInfos['_namesStashed'] = true;
@@ -237,7 +233,7 @@ export function resemblesURL(str: unknown): str is string {
 
   @private
 */
-export function prefixRouteNameArg<T extends NamedRouteArgs<Route> | UnnamedRouteArgs<Route>>(
+export function prefixRouteNameArg<T extends NamedRouteArgs | UnnamedRouteArgs>(
   route: Route,
   args: T
 ): T {
diff --git a/packages/@ember/routing/location-ext.d.ts b/packages/@ember/routing/location-ext.d.ts
new file mode 100644
index 00000000000..27705740712
--- /dev/null
+++ b/packages/@ember/routing/location-ext.d.ts
@@ -0,0 +1,18 @@
+// This module provides an 'extension' to the `@ember/routing/location` module
+// from the `@ember/routing` package, so that users can rely on
+// `owner.lookup('location:hash')` type checking and returning `HashLocation`
+// (and the same for other location types). Our type publishing infrastructure
+// will pass it through unchanged, so end users will get this extension.
+
+import '@ember/routing/location';
+import type HashLocation from '@ember/routing/hash-location';
+import type HistoryLocation from '@ember/routing/history-location';
+import type NoneLocation from '@ember/routing/none-location';
+
+declare module '@ember/routing/location' {
+  interface Registry {
+    hash: HashLocation;
+    history: HistoryLocation;
+    none: NoneLocation;
+  }
+}
diff --git a/packages/@ember/routing/location.ts b/packages/@ember/routing/location.ts
index 6aa5193c914..5c0a8a0d98d 100644
--- a/packages/@ember/routing/location.ts
+++ b/packages/@ember/routing/location.ts
@@ -123,9 +123,3 @@ export type UpdateCallback = (url: string) => void;
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface Registry extends Record<string, Location | undefined> {}
-
-declare module '@ember/owner' {
-  export interface DIRegistry {
-    location: Registry;
-  }
-}
diff --git a/packages/@ember/routing/none-location.ts b/packages/@ember/routing/none-location.ts
index 69a5f9d850e..17f950adec8 100644
--- a/packages/@ember/routing/none-location.ts
+++ b/packages/@ember/routing/none-location.ts
@@ -134,9 +134,3 @@ NoneLocation.reopen({
   path: '',
   rootURL: '/',
 });
-
-declare module '@ember/routing/location' {
-  export interface Registry {
-    none: NoneLocation;
-  }
-}
diff --git a/packages/@ember/routing/owner-ext.d.ts b/packages/@ember/routing/owner-ext.d.ts
new file mode 100644
index 00000000000..29f48018e9e
--- /dev/null
+++ b/packages/@ember/routing/owner-ext.d.ts
@@ -0,0 +1,11 @@
+// This module provides an 'extension' to the `@ember/owner` module from the
+// `@ember/routing/location` module. Our type publishing infrastructure will
+// pass it through unchanged, so end users will get this extension.
+
+import type { Registry } from '@ember/routing/location';
+
+declare module '@ember/owner' {
+  export interface DIRegistry {
+    location: Registry;
+  }
+}
diff --git a/packages/@ember/routing/route.ts b/packages/@ember/routing/route.ts
index ab201fecdb0..33388935909 100644
--- a/packages/@ember/routing/route.ts
+++ b/packages/@ember/routing/route.ts
@@ -23,13 +23,7 @@ import { dependentKeyCompat } from '@ember/object/compat';
 import { once } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 import type { Template, TemplateFactory } from '@glimmer/interfaces';
-import type {
-  InternalRouteInfo,
-  ModelFor,
-  Route as IRoute,
-  Transition,
-  TransitionState,
-} from 'router_js';
+import type { InternalRouteInfo, Route as IRoute, Transition, TransitionState } from 'router_js';
 import { PARAMS_SYMBOL, STATE_SYMBOL } from 'router_js';
 import type { QueryParam } from '@ember/routing/router';
 import EmberRouter from '@ember/routing/router';
@@ -57,7 +51,7 @@ export type QueryParamMeta = {
   };
 };
 
-type RouteTransitionState<R extends Route> = TransitionState<R> & {
+type RouteTransitionState = TransitionState<Route> & {
   fullQueryParams?: Record<string, unknown>;
   queryParamsFor?: Record<string, Record<string, unknown>>;
 };
@@ -83,7 +77,7 @@ const RENDER = Symbol('render');
   @since 1.0.0
   @public
 */
-interface Route<T = unknown> extends IRoute<T> {
+interface Route<Model = unknown> extends IRoute<Model>, ActionHandler, Evented {
   /**
     The `willTransition` action is fired at the beginning of any
     attempted transition with a `Transition` object as the sole
@@ -254,16 +248,21 @@ interface Route<T = unknown> extends IRoute<T> {
   error?(error: Error, transition: Transition): boolean | void;
 }
 
-class Route<T = unknown>
-  extends EmberObject.extend(ActionHandler, Evented)
-  implements IRoute, Evented
-{
+class Route<Model = unknown> extends EmberObject.extend(ActionHandler, Evented) implements IRoute {
   static isRouteFactory = true;
 
-  context = {} as T;
-  declare currentModel: T;
+  // These properties will end up appearing in the public interface because we
+  // `implements IRoute` from `router.js`, which has them as part of *its*
+  // public contract. We mark them as `@internal` so they at least signal to
+  // people subclassing `Route` that they should not use them.
+  /** @internal */
+  context = {} as Model;
+  /** @internal */
+  declare currentModel: Model;
 
+  /** @internal */
   _bucketCache!: BucketCache;
+  /** @internal */
   _internalName!: string;
 
   private _names: unknown;
@@ -272,7 +271,7 @@ class Route<T = unknown>
   declare _topLevelViewTemplate: any;
   declare _environment: any;
 
-  constructor(owner: Owner) {
+  constructor(owner?: Owner) {
     super(owner);
 
     if (owner) {
@@ -291,13 +290,6 @@ class Route<T = unknown>
     }
   }
 
-  // Implement Evented
-  declare on: (name: string, method: ((...args: any[]) => void) | string) => this;
-  declare one: (name: string, method: string | ((...args: any[]) => void)) => this;
-  declare trigger: (name: string, ...args: any[]) => any;
-  declare off: (name: string, method: string | ((...args: any[]) => void)) => this;
-  declare has: (name: string) => boolean;
-
   /**
     A hook you can implement to convert the route's model into parameters
     for the URL.
@@ -343,7 +335,7 @@ class Route<T = unknown>
     @since 1.0.0
     @public
   */
-  serialize(model: T | undefined, params: string[]): { [key: string]: unknown } | undefined {
+  serialize(model: Model | undefined, params: string[]): { [key: string]: unknown } | undefined {
     if (params.length < 1 || !model) {
       return;
     }
@@ -570,7 +562,7 @@ class Route<T = unknown>
     }
 
     // SAFETY: Since `_qp` is protected we can't infer the type
-    let qps = (get(this, '_qp') as Route<T>['_qp']).qps;
+    let qps = (get(this, '_qp') as Route<Model>['_qp']).qps;
 
     let namePaths = new Array(names.length);
     for (let a = 0; a < names.length; ++a) {
@@ -764,8 +756,11 @@ class Route<T = unknown>
     @since 1.7.0
     @public
   */
-  resetController(_controller: Controller, _isExiting: boolean, _transition: Transition) {
-    return this;
+  resetController(_controller: Controller, _isExiting: boolean, _transition: Transition): void {
+    // We document that subclasses do not have to return *anything* and in fact
+    // do not even have to call super, so whiel we *do* return `this`, we need
+    // to be explicit in the types that our return type is *effectively* `void`.
+    return this as unknown as void;
   }
 
   /**
@@ -788,7 +783,7 @@ class Route<T = unknown>
   _internalReset(isExiting: boolean, transition: Transition) {
     let controller = this.controller;
     // SAFETY: Since `_qp` is protected we can't infer the type
-    controller['_qpDelegate'] = (get(this, '_qp') as Route<T>['_qp']).states.inactive;
+    controller['_qpDelegate'] = (get(this, '_qp') as Route<Model>['_qp']).states.inactive;
 
     this.resetController(controller, isExiting, transition);
   }
@@ -883,7 +878,7 @@ class Route<T = unknown>
     @since 1.2.0
     @public
    */
-  intermediateTransitionTo(...args: NamedRouteArgs<this>): void {
+  intermediateTransitionTo(...args: NamedRouteArgs): void {
     let [name, ...preparedArgs] = prefixRouteNameArg(this, args);
     this._router.intermediateTransitionTo(name, ...preparedArgs);
   }
@@ -920,13 +915,13 @@ class Route<T = unknown>
     @private
     @method setup
   */
-  setup(context: T | undefined, transition: Transition) {
+  setup(context: Model | undefined, transition: Transition) {
     let controllerName = this.controllerName || this.routeName;
     let definedController = this.controllerFor(controllerName, true);
     let controller = definedController ?? this.generateController(controllerName);
 
     // SAFETY: Since `_qp` is protected we can't infer the type
-    let queryParams = get(this, '_qp') as Route<T>['_qp'];
+    let queryParams = get(this, '_qp') as Route<Model>['_qp'];
 
     // Assign the route's controller so that it can more easily be
     // referenced in action handlers. Side effects. Side effects everywhere.
@@ -1059,8 +1054,11 @@ class Route<T = unknown>
     @since 1.0.0
     @public
    */
-  afterModel(_resolvedModel: T | undefined, _transition: Transition): unknown | Promise<unknown>;
-  afterModel(_resolvedModel: T | undefined, _transition: Transition): void {}
+  afterModel(
+    _resolvedModel: Model | undefined,
+    _transition: Transition
+  ): unknown | Promise<unknown>;
+  afterModel(_resolvedModel: Model | undefined, _transition: Transition): void {}
 
   /**
     A hook you can implement to optionally redirect to another route.
@@ -1085,7 +1083,7 @@ class Route<T = unknown>
     @since 1.0.0
     @public
   */
-  redirect(_model: T, _transition: Transition) {}
+  redirect(_model: Model, _transition: Transition) {}
 
   /**
     Called when the context is changed by router.js.
@@ -1175,10 +1173,13 @@ class Route<T = unknown>
     @since 1.0.0
     @public
   */
-  model(params: Record<string, unknown>, transition: Transition): T | PromiseLike<T> | undefined {
+  model(
+    params: Record<string, unknown>,
+    transition: Transition
+  ): Model | PromiseLike<Model> | undefined {
     let name, sawParams, value;
     // SAFETY: Since `_qp` is protected we can't infer the type
-    let queryParams = (get(this, '_qp') as Route<T>['_qp']).map;
+    let queryParams = (get(this, '_qp') as Route<Model>['_qp']).map;
 
     for (let prop in params) {
       if (prop === 'queryParams' || (queryParams && prop in queryParams)) {
@@ -1196,15 +1197,15 @@ class Route<T = unknown>
     if (!name) {
       if (sawParams) {
         // SAFETY: This should be equivalent
-        return Object.assign({}, params) as T;
+        return Object.assign({}, params) as Model;
       } else {
         if (transition.resolveIndex < 1) {
           return;
         }
         // SAFETY: This should be correct, but TS is unable to infer this.
         return transition[STATE_SYMBOL]!.routeInfos[transition.resolveIndex - 1]!.context as
-          | T
-          | PromiseLike<T>
+          | Model
+          | PromiseLike<Model>
           | undefined;
       }
     }
@@ -1221,7 +1222,7 @@ class Route<T = unknown>
 
     Router.js hook.
    */
-  deserialize(_params: {}, transition: Transition) {
+  deserialize(_params: Record<string, unknown>, transition: Transition) {
     return this.model(this._paramsFor(this.routeName, _params), transition);
   }
 
@@ -1306,7 +1307,7 @@ class Route<T = unknown>
     @since 1.0.0
     @public
   */
-  setupController(controller: Controller, context: T | undefined, _transition?: Transition) {
+  setupController(controller: Controller, context: Model | undefined, _transition?: Transition) {
     if (controller && context !== undefined) {
       set(controller, 'model', context);
     }
@@ -1548,7 +1549,7 @@ class Route<T = unknown>
   buildRouteInfoMetadata(): unknown;
   buildRouteInfoMetadata(): void {}
 
-  private _paramsFor(routeName: string, params: {}) {
+  private _paramsFor(routeName: string, params: Record<string, unknown>) {
     let transition = this._router._routerMicrolib.activeTransition;
     if (transition !== undefined) {
       return this.paramsFor(routeName);
@@ -1965,10 +1966,7 @@ type PartialRenderOptions = Partial<
   Pick<RenderOptions, 'into' | 'outlet' | 'controller' | 'model'>
 >;
 
-export function getFullQueryParams<R extends Route>(
-  router: EmberRouter<R>,
-  state: RouteTransitionState<R>
-) {
+export function getFullQueryParams(router: EmberRouter, state: RouteTransitionState) {
   if (state.fullQueryParams) {
     return state.fullQueryParams;
   }
@@ -1991,10 +1989,7 @@ export function getFullQueryParams<R extends Route>(
   return fullQueryParamsState;
 }
 
-function getQueryParamsFor<R extends Route>(
-  route: R,
-  state: RouteTransitionState<R>
-): Record<string, unknown> {
+function getQueryParamsFor(route: Route, state: RouteTransitionState): Record<string, unknown> {
   state.queryParamsFor = state.queryParamsFor || {};
   let name = route.fullRouteName;
 
@@ -2009,7 +2004,7 @@ function getQueryParamsFor<R extends Route>(
 
   // Copy over all the query params for this route/controller into params hash.
   // SAFETY: Since `_qp` is protected we can't infer the type
-  let qps = (get(route, '_qp') as Route<ModelFor<R>>['_qp']).qps;
+  let qps = (get(route, '_qp') as Route['_qp']).qps;
   for (let qp of qps) {
     // Put deserialized qp on params hash.
     let qpValueWasPassedIn = qp.prop in fullQueryParams;
diff --git a/packages/@ember/routing/router-service.ts b/packages/@ember/routing/router-service.ts
index 37df40ca91b..1c29a9479f7 100644
--- a/packages/@ember/routing/router-service.ts
+++ b/packages/@ember/routing/router-service.ts
@@ -55,12 +55,16 @@ function cleanURL(url: string, rootURL: string) {
    @extends Service
    @class RouterService
  */
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-interface RouterService<R extends Route> extends Evented {}
-class RouterService<R extends Route> extends Service.extend(Evented) {
-  [ROUTER]?: EmberRouter<R>;
+interface RouterService extends Evented {
+  on(
+    eventName: 'routeWillChange' | 'routeDidChange',
+    callback: (transition: Transition) => void
+  ): this;
+}
+class RouterService extends Service.extend(Evented) {
+  [ROUTER]?: EmberRouter;
 
-  get _router(): EmberRouter<R> {
+  get _router(): EmberRouter {
     let router = this[ROUTER];
     if (router !== undefined) {
       return router;
@@ -127,7 +131,7 @@ class RouterService<R extends Route> extends Service.extend(Evented) {
        attempted transition
      @public
    */
-  transitionTo(...args: RouteArgs<R>): Transition {
+  transitionTo(...args: RouteArgs): Transition {
     if (resemblesURL(args[0])) {
       // NOTE: this `args[0] as string` cast is safe and TS correctly infers it
       // in 3.6+, so it can be removed when TS is upgraded.
@@ -178,7 +182,7 @@ class RouterService<R extends Route> extends Service.extend(Evented) {
        attempted transition
      @public
    */
-  replaceWith(...args: RouteArgs<R>): Transition {
+  replaceWith(...args: RouteArgs): Transition {
     return this.transitionTo(...args).method('replace');
   }
 
@@ -250,7 +254,10 @@ class RouterService<R extends Route> extends Service.extend(Evented) {
      @return {String} the string representing the generated URL
      @public
    */
-  urlFor(routeName: string, ...args: ModelFor<R>[] | [...ModelFor<R>[], RouteOptions]) {
+  urlFor<R extends Route>(
+    routeName: string,
+    ...args: ModelFor<R>[] | [...ModelFor<R>[], RouteOptions]
+  ) {
     this._router.setupRouter();
     return this._router.generate(routeName, ...args);
   }
@@ -302,7 +309,7 @@ class RouterService<R extends Route> extends Service.extend(Evented) {
      @return {boolean} true if the provided routeName/models/queryParams are active
      @public
    */
-  isActive(...args: RouteArgs<R>) {
+  isActive(...args: RouteArgs) {
     let { routeName, models, queryParams } = extractRouteArgs(args);
     let routerMicrolib = this._router._routerMicrolib;
 
@@ -581,7 +588,6 @@ class RouterService<R extends Route> extends Service.extend(Evented) {
     assert('RouterService is unexpectedly missing an owner', owner);
     let pivotRoute = owner.lookup(`route:${pivotRouteName}`) as Route;
 
-    // @ts-expect-error R could be instantiated with a different sub-type
     return this._router._routerMicrolib.refresh(pivotRoute);
   }
 
@@ -746,9 +752,3 @@ class RouterService<R extends Route> extends Service.extend(Evented) {
 }
 
 export { RouterService as default, RouteInfo, RouteInfoWithAttributes };
-
-declare module '@ember/service' {
-  interface Registry {
-    router: RouterService<Route>;
-  }
-}
diff --git a/packages/@ember/routing/router.ts b/packages/@ember/routing/router.ts
index 326b73d36bc..dbe51bfbc89 100644
--- a/packages/@ember/routing/router.ts
+++ b/packages/@ember/routing/router.ts
@@ -46,7 +46,7 @@ import type {
   TransitionState,
 } from 'router_js';
 import Router, { logAbort, STATE_SYMBOL } from 'router_js';
-import type { Timer } from 'backburner';
+import type { Timer } from 'backburner.js';
 import EngineInstance from '@ember/engine/instance';
 import type { QueryParams } from 'route-recognizer';
 import type { AnyFn, MethodNamesOf, OmitFirst } from '@ember/-internals/utility-types';
@@ -57,10 +57,7 @@ import type ApplicationInstance from '@ember/application/instance';
 @module @ember/routing/router
 */
 
-function defaultDidTransition<R extends Route>(
-  this: EmberRouter<R>,
-  infos: InternalRouteInfo<R>[]
-) {
+function defaultDidTransition(this: EmberRouter, infos: InternalRouteInfo<Route>[]) {
   updatePaths(this);
 
   this._cancelSlowTransitionTimer();
@@ -77,10 +74,10 @@ function defaultDidTransition<R extends Route>(
   }
 }
 
-function defaultWillTransition<R extends Route>(
-  this: EmberRouter<R>,
-  oldInfos: InternalRouteInfo<R>[],
-  newInfos: InternalRouteInfo<R>[]
+function defaultWillTransition(
+  this: EmberRouter,
+  oldInfos: InternalRouteInfo<Route>[],
+  newInfos: InternalRouteInfo<Route>[]
 ) {
   if (DEBUG) {
     // @ts-expect-error namespace isn't public
@@ -154,7 +151,7 @@ const { slice } = Array.prototype;
   @uses Evented
   @public
 */
-class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) implements Evented {
+class EmberRouter extends EmberObject.extend(Evented) implements Evented {
   /**
    Represents the URL of the root of the application, often '/'. This prefix is
     assumed on all routes defined on this router.
@@ -187,7 +184,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
   // Set with reopen to allow overriding via extend
   declare location: (keyof LocationRegistry & string) | EmberLocation;
 
-  _routerMicrolib!: Router<R>;
+  _routerMicrolib!: Router<Route>;
   _didSetupRouter = false;
   _initialTransitionStarted = false;
 
@@ -207,7 +204,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
   _handledErrors = new Set();
   _engineInstances: Record<string, Record<string, EngineInstance>> = Object.create(null);
   _engineInfoByRoute = Object.create(null);
-  _routerService: RouterService<R>;
+  _routerService: RouterService;
 
   _slowTransitionTimer: Timer | null = null;
 
@@ -325,7 +322,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     assert('BUG: BucketCache should always be present', bucketCache instanceof BucketCache);
     this._bucketCache = bucketCache;
 
-    let routerService = owner.lookup('service:router') as RouterService<R> | undefined;
+    let routerService = owner.lookup('service:router') as RouterService | undefined;
     assert('BUG: RouterService should always be present', routerService !== undefined);
     this._routerService = routerService;
   }
@@ -337,8 +334,8 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     assert('Router is unexpectedly missing an owner', owner);
     let seen = Object.create(null);
 
-    class PrivateRouter extends Router<R> {
-      getRoute(name: string): R {
+    class PrivateRouter extends Router<Route> {
+      getRoute(name: string): Route {
         let routeName = name;
         let routeOwner = owner;
         let engineInfo = router._engineInfoByRoute[routeName];
@@ -354,7 +351,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
 
         assert('Route is unexpectedly missing an owner', routeOwner);
 
-        let route = routeOwner.lookup(fullRouteName) as R | undefined;
+        let route = routeOwner.lookup(fullRouteName) as Route | undefined;
 
         if (seen[name]) {
           assert('seen routes should exist', route);
@@ -368,7 +365,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
           // `@ember/application/lib` package.
           let DefaultRoute: any = routeOwner.factoryFor('route:basic')!.class;
           routeOwner.register(fullRouteName, DefaultRoute.extend());
-          route = routeOwner.lookup(fullRouteName) as R;
+          route = routeOwner.lookup(fullRouteName) as Route;
 
           if (DEBUG) {
             if (router.namespace.LOG_ACTIVE_GENERATION) {
@@ -407,25 +404,25 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
       }
 
       // TODO: merge into routeDidChange
-      didTransition(infos: InternalRouteInfo<R>[]) {
+      didTransition(infos: InternalRouteInfo<Route>[]) {
         assert(
           'You attempted to override the "didTransition" method which has been deprecated. Please inject the router service and listen to the "routeDidChange" event.',
           router.didTransition === defaultDidTransition
         );
-        router.didTransition<R>(infos);
+        router.didTransition(infos);
       }
 
       // TODO: merge into routeWillChange
-      willTransition(oldInfos: InternalRouteInfo<R>[], newInfos: InternalRouteInfo<R>[]) {
+      willTransition(oldInfos: InternalRouteInfo<Route>[], newInfos: InternalRouteInfo<Route>[]) {
         assert(
           'You attempted to override the "willTransition" method which has been deprecated. Please inject the router service and listen to the "routeWillChange" event.',
           router.willTransition === defaultWillTransition
         );
-        router.willTransition<R>(oldInfos, newInfos);
+        router.willTransition(oldInfos, newInfos);
       }
 
       triggerEvent<N extends MethodNamesOf<typeof defaultActionHandlers>>(
-        routeInfos: InternalRouteInfo<R>[],
+        routeInfos: InternalRouteInfo<Route>[],
         ignoreFailure: boolean,
         name: N,
         args: OmitFirst<Parameters<typeof defaultActionHandlers[N]>>
@@ -719,7 +716,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
       attempted transition
     @public
   */
-  transitionTo(...args: RouteArgs<R>): Transition {
+  transitionTo(...args: RouteArgs): Transition {
     if (resemblesURL(args[0])) {
       assert(
         `A transition was attempted from '${this.currentRouteName}' to '${args[0]}' but the application instance has already been destroyed.`,
@@ -727,7 +724,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
       );
       return this._doURLTransition('transitionTo', args[0]);
     }
-    let { routeName, models, queryParams } = extractRouteArgs<R>(args);
+    let { routeName, models, queryParams } = extractRouteArgs(args);
     assert(
       `A transition was attempted from '${this.currentRouteName}' to '${routeName}' but the application instance has already been destroyed.`,
       !this.isDestroying && !this.isDestroyed
@@ -767,11 +764,11 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
       attempted transition
     @public
   */
-  replaceWith(...args: RouteArgs<R>): Transition {
+  replaceWith(...args: RouteArgs): Transition {
     return this.transitionTo(...args).method('replace');
   }
 
-  generate(name: string, ...args: ModelFor<R>[] | [...ModelFor<R>[], RouteOptions]) {
+  generate(name: string, ...args: ModelFor<Route>[] | [...ModelFor<Route>[], RouteOptions]) {
     let url = this._routerMicrolib.generate(name, ...args);
     assert('expected non-string location', typeof this.location !== 'string');
     return this.location.formatURL(url);
@@ -802,7 +799,11 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     @private
     @since 1.7.0
   */
-  isActiveIntent(routeName: string, models: ModelFor<R>[], queryParams: Record<string, unknown>) {
+  isActiveIntent(
+    routeName: string,
+    models: ModelFor<Route>[],
+    queryParams: Record<string, unknown>
+  ) {
     return this.currentState!.isActiveIntent(routeName, models, queryParams);
   }
 
@@ -852,7 +853,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
       let instanceMap = instances[name];
       assert('has instanceMap', instanceMap);
       for (let id in instanceMap) {
-        let instance = instanceMap[id];
+        let instance: EngineInstance | undefined = instanceMap[id];
         assert('has instance', instance);
         run(instance, 'destroy');
       }
@@ -931,7 +932,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     @return {Void}
   */
   _serializeQueryParams(
-    routeInfos: InternalRouteInfo<R>[],
+    routeInfos: InternalRouteInfo<Route>[],
     queryParams: Record<string, unknown>
   ): asserts queryParams is Record<string, string | null | undefined> {
     forEachQueryParam(
@@ -979,7 +980,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     @return {Void}
   */
   _deserializeQueryParams(
-    routeInfos: InternalRouteInfo<R>[],
+    routeInfos: InternalRouteInfo<Route>[],
     queryParams: Record<string, unknown>
   ) {
     forEachQueryParam(
@@ -1029,7 +1030,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     @return {Void}
   */
   _pruneDefaultQueryParamValues(
-    routeInfos: InternalRouteInfo<R>[],
+    routeInfos: InternalRouteInfo<Route>[],
     queryParams: Record<string, string | null | undefined>
   ) {
     let qps = this._queryParamsFor(routeInfos);
@@ -1043,7 +1044,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
 
   _doTransition(
     _targetRouteName: string | undefined,
-    models: ModelFor<R>[],
+    models: ModelFor<Route>[],
     _queryParams: Record<string, unknown>,
     _fromRouterService?: boolean
   ): Transition {
@@ -1072,7 +1073,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
 
   _processActiveTransitionQueryParams(
     targetRouteName: string,
-    models: ModelFor<R>[],
+    models: ModelFor<Route>[],
     queryParams: Record<string, unknown>,
     _queryParams: {}
   ) {
@@ -1113,7 +1114,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
   */
   _prepareQueryParams(
     targetRouteName: string,
-    models: ModelFor<R>[],
+    models: ModelFor<Route>[],
     queryParams: Record<string, unknown>,
     _fromRouterService?: boolean
   ) {
@@ -1135,7 +1136,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     @param {RouteInfo} routeInfo
     @return {Object}
   */
-  _getQPMeta(routeInfo: InternalRouteInfo<R>) {
+  _getQPMeta(routeInfo: InternalRouteInfo<Route>) {
     let route = routeInfo.route;
     return route && (get(route, '_qp') as Route['_qp']);
   }
@@ -1149,7 +1150,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     @param {Array<RouteInfo>} routeInfos
     @return {Object}
    */
-  _queryParamsFor(routeInfos: InternalRouteInfo<R>[]) {
+  _queryParamsFor(routeInfos: InternalRouteInfo<Route>[]) {
     let routeInfoLength = routeInfos.length;
     let leafRouteName = routeInfos[routeInfoLength - 1]!.name;
     let cached = this._qpCache[leafRouteName];
@@ -1213,7 +1214,11 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     @param {Object} queryParams
     @return {Void}
   */
-  _fullyScopeQueryParams(leafRouteName: string, contexts: ModelFor<R>[], queryParams: QueryParams) {
+  _fullyScopeQueryParams(
+    leafRouteName: string,
+    contexts: ModelFor<Route>[],
+    queryParams: QueryParams
+  ) {
     let state = calculatePostTransitionState(this, leafRouteName, contexts);
     let routeInfos = state.routeInfos;
     let qpMeta;
@@ -1252,7 +1257,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     @return {Void}
   */
   _hydrateUnsuppliedQueryParams(
-    state: TransitionState<R>,
+    state: TransitionState<Route>,
     queryParams: QueryParams,
     _fromRouterService: boolean
   ): void {
@@ -1327,8 +1332,8 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     );
   }
 
-  currentState: null | RouterState<R> = null;
-  targetState = null;
+  currentState: null | RouterState = null;
+  targetState: null | RouterState = null;
 
   _handleSlowTransition(transition: Transition, originRoute: Route) {
     if (!this._routerMicrolib.activeTransition) {
@@ -1487,9 +1492,9 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
   @param {Function} callback
   @return {Void}
  */
-function forEachRouteAbove<R extends Route>(
-  routeInfos: InternalRouteInfo<R>[],
-  callback: (route: R, routeInfo: InternalRouteInfo<R>) => boolean
+function forEachRouteAbove(
+  routeInfos: InternalRouteInfo<Route>[],
+  callback: (route: Route, routeInfo: InternalRouteInfo<Route>) => boolean
 ) {
   for (let i = routeInfos.length - 1; i >= 0; --i) {
     let routeInfo = routeInfos[i];
@@ -1518,8 +1523,8 @@ function forEachRouteAbove<R extends Route>(
 // and are not meant to be overridable.
 let defaultActionHandlers = {
   willResolveModel<R extends Route>(
-    this: EmberRouter<R>,
-    _routeInfos: InternalRouteInfo<R>[],
+    this: EmberRouter,
+    _routeInfos: InternalRouteInfo<Route>[],
     transition: Transition,
     originRoute: R
   ) {
@@ -1527,9 +1532,9 @@ let defaultActionHandlers = {
   },
 
   // Attempt to find an appropriate error route or substate to enter.
-  error<R extends Route>(
-    this: EmberRouter<R>,
-    routeInfos: InternalRouteInfo<R>[],
+  error(
+    this: EmberRouter,
+    routeInfos: InternalRouteInfo<Route>[],
     error: Error,
     transition: Transition
   ) {
@@ -1537,7 +1542,7 @@ let defaultActionHandlers = {
 
     let routeInfoWithError = routeInfos[routeInfos.length - 1];
 
-    forEachRouteAbove(routeInfos, (route: R, routeInfo: InternalRouteInfo<R>) => {
+    forEachRouteAbove(routeInfos, (route, routeInfo) => {
       // We don't check the leaf most routeInfo since that would
       // technically be below where we're at in the route hierarchy.
       if (routeInfo !== routeInfoWithError) {
@@ -1565,16 +1570,12 @@ let defaultActionHandlers = {
   },
 
   // Attempt to find an appropriate loading route or substate to enter.
-  loading<R extends Route>(
-    this: EmberRouter<R>,
-    routeInfos: InternalRouteInfo<R>[],
-    transition: Transition
-  ) {
+  loading(this: EmberRouter, routeInfos: InternalRouteInfo<Route>[], transition: Transition) {
     let router = this;
 
     let routeInfoWithSlowLoading = routeInfos[routeInfos.length - 1];
 
-    forEachRouteAbove(routeInfos, (route: R, routeInfo: InternalRouteInfo<R>) => {
+    forEachRouteAbove(routeInfos, (route, routeInfo) => {
       // We don't check the leaf most routeInfos since that would
       // technically be below where we're at in the route hierarchy.
       if (routeInfo !== routeInfoWithSlowLoading) {
@@ -1689,12 +1690,9 @@ function routeHasBeenDefined(owner: Owner, router: any, localName: string, fullN
   return routerHasRoute && ownerHasRoute;
 }
 
-export function triggerEvent<
-  R extends Route,
-  N extends MethodNamesOf<typeof defaultActionHandlers>
->(
-  this: EmberRouter<R>,
-  routeInfos: InternalRouteInfo<R>[],
+export function triggerEvent<N extends MethodNamesOf<typeof defaultActionHandlers>>(
+  this: EmberRouter,
+  routeInfos: InternalRouteInfo<Route>[],
   ignoreFailure: boolean,
   name: N,
   args: OmitFirst<Parameters<typeof defaultActionHandlers[N]>>
@@ -1745,7 +1743,7 @@ export function triggerEvent<
 }
 
 function calculatePostTransitionState<R extends Route>(
-  emberRouter: EmberRouter<R>,
+  emberRouter: EmberRouter,
   leafRouteName: string,
   contexts: ModelFor<R>[]
 ) {
@@ -1799,9 +1797,9 @@ function didBeginTransition(transition: Transition, router: EmberRouter) {
   }, 'Transition Error');
 }
 
-function forEachQueryParam<R extends Route>(
-  router: EmberRouter<R>,
-  routeInfos: InternalRouteInfo<R>[],
+function forEachQueryParam(
+  router: EmberRouter,
+  routeInfos: InternalRouteInfo<Route>[],
   queryParams: Record<string, unknown>,
   callback: (key: string, value: unknown, qp: QueryParam | undefined) => void
 ) {
@@ -1900,7 +1898,7 @@ EmberRouter.reopen({
 
   // FIXME: Does this need to be overrideable via extend?
   url: computed(function (this: EmberRouter) {
-    let location = get(this, 'location') as string | EmberLocation;
+    let location = get(this, 'location');
 
     if (typeof location === 'string') {
       return undefined;
diff --git a/packages/@ember/routing/service-ext.d.ts b/packages/@ember/routing/service-ext.d.ts
new file mode 100644
index 00000000000..987fcd8977e
--- /dev/null
+++ b/packages/@ember/routing/service-ext.d.ts
@@ -0,0 +1,14 @@
+// This module provides an 'extension' to the `@ember/service` module from the
+// `@ember/routing` package, so that users can rely on `@service('router')` type
+// checking and `Owner.lookup('service:router')` returning `RouterService`. Our
+// type publishing infrastructure will pass it through unchanged, so end users
+// will get this extension.
+
+import '@ember/service';
+import type RouterService from '@ember/routing/router-service';
+
+declare module '@ember/service' {
+  export interface Registry {
+    router: RouterService;
+  }
+}
diff --git a/packages/@ember/routing/type-tests/router-service.test.ts b/packages/@ember/routing/type-tests/router-service.test.ts
index 7b73f046016..bf8f252eb29 100644
--- a/packages/@ember/routing/type-tests/router-service.test.ts
+++ b/packages/@ember/routing/type-tests/router-service.test.ts
@@ -5,7 +5,6 @@ import type {
   default as EmberLocation,
   Registry as LocationRegistry,
 } from '@ember/routing/location';
-import type Route from '@ember/routing/route';
 import type { RouteInfo, RouteInfoWithAttributes } from '@ember/routing/router-service';
 import RouterService from '@ember/routing/router-service';
 import { expectTypeOf } from 'expect-type';
@@ -18,7 +17,7 @@ let owner = {} as Owner;
 class Post {}
 class Comment {}
 
-let router = new RouterService<Route<Post | Comment>>(owner);
+let router = new RouterService(owner);
 
 let aPost = new Post();
 let aComment = new Comment();
diff --git a/packages/@ember/runloop/-private/backburner.ts b/packages/@ember/runloop/-private/backburner.ts
new file mode 100644
index 00000000000..d75ed9d1466
--- /dev/null
+++ b/packages/@ember/runloop/-private/backburner.ts
@@ -0,0 +1,16 @@
+// This exists solely to provide a compatibility shim for `ember-test-helpers`
+// as part of the transition off of DefinitelyTyped. Long-term, this should be
+// structured differently:
+//
+// 1. `backburner.js` should provide actual public types for things which are
+//    actually part of its public contract: these are currently used in key
+//    areas as "intimate" API.
+// 2. `ember-test-helpers` should use the types from `backburner.js` directly,
+//    rather than relying on Ember's re-export.
+
+import type Backburner from 'backburner.js';
+export type { Backburner };
+export type DebugInfo = ReturnType<Backburner['getDebugInfo']>;
+
+export { IQueueItem as QueueItem } from 'backburner.js/dist/backburner/interfaces';
+export { DeferredActionQueues } from 'backburner.js';
diff --git a/packages/@ember/runloop/index.ts b/packages/@ember/runloop/index.ts
index 187834fe8f5..bb2494c03a1 100644
--- a/packages/@ember/runloop/index.ts
+++ b/packages/@ember/runloop/index.ts
@@ -1,8 +1,7 @@
 import { assert } from '@ember/debug';
 import { onErrorTarget } from '@ember/-internals/error-handling';
 import { flushAsyncObservers } from '@ember/-internals/metal';
-import type { DeferredActionQueues } from 'backburner';
-import Backburner, { Timer } from 'backburner';
+import Backburner, { Timer, type DeferredActionQueues } from 'backburner.js';
 import type { AnyFn } from '@ember/-internals/utility-types';
 
 export { Timer };
@@ -86,6 +85,10 @@ export const _queues = [
   _rsvpErrorQueue,
 ];
 
+/**
+ * @internal
+ * @private
+ */
 export const _backburner = new Backburner(_queues, {
   defaultQueue: 'actions',
   onBegin,
@@ -292,6 +295,14 @@ export function bind<
 ): T[U] extends AnyFn
   ? (...args: RemainingParams<A, Parameters<T[U]>>) => ReturnType<T[U]> | void
   : never;
+// This final fallback is the equivalent of the (quite unsafe!) type for `bind`
+// from TS' defs for `Function.prototype.bind`. In general, it means we have a
+// loss of safety if we do not
+export function bind<T, M extends keyof T & PropertyKey>(
+  target: T,
+  methodName: M,
+  ...args: any[]
+): (...args: any[]) => unknown;
 export function bind(...curried: any[]): any {
   assert(
     'could not find a suitable method to bind',
@@ -760,11 +771,11 @@ export function next(...args: any[]) {
   @method cancel
   @static
   @for @ember/runloop
-  @param {Object} timer Timer object to cancel
+  @param {Object} [timer] Timer object to cancel
   @return {Boolean} true if canceled or false/undefined if it wasn't found
   @public
 */
-export function cancel(timer: Timer): boolean {
+export function cancel(timer?: Timer): boolean {
   return _backburner.cancel(timer);
 }
 
diff --git a/packages/@ember/runloop/type-tests/bind.test.ts b/packages/@ember/runloop/type-tests/bind.test.ts
index f8886aed0c2..9ef518bafa7 100644
--- a/packages/@ember/runloop/type-tests/bind.test.ts
+++ b/packages/@ember/runloop/type-tests/bind.test.ts
@@ -135,4 +135,8 @@ expectTypeOf(bind(foo, 'test', 1, true, 'baz')).toEqualTypeOf<() => number | voi
 expectTypeOf(bind(foo, 'test', 1, true, undefined)).toEqualTypeOf<() => number | void>();
 
 // @ts-expect-error Invalid args
-bind(foo, 'test', 'string');
+bind(foo, foo.test, 'string');
+// We would like to catch this, but it ends up in the fallback path. This type
+// test simply asserts as much, so that if we change that behavior we will know
+// about it.
+expectTypeOf(bind(foo, 'test', 'string')).toEqualTypeOf<(...args: any[]) => unknown>();
diff --git a/packages/@ember/service/index.ts b/packages/@ember/service/index.ts
index e5b271fec30..5ae8075f5a0 100644
--- a/packages/@ember/service/index.ts
+++ b/packages/@ember/service/index.ts
@@ -97,12 +97,29 @@ export default class Service extends FrameworkObject {
 /**
   A type registry for Ember `Service`s. Meant to be declaration-merged so string
   lookups resolve to the correct type.
- */
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface Registry {}
 
-declare module '@ember/owner' {
-  export interface DIRegistry {
-    service: Registry;
+  Blueprints should include such a declaration merge for TypeScript:
+
+  ```ts
+  import Service from '@ember/service';
+
+  export default class ExampleService extends Service {
+    // ...
   }
-}
+
+  declare module '@ember/service' {
+    export interface Registry {
+      example: ExampleService;
+    }
+  }
+  ```
+
+  Then `@service` can check that the service is registered correctly, and APIs
+  like `owner.lookup('service:example')` can return `ExampleService`.
+ */
+// NOTE: this cannot be `Record<string, Service | undefined>`, convenient as
+// that would be for end users, because there is no actual contract to that
+// effect with Ember -- and in the future this choice would allow us to have
+// registered services which have no base class.
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface Registry extends Record<string, object | undefined> {}
diff --git a/packages/@ember/service/owner-ext.d.ts b/packages/@ember/service/owner-ext.d.ts
new file mode 100644
index 00000000000..8e166bc074b
--- /dev/null
+++ b/packages/@ember/service/owner-ext.d.ts
@@ -0,0 +1,11 @@
+// This module provides an 'extension' to the `@ember/owner` module from the
+// `@ember/service` module. Our type publishing infrastructure will pass it
+// through unchanged, so end users will get this extension.
+
+import type { Registry } from '@ember/service';
+
+declare module '@ember/owner' {
+  export interface DIRegistry {
+    service: Registry;
+  }
+}
diff --git a/packages/@ember/template-compilation/index.ts b/packages/@ember/template-compilation/index.ts
index 05536649991..6fdbd508702 100644
--- a/packages/@ember/template-compilation/index.ts
+++ b/packages/@ember/template-compilation/index.ts
@@ -1,8 +1,33 @@
 import { DEBUG } from '@glimmer/env';
+import type { TemplateFactory } from '@glimmer/interfaces';
 
 export { compile as compileTemplate } from 'ember-template-compiler';
 
-export let precompileTemplate: (() => never) | undefined;
+interface CommonOptions {
+  moduleName?: string;
+}
+
+interface LooseModeOptions extends CommonOptions {
+  strictMode?: false;
+}
+
+interface StrictModeOptions extends CommonOptions {
+  strictMode: true;
+  scope: () => Record<string, unknown>;
+}
+
+// (UN)SAFETY: the public API is that people can import and use this (and indeed
+// it is emitted as part of Ember's build!), so we define it as having the type
+// which makes that work. However, in practice it is supplied by the build,
+// *for* the build, and will *not* be present at runtime, so the actual value
+// here is `undefined` in prod; in dev it is a function which throws a somewhat
+// nicer error. This is janky, but... here we are.
+interface PrecompileTemplate {
+  (templateString: string, options?: LooseModeOptions): TemplateFactory;
+  (templateString: string, options: StrictModeOptions): TemplateFactory;
+}
+
+export let precompileTemplate: PrecompileTemplate;
 
 if (DEBUG) {
   precompileTemplate = () => {
diff --git a/packages/@ember/test/index.ts b/packages/@ember/test/index.ts
index 2cf30f846ce..70a78f139ce 100644
--- a/packages/@ember/test/index.ts
+++ b/packages/@ember/test/index.ts
@@ -1,14 +1,18 @@
 import require, { has } from 'require';
-import { type Test } from 'ember-testing';
+import { type Test as TestNS } from 'ember-testing';
 
-export let registerAsyncHelper: typeof Test['registerAsyncHelper'] | (() => never);
-export let registerHelper: typeof Test['registerHelper'] | (() => never);
-export let registerWaiter: typeof Test['registerWaiter'] | (() => never);
-export let unregisterHelper: typeof Test['unregisterHelper'] | (() => never);
-export let unregisterWaiter: typeof Test['unregisterWaiter'] | (() => never);
+export let registerAsyncHelper: typeof TestNS['registerAsyncHelper'];
+export let registerHelper: typeof TestNS['registerHelper'];
+export let registerWaiter: typeof TestNS['registerWaiter'];
+export let unregisterHelper: typeof TestNS['unregisterHelper'];
+export let unregisterWaiter: typeof TestNS['unregisterWaiter'];
 
 if (has('ember-testing')) {
-  let { Test } = require('ember-testing');
+  // SAFETY: since `require` is opaque to TS, we need to inform it that this is
+  // the actual type of what we import. This `require` needs to stay in sync
+  // with the `import type` statement above. (This cast *increases* safety,
+  // because the result of `require` is `any`.)
+  let Test = require('ember-testing').Test as typeof TestNS;
 
   registerAsyncHelper = Test.registerAsyncHelper;
   registerHelper = Test.registerHelper;
diff --git a/packages/@ember/utils/lib/compare.ts b/packages/@ember/utils/lib/compare.ts
index d4d963b0516..ed070317f29 100644
--- a/packages/@ember/utils/lib/compare.ts
+++ b/packages/@ember/utils/lib/compare.ts
@@ -96,7 +96,7 @@ function spaceship(a: number, b: number): Compare {
  @return {Number} -1 if v < w, 0 if v = w and 1 if v > w.
  @public
 */
-export default function compare(v: unknown, w: unknown): Compare {
+export default function compare<T>(v: T, w: T): Compare {
   if (v === w) {
     return 0;
   }
diff --git a/packages/@ember/utils/type-tests/compare.test.ts b/packages/@ember/utils/type-tests/compare.test.ts
index 5836b65d75c..fbd370e95fa 100644
--- a/packages/@ember/utils/type-tests/compare.test.ts
+++ b/packages/@ember/utils/type-tests/compare.test.ts
@@ -4,5 +4,7 @@ import { expectTypeOf } from 'expect-type';
 expectTypeOf(compare('hello', 'hello')).toEqualTypeOf<-1 | 0 | 1>(); // 0
 compare('abc', 'dfg'); // -1
 compare(2, 1); // 1
+// @ts-expect-error -- cannot compare different types!
 compare('hello', 50); // 1
+// @ts-expect-error -- cannot compare different types!
 compare(50, 'hello'); // -1
diff --git a/packages/ember-template-compiler/index.ts b/packages/ember-template-compiler/index.ts
index 38d8ddc4b3a..2c5a5f1c85f 100644
--- a/packages/ember-template-compiler/index.ts
+++ b/packages/ember-template-compiler/index.ts
@@ -4,14 +4,6 @@ import * as _GlimmerSyntax from '@glimmer/syntax';
 import VERSION from 'ember/version';
 import require from 'require';
 
-declare global {
-  interface NodeRequire {
-    has(name: string): boolean;
-  }
-
-  function define(path: string, deps: string[], module: () => void): void;
-}
-
 export let _Ember: unknown;
 
 try {
@@ -31,7 +23,7 @@ export {
   buildCompileOptions as _buildCompileOptions,
   transformsFor as _transformsFor,
 } from './lib/system/compile-options';
-export { RESOLUTION_MODE_TRANSFORMS, STRICT_MODE_TRANSFORMS } from './lib/plugins/index';
+export { RESOLUTION_MODE_TRANSFORMS, STRICT_MODE_TRANSFORMS } from './lib/plugins';
 export { EmberPrecompileOptions } from './lib/types';
 
 export { preprocess as _preprocess, print as _print } from '@glimmer/syntax';
diff --git a/packages/ember-template-compiler/lib/types.d.ts b/packages/ember-template-compiler/lib/types.ts
similarity index 100%
rename from packages/ember-template-compiler/lib/types.d.ts
rename to packages/ember-template-compiler/lib/types.ts
diff --git a/packages/ember-testing/lib/adapters/qunit.ts b/packages/ember-testing/lib/adapters/qunit.ts
index 9c550ee2e37..38bc09d4b0c 100644
--- a/packages/ember-testing/lib/adapters/qunit.ts
+++ b/packages/ember-testing/lib/adapters/qunit.ts
@@ -23,14 +23,15 @@ function isVeryOldQunit(obj: unknown): obj is VeryOldQunit {
   @extends TestAdapter
   @public
 */
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-interface QUnitAdapter extends Adapter {}
+interface QUnitAdapter extends Adapter {
+  doneCallbacks: Array<Function>;
+}
 const QUnitAdapter = Adapter.extend({
-  init() {
+  init(this: QUnitAdapter) {
     this.doneCallbacks = [];
   },
 
-  asyncStart() {
+  asyncStart(this: QUnitAdapter) {
     if (isVeryOldQunit(QUnit)) {
       // very old QUnit version
       // eslint-disable-next-line qunit/no-qunit-stop
@@ -40,7 +41,7 @@ const QUnitAdapter = Adapter.extend({
     }
   },
 
-  asyncEnd() {
+  asyncEnd(this: QUnitAdapter) {
     // checking for QUnit.stop here (even though we _need_ QUnit.start) because
     // QUnit.start() still exists in QUnit 2.x (it just throws an error when calling
     // inside a test context)
diff --git a/packages/ember-testing/lib/test/helpers.ts b/packages/ember-testing/lib/test/helpers.ts
index 884e7352609..a7e345c7217 100644
--- a/packages/ember-testing/lib/test/helpers.ts
+++ b/packages/ember-testing/lib/test/helpers.ts
@@ -1,4 +1,5 @@
 import type { AnyFn } from '@ember/-internals/utility-types';
+import type Application from '@ember/application';
 import TestPromise from './promise';
 
 export const helpers: Record<
@@ -49,7 +50,10 @@ export const helpers: Record<
   @param {Function} helperMethod
   @param options {Object}
 */
-export function registerHelper(name: string, helperMethod: AnyFn) {
+export function registerHelper(
+  name: string,
+  helperMethod: (app: Application, ...args: any[]) => unknown
+) {
   helpers[name] = {
     method: helperMethod,
     meta: { wait: false },
diff --git a/packages/ember-testing/lib/test/promise.ts b/packages/ember-testing/lib/test/promise.ts
index ccd095e98b7..4a1fe520d56 100644
--- a/packages/ember-testing/lib/test/promise.ts
+++ b/packages/ember-testing/lib/test/promise.ts
@@ -42,7 +42,7 @@ export default class TestPromise<T> extends RSVP.Promise<T> {
   @param {Function} resolver The function used to resolve the promise.
   @param {String} label An optional string for identifying the promise.
 */
-export function promise<T>(resolver: Executor<T>, label: string) {
+export function promise<T>(resolver: Executor<T>, label?: string) {
   let fullLabel = `Ember.Test.promise: ${label || '<Unknown Promise>'}`;
   return new TestPromise(resolver, fullLabel);
 }
diff --git a/packages/ember-testing/lib/test/waiters.ts b/packages/ember-testing/lib/test/waiters.ts
index 5b53310d976..2f59d908e8f 100644
--- a/packages/ember-testing/lib/test/waiters.ts
+++ b/packages/ember-testing/lib/test/waiters.ts
@@ -43,7 +43,11 @@ const callbacks: Array<() => unknown> = [];
 export function registerWaiter<T>(context: T, callback: (this: T) => unknown): void;
 export function registerWaiter(callback: (this: null) => unknown): void;
 export function registerWaiter<T>(
-  ...args: [context: T, callback: (this: T) => unknown] | [callback: (this: null) => unknown]
+  // Formatting makes a pretty big difference in how readable this is.
+  // prettier-ignore
+  ...args:
+    | [context: T, callback: (this: T) => unknown]
+    | [callback: (this: null) => unknown]
 ): void {
   let checkedCallback: () => unknown;
   let checkedContext: T | null;
diff --git a/packages/ember/index.ts b/packages/ember/index.ts
index a33c307dccd..7d643b10141 100644
--- a/packages/ember/index.ts
+++ b/packages/ember/index.ts
@@ -6,41 +6,61 @@ import require, { has } from 'require';
 
 import { getENV, getLookup, setLookup } from '@ember/-internals/environment';
 import * as utils from '@ember/-internals/utils';
-import { Registry, Container } from '@ember/-internals/container';
+import {
+  Registry as InternalRegistry,
+  Container as InternalContainer,
+} from '@ember/-internals/container';
 import * as instrumentation from '@ember/instrumentation';
-import { meta } from '@ember/-internals/meta';
+import { meta as internalMeta } from '@ember/-internals/meta';
 import * as metal from '@ember/-internals/metal';
-import { FEATURES, isEnabled } from '@ember/canary-features';
+import { FEATURES as EmberFEATURES, isEnabled } from '@ember/canary-features';
 import * as EmberDebug from '@ember/debug';
-import { assert, captureRenderTree } from '@ember/debug';
-import Backburner from 'backburner';
-import Controller, { inject as injectController, ControllerMixin } from '@ember/controller';
-import Service, { service } from '@ember/service';
+import { assert as emberAssert, captureRenderTree } from '@ember/debug';
+import Backburner from 'backburner.js';
+import EmberController, {
+  inject as injectController,
+  ControllerMixin as EmberControllerMixin,
+} from '@ember/controller';
+import EmberService, { service } from '@ember/service';
 
 import EmberObject, {
   action,
-  computed,
-  defineProperty,
-  notifyPropertyChange,
-  observer,
-  get,
-  getProperties,
-  set,
-  setProperties,
-  trySet,
+  computed as emberComputed,
+  defineProperty as emberDefineProperty,
+  notifyPropertyChange as emberNotifyPropertyChange,
+  observer as emberObserver,
+  get as emberGet,
+  getProperties as emberGetProperties,
+  set as emberSet,
+  setProperties as emberSetProperties,
+  trySet as emberTrySet,
 } from '@ember/object';
-import { cacheFor } from '@ember/object/-internals';
+import { cacheFor as emberCacheFor } from '@ember/object/-internals';
 import { dependentKeyCompat } from '@ember/object/compat';
-import ComputedProperty, { expandProperties } from '@ember/object/computed';
-import { addListener, removeListener, sendEvent } from '@ember/object/events';
+import EmberComputedProperty, {
+  expandProperties as emberExpandProperties,
+} from '@ember/object/computed';
+import {
+  addListener as emberAddListener,
+  removeListener as emberRemoveListener,
+  sendEvent as emberSendEvent,
+} from '@ember/object/events';
+
+// This is available in global scope courtesy of `loader/lib/index.js`, but that
+// "module" is created as a runtime-only module and makes `define` available as
+// a global as one of the side effects of executing the script. Since our type
+// publishing infrastructure does not handle `declare global { }` blocks at this
+// point, we "just" define it here, which is the only place it is actually used
+// in Ember's own public or intimate APIs.
+declare function define(path: string, deps: string[], module: () => void): void;
 
 import {
   RegistryProxyMixin,
   ContainerProxyMixin,
-  _ProxyMixin,
-  RSVP,
-  Comparable,
-  ActionHandler,
+  _ProxyMixin as internalProxyMixin,
+  RSVP as _RSVP,
+  Comparable as InternalComparable,
+  ActionHandler as InternalActionHandler,
 } from '@ember/-internals/runtime';
 import {
   componentCapabilities,
@@ -53,43 +73,64 @@ import {
   isSerializationFirstNode,
   type TemplatesRegistry,
 } from '@ember/-internals/glimmer';
-import VERSION from './version';
+import Version from './version';
 import * as views from '@ember/-internals/views';
-import ContainerDebugAdapter from '@ember/debug/container-debug-adapter';
-import DataAdapter from '@ember/debug/data-adapter';
-import { run } from '@ember/runloop';
+import EmberContainerDebugAdapter from '@ember/debug/container-debug-adapter';
+import EmberDataAdapter from '@ember/debug/data-adapter';
+import { run as emberRun } from '@ember/runloop';
 import { getOnerror, setOnerror } from '@ember/-internals/error-handling';
-import EmberArray, { A, NativeArray, isArray, makeArray } from '@ember/array';
-import MutableArray from '@ember/array/mutable';
-import ArrayProxy from '@ember/array/proxy';
-import Application, { getOwner, setOwner, onLoad, runLoadHooks } from '@ember/application';
-import ApplicationInstance from '@ember/application/instance';
-import Namespace from '@ember/application/namespace';
-import Component, { Input } from '@ember/component';
-import Helper from '@ember/component/helper';
-import Engine from '@ember/engine';
-import EngineInstance from '@ember/engine/instance';
-import Enumerable from '@ember/enumerable';
-import MutableEnumerable from '@ember/enumerable/mutable';
-import CoreObject from '@ember/object/core';
-import Evented, { on } from '@ember/object/evented';
-import Mixin, { mixin } from '@ember/object/mixin';
-import Observable from '@ember/object/observable';
-import { addObserver, removeObserver } from '@ember/object/observers';
-import ObjectProxy from '@ember/object/proxy';
-import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
-import HashLocation from '@ember/routing/hash-location';
-import HistoryLocation from '@ember/routing/history-location';
-import NoneLocation from '@ember/routing/none-location';
-import Route from '@ember/routing/route';
-import Router from '@ember/routing/router';
+import EmberArray, {
+  A as EmberA,
+  NativeArray as EmberNativeArray,
+  isArray as emberIsArray,
+  makeArray as emberMakeArray,
+} from '@ember/array';
+import EmberMutableArray from '@ember/array/mutable';
+import EmberArrayProxy from '@ember/array/proxy';
+import EmberApplication, {
+  getOwner as applicationGetOwner,
+  setOwner as applicationSetOwner,
+  onLoad as applicationOnLoad,
+  runLoadHooks as applicationRunLoadHooks,
+} from '@ember/application';
+import EmberApplicationInstance from '@ember/application/instance';
+import EmberNamespace from '@ember/application/namespace';
+import EmberComponent, { Input as EmberInput } from '@ember/component';
+import EmberHelper from '@ember/component/helper';
+import EmberEngine from '@ember/engine';
+import EmberEngineInstance from '@ember/engine/instance';
+import EmberEnumerable from '@ember/enumerable';
+import EmberMutableEnumerable from '@ember/enumerable/mutable';
+import EmberCoreObject from '@ember/object/core';
+import EmberEvented, { on as emberOn } from '@ember/object/evented';
+import EmberMixin, { mixin as emberMixin } from '@ember/object/mixin';
+import EmberObservable from '@ember/object/observable';
 import {
-  controllerFor,
-  generateController,
-  generateControllerFactory,
-  DSL as RouterDSL,
+  addObserver as emberAddObserver,
+  removeObserver as emberRemoveObserver,
+} from '@ember/object/observers';
+import EmberObjectProxy from '@ember/object/proxy';
+import EmberPromiseProxyMixin from '@ember/object/promise-proxy-mixin';
+import EmberHashLocation from '@ember/routing/hash-location';
+import EmberHistoryLocation from '@ember/routing/history-location';
+import EmberNoneLocation from '@ember/routing/none-location';
+import EmberRoute from '@ember/routing/route';
+import EmberRouter from '@ember/routing/router';
+import {
+  controllerFor as emberControllerFor,
+  generateController as emberGenerateController,
+  generateControllerFactory as emberGenerateControllerFactory,
+  DSL as EmberRouterDSL,
 } from '@ember/routing/-internals';
-import { isNone, isBlank, isEmpty, isPresent, isEqual, typeOf, compare } from '@ember/utils';
+import {
+  isNone as emberIsNone,
+  isBlank as emberIsBlank,
+  isEmpty as emberIsEmpty,
+  isPresent as emberIsPresent,
+  isEqual as emberIsEqual,
+  typeOf as emberTypeOf,
+  compare as emberCompare,
+} from '@ember/utils';
 
 import * as glimmerRuntime from '@glimmer/runtime';
 
@@ -104,7 +145,7 @@ import {
 import {
   assertDestroyablesDestroyed,
   associateDestroyableChild,
-  destroy,
+  destroy as emberDestroy,
   enableDestroyableTracking,
   isDestroying,
   isDestroyed,
@@ -116,264 +157,289 @@ import type * as EmberTemplateCompiler from 'ember-template-compiler';
 import type { precompile, compile } from 'ember-template-compiler';
 import type * as EmberTesting from 'ember-testing';
 
-/**
-  Namespace for injection helper methods.
+// eslint-disable-next-line @typescript-eslint/no-namespace
+namespace Ember {
+  export const isNamespace = true;
 
-  @class inject
-  @namespace Ember
-  @static
-  @public
-*/
-function inject() {
-  assert(
-    `Injected properties must be created through helpers, see '${Object.keys(inject)
-      .map((k) => `'inject.${k}'`)
-      .join(' or ')}'`
-  );
-}
-// ****@ember/controller****
-inject.controller = injectController;
-// ****@ember/service****
-inject.service = service;
-
-const PartialEmber = {
-  isNamespace: true,
-
-  toString() {
+  export function toString() {
     return 'Ember';
-  },
+  }
 
   // ****@ember/-internals/container****
-  Container,
-  Registry,
+  export const Container = InternalContainer;
+  export type Container = InternalContainer;
+  export const Registry = InternalRegistry;
+  export type Registry = InternalRegistry;
 
   // ****@ember/-internals/glimmer****
   // Partially re-exported from @glimmer/manager
-  _setComponentManager: setComponentManager,
-  _componentManagerCapabilities: componentCapabilities,
-  _modifierManagerCapabilities: modifierCapabilities,
+  export const _setComponentManager = setComponentManager;
+  export const _componentManagerCapabilities = componentCapabilities;
+  export const _modifierManagerCapabilities = modifierCapabilities;
 
   // ****@ember/-internals/meta****
-  meta,
+  export const meta = internalMeta;
 
   // ****@ember/-internals/metal****
-  _createCache: metal.createCache, // Also @glimmer/validator
-  _cacheGetValue: metal.getValue, // Also @glimmer/validator
-  _cacheIsConst: metal.isConst, // Also @glimmer/validator
-  _descriptor: metal.nativeDescDecorator,
-  _getPath: metal._getPath,
-  _setClassicDecorator: metal.setClassicDecorator,
-  _tracked: metal.tracked, // Also exported from @glimmer/tracking
-  beginPropertyChanges: metal.beginPropertyChanges,
-  changeProperties: metal.changeProperties,
-  endPropertyChanges: metal.endPropertyChanges,
-  hasListeners: metal.hasListeners,
-  libraries: metal.libraries,
+  export const _createCache = metal.createCache; // Also @glimmer/validator
+  export const _cacheGetValue = metal.getValue; // Also @glimmer/validator
+  export const _cacheIsConst = metal.isConst; // Also @glimmer/validator
+  export const _descriptor = metal.nativeDescDecorator;
+  export const _getPath = metal._getPath;
+  export const _setClassicDecorator = metal.setClassicDecorator;
+  export const _tracked = metal.tracked; // Also exported from @glimmer/tracking
+  export const beginPropertyChanges = metal.beginPropertyChanges;
+  export const changeProperties = metal.changeProperties;
+  export const endPropertyChanges = metal.endPropertyChanges;
+  export const hasListeners = metal.hasListeners;
+  export const libraries = metal.libraries;
 
   // ****@ember/-internals/runtime****
-  _ContainerProxyMixin: ContainerProxyMixin,
-  _ProxyMixin,
-  _RegistryProxyMixin: RegistryProxyMixin,
-  ActionHandler,
-  Comparable,
-  RSVP, // Also from 'rsvp' directly.
+  export const _ContainerProxyMixin = ContainerProxyMixin;
+  export const _ProxyMixin = internalProxyMixin;
+  export const _RegistryProxyMixin = RegistryProxyMixin;
+  export const ActionHandler = InternalActionHandler;
+  export type ActionHandler = InternalActionHandler;
+  export const Comparable = InternalComparable;
+  export type Comparable = InternalComparable;
+
+  // This syntax is namespace-specific: `import` in a namespace is aliasing one
+  // namespace to another, while `export` marks the item public on the namespace
+  // (as with the rest of the exported items).
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  export import RSVP = _RSVP;
 
   // ****@ember/-internals/view****
-  ComponentLookup: views.ComponentLookup,
-  EventDispatcher: views.EventDispatcher,
+  export const ComponentLookup = views.ComponentLookup;
+  export const EventDispatcher = views.EventDispatcher;
 
   // ****@ember/-internals/utils****
-  _Cache: utils.Cache,
-  GUID_KEY: utils.GUID_KEY,
-  canInvoke: utils.canInvoke,
-  generateGuid: utils.generateGuid,
-  guidFor: utils.guidFor,
-  uuid: utils.uuid,
-  wrap: utils.wrap,
+  export const _Cache = utils.Cache;
+  export const GUID_KEY = utils.GUID_KEY;
+  export const canInvoke = utils.canInvoke;
+  export const generateGuid = utils.generateGuid;
+  export const guidFor = utils.guidFor;
+  export const uuid = utils.uuid;
+  export const wrap = utils.wrap;
 
   // ****@ember/application****
-  getOwner,
-  onLoad,
-  runLoadHooks,
-  setOwner,
-  Application,
+  export const getOwner = applicationGetOwner;
+  export const onLoad = applicationOnLoad;
+  export const runLoadHooks = applicationRunLoadHooks;
+  export const setOwner = applicationSetOwner;
+  export const Application = EmberApplication;
+  export type Application = EmberApplication;
 
   // ****@ember/application/instance****
-  ApplicationInstance,
+  export const ApplicationInstance = EmberApplicationInstance;
+  export type ApplicationInstance = EmberApplicationInstance;
 
-  // ****@ember/application/namespace****
-  Namespace,
+  // // ****@ember/application/namespace****
+  export const Namespace = EmberNamespace;
+  export type Namespace = EmberNamespace;
 
   // ****@ember/array****
-  A,
-  Array: EmberArray,
-  NativeArray,
-  isArray,
-  makeArray,
+  export const A = EmberA;
+  export const Array = EmberArray;
+  export type Array<T> = EmberArray<T>;
+  export const NativeArray = EmberNativeArray;
+  export type NativeArray<T> = EmberNativeArray<T>;
+  export const isArray = emberIsArray;
+  export const makeArray = emberMakeArray;
 
   // ****@ember/array/mutable****
-  MutableArray,
+  export const MutableArray = EmberMutableArray;
+  export type MutableArray<T> = EmberMutableArray<T>;
 
   // ****@ember/array/proxy****
-  ArrayProxy,
+  export const ArrayProxy = EmberArrayProxy;
+  export type ArrayProxy<T> = EmberArrayProxy<T>;
 
   // ****@ember/canary-features****
-  FEATURES: { isEnabled, ...FEATURES },
+  export const FEATURES = { isEnabled, ...EmberFEATURES };
 
   // ****@ember/component****
-  _Input: Input,
-  Component,
+  export const _Input = EmberInput;
+  export const Component = EmberComponent;
+  export type Component<S = unknown> = EmberComponent<S>;
 
-  // ****@ember/component/helper****
-  Helper,
+  // // ****@ember/component/helper****
+  export const Helper = EmberHelper;
+  export type Helper<S = unknown> = EmberHelper<S>;
 
   // ****@ember/controller****
-  Controller,
-  ControllerMixin,
+  export const Controller = EmberController;
+  export type Controller<T = unknown> = EmberController<T>;
+  export const ControllerMixin = EmberControllerMixin;
+  export type ControllerMixin<T> = EmberControllerMixin<T>;
 
   // ****@ember/debug****
-  _captureRenderTree: captureRenderTree,
-  assert: EmberDebug.assert,
-  warn: EmberDebug.warn,
-  debug: EmberDebug.debug,
-  deprecate: EmberDebug.deprecate,
-  deprecateFunc: EmberDebug.deprecateFunc,
-  runInDebug: EmberDebug.runInDebug,
-  inspect: EmberDebug.inspect,
-
-  Debug: {
+  export const _captureRenderTree = captureRenderTree;
+  export const assert = EmberDebug.assert;
+  export const warn = EmberDebug.warn;
+  export const debug = EmberDebug.debug;
+  export const deprecate = EmberDebug.deprecate;
+  export const deprecateFunc = EmberDebug.deprecateFunc;
+  export const runInDebug = EmberDebug.runInDebug;
+  export const inspect = EmberDebug.inspect;
+
+  export const Debug = {
     registerDeprecationHandler: EmberDebug.registerDeprecationHandler,
     registerWarnHandler: EmberDebug.registerWarnHandler,
     // ****@ember/-internals/metal****
     isComputed: metal.isComputed,
-  },
+  };
 
   // ****@ember/debug/container-debug-adapter****
-  ContainerDebugAdapter,
+  export const ContainerDebugAdapter = EmberContainerDebugAdapter;
+  export type ContainerDebugAdapter = EmberContainerDebugAdapter;
 
   // ****@ember/debug/data-adapter****
-  DataAdapter,
+  export const DataAdapter = EmberDataAdapter;
+  export type DataAdapter<T> = EmberDataAdapter<T>;
 
   // ****@ember/destroyable****
-  _assertDestroyablesDestroyed: assertDestroyablesDestroyed,
-  _associateDestroyableChild: associateDestroyableChild,
-  _enableDestroyableTracking: enableDestroyableTracking,
-  _isDestroying: isDestroying,
-  _isDestroyed: isDestroyed,
-  _registerDestructor: registerDestructor,
-  _unregisterDestructor: unregisterDestructor,
-  destroy,
+  export const _assertDestroyablesDestroyed = assertDestroyablesDestroyed;
+  export const _associateDestroyableChild = associateDestroyableChild;
+  export const _enableDestroyableTracking = enableDestroyableTracking;
+  export const _isDestroying = isDestroying;
+  export const _isDestroyed = isDestroyed;
+  export const _registerDestructor = registerDestructor;
+  export const _unregisterDestructor = unregisterDestructor;
+  export const destroy = emberDestroy;
 
   // ****@ember/engine****
-  Engine,
+  export const Engine = EmberEngine;
+  export type Engine = EmberEngine;
 
   // ****@ember/engine/instance****
-  EngineInstance,
+  export const EngineInstance = EmberEngineInstance;
+  export type EngineInstance = EmberEngineInstance;
 
   // ****@ember/enumerable****
-  Enumerable,
+  export const Enumerable = EmberEnumerable;
+  export type Enumerable = EmberEnumerable;
 
   // ****@ember/enumerable/mutable****
-  MutableEnumerable,
+  export const MutableEnumerable = EmberMutableEnumerable;
+  export type MutableEnumerable = EmberMutableEnumerable;
 
   // ****@ember/instrumentation****
-  instrument: instrumentation.instrument,
-  subscribe: instrumentation.subscribe,
+  /** @private */
+  export const instrument = instrumentation.instrument;
+  /** @private */
+  export const subscribe = instrumentation.subscribe;
 
-  Instrumentation: {
+  /** @private */
+  export const Instrumentation = {
     instrument: instrumentation.instrument,
     subscribe: instrumentation.subscribe,
     unsubscribe: instrumentation.unsubscribe,
     reset: instrumentation.reset,
-  },
+  };
 
   // ****@ember/object****
-  Object: EmberObject,
-  _action: action,
-  computed,
-  defineProperty,
-  get,
-  getProperties,
-  notifyPropertyChange,
-  observer,
-  set,
-  trySet,
-  setProperties,
+  export const Object = EmberObject;
+  export type Object = EmberObject;
+  export const _action = action;
+  export const computed = emberComputed;
+  export const defineProperty = emberDefineProperty;
+  export const get = emberGet;
+  export const getProperties = emberGetProperties;
+  export const notifyPropertyChange = emberNotifyPropertyChange;
+  export const observer = emberObserver;
+  export const set = emberSet;
+  export const trySet = emberTrySet;
+  export const setProperties = emberSetProperties;
 
   // ****@ember/object/-internals****
-  cacheFor,
+  export const cacheFor = emberCacheFor;
 
   // ****@ember/object/compat****
-  _dependentKeyCompat: dependentKeyCompat,
+  export const _dependentKeyCompat = dependentKeyCompat;
 
   // ****@ember/object/computed****
-  ComputedProperty,
-  expandProperties,
+  export const ComputedProperty = EmberComputedProperty;
+  export type ComputedProperty = EmberComputedProperty;
+  export const expandProperties = emberExpandProperties;
 
   // ****@ember/object/core****
-  CoreObject,
+  export const CoreObject = EmberCoreObject;
+  export type CoreObject = EmberCoreObject;
 
   // ****@ember/object/evented****
-  Evented,
-  on,
+  export const Evented = EmberEvented;
+  export type Evented = EmberEvented;
+  export const on = emberOn;
 
   // ****@ember/object/events****
-  addListener,
-  removeListener,
-  sendEvent,
+  export const addListener = emberAddListener;
+  export const removeListener = emberRemoveListener;
+  export const sendEvent = emberSendEvent;
 
   // ****@ember/object/mixin****
-  Mixin,
-  mixin,
+  export const Mixin = EmberMixin;
+  export type Mixin = EmberMixin;
+  export const mixin = emberMixin;
 
   // ****@ember/object/observable****
-  Observable,
+  export const Observable = EmberObservable;
+  export type Observable = EmberObservable;
 
   // ****@ember/object/observers****
-  addObserver,
-  removeObserver,
+  export const addObserver = emberAddObserver;
+  export const removeObserver = emberRemoveObserver;
 
   // ****@ember/object/promise-proxy-mixin****
-  PromiseProxyMixin,
+  export const PromiseProxyMixin = EmberPromiseProxyMixin;
+  export type PromiseProxyMixin<T> = EmberPromiseProxyMixin<T>;
 
   // ****@ember/object/proxy****
-  ObjectProxy,
+  export const ObjectProxy = EmberObjectProxy;
+  export type ObjectProxy = EmberObjectProxy;
 
   // ****@ember/routing/-internals****
-  RouterDSL,
-  controllerFor,
-  generateController,
-  generateControllerFactory,
+  export const RouterDSL = EmberRouterDSL;
+  export type RouterDSL = EmberRouterDSL;
+  export const controllerFor = emberControllerFor;
+  export const generateController = emberGenerateController;
+  export const generateControllerFactory = emberGenerateControllerFactory;
 
   // ****@ember/routing/hash-location****
-  HashLocation,
+  export const HashLocation = EmberHashLocation;
+  export type HashLocation = EmberHashLocation;
 
   // ****@ember/routing/history-location****
-  HistoryLocation,
+  export const HistoryLocation = EmberHistoryLocation;
+  export type HistoryLocation = EmberHistoryLocation;
 
   // ****@ember/routing/none-location****
-  NoneLocation,
+  export const NoneLocation = EmberNoneLocation;
+  export type NoneLocation = EmberNoneLocation;
 
   // ****@ember/routing/route****
-  Route,
+  export const Route = EmberRoute;
+  export type Route = EmberRoute;
 
   // ****@ember/routing/router****
-  Router,
+  export const Router = EmberRouter;
+  export type Router = EmberRouter;
 
-  // ****@ember/runloop****
-  run,
+  // // ****@ember/runloop****
+  export const run = emberRun;
 
-  // ****@ember/service****
-  Service,
+  // // ****@ember/service****
+  export const Service = EmberService;
+  export type Service = EmberService;
 
   // ****@ember/utils****
-  compare,
-  isBlank,
-  isEmpty,
-  isEqual,
-  isNone,
-  isPresent,
-  typeOf,
+  export const compare = emberCompare;
+  export const isBlank = emberIsBlank;
+  export const isEmpty = emberIsEmpty;
+  export const isEqual = emberIsEqual;
+  export const isNone = emberIsNone;
+  export const isPresent = emberIsPresent;
+  export const typeOf = emberTypeOf;
 
   // ****@ember/version****
   /**
@@ -383,9 +449,9 @@ const PartialEmber = {
     @type String
     @public
   */
-  VERSION,
+  export const VERSION = Version;
 
-  ViewUtils: {
+  export const ViewUtils = {
     // ****@ember/-internals/views****
     getChildViews: views.getChildViews,
     getElementView: views.getElementView,
@@ -398,61 +464,67 @@ const PartialEmber = {
 
     // ****@ember/-internals/glimmer****
     isSerializationFirstNode,
-  },
+  };
 
   // ****@glimmer/manager****
-  _getComponentTemplate: getComponentTemplate,
-  _helperManagerCapabilities: helperCapabilities,
-  _setComponentTemplate: setComponentTemplate,
-  _setHelperManager: setHelperManager,
-  _setModifierManager: setModifierManager,
+  export const _getComponentTemplate = getComponentTemplate;
+  export const _helperManagerCapabilities = helperCapabilities;
+  export const _setComponentTemplate = setComponentTemplate;
+  export const _setHelperManager = setHelperManager;
+  export const _setModifierManager = setModifierManager;
 
   // ****@glimmer/runtime****
-  _templateOnlyComponent: glimmerRuntime.templateOnlyComponent,
-  _invokeHelper: glimmerRuntime.invokeHelper,
-  _hash: glimmerRuntime.hash,
-  _array: glimmerRuntime.array,
-  _concat: glimmerRuntime.concat,
-  _get: glimmerRuntime.get,
-  _on: glimmerRuntime.on,
-  _fn: glimmerRuntime.fn,
+  export const _templateOnlyComponent = glimmerRuntime.templateOnlyComponent;
+  export const _invokeHelper = glimmerRuntime.invokeHelper;
+  export const _hash = glimmerRuntime.hash;
+  export const _array = glimmerRuntime.array;
+  export const _concat = glimmerRuntime.concat;
+  export const _get = glimmerRuntime.get;
+  export const _on = glimmerRuntime.on;
+  export const _fn = glimmerRuntime.fn;
 
   // Backburner
-  _Backburner: Backburner,
+  export const _Backburner = Backburner;
+  export type _Backburner = Backburner;
 
-  // ****@ember/controller, @ember/service****
-  inject,
+  // // ****@ember/controller, @ember/service****
+  /**
+    Namespace for injection helper methods.
 
-  __loader: {
+    @class inject
+    @namespace Ember
+    @static
+    @public
+  */
+  export function inject() {
+    // uses `globalThis` to avoid clobbering with `Ember.Object` in TS namespace
+    emberAssert(
+      `Injected properties must be created through helpers, see '${globalThis.Object.keys(inject)
+        .map((k) => `'inject.${k}'`)
+        .join(' or ')}'`
+    );
+  }
+  // ****@ember/controller****
+  inject.controller = injectController;
+  // ****@ember/service****
+  inject.service = service;
+
+  export const __loader = {
     require,
     define,
     // @ts-expect-error These properties don't appear as being defined
     registry: typeof requirejs !== 'undefined' ? requirejs.entries : require.entries,
-  },
-} as const;
-
-interface EmberHandlebars {
-  template: typeof template;
-  Utils: {
-    escapeExpression: typeof escapeExpression;
   };
-  compile?: typeof compile;
-  precompile?: typeof precompile;
-}
 
-interface EmberHTMLBars {
-  template: typeof template;
-  compile?: typeof compile;
-  precompile?: typeof precompile;
-}
+  // ------------------------------------------------------------------------ //
+  // These properties are assigned to the namespace with getters (and, in some
+  // cases setters) with `Object.defineProperty` below.
+  // ------------------------------------------------------------------------ //
 
-type PartialEmber = typeof PartialEmber;
-interface Ember extends PartialEmber {
-  get ENV(): object;
+  export declare const ENV: Readonly<object>;
 
   // ****@ember/-internals/environment****
-  get lookup(): Record<string, unknown>;
-  set lookup(value: Record<string, unknown>);
+  export declare let lookup: Record<string, unknown>;
 
   /**
     A function may be assigned to `Ember.onerror` to be called when Ember
@@ -478,15 +550,13 @@ interface Ember extends PartialEmber {
 
     @event onerror
     @for Ember
-    @param {Exception} error the error object
+    @param {Error} error the error object
     @public
   */
   // ****@ember/-internals/error-handling****
-  get onerror(): Function | undefined;
-  set onerror(handler: Function | undefined);
+  export declare let onerror: ((error: Error) => unknown) | undefined;
 
-  get testing(): boolean;
-  set testing(value: boolean);
+  export declare let testing: boolean;
 
   /**
     Whether searching on the global for new Namespace instances is enabled.
@@ -502,8 +572,7 @@ interface Ember extends PartialEmber {
     @type Boolean
     @private
   */
-  get BOOTED(): boolean;
-  set BOOTED(flag: boolean);
+  export declare let BOOTED: boolean;
 
   /**
     Global hash of shared templates. This will automatically be populated
@@ -515,18 +584,33 @@ interface Ember extends PartialEmber {
     @type Object
     @private
   */
-  get TEMPLATES(): TemplatesRegistry;
-  set TEMPLATES(registry: TemplatesRegistry);
-
-  HTMLBars: EmberHTMLBars;
-  Handlebars: EmberHandlebars;
-  Test?: typeof EmberTesting['Test'] & {
-    Adapter: typeof EmberTesting['Adapter'];
-    QUnitAdapter: typeof EmberTesting['QUnitAdapter'];
+  export declare let TEMPLATES: TemplatesRegistry;
+
+  export declare let HTMLBars: EmberHTMLBars;
+  export declare let Handlebars: EmberHandlebars;
+  export declare let Test:
+    | (typeof EmberTesting['Test'] & {
+        Adapter: typeof EmberTesting['Adapter'];
+        QUnitAdapter: typeof EmberTesting['QUnitAdapter'];
+      })
+    | undefined;
+  export declare let setupForTesting: typeof EmberTesting['setupForTesting'] | undefined;
+}
+
+interface EmberHandlebars {
+  template: typeof template;
+  Utils: {
+    escapeExpression: typeof escapeExpression;
   };
-  setupForTesting?: typeof EmberTesting['setupForTesting'];
+  compile?: typeof compile;
+  precompile?: typeof precompile;
+}
+
+interface EmberHTMLBars {
+  template: typeof template;
+  compile?: typeof compile;
+  precompile?: typeof precompile;
 }
-const Ember = PartialEmber as Ember;
 
 Object.defineProperty(Ember, 'ENV', {
   get: getENV,
@@ -579,7 +663,7 @@ Object.defineProperty(Ember, 'testing', {
   enumerable: false,
 });
 
-runLoadHooks('Ember.Application', Application);
+applicationRunLoadHooks('Ember.Application', EmberApplication);
 
 let EmberHandlebars: EmberHandlebars = {
   template,
@@ -666,6 +750,6 @@ defineEmberTestingLazyLoad('Test');
 defineEmberTestingLazyLoad('setupForTesting');
 
 // @ts-expect-error Per types, runLoadHooks requires a second parameter. Should we loosen types?
-runLoadHooks('Ember');
+applicationRunLoadHooks('Ember');
 
 export default Ember;
diff --git a/packages/ember/tests/reexports_test.js b/packages/ember/tests/reexports_test.js
index ee67179c925..3b6164de32a 100644
--- a/packages/ember/tests/reexports_test.js
+++ b/packages/ember/tests/reexports_test.js
@@ -332,7 +332,7 @@ let allExports = [
   ['RouterDSL', '@ember/-internals/routing'],
 
   // backburner
-  ['_Backburner', 'backburner', 'default'],
+  ['_Backburner', 'backburner.js', 'default'],
 
   // rsvp
   [null, 'rsvp', 'default'],
diff --git a/packages/ember/type-tests/ember.test.ts b/packages/ember/type-tests/ember.test.ts
index 2eb5a03ea6d..8ff5bc0b446 100644
--- a/packages/ember/type-tests/ember.test.ts
+++ b/packages/ember/type-tests/ember.test.ts
@@ -2,6 +2,6 @@ import Ember from 'ember';
 
 import { expectTypeOf } from 'expect-type';
 
-expectTypeOf(Ember.onerror).toEqualTypeOf<Function | undefined>();
+expectTypeOf(Ember.onerror).toEqualTypeOf<((error: Error) => unknown) | undefined>();
 
 expectTypeOf(Ember.HTMLBars).toMatchTypeOf<object>();
diff --git a/packages/internal-test-helpers/lib/build-owner.ts b/packages/internal-test-helpers/lib/build-owner.ts
index bf087cc2d38..5172f6f91ef 100644
--- a/packages/internal-test-helpers/lib/build-owner.ts
+++ b/packages/internal-test-helpers/lib/build-owner.ts
@@ -4,15 +4,16 @@ import Engine from '@ember/engine';
 import { registerDestructor } from '@ember/destroyable';
 import type Resolver from './test-resolver';
 import type { EngineInstanceOptions } from '@ember/engine/instance';
+import type { ResolverClass } from '@ember/-internals/container';
 
-class ResolverWrapper {
-  resolver: Resolver | undefined;
+class ResolverWrapper implements ResolverClass {
+  resolver: Resolver;
 
-  constructor(resolver: Resolver | undefined) {
+  constructor(resolver: Resolver) {
     this.resolver = resolver;
   }
 
-  create() {
+  create(): Resolver {
     return this.resolver;
   }
 }
@@ -27,7 +28,14 @@ export default function buildOwner(
 ) {
   let ownerType = options.ownerType || 'application';
   let ownerOptions = options.ownerOptions || {};
-  let resolver = options.resolver;
+  // TODO(SAFETY): this is a lie, and we should use the error thrown below.
+  // At the moment, though, some *tests* pass no resolver, and expect this to
+  // work anyway. The fix is to have those tests pass a test-friendly resolver
+  // and then this will work as expected.
+  let resolver = options.resolver!;
+  // if (!resolver) {
+  //   throw new Error('You must provide a resolver to buildOwner');
+  // }
   let bootOptions = options.bootOptions || {};
 
   let namespace: Application | Engine;
diff --git a/packages/internal-test-helpers/lib/test-cases/rendering.ts b/packages/internal-test-helpers/lib/test-cases/rendering.ts
index b73a952824d..e2b4ef86039 100644
--- a/packages/internal-test-helpers/lib/test-cases/rendering.ts
+++ b/packages/internal-test-helpers/lib/test-cases/rendering.ts
@@ -13,7 +13,6 @@ import { runAppend, runDestroy, runTask } from '../run';
 import type { InternalFactory } from '@ember/-internals/owner';
 import type { BootOptions, EngineInstanceOptions } from '@ember/engine/instance';
 import type EngineInstance from '@ember/engine/instance';
-import type { HelperFunction } from '@ember/-internals/glimmer/lib/helper';
 
 const TextNode = window.Text;
 
@@ -162,7 +161,7 @@ export default abstract class RenderingTestCase extends AbstractTestCase {
 
   registerHelper<T, P extends unknown[], N extends Record<string, unknown>>(
     name: string,
-    funcOrClassBody: HelperFunction<T, P, N> | Record<string, unknown>
+    funcOrClassBody: (positional: P, named: N) => T | Record<string, unknown>
   ) {
     if (typeof funcOrClassBody === 'function') {
       this.owner.register(`helper:${name}`, helper(funcOrClassBody));
diff --git a/tsconfig/publish-types.json b/tsconfig/publish-types.json
index 3e459bb6039..b0f8a517e0d 100644
--- a/tsconfig/publish-types.json
+++ b/tsconfig/publish-types.json
@@ -16,16 +16,11 @@
     "declarationDir": "../types/stable"
   },
   "include": [
-    // Note: these will also pull on all their transitive dependencies, so we
-    // will end up publishing the (private!) types for packages not named here
-    // until we update the actual internals to avoid referencing them!
-    "../packages/@ember/**/*",
-    "../packages/ember/**/*",
-    "../packages/@glimmer/**/*"
+    "../packages/**/*.ts"
   ],
   "exclude": [
     "../**/type-tests",
     "../**/tests",
     "../**/internal-test-helpers"
   ]
-}
+}
\ No newline at end of file
diff --git a/type-tests/@ember/application-test/application.ts b/type-tests/@ember/application-test/application.ts
index fa90f68b203..fea5ad335f5 100755
--- a/type-tests/@ember/application-test/application.ts
+++ b/type-tests/@ember/application-test/application.ts
@@ -41,4 +41,11 @@ const App2 = BaseApp.create({
 const App3 = BaseApp.create();
 
 expectTypeOf(App3.buildInstance()).toEqualTypeOf<ApplicationInstance>();
-expectTypeOf(App3.buildInstance({ foo: 'bar' })).toEqualTypeOf<ApplicationInstance>();
+expectTypeOf(App3.buildInstance({})).toEqualTypeOf<ApplicationInstance>();
+expectTypeOf(App3.buildInstance).parameter(0).toEqualTypeOf<
+  | {
+      mountPoint?: string;
+      routable?: boolean;
+    }
+  | undefined
+>();
diff --git a/type-tests/@ember/array-test/array-proxy.ts b/type-tests/@ember/array-test/array-proxy.ts
index 9b2c81782ff..fe5bf70973e 100644
--- a/type-tests/@ember/array-test/array-proxy.ts
+++ b/type-tests/@ember/array-test/array-proxy.ts
@@ -15,7 +15,7 @@ const overridden = ArrayProxy.create({
   objectAtContent(this: ArrayProxy<string>, idx: number): string | undefined {
     // NOTE: cast is necessary because `this` is not managed correctly in the
     // `.create()` body anymore.
-    return (this.get('content') as EmberArray<string>).objectAt(idx)?.toUpperCase();
+    return (this.get('content') as unknown as EmberArray<string>).objectAt(idx)?.toUpperCase();
   },
 });
 
@@ -25,8 +25,8 @@ class MyNewProxy<T> extends ArrayProxy<T> {
   isNew = true;
 }
 
-const x = MyNewProxy.create({ content: A([1, 2, 3]) }) as MyNewProxy<number>;
-expectTypeOf(x.get('firstObject')).toEqualTypeOf<number | undefined>();
+const x = MyNewProxy.create({ content: A([1, 2, 3]) });
+expectTypeOf(x.get('firstObject')).toBeUnknown();
 expectTypeOf(x.isNew).toBeBoolean();
 
 // Custom EmberArray
diff --git a/type-tests/@ember/array-test/array.ts b/type-tests/@ember/array-test/array.ts
index e9ad363e0f7..f8350f8ae1a 100755
--- a/type-tests/@ember/array-test/array.ts
+++ b/type-tests/@ember/array-test/array.ts
@@ -1,9 +1,6 @@
 import EmberObject from '@ember/object';
-import type Array from '@ember/array';
-import { A } from '@ember/array';
-import type MutableArray from '@ember/array/mutable';
+import { A, NativeArray } from '@ember/array';
 import { expectTypeOf } from 'expect-type';
-import NativeArray from '@ember/array/-private/native-array';
 
 class Person extends EmberObject {
   name = '';
diff --git a/type-tests/@ember/component-test/component.ts b/type-tests/@ember/component-test/component.ts
index 3df213d853c..d349089f2fa 100644
--- a/type-tests/@ember/component-test/component.ts
+++ b/type-tests/@ember/component-test/component.ts
@@ -119,7 +119,6 @@ Component.extend({
   },
 });
 
-// @ts-expect-error
 Component.reopen({
   attributeBindings: ['metadata:data-my-metadata'],
   metadata: '',
diff --git a/type-tests/@ember/component-test/helper.ts b/type-tests/@ember/component-test/helper.ts
index f63a4c6077f..4155a70eb91 100644
--- a/type-tests/@ember/component-test/helper.ts
+++ b/type-tests/@ember/component-test/helper.ts
@@ -1,35 +1,10 @@
-import { BadType, DefaultPositional, EmptyObject } from '@ember/component/-private/signature-utils';
 import Helper, {
-  ExpandSignature,
   FunctionBasedHelper,
   FunctionBasedHelperInstance,
   helper,
 } from '@ember/component/helper';
 import { expectTypeOf } from 'expect-type';
 
-class DeprecatedSignatureForm extends Helper<{
-  PositionalArgs: [offset: Date];
-  Return: Date;
-}> {
-  timer?: ReturnType<typeof setInterval> | undefined;
-  now = new Date();
-  init() {
-    super.init();
-    this.timer = setInterval(() => {
-      this.set('now', new Date());
-      this.recompute();
-    }, 100);
-  }
-  compute([offset]: [Date]): Date {
-    return new Date(this.now.getTime() + offset.getTime());
-  }
-  willDestroy() {
-    if (this.timer) {
-      clearInterval(this.timer);
-    }
-  }
-}
-
 interface DemoSig {
   Args: {
     Named: {
@@ -41,13 +16,6 @@ interface DemoSig {
   Return: string;
 }
 
-function testMissingSignature({ Args, Return }: ExpandSignature<unknown>) {
-  expectTypeOf(Args.Named).toEqualTypeOf<BadType<'This helper is missing a signature'>>();
-
-  expectTypeOf(Args.Positional).toEqualTypeOf<unknown[]>();
-  expectTypeOf(Return).toBeUnknown();
-}
-
 class SignatureForm extends Helper<DemoSig> {
   compute(
     [i18nizer]: [i18nizer: (s: string) => string],
@@ -57,7 +25,11 @@ class SignatureForm extends Helper<DemoSig> {
   }
 }
 
-class NoSignatureForm extends Helper {
+// Type-safe helpers require you to pass a signature so that it is visible to
+// external callers (via Glint) *or* to handle the fact that your callers may
+// pass you anything if there is no signature. Unfortunately, the only way to
+// make that safe would be to make the signature *required*.
+class BadNoSigForm extends Helper {
   compute(
     [i18nizer]: [i18nizer: (s: string) => string],
     { name, age }: { name: string; age: number }
@@ -102,23 +74,29 @@ const inferenceOnPositional = helper(function add([a, b]: [number, number]) {
 
 expectTypeOf(inferenceOnPositional).toEqualTypeOf<
   FunctionBasedHelper<{
-    Args: { Positional: [number, number]; Named: EmptyObject };
+    Args: { Positional: [number, number]; Named: object };
     Return: number;
   }>
 >();
 
 const coolHelper = helper((_, named) => {
-  expectTypeOf(named).toEqualTypeOf<EmptyObject>();
+  expectTypeOf(named).toEqualTypeOf<object>();
 });
 
-const typeInferenceOnNamed = helper((_, { cool }: { cool: boolean }) => {
+const typeInferenceOnNamed = helper((_: [], { cool }: { cool: boolean }) => {
   expectTypeOf(cool).toBeBoolean();
 
   return cool ? 123 : 'neat';
 });
+
 expectTypeOf(typeInferenceOnNamed).toEqualTypeOf<
   FunctionBasedHelper<{
-    Args: { Positional: DefaultPositional; Named: { cool: boolean } };
+    Args: {
+      Positional: [];
+      Named: {
+        cool: boolean;
+      };
+    };
     Return: 123 | 'neat';
   }>
 >();
@@ -130,7 +108,13 @@ const dasherizeHelper = helper(function dasherize(
   return str.split(/[\s\n_.]+/g).join(delim);
 });
 expectTypeOf(dasherizeHelper).toEqualTypeOf<
-  FunctionBasedHelper<{ Args: { Positional: [string]; Named: { delim?: string } }; Return: string }>
+  FunctionBasedHelper<{
+    Args: {
+      Positional: [string];
+      Named: { delim?: string };
+    };
+    Return: string;
+  }>
 >();
 
 const signatureForm = helper<DemoSig>(([i18nizer], { name, age }) =>
@@ -153,6 +137,15 @@ const badReturnSig = helper<DemoSig>(([i18nizer], { name, age }) =>
 );
 
 const greet = helper(([name]: [string]) => `Hello, ${name}`);
+expectTypeOf(greet).toEqualTypeOf<
+  FunctionBasedHelper<{
+    Args: {
+      Positional: [string];
+      Named: object;
+    };
+    Return: string;
+  }>
+>();
 
 // @ts-expect-error
 new greet();
@@ -160,10 +153,15 @@ new greet();
 // @ts-expect-error
 class Subgreet extends greet {}
 
+// Check that generics are accepted. (We cannot meaningfully test for how they
+// are *handled* because it uses items we do not want to expose in public API.)
 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];
+    Args: {
+      Positional: [T, T];
+      Named: object;
+    };
+    Return: T;
   }>
 >();
diff --git a/type-tests/@ember/component-test/set-component-template.ts b/type-tests/@ember/component-test/set-component-template.ts
index d416ae6e83c..9cf8615b4c4 100644
--- a/type-tests/@ember/component-test/set-component-template.ts
+++ b/type-tests/@ember/component-test/set-component-template.ts
@@ -1,5 +1,5 @@
 import { setComponentTemplate } from '@ember/component';
-import type { TemplateFactory } from 'htmlbars-inline-precompile';
+import type { TemplateFactory } from '@glimmer/interfaces';
 import { expectTypeOf } from 'expect-type';
 
 // Good enough for testing
diff --git a/type-tests/@ember/controller-test/octane.ts b/type-tests/@ember/controller-test/octane.ts
index 9d22f33f37b..ecb58c19dca 100644
--- a/type-tests/@ember/controller-test/octane.ts
+++ b/type-tests/@ember/controller-test/octane.ts
@@ -1,4 +1,4 @@
-import Controller, { inject } from '@ember/controller';
+import Controller, { ControllerQueryParam, inject } from '@ember/controller';
 
 class FirstController extends Controller {
   foo = 'bar';
@@ -10,11 +10,13 @@ class FirstController extends Controller {
     'category',
     {
       searchTerm: {
-        as: 'search',
+        type: 'number',
       },
+    },
+    {
       subCategory: 'sub-category',
     },
-  ];
+  ] as const;
 
   first() {
     return '';
diff --git a/type-tests/@ember/debug-tests.ts b/type-tests/@ember/debug-tests.ts
index bf5c8f39fbe..16e33d2bb46 100644
--- a/type-tests/@ember/debug-tests.ts
+++ b/type-tests/@ember/debug-tests.ts
@@ -18,10 +18,8 @@ expectTypeOf(runInDebug(() => console.log('Should not show up in prod'))).toBeVo
 
 // 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(
@@ -85,6 +83,14 @@ expectTypeOf(
   })
 ).toBeVoid();
 
+type ExpectedDeprecationOptions = {
+  id: string;
+  until: string;
+  url?: string;
+  for: string;
+  since: { available: string } | { available: string; enabled: string };
+};
+
 // next is not called, so no warnings get the default behavior
 // @ts-expect-error
 registerDeprecationHandler();
@@ -92,16 +98,16 @@ expectTypeOf(registerDeprecationHandler(() => {})).toBeVoid();
 expectTypeOf(
   registerDeprecationHandler((message, options, next) => {
     expectTypeOf(message).toBeString();
-    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(options).toEqualTypeOf<ExpectedDeprecationOptions | undefined>();
     expectTypeOf(next).toEqualTypeOf<
-      (message: string, options?: { id: string; until: string } | undefined) => void
+      (message: string, options?: ExpectedDeprecationOptions | undefined) => void
     >();
   })
 ).toBeVoid();
 expectTypeOf(
   registerDeprecationHandler((message, options, next) => {
     expectTypeOf(message).toBeString();
-    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(options).toEqualTypeOf<ExpectedDeprecationOptions | undefined>();
     // @ts-expect-error
     next();
   })
@@ -109,25 +115,22 @@ expectTypeOf(
 expectTypeOf(
   registerDeprecationHandler((message, options, next) => {
     expectTypeOf(message).toBeString();
-    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(options).toEqualTypeOf<ExpectedDeprecationOptions | undefined>();
     expectTypeOf(next(message)).toBeVoid();
   })
 ).toBeVoid();
 expectTypeOf(
   registerDeprecationHandler((message, options, next) => {
     expectTypeOf(message).toBeString();
-    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(options).toEqualTypeOf<ExpectedDeprecationOptions | 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, {});
diff --git a/type-tests/@ember/destroyable-test.ts b/type-tests/@ember/destroyable-test.ts
index 918f34296ce..f85f1604333 100644
--- a/type-tests/@ember/destroyable-test.ts
+++ b/type-tests/@ember/destroyable-test.ts
@@ -18,7 +18,7 @@ enableDestroyableTracking({});
 enableDestroyableTracking('foo');
 // @ts-expect-error
 enableDestroyableTracking(1);
-enableDestroyableTracking();
+enableDestroyableTracking?.();
 
 class Child {
   state: boolean;
@@ -87,4 +87,4 @@ assertDestroyablesDestroyed({});
 assertDestroyablesDestroyed('foo');
 // @ts-expect-error
 assertDestroyablesDestroyed(1);
-assertDestroyablesDestroyed();
+assertDestroyablesDestroyed?.();
diff --git a/type-tests/@ember/engine-test/engine.ts b/type-tests/@ember/engine-test/engine.ts
index 994ff9da610..e6a0057874f 100755
--- a/type-tests/@ember/engine-test/engine.ts
+++ b/type-tests/@ember/engine-test/engine.ts
@@ -42,4 +42,7 @@ const Engine3 = BaseEngine.create();
 
 const Engine3Instance1 = Engine3.buildInstance();
 
+// @ts-expect-error
 const Engine3Instance2 = Engine3.buildInstance({ foo: 'bar' });
+
+const Engine3Instance3 = Engine3.buildInstance({ mountPoint: 'somewhere', routable: true });
diff --git a/type-tests/@ember/modifier-tests.ts b/type-tests/@ember/modifier-tests.ts
index b90b0356d27..298ab61f7c4 100644
--- a/type-tests/@ember/modifier-tests.ts
+++ b/type-tests/@ember/modifier-tests.ts
@@ -1,6 +1,15 @@
-import { setModifierManager, capabilities, on, OnModifier } from '@ember/modifier';
+import {
+  setModifierManager,
+  capabilities,
+  on,
+  type OnModifier,
+  type ModifierCapabilities,
+} from '@ember/modifier';
+import { ModifierManager } from '@glimmer/interfaces';
 import { expectTypeOf } from 'expect-type';
 
 expectTypeOf(on).toEqualTypeOf<OnModifier>();
-expectTypeOf(setModifierManager((_owner) => {}, {})).toEqualTypeOf<{}>();
-expectTypeOf(capabilities('3.24')).toBeUnknown();
+
+declare let manager: ModifierManager<unknown>;
+expectTypeOf(setModifierManager((_owner) => manager, {})).toEqualTypeOf<{}>();
+expectTypeOf(capabilities('3.22')).toEqualTypeOf<ModifierCapabilities>();
diff --git a/type-tests/@ember/object-test/computed.ts b/type-tests/@ember/object-test/computed.ts
index cbb90910b6d..621bbb5cfa4 100644
--- a/type-tests/@ember/object-test/computed.ts
+++ b/type-tests/@ember/object-test/computed.ts
@@ -153,6 +153,7 @@ class Bar extends EmberObject {
 
   // @ts-expect-error
   @and declare andTest0: boolean;
+  // @ts-expect-error
   @and() declare andTest1: boolean;
   @and('firstName') declare andTest2: boolean;
   @and('firstName', 'lastName') declare andTest3: boolean;
@@ -165,6 +166,7 @@ class Bar extends EmberObject {
 
   // @ts-expect-error
   @collect declare collectTest0: unknown[];
+  // @ts-expect-error
   @collect() declare collectTest1: unknown[];
   @collect('firstName') declare collectTest2: string[];
 
@@ -174,7 +176,12 @@ class Bar extends EmberObject {
   @deprecatingAlias() declare deprecatingAliasTest1: string;
   // @ts-expect-error
   @deprecatingAlias('firstName') declare deprecatingAliasTest2: string;
-  @deprecatingAlias('firstName', { id: 'deprecate-everything', until: 'v5.0.0' })
+  @deprecatingAlias('firstName', {
+    id: 'deprecate-everything',
+    until: 'v5.0.0',
+    for: 'test',
+    since: { available: '5.1.0', enabled: '5.3.0' },
+  })
   declare deprecatingAliasTest3: string;
 
   // @ts-expect-error
@@ -228,6 +235,7 @@ class Bar extends EmberObject {
 
   // @ts-expect-error
   @intersect declare intersectTest1: any;
+  // @ts-expect-error
   @intersect() declare intersectTest2: any;
   @intersect('firstName') declare intersectTest3: any;
   @intersect('firstName', 'lastName') declare intersectTest4: any;
@@ -324,6 +332,7 @@ class Bar extends EmberObject {
 
   // @ts-expect-error
   @or declare orTest1: boolean;
+  // @ts-expect-error
   @or() declare orTest2: boolean;
   @or('firstName') declare orTest3: boolean;
   @or('firstName', 'lastName') declare orTest4: boolean;
@@ -376,6 +385,7 @@ class Bar extends EmberObject {
 
   // @ts-expect-error
   @union declare unionTest1: never;
+  // @ts-expect-error
   @union() declare unionTest2: [];
   @union('firstName') declare unionTest3: string[];
   @union('firstName', 'lastName') declare unionTest4: string[];
diff --git a/type-tests/@ember/object-test/core.ts b/type-tests/@ember/object-test/core.ts
index bc028dc41e4..0171bd74f88 100644
--- a/type-tests/@ember/object-test/core.ts
+++ b/type-tests/@ember/object-test/core.ts
@@ -48,6 +48,6 @@ class CO5 extends CoreObject {
 }
 // @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: true })).toEqualTypeOf<CO5 & { foo: boolean }>();
+expectTypeOf(CO5.create({ foo: 'abc' })).toEqualTypeOf<CO5 & { foo: string }>();
 expectTypeOf(CO5.create().foo).toEqualTypeOf<boolean | string>();
diff --git a/type-tests/@ember/object-test/create-negative.ts b/type-tests/@ember/object-test/create-negative.ts
index 86557265951..feeb9366f30 100644
--- a/type-tests/@ember/object-test/create-negative.ts
+++ b/type-tests/@ember/object-test/create-negative.ts
@@ -1,8 +1,25 @@
+import { expectTypeOf } from 'expect-type';
 import { Person } from './create';
 
-// @ts-expect-error
-Person.create({ firstName: 99 });
-// @ts-expect-error
-Person.create({}, { firstName: 99 });
-// @ts-expect-error
-Person.create({}, {}, { firstName: 99 });
+// Let's see some *real* type-unsafety! These demonstrate that we just
+// absolutely lie about the runtime behavior for `.create()`. 😬 The result of
+// calling these with `firstName: 99` is to *change the type* of the resulting
+// object from `Person` to `Person` with `firstName: number`. While we might
+// *like* to prevent that call and make sure that `firstName` matches the type
+// we cannot reasonably do so.
+
+expectTypeOf(Person.create({ firstName: 99 })).toEqualTypeOf<
+  Person & {
+    firstName: number;
+  }
+>();
+expectTypeOf(Person.create({}, { firstName: 99 })).toEqualTypeOf<
+  Person & {
+    firstName: number;
+  }
+>();
+expectTypeOf(Person.create({}, {}, { firstName: 99 })).toEqualTypeOf<
+  Person & {
+    firstName: number;
+  }
+>();
diff --git a/type-tests/@ember/object-test/event.ts b/type-tests/@ember/object-test/event.ts
index dc80b26f1ec..f2968910809 100644
--- a/type-tests/@ember/object-test/event.ts
+++ b/type-tests/@ember/object-test/event.ts
@@ -60,15 +60,6 @@ function testEvented() {
   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() {}
 
@@ -81,12 +72,12 @@ function testListener() {
       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);
+      addListener(this, 'willDestroy', null, 'willDestroyListener');
+      addListener(this, 'willDestroy', null, 'willDestroyListener', true);
+      addListener(this, 'willDestroy', null, willDestroyListener);
+      addListener(this, 'willDestroy', null, willDestroyListener, true);
+      removeListener(this, 'willDestroy', null, 'willDestroyListener');
+      removeListener(this, 'willDestroy', null, willDestroyListener);
     }
 
     willDestroyListener() {
diff --git a/type-tests/@ember/object-test/extend.ts b/type-tests/@ember/object-test/extend.ts
index 235271801e9..19ee88b8a45 100644
--- a/type-tests/@ember/object-test/extend.ts
+++ b/type-tests/@ember/object-test/extend.ts
@@ -16,16 +16,16 @@ class Person extends EmberObject {
 expectTypeOf(Person.prototype.firstName).toBeString();
 expectTypeOf(Person.prototype.fullName).toBeString();
 
+// We cannot forbid extra properties, but we do at least smush them onto the
+// resulting type.
 const person = Person.create({
   firstName: 'Joe',
   lastName: 'Blow',
-  // @ts-expect-error
   extra: 42,
 });
 
 expectTypeOf(person.fullName).toBeString();
-// @ts-expect-error
-person.extra;
+expectTypeOf(person.extra).toBeNumber();
 
 class PersonWithStatics extends EmberObject {
   static isPerson = true;
diff --git a/type-tests/@ember/object-test/get-set.ts b/type-tests/@ember/object-test/get-set.ts
index d17a7d3bb05..dd4dceefeed 100644
--- a/type-tests/@ember/object-test/get-set.ts
+++ b/type-tests/@ember/object-test/get-set.ts
@@ -6,8 +6,12 @@ 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');
+// This matches the runtime behavior. We do not catch setting things this way,
+// as a result, but in a world where native property access works everywhere,
+// this is actually somewhat useful: it means you can set anything on a target
+// object, and although the type will not be updated with that change, it will
+// at least type check in a way that matches the dynamic runtime behavior.
+expectTypeOf(set(basicPojo, 'salutation', 'heyo')).toBeString();
 
 declare let whoKnows: unknown;
 expectTypeOf(get(whoKnows, 'any-string')).toEqualTypeOf<unknown>();
diff --git a/type-tests/@ember/object-test/object.ts b/type-tests/@ember/object-test/object.ts
index 6a022f01099..17f0cec86d0 100644
--- a/type-tests/@ember/object-test/object.ts
+++ b/type-tests/@ember/object-test/object.ts
@@ -1,4 +1,5 @@
 import Object, { computed, get, notifyPropertyChange, set, setProperties } from '@ember/object';
+import Owner from '@ember/owner';
 import { expectTypeOf } from 'expect-type';
 
 class LifetimeHooks extends Object {
@@ -22,8 +23,8 @@ class MyObject30 extends Object {
 }
 
 class MyObject31 extends Object {
-  constructor(properties: object) {
-    super(properties);
+  constructor(owner: Owner) {
+    super(owner);
   }
 }
 
@@ -82,8 +83,8 @@ export class Foo2 extends Object {
     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'>>();
+    expectTypeOf(this.setProperties({ name })).toEqualTypeOf<{ name: string }>();
+    expectTypeOf(setProperties(this, { name })).toEqualTypeOf<{ name: string }>();
   }
 
   bar() {
diff --git a/type-tests/@ember/object-test/observable.ts b/type-tests/@ember/object-test/observable.ts
index cec5a0f11c5..47f7d5b9b97 100644
--- a/type-tests/@ember/object-test/observable.ts
+++ b/type-tests/@ember/object-test/observable.ts
@@ -72,9 +72,12 @@ function testGetProperties() {
     name: string;
     age: number;
   }>();
-  expectTypeOf(person.getProperties('name', 'age', 'capitalized')).toEqualTypeOf<
-    Pick<Person, 'name' | 'age' | 'capitalized'>
-  >();
+
+  expectTypeOf(person.getProperties('name', 'age', 'capitalized')).toEqualTypeOf<{
+    name: string;
+    age: number;
+    capitalized: string;
+  }>();
   expectTypeOf(getProperties(pojo, 'name', 'age')).toEqualTypeOf<{ name: string; age: number }>();
 }
 
@@ -82,9 +85,9 @@ function testSet() {
   expectTypeOf(set(person, 'name', 'Joe')).toEqualTypeOf<string>();
   expectTypeOf(set(person, 'age', 35)).toEqualTypeOf<number>();
   expectTypeOf(set(person, 'capitalized', 'JOE')).toEqualTypeOf<string>();
-  expectTypeOf(person.set('name', 'Joe')).toEqualTypeOf<string>();
-  expectTypeOf(person.set('age', 35)).toEqualTypeOf<number>();
-  expectTypeOf(person.set('capitalized', 'JOE')).toEqualTypeOf<string>();
+  expectTypeOf(person.set('name', 'Joe')).toEqualTypeOf<'Joe'>();
+  expectTypeOf(person.set('age', 35)).toEqualTypeOf<35>();
+  expectTypeOf(person.set('capitalized', 'JOE')).toEqualTypeOf<'JOE'>();
   expectTypeOf(set(pojo, 'name', 'Joe')).toEqualTypeOf<string>();
 }
 
@@ -101,9 +104,10 @@ function testSetProperties() {
   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(person.setProperties({ name: 'Joe', capitalized: 'JOE' })).toEqualTypeOf<{
+    name: string;
+    capitalized: string;
+  }>();
   expectTypeOf(setProperties(pojo, { name: 'Joe', age: 35 })).toEqualTypeOf<
     Pick<Person, 'name' | 'age'>
   >();
diff --git a/type-tests/@ember/object-test/proxy.ts b/type-tests/@ember/object-test/proxy.ts
index fec756a37c3..ebebf9a6ffe 100644
--- a/type-tests/@ember/object-test/proxy.ts
+++ b/type-tests/@ember/object-test/proxy.ts
@@ -2,6 +2,14 @@ import Ember from 'ember';
 import ObjectProxy from '@ember/object/proxy';
 import { expectTypeOf } from 'expect-type';
 
+declare class X extends Ember.Object {
+  foo: string;
+  bar: number;
+}
+
+declare let x: X;
+x.getProperties('foo', 'bar');
+
 interface Book {
   title: string;
   subtitle: string;
@@ -9,7 +17,7 @@ interface Book {
 }
 
 class DefaultProxy extends ObjectProxy {}
-expectTypeOf(DefaultProxy.create().content).toEqualTypeOf<object | undefined>();
+expectTypeOf(DefaultProxy.create().content).toBeUnknown();
 
 class BookProxy extends ObjectProxy<Book> {
   private readonly baz = 'baz';
@@ -26,30 +34,30 @@ class BookProxy extends ObjectProxy<Book> {
 }
 
 const book = BookProxy.create();
-expectTypeOf(book.content).toEqualTypeOf<Book | undefined>();
+expectTypeOf(book.content).toEqualTypeOf<Book | null>();
 
-// @ts-expect-error
-book.get('unknownProperty');
-expectTypeOf(book.get('title')).toEqualTypeOf<string | undefined>();
+expectTypeOf(book.get('some-nonsense-property')).toBeUnknown();
+expectTypeOf(book.get('title')).toBeString();
 expectTypeOf(book.get('altTitle')).toBeString();
-expectTypeOf(book.getTitle()).toEqualTypeOf<string | undefined>();
+expectTypeOf(book.getTitle()).toBeString();
 
-// @ts-expect-error
-book.getProperties('title', 'unknownProperty');
+book.getProperties('title', 'some-nonsense-property');
 expectTypeOf(book.getProperties('title', 'subtitle')).toEqualTypeOf<
-  Pick<Partial<Book>, 'title' | 'subtitle'>
->();
-expectTypeOf(book.getPropertiesTitleSubtitle()).toEqualTypeOf<
-  Pick<Partial<Book>, 'title' | 'subtitle'>
+  Pick<Book, 'title' | 'subtitle'>
 >();
+expectTypeOf(book.getPropertiesTitleSubtitle()).toEqualTypeOf<Pick<Book, 'title' | 'subtitle'>>();
 expectTypeOf(book.getProperties(['subtitle', 'chapters'])).toEqualTypeOf<
-  Pick<Partial<Book>, 'subtitle' | 'chapters'>
+  Pick<Book, 'subtitle' | 'chapters'>
 >();
-// @ts-expect-error
-book.getProperties(['title', 'unknownProperty']);
+expectTypeOf(book.getProperties(['title', 'some-nonsense-property'])).toEqualTypeOf<
+  Record<'title' | 'some-nonsense-property', unknown>
+>;
+expectTypeOf(book.getProperties('title', 'altTitle')).toEqualTypeOf<{
+  title: string;
+  altTitle: string;
+}>;
 
-// @ts-expect-error
-book.get('baz');
+expectTypeOf(book.get('baz')).toBeUnknown();
 
 book.set('title', 'New');
 // @ts-expect-error
@@ -62,11 +70,8 @@ book.setProperties({
   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 {
@@ -91,18 +96,16 @@ class PersonProxy extends ObjectProxy<Person> {}
 
 const person = PersonProxy.create();
 
-expectTypeOf(person.get('firstName')).toEqualTypeOf<string | undefined>();
-expectTypeOf(person.get('fullName')).toEqualTypeOf<string | undefined>();
+expectTypeOf(person.get('firstName')).toBeString();
+expectTypeOf(person.get('fullName')).toBeString();
 expectTypeOf(person.set('fullName', 'John Doe')).toBeString();
 // @ts-expect-error
 person.set('fullName', 1);
 // @ts-expect-error
 person.set('invalid', true);
-expectTypeOf(person.setProperties({ fullName: 'John Doe' })).toEqualTypeOf<
-  Pick<PersonProxy & Person, 'fullName'>
->();
+expectTypeOf(person.setProperties({ fullName: 'John Doe' })).toEqualTypeOf<{
+  fullName: 'John Doe';
+}>();
 expectTypeOf(person.setProperties({ fullName: 'John Doe' }).fullName).toBeString();
-// @ts-expect-error
 person.setProperties({ fullName: 1 });
-// @ts-expect-error
 person.setProperties({ fullName: 'John Doe', invalid: true });
diff --git a/type-tests/@ember/routing-test/built-ins.ts b/type-tests/@ember/routing-test/built-ins.ts
index 80efe6516b6..98752f0f50b 100644
--- a/type-tests/@ember/routing-test/built-ins.ts
+++ b/type-tests/@ember/routing-test/built-ins.ts
@@ -2,4 +2,9 @@ import { LinkTo } from '@ember/routing';
 import { expectTypeOf } from 'expect-type';
 
 // Basic check taht we export both type and value correctly.
-expectTypeOf(LinkTo).toEqualTypeOf<LinkTo>();
+expectTypeOf(LinkTo).not.toBeUndefined();
+expectTypeOf<LinkTo>().not.toBeUndefined();
+
+// And that it is opaquified as we expect.
+expectTypeOf(LinkTo.create()).toEqualTypeOf<never>();
+expectTypeOf(LinkTo.toString()).toBeString();
diff --git a/type-tests/@ember/routing-test/route.ts b/type-tests/@ember/routing-test/route.ts
index 2ce642ec79d..d46c61cb460 100755
--- a/type-tests/@ember/routing-test/route.ts
+++ b/type-tests/@ember/routing-test/route.ts
@@ -6,21 +6,25 @@ import EmberObject from '@ember/object';
 import Controller from '@ember/controller';
 import type Transition from '@ember/routing/transition';
 import { expectTypeOf } from 'expect-type';
+import { service } from '@ember/service';
+import RouterService from '@ember/routing/router-service';
 
 class Post extends EmberObject {}
 
 interface Posts extends Array<Post> {}
 
 class BeforeModelText extends Route {
+  @service declare router: RouterService;
   beforeModel(transition: Transition) {
-    this.transitionTo('someOtherRoute');
+    this.router.transitionTo('someOtherRoute');
   }
 }
 
 class AfterModel extends Route {
+  @service declare router: RouterService;
   afterModel(posts: Posts, transition: Transition) {
     if (posts.firstObject) {
-      this.transitionTo('post.show', posts.firstObject);
+      this.router.transitionTo('post.show', posts.firstObject);
     }
   }
 }
@@ -47,78 +51,39 @@ class ResetControllerTest extends Route {
 }
 
 class ActivateRoute extends Route {
+  @service declare router: RouterService;
   activate(transition: Transition) {
-    this.transitionTo('someOtherRoute');
+    this.router.transitionTo('someOtherRoute');
   }
 }
 
 class DeactivateRoute extends Route {
+  @service declare router: RouterService;
   deactivate(transition: Transition) {
-    this.transitionTo('someOtherRoute');
+    this.router.transitionTo('someOtherRoute');
   }
 }
 
 class RedirectRoute extends Route {
+  @service declare router: RouterService;
   redirect(model: {}, a: Transition) {
     if (!model) {
-      this.transitionTo('there');
+      this.router.transitionTo('there');
     }
   }
 }
 
 class InvalidRedirect extends Route {
+  @service declare router: RouterService;
   // @ts-expect-error
   redirect(model: {}, a: Transition, anOddArg: unknown) {
     if (!model) {
-      this.transitionTo('there');
+      this.router.transitionTo('there');
     }
   }
 }
 
-class TransitionToExamples extends Route {
-  // NOTE: this one won't check that `queryParams` has the right shape,
-  // because the overload for the version where `models` are passed
-  // necessarily includes all objects.
-  transitionToModelAndQP() {
-    expectTypeOf(
-      this.transitionTo('somewhere', { queryParams: { neat: true } })
-    ).toEqualTypeOf<Transition>();
-  }
-
-  transitionToJustQP() {
-    expectTypeOf(this.transitionTo({ queryParams: { neat: 'true' } })).toEqualTypeOf<Transition>();
-  }
-
-  transitionToNonsense() {
-    // @ts-expect-error
-    this.transitionTo({ cannotDoModelHere: true });
-  }
-
-  transitionToBadQP() {
-    // @ts-expect-error
-    this.transitionTo({ queryParams: 12 });
-  }
-
-  transitionToId() {
-    expectTypeOf(this.transitionTo('blog-post', 1)).toEqualTypeOf<Transition<unknown>>();
-  }
-
-  transitionToIdWithQP() {
-    expectTypeOf(
-      this.transitionTo('blog-post', 1, { queryParams: { includeComments: true } })
-    ).toEqualTypeOf<Transition<unknown>>();
-  }
-
-  transitionToIds() {
-    expectTypeOf(this.transitionTo('blog-comment', 1, '13')).toEqualTypeOf<Transition<unknown>>();
-  }
-
-  transitionToIdsWithQP() {
-    expectTypeOf(
-      this.transitionTo('blog-comment', 1, '13', { queryParams: { includePost: true } })
-    ).toEqualTypeOf<Transition<unknown>>();
-  }
-
+class BuidlRouteInfoMetadata extends Route {
   buildRouteInfoMetadata() {
     return { foo: 'bar' };
   }
@@ -141,27 +106,7 @@ class SetupControllerTest extends Route {
 
 const route = Route.create();
 expectTypeOf(route.controllerFor('whatever')).toEqualTypeOf<Controller>();
-expectTypeOf(route.paramsFor('whatever')).toEqualTypeOf<object>();
-
-class RouteUsingClass extends Route.extend({
-  randomProperty: 'the .extend + extends bit type-checks properly',
-}) {
-  beforeModel() {
-    return Promise.resolve('beforeModel can return promises');
-  }
-  afterModel(resolvedModel: unknown, transition: Transition) {
-    return Promise.resolve('afterModel can also return promises');
-  }
-  intermediateTransitionWithoutModel() {
-    this.intermediateTransitionTo('some-route');
-  }
-  intermediateTransitionWithModel() {
-    this.intermediateTransitionTo('some.other.route', {});
-  }
-  intermediateTransitionWithMultiModel() {
-    this.intermediateTransitionTo('some.other.route', 1, 2, {});
-  }
-}
+expectTypeOf(route.paramsFor('whatever')).toEqualTypeOf<Record<string, unknown>>();
 
 class WithNonReturningBeforeAndModelHooks extends Route {
   beforeModel(transition: Transition): void | Promise<unknown> {
@@ -189,8 +134,8 @@ interface RouteParams {
   cool: string;
 }
 
-class WithParamsInModel extends Route<boolean, RouteParams> {
-  model(params: RouteParams, transition: Transition) {
+class WithParamsInModel extends Route<boolean> {
+  model(params: { cool: string }, transition: Transition) {
     return true;
   }
 }
@@ -199,10 +144,7 @@ class WithParamsInModel extends Route<boolean, RouteParams> {
 class WithNonsenseParams extends Route<boolean, number> {}
 
 class WithImplicitParams extends Route {
-  model(params: RouteParams) {
+  model(params: { cool: string }) {
     return { whatUp: 'dog' };
   }
 }
-
-type ImplicitParams = WithImplicitParams extends Route<any, infer T> ? T : never;
-expectTypeOf<ImplicitParams>().toEqualTypeOf<RouteParams>();
diff --git a/type-tests/@ember/routing-test/router-service.ts b/type-tests/@ember/routing-test/router-service.ts
index 7bd771ca82f..dbd109eda9d 100644
--- a/type-tests/@ember/routing-test/router-service.ts
+++ b/type-tests/@ember/routing-test/router-service.ts
@@ -2,6 +2,7 @@ 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';
+import type { Promise as RSVPPromise } from 'rsvp';
 
 declare let router: RouterService;
 
@@ -20,27 +21,27 @@ expectTypeOf(router.on('routeWillChange', routeWillChangeHandler)).toEqualTypeOf
 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>();
+expectTypeOf(router.trigger('routeWillChange', 'boo')).toBeAny();
 
 const transition = router.transitionTo('someRoute');
 
-expectTypeOf(transition.abort()).toEqualTypeOf<Transition<unknown>>();
+expectTypeOf(transition.abort()).toEqualTypeOf<Transition>();
 
-expectTypeOf(transition.catch()).toEqualTypeOf<Promise<unknown>>();
+expectTypeOf(transition.catch()).toEqualTypeOf<RSVPPromise<any>>();
 transition.catch((err) => console.log(err), 'label');
 
-expectTypeOf(transition.finally()).toEqualTypeOf<Promise<unknown>>();
+expectTypeOf(transition.finally()).toEqualTypeOf<RSVPPromise<unknown>>();
 transition.finally(() => console.log('finally!'));
 transition.finally(() => console.log('finally!'), 'label');
 
-expectTypeOf(transition.followRedirects()).toEqualTypeOf<Promise<unknown>>();
+expectTypeOf(transition.followRedirects()).toEqualTypeOf<RSVPPromise<unknown>>();
 
-expectTypeOf(transition.method()).toEqualTypeOf<Transition<unknown>>();
+expectTypeOf(transition.method('refresh')).toEqualTypeOf<Transition>();
 transition.method('replace');
 
-expectTypeOf(transition.retry()).toEqualTypeOf<Transition<unknown>>();
+expectTypeOf(transition.retry()).toEqualTypeOf<Transition>();
 
-expectTypeOf(transition.then()).toEqualTypeOf<Promise<unknown>>();
+expectTypeOf(transition.then()).toEqualTypeOf<RSVPPromise<unknown>>();
 transition.then(
   (result) => console.log(result),
   (err) => console.log(err),
@@ -53,19 +54,19 @@ expectTypeOf(transition.send(false, 'error')).toEqualTypeOf<void>();
 
 transition.data = { some: 'data' };
 
-expectTypeOf(transition.from).toEqualTypeOf<RouteInfoWithAttributes | null>();
+expectTypeOf(transition.from).toEqualTypeOf<RouteInfoWithAttributes | null | undefined | void>();
 // @ts-expect-error
 transition.from = 'from';
 
-expectTypeOf(transition.promise).toEqualTypeOf<Promise<unknown>>();
+expectTypeOf(transition.promise).toEqualTypeOf<RSVPPromise<any> | undefined>();
 // @ts-expect-error
 transition.promise = 'promise';
 
-expectTypeOf(transition.to).toEqualTypeOf<RouteInfo | RouteInfoWithAttributes>();
+expectTypeOf(transition.to).toEqualTypeOf<RouteInfo | RouteInfoWithAttributes | undefined>();
 // @ts-expect-error
 transition.to = 'to';
 
-expectTypeOf(transition.to.metadata).toEqualTypeOf<unknown>();
+expectTypeOf(transition.to?.metadata).toEqualTypeOf<unknown>();
 // @ts-expect-error
 transition.to.metadata = 'foo';
 
@@ -73,30 +74,29 @@ transition.to.metadata = 'foo';
 // 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
+expectTypeOf(
+  router.transitionTo('someRoute', { queryParams: { shouldWork: true } })
+).toEqualTypeOf<Transition>();
+expectTypeOf(
+  router.transitionTo({ queryParams: { areSupported: true } })
+).toEqualTypeOf<Transition>();
 router.transitionTo({ queryParams: 'potato' });
-expectTypeOf(router.transitionTo('someRoute', 1)).toEqualTypeOf<Transition<unknown>>();
+expectTypeOf(router.transitionTo('someRoute', 1)).toEqualTypeOf<Transition>();
 expectTypeOf(
   router.transitionTo('someRoute', 1, { queryParams: { areSupported: true } })
-).toEqualTypeOf<Transition<unknown>>();
-expectTypeOf(router.transitionTo('someRoute', 1, '13')).toEqualTypeOf<Transition<unknown>>();
+).toEqualTypeOf<Transition>();
+expectTypeOf(router.transitionTo('someRoute', 1, '13')).toEqualTypeOf<Transition>();
 expectTypeOf(
   router.transitionTo('someRoute', 1, '13', { queryParams: { areSupported: true } })
-).toEqualTypeOf<Transition<unknown>>();
+).toEqualTypeOf<Transition>();
 
-expectTypeOf(router.recognize('foo/bar')).toEqualTypeOf<RouteInfo>();
+expectTypeOf(router.recognize('foo/bar')).toEqualTypeOf<RouteInfo | null>();
 
-expectTypeOf(router.recognizeAndLoad('foo/bar')).toEqualTypeOf<RouteInfoWithAttributes>();
+expectTypeOf(router.recognizeAndLoad('foo/bar')).toEqualTypeOf<Promise<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>>();
+expectTypeOf(router.refresh()).toEqualTypeOf<Transition>();
+expectTypeOf(router.refresh('my-route')).toEqualTypeOf<Transition>();
diff --git a/type-tests/@ember/routing-test/router.ts b/type-tests/@ember/routing-test/router.ts
index fab3ba98b8b..940f538e3b2 100755
--- a/type-tests/@ember/routing-test/router.ts
+++ b/type-tests/@ember/routing-test/router.ts
@@ -2,7 +2,7 @@ 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 RouteInfo, { RouteInfoWithAttributes } from '@ember/routing/route-info';
 
 import { expectTypeOf } from 'expect-type';
 
@@ -31,13 +31,14 @@ AppRouter.map(function () {
 class RouterServiceConsumer extends Service {
   @service('router') declare router: RouterService;
   currentRouteName() {
-    expectTypeOf(get(this, 'router').currentRouteName).toEqualTypeOf<string>();
+    let router = get(this, 'router');
+    expectTypeOf(this.router.currentRouteName).toEqualTypeOf<string | null>();
   }
   currentURL() {
-    expectTypeOf(get(this, 'router').currentURL).toEqualTypeOf<string>();
+    expectTypeOf(this.router.currentURL).toEqualTypeOf<string | null>();
   }
   rootURL() {
-    expectTypeOf(get(this, 'router').rootURL).toEqualTypeOf<string>();
+    expectTypeOf(this.router.rootURL).toEqualTypeOf<string>();
   }
   transitionWithoutModel() {
     get(this, 'router').transitionTo('some-route');
@@ -55,29 +56,32 @@ class RouterServiceConsumer extends Service {
     get(this, 'router').transitionTo('index', model, { queryParams: { search: 'ember' } });
   }
   onAndRouteInfo() {
-    const router = get(this, 'router');
-    router
+    this.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>();
+        if (to) {
+          expectTypeOf(to.child).toEqualTypeOf<RouteInfo | RouteInfoWithAttributes | null>();
+          expectTypeOf(to.localName).toEqualTypeOf<string>();
+          expectTypeOf(to.name).toEqualTypeOf<string>();
+          expectTypeOf(to.paramNames).toEqualTypeOf<string[]>();
+          expectTypeOf(to.params?.['foo']).toBeUnknown();
+          expectTypeOf(to.parent).toEqualTypeOf<RouteInfo | RouteInfoWithAttributes | null>();
+          expectTypeOf(to.queryParams['foo']).toBeUnknown();
+          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.child).toEqualTypeOf<RouteInfo | RouteInfoWithAttributes | 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.params?.['foo']).toBeUnknown();
+          expectTypeOf(from.parent).toEqualTypeOf<RouteInfo | RouteInfoWithAttributes | null>();
+          expectTypeOf(from.queryParams['foo']).toBeUnknown();
           expectTypeOf(from.find((info) => info.name === 'foo')).toEqualTypeOf<
             RouteInfo | undefined
           >();
diff --git a/type-tests/@ember/runloop-tests.ts b/type-tests/@ember/runloop-tests.ts
index 799d86ef5c6..4e4c3c9ef8f 100644
--- a/type-tests/@ember/runloop-tests.ts
+++ b/type-tests/@ember/runloop-tests.ts
@@ -16,18 +16,8 @@ import {
   _backburner,
 } from '@ember/runloop';
 import EmberObject, { action } from '@ember/object';
-import type {
-  Backburner,
-  DebugInfo,
-  QueueItem,
-  DeferredActionQueues,
-} from '@ember/runloop/-private/backburner';
-
-// It will be the responsibility of each consuming package that needs access to the backburner property
-// to merge the private types in the public API.
-declare module '@ember/runloop' {
-  const _backburner: Backburner;
-}
+import { AnyFn, MethodsOf } from '@ember/-internals/utility-types';
+import { expectTypeOf } from 'expect-type';
 
 function testRun() {
   run(() => {
@@ -68,10 +58,27 @@ function testRun() {
 
 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');
+    // @ts-expect-error
+    bound(123);
+    // @ts-expect-error
+    bound();
+
+    const boundWithArg = bind(this, this.setupEditor, 'hello');
+    boundWithArg();
+    // @ts-expect-error
+    boundWithArg('hello');
+    // @ts-expect-error
+    boundWithArg(123);
+
+    // @ts-expect-error
+    const badBind = bind(this, this.setupEditor, 123);
+
+    // We would like to make this safe in the same way as the version above,
+    // but TS cannot see the string relationship *specifically when doing a
+    // lookup against a `this` type*, so we fall back to the comparable types
+    // as in `Function.prototype.bind` here.
     const boundAgain = bind(this, 'setupEditor');
     boundAgain('hello');
   }
@@ -83,6 +90,27 @@ class TestBind extends EmberObject {
   }
 }
 
+// We *can* check that it works on a general instance, though.
+declare let testBindInstance: TestBind;
+let bound = bind(testBindInstance, 'setupEditor');
+bound('hello');
+// @ts-expect-error
+bound(123);
+// @ts-expect-error
+bound();
+
+let boundWithArg = bind(testBindInstance, 'setupEditor', 'hello');
+boundWithArg();
+// @ts-expect-error
+boundWithArg('hello');
+// @ts-expect-error
+boundWithArg(123);
+
+// @ts-expect-error
+const badBindValue = bind(testBindInstance, testBindInstance.setupEditor, 123);
+// This would be *nice* to check, bug it falls into the 'fallback' path.
+const badBindString = bind(testBindInstance, 'setupEditor', 123);
+
 function testCancel() {
   const myContext = {
     method(arg: string, another: number): number {
@@ -299,9 +327,3 @@ function testThrottle() {
   throttle(runIt, 150);
   throttle(myContext, runIt, 150);
 }
-
-function testBackburner() {
-  const debugInfo: DebugInfo = _backburner.getDebugInfo();
-  const queueItems: QueueItem[] = debugInfo.timers;
-  const deferredActionQueues: DeferredActionQueues[] = debugInfo.instanceStack;
-}
diff --git a/type-tests/@ember/test-tests.ts b/type-tests/@ember/test-tests.ts
index c21818e92aa..36aca9bcb1c 100644
--- a/type-tests/@ember/test-tests.ts
+++ b/type-tests/@ember/test-tests.ts
@@ -16,7 +16,7 @@ registerWaiter();
 registerHelper('boot', (app) => {
   expectTypeOf(app.advanceReadiness()).toBeVoid();
   expectTypeOf(app.deferReadiness()).toBeVoid();
-  expectTypeOf(app.register('foo', class {})).toBeVoid();
+  expectTypeOf(app.register('foo:bar', class {})).toBeVoid();
   // @ts-expect-error
   app.register('foo');
   // @ts-expect-error
@@ -34,7 +34,15 @@ registerAsyncHelper('waitForPromise', (app, promise) => {
   app.deferReadiness();
   app.register('foo', class {});
   return new Promise(() => {
-    const adapter = new TestAdapter();
+    // This needs a cast to itself, weird though that looks, because it is
+    // defined `EmberObject.extend()` not `class extends EmberObject`, and our
+    // types for `.extend` do not produce new classes (as described in the RFC
+    // for official TS support). Unfortunately, the "zebra-striping" problem,
+    // where doing `SomeNativeClass.extend()` can have weird behaviors in some
+    // edge cases, means that changing `TestAdapter` to use a native class would
+    // technically be a breaking change. Once the entire framework switches to
+    // native classes end to end, this cast will be unnecessary.
+    const adapter = new TestAdapter() as TestAdapter;
     adapter.asyncStart();
     return promise.then(() => {
       adapter.asyncEnd();
diff --git a/type-tests/@ember/utils-tests.ts b/type-tests/@ember/utils-tests.ts
index 506dfb94b1b..59887590f93 100644
--- a/type-tests/@ember/utils-tests.ts
+++ b/type-tests/@ember/utils-tests.ts
@@ -11,7 +11,8 @@ import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@
     return;
   }
   expectTypeOf(maybeUndefined).toBeString();
-  expectTypeOf(isNone()).toEqualTypeOf<boolean>();
+  // @ts-expect-error
+  isNone();
   expectTypeOf(isNone(null)).toEqualTypeOf<boolean>();
   expectTypeOf(isNone(undefined)).toEqualTypeOf<boolean>();
   expectTypeOf(isNone('')).toEqualTypeOf<boolean>();
@@ -21,7 +22,8 @@ import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@
 
 (function () {
   /** isPresent */
-  expectTypeOf(isPresent()).toEqualTypeOf<boolean>();
+  // @ts-expect-error
+  isPresent();
   expectTypeOf(isPresent(null)).toEqualTypeOf<boolean>();
   expectTypeOf(isPresent(undefined)).toEqualTypeOf<boolean>();
   expectTypeOf(isPresent('')).toEqualTypeOf<boolean>();
@@ -42,24 +44,25 @@ import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@
 
 (function () {
   /** typeOf */
-  expectTypeOf(typeOf(null)).toEqualTypeOf<'null'>();
-  expectTypeOf(typeOf(undefined)).toEqualTypeOf<'undefined'>();
-  expectTypeOf(typeOf('michael')).toEqualTypeOf<'string'>();
-  expectTypeOf(typeOf(new String('michael'))).toEqualTypeOf<'string'>();
-  expectTypeOf(typeOf(101)).toEqualTypeOf<'number'>();
-  expectTypeOf(typeOf(new Number(101))).toEqualTypeOf<'number'>();
-  expectTypeOf(typeOf(true)).toEqualTypeOf<'boolean'>();
-  expectTypeOf(typeOf(new Boolean(true))).toEqualTypeOf<'boolean'>();
-  expectTypeOf(typeOf(() => 4)).toEqualTypeOf<'function'>();
-  expectTypeOf(typeOf([1, 2, 90])).toEqualTypeOf<'array'>();
-  expectTypeOf(typeOf(/abc/)).toEqualTypeOf<'regexp'>();
-  expectTypeOf(typeOf(new Date())).toEqualTypeOf<'date'>();
-  expectTypeOf(typeOf(new FileList())).toEqualTypeOf<'filelist'>();
-  expectTypeOf(typeOf(EmberObject.extend())).toEqualTypeOf<'class'>();
-  expectTypeOf(typeOf(EmberObject.create())).toEqualTypeOf<'instance'>();
-  expectTypeOf(typeOf(new Error('teamocil'))).toEqualTypeOf<'error'>();
-  expectTypeOf(typeOf({ justAPojo: true })).toEqualTypeOf<'object'>();
+  expectTypeOf(typeOf(null)).toBeString();
+  expectTypeOf(typeOf(undefined)).toBeString();
+  expectTypeOf(typeOf('michael')).toBeString();
+  expectTypeOf(typeOf(new String('michael'))).toBeString();
+  expectTypeOf(typeOf(101)).toBeString();
+  expectTypeOf(typeOf(new Number(101))).toBeString();
+  expectTypeOf(typeOf(true)).toBeString();
+  expectTypeOf(typeOf(new Boolean(true))).toBeString();
+  expectTypeOf(typeOf(() => 4)).toBeString();
+  expectTypeOf(typeOf([1, 2, 90])).toBeString();
+  expectTypeOf(typeOf(/abc/)).toBeString();
+  expectTypeOf(typeOf(new Date())).toBeString();
+  expectTypeOf(typeOf(new FileList())).toBeString();
+  expectTypeOf(typeOf(EmberObject.extend())).toBeString();
+  expectTypeOf(typeOf(EmberObject.create())).toBeString();
+  expectTypeOf(typeOf(new Error('teamocil'))).toBeString();
+  expectTypeOf(typeOf({ justAPojo: true })).toBeString();
 
+  // @ts-expect-error
   typeOf();
   typeOf(null);
   typeOf(undefined);
@@ -99,8 +102,10 @@ import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@
   expectTypeOf(compare('foo', 'bar')).toBeNumber();
   expectTypeOf(compare(14, 37)).toBeNumber();
   expectTypeOf(compare(class {}, class {})).toBeNumber();
+  // @ts-expect-error -- cannot compare different types
   expectTypeOf(compare([], class {})).toBeNumber();
   expectTypeOf(compare([], undefined)).toBeNumber();
+  // @ts-expect-error -- cannot compare different types
   expectTypeOf(compare({}, () => 4)).toBeNumber();
   // @ts-expect-error
   compare(14);
@@ -110,8 +115,8 @@ import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@
 
 (function () {
   /** isBlank */
-
-  expectTypeOf(isBlank()).toEqualTypeOf<boolean>();
+  // @ts-expect-error
+  isBlank();
   expectTypeOf(isBlank(null)).toEqualTypeOf<boolean>();
   expectTypeOf(isBlank(undefined)).toEqualTypeOf<boolean>();
   expectTypeOf(isBlank('')).toEqualTypeOf<boolean>();
@@ -127,7 +132,8 @@ import { compare, isBlank, isEmpty, isEqual, isNone, isPresent, typeOf } from '@
 (function () {
   /** isEmpty */
 
-  expectTypeOf(isEmpty()).toEqualTypeOf<boolean>();
+  // @ts-expect-error
+  isEmpty();
   expectTypeOf(isEmpty(null)).toEqualTypeOf<boolean>();
   expectTypeOf(isEmpty(undefined)).toEqualTypeOf<boolean>();
   expectTypeOf(isEmpty('')).toEqualTypeOf<boolean>();
diff --git a/type-tests/ember/application.ts b/type-tests/ember/application.ts
index a59fc150578..3f4aa047652 100755
--- a/type-tests/ember/application.ts
+++ b/type-tests/ember/application.ts
@@ -40,4 +40,7 @@ const App3 = BaseApp.create();
 
 const App3Instance1 = App3.buildInstance();
 
+// @ts-expect-error
 const App3Instance2 = App3.buildInstance({ foo: 'bar' });
+
+const App3Instance3 = App3.buildInstance({ mountPoint: 'somewhere', routable: true });
diff --git a/type-tests/ember/array.ts b/type-tests/ember/array.ts
index bfb575e38b4..0daa72308e6 100755
--- a/type-tests/ember/array.ts
+++ b/type-tests/ember/array.ts
@@ -20,7 +20,7 @@ expectTypeOf(people.isAny('isHappy', false)).toBeBoolean();
 people.isAny('isHappy', 'false');
 
 expectTypeOf(people.objectAt(0)).toEqualTypeOf<Person | undefined>();
-expectTypeOf(people.objectsAt([1, 2, 3])).toEqualTypeOf<Ember.Array<Person | undefined>>();
+expectTypeOf(people.objectsAt([1, 2, 3])).toEqualTypeOf<Array<Person | undefined>>();
 
 expectTypeOf(people.filterBy('isHappy')).toMatchTypeOf<Person[]>();
 expectTypeOf(people.filterBy('isHappy')).toMatchTypeOf<Ember.NativeArray<Person>>();
diff --git a/type-tests/ember/core-object.ts b/type-tests/ember/core-object.ts
index 98dfc21a3a1..57fdb990321 100644
--- a/type-tests/ember/core-object.ts
+++ b/type-tests/ember/core-object.ts
@@ -50,6 +50,6 @@ class CO5 extends CoreObject {
 }
 // @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: true })).toEqualTypeOf<CO5 & { foo: boolean }>();
+expectTypeOf(CO5.create({ foo: 'abc' })).toEqualTypeOf<CO5 & { foo: string }>();
 expectTypeOf(CO5.create().foo).toEqualTypeOf<boolean | string>();
diff --git a/type-tests/ember/create-negative.ts b/type-tests/ember/create-negative.ts
index 86557265951..feeb9366f30 100644
--- a/type-tests/ember/create-negative.ts
+++ b/type-tests/ember/create-negative.ts
@@ -1,8 +1,25 @@
+import { expectTypeOf } from 'expect-type';
 import { Person } from './create';
 
-// @ts-expect-error
-Person.create({ firstName: 99 });
-// @ts-expect-error
-Person.create({}, { firstName: 99 });
-// @ts-expect-error
-Person.create({}, {}, { firstName: 99 });
+// Let's see some *real* type-unsafety! These demonstrate that we just
+// absolutely lie about the runtime behavior for `.create()`. 😬 The result of
+// calling these with `firstName: 99` is to *change the type* of the resulting
+// object from `Person` to `Person` with `firstName: number`. While we might
+// *like* to prevent that call and make sure that `firstName` matches the type
+// we cannot reasonably do so.
+
+expectTypeOf(Person.create({ firstName: 99 })).toEqualTypeOf<
+  Person & {
+    firstName: number;
+  }
+>();
+expectTypeOf(Person.create({}, { firstName: 99 })).toEqualTypeOf<
+  Person & {
+    firstName: number;
+  }
+>();
+expectTypeOf(Person.create({}, {}, { firstName: 99 })).toEqualTypeOf<
+  Person & {
+    firstName: number;
+  }
+>();
diff --git a/type-tests/ember/data-adapter.ts b/type-tests/ember/data-adapter.ts
index 2334803ccbb..a7e0096691c 100644
--- a/type-tests/ember/data-adapter.ts
+++ b/type-tests/ember/data-adapter.ts
@@ -5,8 +5,7 @@ const da = Ember.DataAdapter.create();
 
 const filters = da.getFilters();
 expectTypeOf(filters.includes({ name: 'foo', desc: 'bar' })).toBeBoolean();
-// @ts-expect-error
-filters.includes({});
+filters.includes({ name: 'lol', desc: 'wut' });
 
 expectTypeOf(filters[0]?.name).toEqualTypeOf<string | undefined>();
 expectTypeOf(filters[0]?.desc).toEqualTypeOf<string | undefined>();
@@ -15,19 +14,17 @@ 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>();
+      expectTypeOf(wrappedTypes[0]?.columns[0]?.desc).toEqualTypeOf<string | undefined>();
+      expectTypeOf(wrappedTypes[0]?.columns[0]?.name).toEqualTypeOf<string | undefined>();
+      expectTypeOf(wrappedTypes[0]?.count).toEqualTypeOf<number | undefined>();
+      expectTypeOf(wrappedTypes[0]?.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>();
+      expectTypeOf(wrappedTypes[0]?.columns[0]?.desc).toEqualTypeOf<string | undefined>();
+      expectTypeOf(wrappedTypes[0]?.columns[0]?.name).toEqualTypeOf<string | undefined>();
+      expectTypeOf(wrappedTypes[0]?.count).toEqualTypeOf<number | undefined>();
+      expectTypeOf(wrappedTypes[0]?.name).toEqualTypeOf<string | undefined>();
     }
   )
 ).toEqualTypeOf<() => void>();
@@ -38,16 +35,16 @@ expectTypeOf(
   da.watchRecords(
     'house',
     function added(records) {
-      expectTypeOf(records[0]?.object).toEqualTypeOf<object | undefined>();
+      expectTypeOf(records[0]?.object).toBeUnknown();
       expectTypeOf(records[0]?.columnValues).toEqualTypeOf<object | undefined>();
     },
     function updated(records) {
-      expectTypeOf(records[0]?.object).toEqualTypeOf<object | undefined>();
+      expectTypeOf(records[0]?.object).toEqualTypeOf<unknown>();
       expectTypeOf(records[0]?.columnValues).toEqualTypeOf<object | undefined>();
     },
-    function removed(idx, count) {
-      expectTypeOf(idx).toBeNumber();
-      expectTypeOf(count).toBeNumber();
+    function removed(records) {
+      expectTypeOf(records[0]?.object).toEqualTypeOf<unknown>();
+      expectTypeOf(records[0]?.columnValues).toEqualTypeOf<object | undefined>();
     }
   )
 ).toEqualTypeOf<() => void>();
diff --git a/type-tests/ember/debug.ts b/type-tests/ember/debug.ts
index 4c7f02ce410..75ff474845c 100644
--- a/type-tests/ember/debug.ts
+++ b/type-tests/ember/debug.ts
@@ -20,10 +20,8 @@ expectTypeOf(runInDebug(() => console.log('Should not show up in prod'))).toBeVo
 
 // 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(
@@ -74,6 +72,14 @@ expectTypeOf(
   })
 ).toBeVoid();
 
+type ExpectedOptions = {
+  id: string;
+  until: string;
+  url?: string;
+  for: string;
+  since: { available: string } | { available: string; enabled: string };
+};
+
 // next is not called, so no warnings get the default behavior
 // @ts-expect-error
 registerDeprecationHandler();
@@ -81,16 +87,16 @@ expectTypeOf(registerDeprecationHandler(() => {})).toBeVoid();
 expectTypeOf(
   registerDeprecationHandler((message, options, next) => {
     expectTypeOf(message).toBeString();
-    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(options).toEqualTypeOf<ExpectedOptions | undefined>();
     expectTypeOf(next).toEqualTypeOf<
-      (message: string, options?: { id: string; until: string } | undefined) => void
+      (message: string, options?: ExpectedOptions | undefined) => void
     >();
   })
 ).toBeVoid();
 expectTypeOf(
   registerDeprecationHandler((message, options, next) => {
     expectTypeOf(message).toBeString();
-    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(options).toEqualTypeOf<ExpectedOptions | undefined>();
     // @ts-expect-error
     next();
   })
@@ -98,14 +104,14 @@ expectTypeOf(
 expectTypeOf(
   registerDeprecationHandler((message, options, next) => {
     expectTypeOf(message).toBeString();
-    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(options).toEqualTypeOf<ExpectedOptions | undefined>();
     expectTypeOf(next(message)).toBeVoid();
   })
 ).toBeVoid();
 expectTypeOf(
   registerDeprecationHandler((message, options, next) => {
     expectTypeOf(message).toBeString();
-    expectTypeOf(options).toEqualTypeOf<{ id: string; until: string } | undefined>();
+    expectTypeOf(options).toEqualTypeOf<ExpectedOptions | undefined>();
     expectTypeOf(next(message, options)).toBeVoid();
   })
 ).toBeVoid();
diff --git a/type-tests/ember/ember-module-tests.ts b/type-tests/ember/ember-module-tests.ts
index 0af942db625..d96579fefc2 100644
--- a/type-tests/ember/ember-module-tests.ts
+++ b/type-tests/ember/ember-module-tests.ts
@@ -1,5 +1,4 @@
 import type Owner from '@ember/owner';
-import type { SafeString } from '@ember/template/-private/handlebars';
 import Ember from 'ember';
 import { expectTypeOf } from 'expect-type';
 
@@ -12,7 +11,6 @@ expectTypeOf(Ember.A([1, 2])).toEqualTypeOf<Ember.NativeArray<number>>();
 // addListener
 Ember.addListener({ a: 'foo' }, 'event', {}, () => {});
 Ember.addListener({ a: 'foo' }, 'event', {}, 'a');
-// @ts-expect-error
 Ember.addListener({ a: 'foo' }, 'event', {}, 'b');
 Ember.addListener({ a: 'foo' }, 'event', null, () => {});
 // addObserver
@@ -24,10 +22,9 @@ Ember.assert('2+2 should always be 4', 2 + 2 === 4);
 // Ember.bind // @ts-expect-error
 // cacheFor
 expectTypeOf(Ember.cacheFor({ a: 123 }, 'a')).toEqualTypeOf<number | undefined>();
-// @ts-expect-error
 Ember.cacheFor({ a: 123 }, 'x');
 // compare
-expectTypeOf(Ember.compare('31', '114')).toEqualTypeOf<number>();
+expectTypeOf(Ember.compare('31', '114')).toEqualTypeOf<-1 | 0 | 1>();
 // debug
 Ember.debug('some info for developers');
 // deprecate
@@ -40,20 +37,15 @@ Ember.deprecate("you shouldn't use this anymore", 3 === 3, {
 // get
 expectTypeOf(Ember.get({ z: 23 }, 'z')).toEqualTypeOf<number>();
 expectTypeOf(Ember.get({ z: 23 }, 'zz')).toEqualTypeOf<unknown>();
-// getEngineParent
-expectTypeOf(
-  Ember.getEngineParent(new Ember.EngineInstance())
-).toEqualTypeOf<Ember.EngineInstance>();
 // getOwner
 expectTypeOf(Ember.getOwner(new Ember.Component())).toEqualTypeOf<Owner | undefined>();
 // getProperties
 expectTypeOf(Ember.getProperties({ z: 23 }, 'z').z).toEqualTypeOf<number>();
 expectTypeOf(Ember.getProperties({ z: 23 }, 'z', 'z').z).toEqualTypeOf<number>();
-// @ts-expect-error
-Ember.getProperties({ z: 23 }, 'z', 'a').z;
+// We cannot get both known and  unknown keys at the same time.
+expectTypeOf(Ember.getProperties({ z: 23 }, 'z', 'a').z).toBeUnknown();
 expectTypeOf(Ember.getProperties({ z: 23 }, ['z', 'z']).z).toEqualTypeOf<number>();
-// @ts-expect-error
-Ember.getProperties({ z: 23 }, ['z', 'a']).z;
+expectTypeOf(Ember.getProperties({ z: 23 }, ['z', 'a'])['z']).toBeUnknown();
 
 // guidFor
 expectTypeOf(Ember.guidFor({})).toEqualTypeOf<string>();
@@ -98,11 +90,9 @@ const o3 = O3.create();
 // removeListener
 Ember.removeListener(O2, 'create', null, () => {});
 Ember.removeListener(O2, 'create', null, 'create');
-// @ts-expect-error
 Ember.removeListener({}, 'create', null, 'blah');
 // removeObserver
 Ember.removeObserver(O2, 'create', () => {});
-// @ts-expect-error
 Ember.removeObserver({}, 'create', () => {});
 // runInDebug
 Ember.runInDebug(() => {});
@@ -111,23 +101,19 @@ expectTypeOf(Ember.sendEvent(o2, 'clicked', [1, 2])).toBeBoolean();
 // set
 expectTypeOf(Ember.set(O2.create(), 'name', 'bar')).toEqualTypeOf<string>();
 expectTypeOf(Ember.set(O2.create(), 'age', 4)).toEqualTypeOf<number>();
-// @ts-expect-error
-Ember.set(O2.create(), 'nam', 'bar');
+// We allow setting arbitrary properties with `set`.
+expectTypeOf(Ember.set(O2.create(), 'nam', 'bar')).toBeString();
 // setOwner
 declare let app: Ember.ApplicationInstance;
 Ember.setOwner(O2.create(), app);
 // setProperties
 expectTypeOf(Ember.setProperties(O2.create(), { name: 'bar' }).name).toEqualTypeOf<string>();
 // trySet
-expectTypeOf(Ember.trySet(O2, 'nam', '')).toBeUnknown();
+expectTypeOf(Ember.trySet(O2, 'nam', '')).toEqualTypeOf<string | undefined>();
 // typeOf
-expectTypeOf(Ember.typeOf('')).toEqualTypeOf<'string'>();
-// @ts-ignore -- this *should* work but the namespace version is not carrying
-// it through correctly. However, people can *and should* simply use the
-// module import instead!
-expectTypeOf(Ember.typeOf(Ember.A())).toEqualTypeOf<'array'>();
+expectTypeOf(Ember.typeOf('')).toBeString();
+expectTypeOf(Ember.typeOf(Ember.A())).toBeString();
 // warn
-// @ts-expect-error
 Ember.warn('be caseful!');
 Ember.warn('be caseful!', { id: 'some-warning' });
 // VERSION
@@ -153,8 +139,10 @@ expectTypeOf(Ember.ApplicationInstance.create()).toEqualTypeOf<Ember.Application
 const a1: Ember.NativeArray<string> = Ember.A([]);
 // @ts-expect-error
 const a2: Ember.Array<string> = {};
-// Ember.ArrayProxy
-expectTypeOf(new Ember.ArrayProxy<number>([3, 3, 2])).toEqualTypeOf<Ember.ArrayProxy<number>>();
+// Ember.ArrayProxy -- we cannot make this type safe with our limited types.
+expectTypeOf(Ember.ArrayProxy.create({ content: [3, 3, 2] })).toMatchTypeOf<
+  Ember.ArrayProxy<unknown>
+>();
 // Ember.Component
 const C1 = Ember.Component.extend({ classNames: ['foo'] });
 class C2 extends Ember.Component {
@@ -180,14 +168,16 @@ class Foo {
   }
 }
 
+declare let owner: Ember.ApplicationInstance;
+
 // Ember.ContainerDebugAdapter
-expectTypeOf(new Ember.ContainerDebugAdapter()).toEqualTypeOf<Ember.ContainerDebugAdapter>();
+expectTypeOf(new Ember.ContainerDebugAdapter(owner)).toEqualTypeOf<Ember.ContainerDebugAdapter>();
 // Ember.Controller
 expectTypeOf(new Ember.Controller()).toEqualTypeOf<Ember.Controller>();
 // Ember.CoreObject
 expectTypeOf(new Ember.CoreObject()).toEqualTypeOf<Ember.CoreObject>();
 // Ember.DataAdapter
-expectTypeOf(new Ember.DataAdapter()).toEqualTypeOf<Ember.DataAdapter>();
+expectTypeOf(new Ember.DataAdapter(owner)).toEqualTypeOf<Ember.DataAdapter<unknown>>();
 // Ember.Debug
 Ember.Debug.registerDeprecationHandler(() => {});
 Ember.Debug.registerWarnHandler(() => {});
@@ -265,22 +255,21 @@ class PPM<T> extends Ember.Object.extend(Ember.PromiseProxyMixin) {
   }
 }
 // Ember.Route
-new Ember.Route();
+new Ember.Route(owner);
 // 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();
+if (Ember.Test) {
+  new Ember.Test.Adapter();
+  new Ember.Test.QUnitAdapter();
+  // Ember.Test
+  expectTypeOf(Ember.Test.checkWaiters()).toEqualTypeOf<boolean>();
+}
 // Ember.Helper
 // helper
 Ember.Helper.helper(([a, b]: [number, number]) => a + b);
-// Ember.Test
-expectTypeOf(Ember.Test.checkWaiters()).toEqualTypeOf<boolean>();
 // checkWaiters
 
 /**
@@ -306,9 +295,3 @@ Ember.create;
 Ember.reset;
 // @ts-expect-error
 Ember.unsubscribe;
-// @ts-expect-error
-Ember.subscribe;
-// @ts-expect-error
-Ember.instrument;
-// @ts-expect-error
-Ember.Instrumentation;
diff --git a/type-tests/ember/ember-tests.ts b/type-tests/ember/ember-tests.ts
index 68136ec4b53..41fe1360213 100755
--- a/type-tests/ember/ember-tests.ts
+++ b/type-tests/ember/ember-tests.ts
@@ -1,7 +1,6 @@
+import { AnyFn } from '@ember/-internals/utility-types';
 import { A } from '@ember/array';
-import type { SafeString } from '@ember/template/-private/handlebars';
 import Ember from 'ember';
-import type { AnyFn } from 'ember/-private/type-utils';
 import { expectTypeOf } from 'expect-type';
 
 class President extends Ember.Object {
@@ -90,12 +89,6 @@ const NormalApp = Ember.Application.create({
   rootElement: '#sidebar',
 });
 
-Ember.Handlebars.registerHelper(
-  'highlight',
-  (property: string, options: any) =>
-    new Ember.Handlebars.SafeString('<span class="highlight">' + 'some value' + '</span>')
-);
-
 class Person2 extends Ember.Object {
   name = '';
 
@@ -177,5 +170,5 @@ const mix2 = Ember.Mixin.create({
 
 const component1 = Ember.Component.extend(mix1, mix2, {
   lyft: Ember.inject.service(),
-  cars: Ember.computed.readOnly('lyft.cars'),
+  cars: Ember.computed('lyft.cars').readOnly(),
 });
diff --git a/type-tests/ember/engine.ts b/type-tests/ember/engine.ts
index f8ebea2ce65..f409fb708c4 100755
--- a/type-tests/ember/engine.ts
+++ b/type-tests/ember/engine.ts
@@ -41,4 +41,7 @@ const Engine3 = BaseEngine.create();
 
 const Engine3Instance1 = Engine3.buildInstance();
 
+// @ts-expect-error
 const Engine3Instance2 = Engine3.buildInstance({ foo: 'bar' });
+
+const Engine3Instance3 = Engine3.buildInstance({ mountPoint: 'somewhere', routable: true });
diff --git a/type-tests/ember/extend.ts b/type-tests/ember/extend.ts
index a8a50e1b0de..a994fa39867 100755
--- a/type-tests/ember/extend.ts
+++ b/type-tests/ember/extend.ts
@@ -19,13 +19,11 @@ expectTypeOf(Person.prototype.fullName).toBeString();
 const person = Person.create({
   firstName: 'Joe',
   lastName: 'Blow',
-  // @ts-expect-error
   extra: 42,
 });
 
 expectTypeOf(person.fullName).toBeString();
-// @ts-expect-error
-person.extra;
+expectTypeOf(person.extra).toBeNumber();
 
 class PersonWithStatics extends Ember.Object {
   static isPerson = true;
diff --git a/type-tests/ember/object.ts b/type-tests/ember/object.ts
index ada59c9eff4..9ae285df6a1 100755
--- a/type-tests/ember/object.ts
+++ b/type-tests/ember/object.ts
@@ -22,8 +22,8 @@ class MyObject30 extends Ember.Object {
 }
 
 class MyObject31 extends Ember.Object {
-  constructor(properties: object) {
-    super(properties);
+  constructor(owner: Ember.EngineInstance) {
+    super(owner);
   }
 }
 
@@ -70,8 +70,8 @@ export class Foo2 extends Ember.Object {
     expectTypeOf(Ember.get(this as Foo2, 'name')).toBeString();
     expectTypeOf((this as Foo2).get('name')).toBeString();
 
-    expectTypeOf(this.setProperties({ name })).toEqualTypeOf<Pick<this, 'name'>>();
-    expectTypeOf(Ember.setProperties(this, { name })).toEqualTypeOf<Pick<this, 'name'>>();
+    expectTypeOf(this.setProperties({ name })).toEqualTypeOf<{ name: string }>();
+    expectTypeOf(Ember.setProperties(this, { name })).toEqualTypeOf<{ name: string }>();
   }
 
   bar() {
diff --git a/type-tests/ember/observable.ts b/type-tests/ember/observable.ts
index 013bf77e61b..88fc7634aff 100755
--- a/type-tests/ember/observable.ts
+++ b/type-tests/ember/observable.ts
@@ -83,9 +83,11 @@ function testGetProperties() {
     name: string;
     age: number;
   }>();
-  expectTypeOf(person.getProperties('name', 'age', 'capitalized')).toEqualTypeOf<
-    Pick<Person, 'name' | 'age' | 'capitalized'>
-  >();
+  expectTypeOf(person.getProperties('name', 'age', 'capitalized')).toEqualTypeOf<{
+    name: string;
+    age: number;
+    capitalized: string;
+  }>();
   expectTypeOf(Ember.getProperties(pojo, 'name', 'age')).toEqualTypeOf<
     Pick<typeof pojo, 'name' | 'age'>
   >();
@@ -114,9 +116,10 @@ function testSetProperties() {
   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(person.setProperties({ name: 'Joe', capitalized: 'JOE' })).toEqualTypeOf<{
+    name: string;
+    capitalized: string;
+  }>();
   expectTypeOf(Ember.setProperties(pojo, { name: 'Joe', age: 35 })).toEqualTypeOf<
     Pick<typeof pojo, 'name' | 'age'>
   >();
diff --git a/type-tests/ember/private/observable-tests.ts b/type-tests/ember/private/observable-tests.ts
deleted file mode 100644
index abc323ed238..00000000000
--- a/type-tests/ember/private/observable-tests.ts
+++ /dev/null
@@ -1,232 +0,0 @@
-import Ember from 'ember';
-import { ExtractPropertyNamesOfType } from '@ember/object/-private/types';
-import Observable from '@ember/object/observable';
-import { expectTypeOf } from 'expect-type';
-
-class OtherThing {
-  observerOfDemo(target: DemoObservable, key: string) {}
-}
-
-class DemoObservable implements Observable {
-  foo: string;
-  isFoo = true;
-  bar: [boolean, boolean];
-  baz?: number | undefined;
-  constructor() {
-    this.foo = 'hello';
-    this.bar = [false, true];
-    this.baz = 9;
-    this.addObserver('foo', this, 'fooDidChange');
-    // @ts-expect-error
-    this.addObserver('foo', this, 'fooDidChangeProtected');
-    this.addObserver('foo', this, this.fooDidChange);
-    this.addObserver('foo', this, this.fooDidChangeProtected);
-    const ot = new OtherThing();
-    this.addObserver('foo', ot, ot.observerOfDemo);
-    Ember.addObserver(this, 'foo', this, 'fooDidChange');
-    // @ts-expect-error
-    Ember.addObserver(this, 'foo', this, 'fooDidChangeProtected');
-    Ember.addObserver(this, 'foo', this, this.fooDidChange);
-    Ember.addObserver(this, 'foo', this, this.fooDidChangeProtected);
-    this.removeObserver('foo', this, 'fooDidChange');
-    // @ts-expect-error
-    this.removeObserver('foo', this, 'fooDidChangeProtected');
-    this.removeObserver('foo', this, this.fooDidChange);
-    this.removeObserver('foo', this, this.fooDidChangeProtected);
-    Ember.removeObserver(this, 'foo', this, 'fooDidChange');
-    // @ts-expect-error
-    Ember.removeObserver(this, 'foo', this, 'fooDidChangeProtected');
-    Ember.removeObserver(this, 'foo', this, this.fooDidChange);
-    const lambda = () => {
-      this.fooDidChange(this, 'foo');
-    };
-    this.addObserver('foo', lambda);
-    this.addObserver('foo', (sender, key, value, rev) => {
-      // cannot check type equality with `this`, can only check assignability
-      let self = this;
-      self = sender;
-      sender = this;
-
-      expectTypeOf(key).toEqualTypeOf<'foo'>();
-      expectTypeOf(rev).toBeNumber();
-
-      // same issue with assignability and `this` types since `value` derives
-      // from `this['foo']`
-      this.foo = value;
-      value = this.foo;
-    });
-    this.removeObserver('foo', lambda);
-    Ember.addObserver(this, 'foo', lambda);
-    Ember.removeObserver(this, 'foo', lambda);
-  }
-  _super(...args: any[]) {
-    throw new Error('Method not implemented.');
-  }
-  init(): void {
-    throw new Error('Method not implemented.');
-  }
-  declare concatenatedProperties: string[] | null;
-  declare isDestroyed: boolean;
-  declare isDestroying: boolean;
-  destroy(): this {
-    throw new Error('Method not implemented.');
-  }
-  willDestroy(): void {
-    throw new Error('Method not implemented.');
-  }
-  toString(): string {
-    throw new Error('Method not implemented.');
-  }
-
-  fooDidChange(obj: this, propName: string) {}
-  protected fooDidChangeProtected(obj: this, propName: string) {}
-  get<K extends keyof this>(key: K): this[K] {
-    throw new Error('Method not implemented.');
-  }
-  getProperties(): {};
-  getProperties<K extends keyof this>(list: K[]): Pick<this, K>;
-  getProperties<K extends keyof this>(...list: K[]): Pick<this, K>;
-  getProperties(...rest: any[]): any {
-    throw new Error('Method not implemented.');
-  }
-  set<K extends keyof this>(key: K, value: this[K]): this[K] {
-    throw new Error('Method not implemented.');
-  }
-  setProperties<K extends keyof this>(hash: Pick<this, K>): Pick<this, K> {
-    throw new Error('Method not implemented.');
-  }
-  notifyPropertyChange(keyName: string): this {
-    throw new Error('Method not implemented.');
-  }
-  addObserver<Target>(
-    key: keyof this,
-    target: Target,
-    method:
-      | keyof Target
-      | ((this: Target, sender: this, key: string, value: any, rev: number) => void)
-  ): any;
-  addObserver<K extends keyof this>(
-    key: K,
-    method: keyof this | ((this: this, sender: this, key: K, value: this[K], rev: number) => void)
-  ): any;
-  addObserver(key: any, target: any, method?: any) {
-    throw new Error('Method not implemented.');
-  }
-  removeObserver<Target>(
-    key: keyof this,
-    target: Target,
-    method:
-      | keyof Target
-      | ((this: Target, sender: this, key: string, value: any, rev: number) => void)
-  ): any;
-  removeObserver(
-    key: keyof this,
-    method: keyof this | ((this: this, sender: this, key: string, value: any, rev: number) => void)
-  ): any;
-  removeObserver(key: any, target: any, method?: any): void {
-    throw new Error('Method not implemented.');
-  }
-  incrementProperty(
-    keyName: ExtractPropertyNamesOfType<this, number | undefined>,
-    increment?: number
-  ): number {
-    throw new Error('Method not implemented.');
-  }
-  decrementProperty(
-    keyName: ExtractPropertyNamesOfType<this, number | undefined>,
-    decrement?: number
-  ): number {
-    throw new Error('Method not implemented.');
-  }
-  toggleProperty(keyName: ExtractPropertyNamesOfType<this, boolean | undefined>): boolean {
-    throw new Error('Method not implemented.');
-  }
-  cacheFor<K extends keyof this>(key: K): this[K] | undefined {
-    throw new Error('Method not implemented.');
-  }
-}
-const o = new DemoObservable();
-
-/**
- * get
- */
-expectTypeOf(o.get('foo')).toBeString();
-expectTypeOf(o.get('bar')).toEqualTypeOf<[boolean, boolean]>();
-expectTypeOf(o.get('baz')).toEqualTypeOf<number | undefined>();
-
-/**
- * incrementProperty, decrementProperty
- */
-expectTypeOf(o.incrementProperty('baz')).toBeNumber();
-expectTypeOf(o.decrementProperty('baz')).toBeNumber();
-expectTypeOf(o.incrementProperty('baz', 3)).toBeNumber();
-expectTypeOf(o.decrementProperty('baz', 12)).toBeNumber();
-// non-numeric property case
-// @ts-expect-error
-o.incrementProperty('bar');
-// @ts-expect-error
-o.decrementProperty('bar');
-// empty case
-// @ts-expect-error
-o.incrementProperty();
-// @ts-expect-error
-o.decrementProperty();
-
-/**
- * toggleProperty
- */
-expectTypeOf(o.toggleProperty('isFoo')).toBeBoolean();
-// @ts-expect-error
-o.toggleProperty();
-
-/**
- * getProperties
- */
-// ('foo', 'bar')
-expectTypeOf(o.getProperties('foo', 'bar')).toEqualTypeOf<{
-  foo: string;
-  bar: [boolean, boolean];
-}>();
-// ['foo', 'bar']
-expectTypeOf(o.getProperties(['foo', 'bar'])).toEqualTypeOf<{
-  foo: string;
-  bar: [boolean, boolean];
-}>();
-// empty cases
-expectTypeOf(o.getProperties()).toEqualTypeOf<{}>();
-expectTypeOf(o.getProperties([])).toEqualTypeOf<{}>();
-// property that doesn't exist
-// @ts-expect-error
-o.getProperties('jeanShorts', 'foo');
-// @ts-expect-error
-o.getProperties(['foo', 'jeanShorts']);
-
-/**
- * set
- */
-expectTypeOf(o.set('foo', 'abc')).toBeString();
-expectTypeOf(o.set('bar', [false, false])).toEqualTypeOf<[boolean, boolean]>();
-expectTypeOf(o.set('baz', undefined)).toEqualTypeOf<number | undefined>();
-expectTypeOf(o.set('baz', 10)).toEqualTypeOf<number | undefined>();
-// property that doesn't exist
-// @ts-expect-error
-o.set('jeanShorts', 10);
-
-/**
- * setProperties
- */
-expectTypeOf(o.setProperties({ foo: 'abc', bar: [true, true] })).toEqualTypeOf<{
-  foo: string;
-  bar: [boolean, boolean];
-}>();
-// empty case
-expectTypeOf(o.setProperties({})).toEqualTypeOf<{}>();
-// property that doesn't exist
-// @ts-expect-error
-o.setProperties({ jeanShorts: 'under the pants' });
-
-/**
- * notifyPropertyChange
- */
-expectTypeOf(o.notifyPropertyChange('foo')).toEqualTypeOf<DemoObservable>();
-expectTypeOf(o.notifyPropertyChange('jeanShorts')).not.toMatchTypeOf<Observable>();
diff --git a/type-tests/ember/route.ts b/type-tests/ember/route.ts
index ec17310c153..ab811bf7656 100755
--- a/type-tests/ember/route.ts
+++ b/type-tests/ember/route.ts
@@ -3,7 +3,8 @@ import Array from '@ember/array';
 import Ember from 'ember'; // currently needed for Transition
 import Transition from '@ember/routing/transition';
 import { expectTypeOf } from 'expect-type';
-import { AnyFn } from 'ember/-private/type-utils';
+import { service } from '@ember/service';
+import RouterService from '@ember/routing/router-service';
 
 // Ensure that Ember.Transition is private
 // @ts-expect-error
@@ -16,12 +17,13 @@ interface Post extends Ember.Object {
 interface Posts extends Array<Post> {}
 
 class Test extends Route {
+  @service declare router: RouterService;
   queryParams = {
     memberQp: { refreshModel: true },
   };
 
   beforeModel(transition: Transition) {
-    this.transitionTo('someOtherRoute');
+    this.router.transitionTo('someOtherRoute');
   }
 
   model() {
@@ -30,7 +32,7 @@ class Test extends Route {
 
   afterModel(posts: Posts, transition: Transition) {
     if (posts.firstObject) {
-      this.transitionTo('post.show', posts.firstObject);
+      this.router.transitionTo('post.show', posts.firstObject);
     }
   }
 
@@ -97,8 +99,6 @@ class HasEvented extends Route {
 
 class HasActionHandler extends Route {
   methodUsingActionHandler() {
-    expectTypeOf(this.actions).toEqualTypeOf<{
-      [index: string]: AnyFn;
-    }>();
+    expectTypeOf(this.actions).toEqualTypeOf<Record<string, (...args: any[]) => any>>();
   }
 }
diff --git a/type-tests/ember/router.ts b/type-tests/ember/router.ts
index 2519b2af204..849677e4716 100755
--- a/type-tests/ember/router.ts
+++ b/type-tests/ember/router.ts
@@ -29,10 +29,10 @@ class RouterServiceConsumer extends Ember.Service {
   declare router: RouterService;
 
   currentRouteName() {
-    expectTypeOf(Ember.get(this, 'router').currentRouteName).toEqualTypeOf<string>();
+    expectTypeOf(this.router.currentRouteName).toEqualTypeOf<string | null>();
   }
   currentURL() {
-    expectTypeOf(Ember.get(this, 'router').currentURL).toEqualTypeOf<string>();
+    expectTypeOf(this.router.currentURL).toEqualTypeOf<string | null>();
   }
   transitionWithoutModel() {
     Ember.get(this, 'router').transitionTo('some-route');
diff --git a/type-tests/ember/run.ts b/type-tests/ember/run.ts
index 9a6d829a2a1..ad9bf421c2b 100755
--- a/type-tests/ember/run.ts
+++ b/type-tests/ember/run.ts
@@ -1,6 +1,5 @@
 import Ember from 'ember';
 import { expectTypeOf } from 'expect-type';
-import RSVP from 'rsvp';
 
 function testRun() {
   const r = Ember.run(() => {
@@ -16,200 +15,3 @@ function testRun() {
     });
   }
 }
-
-class TestBind extends Ember.Component {
-  init() {
-    const bound = Ember.run.bind(this, this.setupEditor);
-    bound();
-  }
-
-  editor: string | null = null;
-
-  setupEditor(editor: string) {
-    this.set('editor', editor);
-  }
-}
-
-function testCancel() {
-  const myContext = {};
-
-  const runNext = Ember.run.next(myContext, () => {
-    // will not be executed
-  });
-
-  Ember.run.cancel(runNext);
-
-  const runLater = Ember.run.later(
-    myContext,
-    () => {
-      // will not be executed
-    },
-    500
-  );
-
-  Ember.run.cancel(runLater);
-
-  const runScheduleOnce = Ember.run.scheduleOnce('afterRender', myContext, () => {
-    // will not be executed
-  });
-
-  Ember.run.cancel(runScheduleOnce);
-
-  const runOnce = Ember.run.once(myContext, () => {
-    // will not be executed
-  });
-
-  Ember.run.cancel(runOnce);
-
-  const throttle = Ember.run.throttle(
-    myContext,
-    () => {
-      // will not be executed
-    },
-    1,
-    false
-  );
-
-  Ember.run.cancel(throttle);
-
-  const debounce = Ember.run.debounce(
-    myContext,
-    () => {
-      // will not be executed
-    },
-    1
-  );
-
-  Ember.run.cancel(debounce);
-
-  const debounceImmediate = Ember.run.debounce(
-    myContext,
-    () => {
-      // will be executed since we passed in true (immediate)
-    },
-    100,
-    true
-  );
-
-  // the 100ms delay until this method can be called again will be canceled
-  Ember.run.cancel(debounceImmediate);
-}
-
-function testDebounce() {
-  function runIt() {}
-
-  const myContext = { name: 'debounce' };
-
-  Ember.run.debounce(runIt, 150);
-  Ember.run.debounce(myContext, runIt, 150);
-  Ember.run.debounce(myContext, runIt, 150, true);
-
-  class TestDebounce extends Ember.Component {
-    searchValue = 'test';
-    declare fetchResults: (value: string) => void;
-
-    handleTyping() {
-      // the fetchResults function is passed into the component from its parent
-      Ember.run.debounce(this, this.fetchResults, this.get('searchValue'), 250);
-    }
-  }
-}
-
-function testBegin() {
-  Ember.run.begin();
-  // code to be executed within a RunLoop
-  Ember.run.end();
-}
-
-function testJoin() {
-  Ember.run.join(() => {
-    // creates a new run-loop
-  });
-
-  Ember.run(() => {
-    // creates a new run-loop
-    Ember.run.join(() => {
-      // joins with the existing run-loop, and queues for invocation on
-      // the existing run-loops action queue.
-    });
-  });
-
-  new RSVP.Promise((resolve) => {
-    Ember.run.later(() => {
-      resolve({ msg: 'Hold Your Horses' });
-    }, 3000);
-  });
-}
-
-function testLater() {
-  const myContext = {};
-  Ember.run.later(
-    myContext,
-    () => {
-      // code here will execute within a RunLoop in about 500ms with this == myContext
-    },
-    500
-  );
-}
-
-function testNext() {
-  const myContext = {};
-  Ember.run.next(myContext, () => {
-    // code to be executed in the next run loop,
-    // which will be scheduled after the current one
-  });
-}
-
-class TestOnce extends Ember.Object {
-  init() {
-    Ember.run.once(this as TestOnce, 'processFullName');
-    Ember.run.once(this, this.processFullName);
-  }
-
-  processFullName() {}
-}
-
-{
-  class TestSchedule {
-    init() {
-      Ember.run.schedule('sync', this, () => {
-        // this will be executed in the first RunLoop queue, when bindings are synced
-        console.log('scheduled on sync queue');
-      });
-
-      Ember.run.schedule('actions', this, () => {
-        // this will be executed in the 'actions' queue, after bindings have synced.
-        console.log('scheduled on actions queue');
-      });
-    }
-  }
-
-  Ember.run.schedule('actions', () => {
-    // Do more things
-  });
-}
-
-function testScheduleOnce() {
-  function sayHi() {
-    console.log('hi');
-  }
-
-  const myContext = {};
-  Ember.run(() => {
-    Ember.run.scheduleOnce('afterRender', myContext, sayHi);
-    Ember.run.scheduleOnce('afterRender', myContext, sayHi);
-    // sayHi will only be executed once, in the afterRender queue of the RunLoop
-  });
-  Ember.run.scheduleOnce('actions', myContext, () => {
-    console.log('Closure');
-  });
-}
-
-function testThrottle() {
-  function runIt() {}
-
-  const myContext = { name: 'throttle' };
-
-  Ember.run.throttle(runIt, 150);
-  Ember.run.throttle(myContext, runIt, 150);
-}
diff --git a/type-tests/ember/test.ts b/type-tests/ember/test.ts
index f91b8c54f09..09cbeaa21db 100755
--- a/type-tests/ember/test.ts
+++ b/type-tests/ember/test.ts
@@ -1,32 +1,46 @@
 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);
-});
+if (Ember.Test) {
+  Ember.Test.registerWaiter(() => pending !== 0);
 
-Ember.Test.registerHelper('boot', (app) => {
-  Ember.run(app, app.advanceReadiness);
-});
+  Ember.Test.registerWaiter(MyDb, MyDb.hasPendingTransactions);
 
-Ember.Test.registerAsyncHelper('boot', (app) => {
-  Ember.run(app, app.advanceReadiness);
-});
+  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) => {
+    if (!Ember.Test) {
+      return;
+    }
+
+    return new Ember.Test.Promise((resolve) => {
+      if (!Ember.Test) {
+        return;
+      }
+      Ember.Test.Adapter.asyncStart();
 
-Ember.Test.registerAsyncHelper('waitForPromise', (app, promise) => {
-  return new Ember.Test.Promise((resolve) => {
-    Ember.Test.adapter.asyncStart();
+      promise.then(() => {
+        if (!Ember.Test) {
+          return;
+        }
 
-    promise.then(() => {
-      Ember.run.schedule('afterRender', null, resolve);
-      Ember.Test.adapter.asyncEnd();
+        Ember.Test.Adapter.asyncEnd();
+      });
     });
   });
-});
+}
diff --git a/type-tests/ember/utils.ts b/type-tests/ember/utils.ts
index c187d49eef0..fa5d9a36ff3 100755
--- a/type-tests/ember/utils.ts
+++ b/type-tests/ember/utils.ts
@@ -2,7 +2,8 @@ import Ember from 'ember';
 import { expectTypeOf } from 'expect-type';
 
 function testTypeOf() {
-  expectTypeOf(Ember.typeOf()).toEqualTypeOf<'undefined'>();
+  // @ts-expect-error
+  Ember.typeOf();
   const str: string = Ember.typeOf({});
 }
 
@@ -13,32 +14,32 @@ function testIsNoneType() {
   }
 
   const anotherString = maybeUndefined + 'another string';
-  expectTypeOf(Ember.isNone()).toBeBoolean();
+  expectTypeOf(Ember.isNone(anotherString)).toBeBoolean();
 }
 
 function testIsBlank() {
-  expectTypeOf(Ember.isBlank()).toBeBoolean();
+  expectTypeOf(Ember.isBlank(undefined)).toBeBoolean();
   expectTypeOf(Ember.isBlank('')).toBeBoolean();
   // @ts-expect-error
   Ember.isBlank('', '');
 }
 
 function testIsEmpty() {
-  expectTypeOf(Ember.isEmpty()).toBeBoolean();
+  expectTypeOf(Ember.isEmpty(undefined)).toBeBoolean();
   expectTypeOf(Ember.isEmpty('')).toBeBoolean();
   // @ts-expect-error
   Ember.isEmpty('', '');
 }
 
 function testIsPresent() {
-  expectTypeOf(Ember.isPresent()).toBeBoolean();
+  expectTypeOf(Ember.isPresent(undefined)).toBeBoolean();
   expectTypeOf(Ember.isPresent('')).toBeBoolean();
   // @ts-expect-error
   Ember.isPresent('', '');
 }
 
 function testIsNone() {
-  expectTypeOf(Ember.isNone()).toBeBoolean();
+  expectTypeOf(Ember.isNone(undefined)).toBeBoolean();
   expectTypeOf(Ember.isNone('')).toBeBoolean();
   // @ts-expect-error
   Ember.isNone('', '');
@@ -86,29 +87,23 @@ 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'>();
+  expectTypeOf(Ember.typeOf(null)).toBeString();
+  expectTypeOf(Ember.typeOf(undefined)).toBeString();
+  expectTypeOf(Ember.typeOf('michael')).toBeString();
+  expectTypeOf(Ember.typeOf(new String('michael'))).toBeString();
+  expectTypeOf(Ember.typeOf(101)).toBeString();
+  expectTypeOf(Ember.typeOf(new Number(101))).toBeString();
+  expectTypeOf(Ember.typeOf(true)).toBeString();
+  expectTypeOf(Ember.typeOf(new Boolean(true))).toBeString();
+  expectTypeOf(Ember.typeOf(() => 4)).toBeString();
+
+  expectTypeOf(Ember.typeOf([1, 2, 90])).toBeString();
+  expectTypeOf(Ember.typeOf(/abc/)).toBeString();
+  expectTypeOf(Ember.typeOf(new Date())).toBeString();
+  expectTypeOf(Ember.typeOf(fileList)).toBeString();
+  expectTypeOf(Ember.typeOf(Ember.Object.extend())).toBeString();
+  expectTypeOf(Ember.typeOf(Ember.Object.create())).toBeString();
+  expectTypeOf(Ember.typeOf(new Error('teamocil'))).toBeString();
+  expectTypeOf(Ember.typeOf(new Date() as RegExp | Date)).toBeString();
+  expectTypeOf(Ember.typeOf({ randomObject: true })).toBeString();
 })();
diff --git a/type-tests/index.d.ts b/type-tests/index.d.ts
index 32676789226..37cc26e2651 100644
--- a/type-tests/index.d.ts
+++ b/type-tests/index.d.ts
@@ -1,3 +1,2 @@
 // This is equivalent to the import we have end users write.
 import '../types/stable';
-import '../types/preview';
diff --git a/types/preview/@ember/application/-private/event-dispatcher.d.ts b/types/preview/@ember/application/-private/event-dispatcher.d.ts
deleted file mode 100644
index f88ebe85a7c..00000000000
--- a/types/preview/@ember/application/-private/event-dispatcher.d.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-declare module '@ember/application/-private/event-dispatcher' {
-  import { EventDispatcherEvents } from '@ember/application/types';
-
-  /**
-   * `Ember.EventDispatcher` handles delegating browser events to their
-   * corresponding `Ember.Views.` For example, when you click on a view,
-   * `Ember.EventDispatcher` ensures that that view's `mouseDown` method gets
-   * called.
-   */
-  export default class EventDispatcher extends Object {
-    /**
-     * The set of events names (and associated handler function names) to be setup
-     * and dispatched by the `EventDispatcher`. Modifications to this list can be done
-     * at setup time, generally via the `Ember.Application.customEvents` hash.
-     */
-    events: EventDispatcherEvents;
-  }
-}
diff --git a/types/preview/@ember/application/-private/registry.d.ts b/types/preview/@ember/application/-private/registry.d.ts
deleted file mode 100644
index 1af8dff3ef8..00000000000
--- a/types/preview/@ember/application/-private/registry.d.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-declare module '@ember/application/-private/registry' {
-  import { EmberClassConstructor } from '@ember/object/-private/types';
-
-  /**
-   * A registry used to store factory and option information keyed
-   * by type.
-   */
-  export default class Registry {
-    register(
-      fullName: string,
-      factory: EmberClassConstructor<unknown>,
-      options?: { singleton?: boolean | undefined }
-    ): void;
-  }
-}
diff --git a/types/preview/@ember/application/index.d.ts b/types/preview/@ember/application/index.d.ts
deleted file mode 100644
index 1f83001eafc..00000000000
--- a/types/preview/@ember/application/index.d.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-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/router';
-  import Registry from '@ember/application/-private/registry';
-  import { AnyFn } from 'ember/-private/type-utils';
-  import Owner, { Resolver } 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;
-  }
-
-  /**
-   * 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.
-   *
-   * @deprecated Use `import { getOwner } from '@ember/owner';` instead.
-   */
-  export function getOwner(object: object): Owner | undefined;
-
-  /**
-   * `setOwner` forces a new owner on a given object instance. This is primarily
-   * useful in some testing cases.
-   *
-   * @deprecated Use `import { setOwner } from '@ember/owner';` instead.
-   */
-  export function setOwner(object: object, owner: Owner): void;
-}
diff --git a/types/preview/@ember/application/instance.d.ts b/types/preview/@ember/application/instance.d.ts
deleted file mode 100644
index 37b60353c6f..00000000000
--- a/types/preview/@ember/application/instance.d.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-declare module '@ember/application/instance' {
-  import EngineInstance from '@ember/engine/instance';
-
-  /**
-   * The `ApplicationInstance` encapsulates all of the stateful aspects of a
-   * running `Application`.
-   */
-  export default class ApplicationInstance extends EngineInstance {}
-}
diff --git a/types/preview/@ember/application/types.d.ts b/types/preview/@ember/application/types.d.ts
deleted file mode 100644
index fa3692e2458..00000000000
--- a/types/preview/@ember/application/types.d.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-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
deleted file mode 100644
index 36b0120eb94..00000000000
--- a/types/preview/@ember/array/-private/enumerable.d.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-declare module '@ember/array/-private/enumerable' {
-  import Mixin from '@ember/object/mixin';
-
-  /**
-   * The methods in this mixin have been moved to `MutableArray`. This mixin has
-   * been intentionally preserved to avoid breaking `Enumerable.detect` checks
-   * until the community migrates away from them.
-   */
-  interface Enumerable {}
-
-  const Enumerable: Mixin;
-  export default Enumerable;
-}
diff --git a/types/preview/@ember/array/-private/mutable-enumerable.d.ts b/types/preview/@ember/array/-private/mutable-enumerable.d.ts
deleted file mode 100644
index d3bc4972cc3..00000000000
--- a/types/preview/@ember/array/-private/mutable-enumerable.d.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-declare module '@ember/array/-private/mutable-enumerable' {
-  import Mixin from '@ember/object/mixin';
-  import Enumerable from '@ember/array/-private/enumerable';
-
-  /**
-   * This Mixin exists for historical purposes only, and so that someone walking
-   * the types for Ember's arrays sees the same types as those which appear in
-   * the runtime hierarchy.
-   */
-  interface MutableEnumerable extends Enumerable {}
-  const MutableEnumerable: Mixin;
-  export default MutableEnumerable;
-}
diff --git a/types/preview/@ember/array/-private/native-array.d.ts b/types/preview/@ember/array/-private/native-array.d.ts
deleted file mode 100644
index d7be1f52cd3..00000000000
--- a/types/preview/@ember/array/-private/native-array.d.ts
+++ /dev/null
@@ -1,181 +0,0 @@
-declare module '@ember/array/-private/native-array' {
-  import Observable from '@ember/object/observable';
-  import EmberArray from '@ember/array';
-  import MutableArray from '@ember/array/mutable';
-  import Mixin from '@ember/object/mixin';
-
-  // Get an alias to the global Array type to use in inner scope below.
-  type Array<T> = T[];
-
-  type AnyArray<T> = EmberArray<T> | Array<T> | ReadonlyArray<T>;
-
-  /**
-   * The final definition of NativeArray removes all native methods. This is the list of removed methods
-   * when run in Chrome 106.
-   */
-  type IGNORED_MUTABLE_ARRAY_METHODS =
-    | 'length'
-    | 'slice'
-    | 'indexOf'
-    | 'lastIndexOf'
-    | 'forEach'
-    | 'map'
-    | 'filter'
-    | 'find'
-    | 'every'
-    | 'reduce'
-    | 'includes';
-
-  /**
-   * These additional items must be redefined since `Omit` causes methods that return `this` to return the
-   * type at the time of the Omit.
-   */
-  type RETURN_SELF_ARRAY_METHODS =
-    | '[]'
-    | 'clear'
-    | 'insertAt'
-    | 'removeAt'
-    | 'pushObjects'
-    | 'unshiftObjects'
-    | 'reverseObjects'
-    | 'setObjects'
-    | 'removeObject'
-    | 'removeObjects'
-    | 'addObject'
-    | 'addObjects'
-    | 'setEach';
-
-  // This is the same as MutableArray, but removes the actual native methods that exist on Array.prototype.
-  interface MutableArrayWithoutNative<T>
-    extends Omit<MutableArray<T>, IGNORED_MUTABLE_ARRAY_METHODS | RETURN_SELF_ARRAY_METHODS> {
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-    Remove all occurrences of an object in the array.
-
-    ```javascript
-    let cities = ['Chicago', 'Berlin', 'Lima', 'Chicago'];
-
-    cities.removeObject('Chicago');  // ['Berlin', 'Lima']
-    cities.removeObject('Lima');     // ['Berlin']
-    cities.removeObject('Tokyo')     // ['Berlin']
-    ```
-
-    @method removeObject
-    @param {*} obj object to remove
-    @return {EmberArray} receiver
-    @public
-  */
-    removeObject(object: T): this;
-    /**
-     * Removes each object in the passed array from the receiver.
-     */
-    removeObjects(objects: AnyArray<T>): this;
-    /**
-      Push the object onto the end of the array if it is not already
-      present in the array.
-
-      ```javascript
-      let cities = ['Chicago', 'Berlin'];
-
-      cities.addObject('Lima');    // ['Chicago', 'Berlin', 'Lima']
-      cities.addObject('Berlin');  // ['Chicago', 'Berlin', 'Lima']
-      ```
-
-      @method addObject
-      @param {*} obj object to add, if not already present
-      @return {EmberArray} receiver
-      @public
-    */
-    addObject(obj: T): this;
-    /**
-     * Adds each object in the passed enumerable to the receiver.
-     */
-    addObjects(objects: AnyArray<T>): this;
-    /**
-      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 Observable, the value will be changed to `set(),` otherwise
-      it will be set directly. `null` objects are skipped.
-
-      ```javascript
-      let people = [{name: 'Joe'}, {name: 'Matt'}];
-
-      people.setEach('zipCode', '10011');
-      // [{name: 'Joe', zipCode: '10011'}, {name: 'Matt', zipCode: '10011'}];
-      ```
-
-      @method setEach
-      @param {String} key The key to set
-      @param {Object} value The object to set
-      @return {Object} receiver
-      @public
-    */
-    setEach<K extends keyof T>(key: K, value: T[K]): this;
-    /**
-      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.
-
-      ```javascript
-      let peopleToMoon = ['Armstrong', 'Aldrin'];
-
-      peopleToMoon.get('[]'); // ['Armstrong', 'Aldrin']
-
-      peopleToMoon.set('[]', ['Collins']); // ['Collins']
-      peopleToMoon.get('[]'); // ['Collins']
-      ```
-
-      @property []
-      @return this
-      @public
-    */
-    get '[]'(): this;
-    set '[]'(newValue: T[] | this);
-  }
-
-  /**
-   * 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 Array<T>, Observable, MutableArrayWithoutNative<T> {}
-
-  const NativeArray: Mixin;
-  export default NativeArray;
-}
diff --git a/types/preview/@ember/array/index.d.ts b/types/preview/@ember/array/index.d.ts
deleted file mode 100644
index 5a7aa94dc45..00000000000
--- a/types/preview/@ember/array/index.d.ts
+++ /dev/null
@@ -1,251 +0,0 @@
-declare module '@ember/array' {
-  import { MethodNamesOf, MethodParams, MethodReturns } from 'ember/-private/type-utils';
-  import Mixin from '@ember/object/mixin';
-  import Enumerable from '@ember/array/-private/enumerable';
-  import NativeArray from '@ember/array/-private/native-array';
-
-  /**
-   * This module implements Observer-friendly Array-like behavior. This mixin is picked up by the
-   * Array class as well as other controllers, etc. that want to appear to be arrays.
-   */
-  interface Array<T> extends Enumerable {
-    /**
-     * __Required.__ You must implement this method to apply this mixin.
-     */
-    length: number;
-    /**
-     * Returns the object at the given `index`. If the given `index` is negative
-     * or is greater or equal than the array length, returns `undefined`.
-     */
-    objectAt(idx: number): T | undefined;
-    /**
-     * This returns the objects at the specified indexes, using `objectAt`.
-     */
-    objectsAt(indexes: number[]): Array<T | undefined>;
-    /**
-     * Helper method returns the first object from a collection. This is usually
-     * used by bindings and other parts of the framework to extract a single
-     * object if the enumerable contains only one item.
-     */
-    firstObject: T | undefined;
-    /**
-     * Helper method returns the last object from a collection. If your enumerable
-     * contains only one object, this method should always return that object.
-     * If your enumerable is empty, this method should return `undefined`.
-     */
-    lastObject: T | undefined;
-    /**
-     * Returns a new array that is a slice of the receiver. This implementation
-     * uses the observable array methods to retrieve the objects for the new
-     * slice.
-     */
-    slice(beginIndex?: number, endIndex?: number): NativeArray<T>;
-    /**
-     * Returns the index of the given object's first occurrence.
-     * If no `startAt` argument is given, the starting location to
-     * search is 0. If it's negative, will count backward from
-     * the end of the array. Returns -1 if no match is found.
-     */
-    indexOf(searchElement: T, fromIndex?: number): number;
-    /**
-     * Returns the index of the given object's last occurrence.
-     * If no `startAt` argument is given, the search starts from
-     * the last position. If it's negative, will count backward
-     * from the end of the array. Returns -1 if no match is found.
-     */
-    lastIndexOf(searchElement: T, fromIndex?: number): number;
-    /**
-     * Iterates through the enumerable, calling the passed function on each
-     * item. This method corresponds to the `forEach()` method defined in
-     * JavaScript 1.6.
-     */
-    forEach<Target>(
-      callback: (this: Target, item: T, index: number, arr: this) => void,
-      target?: Target
-    ): this;
-    /**
-     * Alias for `mapBy`
-     */
-    getEach<K extends keyof T>(key: K): NativeArray<T[K]>;
-    /**
-     * Sets the value on the named property for each member. This is more
-     * ergonomic than using other methods defined on this helper. If the object
-     * implements Ember.Observable, the value will be changed to `set(),` otherwise
-     * it will be set directly. `null` objects are skipped.
-     */
-    setEach<K extends keyof T>(key: K, value: T[K]): this;
-    /**
-     * 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>;
-    filterBy(key: string, value?: unknown): 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>;
-    rejectBy(key: string, value?: unknown): 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;
-    findBy(key: string, value?: unknown): 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;
-    isEvery(key: string, value?: unknown): 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;
-    isAny(key: string, value?: unknown): 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<V>(
-      callback: (summation: V, current: T, index: number, arr: this) => V,
-      initialValue?: V
-    ): V;
-    /**
-     * 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>
-    ): NativeArray<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[]): 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 '[]'(): this;
-    set '[]'(newValue: T[] | Array<T>);
-  }
-  // Ember.Array rather than Array because the `array-type` lint rule doesn't realize the global is shadowed
-  const Array: Mixin;
-  export default Array;
-
-  /**
-   * Creates an `Ember.NativeArray` from an Array like object.
-   * Does not modify the original object's contents. Ember.A is not needed if
-   * `EmberENV.EXTEND_PROTOTYPES` is `true` (the default value). However,
-   * it is recommended that you use Ember.A when creating addons for
-   * ember or when you can not guarantee that `EmberENV.EXTEND_PROTOTYPES`
-   * will be `true`.
-   */
-  export function A<T>(arr?: T[]): NativeArray<T>;
-
-  /**
-   * Returns true if the passed object is an array or Array-like.
-   */
-  export function isArray(obj: unknown): obj is ArrayLike<unknown>;
-}
diff --git a/types/preview/@ember/array/mutable.d.ts b/types/preview/@ember/array/mutable.d.ts
deleted file mode 100644
index 3890fe05da6..00000000000
--- a/types/preview/@ember/array/mutable.d.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-declare module '@ember/array/mutable' {
-  import Mixin from '@ember/object/mixin';
-  import MutableEnumerable from '@ember/array/-private/mutable-enumerable';
-  import EmberArray from '@ember/array';
-
-  type AnyArray<T> = EmberArray<T> | Array<T>;
-
-  /**
-   * This mixin defines the API for modifying array-like objects. These methods
-   * can be applied only to a collection that keeps its items in an ordered set.
-   * It builds upon the Array mixin and adds methods to modify the array.
-   * One concrete implementations of this class include ArrayProxy.
-   */
-  interface MutableArray<T> extends EmberArray<T>, MutableEnumerable {
-    /**
-     * __Required.__ You must implement this method to apply this mixin.
-     */
-    replace(idx: number, amt: number, objects: T[]): void;
-    /**
-     * 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 | null | undefined;
-    /**
-     * Shift an object from start of array or nil if none are left. Works just
-     * like `shift()` but it is KVO-compliant.
-     */
-    shiftObject(): T | null | undefined;
-    /**
-     * 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): this;
-    /**
-     * Adds each object in the passed enumerable to the receiver.
-     */
-    addObjects(objects: AnyArray<T>): this;
-  }
-
-  const MutableArray: Mixin;
-  export default MutableArray;
-}
diff --git a/types/preview/@ember/array/proxy.d.ts b/types/preview/@ember/array/proxy.d.ts
deleted file mode 100644
index 37efc898204..00000000000
--- a/types/preview/@ember/array/proxy.d.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-declare module '@ember/array/proxy' {
-  import Array from '@ember/array';
-  import type MutableArray from '@ember/array/mutable';
-  import EmberObject from '@ember/object';
-
-  /**
-   * An ArrayProxy wraps any other object that is a native or Ember `Array`
-   * (checked with [`Ember.isArray`](https://api.emberjs.com/ember/release/functions/@ember%2Farray/isArray)),
-   * forwarding all requests. This makes it very useful for a number of
-   * binding use cases or other cases where being able to swap out the
-   * underlying array is useful.
-   *
-   * NOTE: Attempting to mutate the underlying content of an object that
-   * is not a `MutableArray` (e.g. a native Javascript Array) may not
-   * behave as expected. [`Ember.A`](https://api.emberjs.com/ember/release/functions/@ember%2Farray/A)
-   * may be used in this case.
-   */
-  export default interface ArrayProxy<T> extends MutableArray<T> {}
-  export default class ArrayProxy<T> extends EmberObject {
-    content: T[] | Array<T>;
-
-    /**
-     * Should actually retrieve the object at the specified index from the
-     * content. You can override this method in subclasses to transform the
-     * content item to something new.
-     */
-    objectAtContent(idx: number): T | undefined;
-  }
-}
diff --git a/types/preview/@ember/component/-private/class-names-support.d.ts b/types/preview/@ember/component/-private/class-names-support.d.ts
deleted file mode 100644
index a8dc9cf4e28..00000000000
--- a/types/preview/@ember/component/-private/class-names-support.d.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-declare module '@ember/component/-private/class-names-support' {
-  import Mixin from '@ember/object/mixin';
-
-  interface ClassNamesSupport {
-    /**
-     * A list of properties of the view to apply as class names. If the property is a string value,
-     * the value of that string will be applied as a class name.
-     *
-     * If the value of the property is a Boolean, the name of that property is added as a dasherized
-     * class name.
-     *
-     * If you would prefer to use a custom value instead of the dasherized property name, you can
-     * pass a binding like this: `classNameBindings: ['isUrgent:urgent']`
-     *
-     * This list of properties is inherited from the component's superclasses as well.
-     */
-    classNameBindings: string[];
-    /**
-     * Standard CSS class names to apply to the view's outer element. This
-     * property automatically inherits any class names defined by the view's
-     * superclasses as well.
-     */
-    classNames: string[];
-  }
-  const ClassNamesSupport: Mixin;
-  export default ClassNamesSupport;
-}
diff --git a/types/preview/@ember/component/-private/core-view.d.ts b/types/preview/@ember/component/-private/core-view.d.ts
deleted file mode 100644
index cc1b307640f..00000000000
--- a/types/preview/@ember/component/-private/core-view.d.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-declare module '@ember/component/-private/core-view' {
-  import EmberObject from '@ember/object';
-  import type Evented from '@ember/object/evented';
-  import type ActionHandler from '@ember/object/-private/action-handler';
-
-  /**
-   * Ember.CoreView is an abstract class that exists to give view-like behavior to both Ember's main
-   * view class Ember.Component and other classes that don't need the full functionality of Ember.Component.
-   *
-   * Unless you have specific needs for CoreView, you will use Ember.Component in your applications.
-   */
-  export default class CoreView extends EmberObject {}
-  export default interface CoreView extends Evented, ActionHandler {}
-}
diff --git a/types/preview/@ember/component/-private/glimmer-interfaces.d.ts b/types/preview/@ember/component/-private/glimmer-interfaces.d.ts
deleted file mode 100644
index 2298c591b64..00000000000
--- a/types/preview/@ember/component/-private/glimmer-interfaces.d.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-declare module '@ember/component/-private/glimmer-interfaces' {
-  // NOTE: this is a bare-minimum subset of the definitions of the types in
-  // `@glimmer/interfaces`, supplied to make the public types in this package
-  // accurate.
-
-  // This is only present to "brand" the type, and it brands it in a way that
-  // matches [the implementation][1], which *also* uses it as a type-only brand.
-  //
-  // [1]: https://github.com/glimmerjs/glimmer-vm/blob/d6d776cf3797dafa923bcdad47e1897231ef6539/packages/%40glimmer/interfaces/lib/managers/capabilities.d.ts#L1
-  const CAPABILITIES: unique symbol;
-
-  export interface Capabilities {
-    [CAPABILITIES]: true;
-  }
-
-  export interface Arguments {
-    positional: readonly unknown[];
-    named: Record<string, unknown>;
-  }
-
-  export interface ComponentCapabilitiesVersions {
-    '3.4': {
-      asyncLifecycleCallbacks?: boolean;
-      destructor?: boolean;
-    };
-
-    '3.13': {
-      asyncLifecycleCallbacks?: boolean;
-      destructor?: boolean;
-      updateHook?: boolean;
-    };
-  }
-
-  export interface ComponentCapabilities extends Capabilities {
-    asyncLifeCycleCallbacks: boolean;
-    destructor: boolean;
-    updateHook: boolean;
-  }
-
-  export interface ComponentManager<ComponentStateBucket> {
-    capabilities: ComponentCapabilities;
-    createComponent(factory: object, args: Arguments): ComponentStateBucket;
-    getContext(instance: ComponentStateBucket): unknown;
-  }
-
-  export interface TemplateFactory {
-    __htmlbars_inline_precompile_template_factory: any;
-  }
-}
diff --git a/types/preview/@ember/component/-private/signature-utils.d.ts b/types/preview/@ember/component/-private/signature-utils.d.ts
deleted file mode 100644
index e21679429e4..00000000000
--- a/types/preview/@ember/component/-private/signature-utils.d.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-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
deleted file mode 100644
index 152f75af973..00000000000
--- a/types/preview/@ember/component/-private/view-mixin.d.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-declare module '@ember/component/-private/view-mixin' {
-  import Mixin from '@ember/object/mixin';
-
-  interface ViewMixin {
-    /**
-     * A list of properties of the view to apply as attributes. If the property
-     * is a string value, the value of that string will be applied as the value
-     * for an attribute of the property's name.
-     */
-    attributeBindings: string[];
-    /**
-     * Returns the current DOM element for the view.
-     */
-    element: Element;
-    /**
-     * The HTML `id` of the view's element in the DOM. You can provide this
-     * value yourself but it must be unique (just as in HTML):
-     */
-    elementId: string;
-    /**
-     * Tag name for the view's outer element. The tag name is only used when an
-     * element is first created. If you change the `tagName` for an element, you
-     * must destroy and recreate the view element.
-     */
-    tagName: string;
-    /**
-     * Renders the view again. This will work regardless of whether the
-     * view is already in the DOM or not. If the view is in the DOM, the
-     * rendering process will be deferred to give bindings a chance
-     * to synchronize.
-     */
-    rerender(): void;
-    /**
-     * Called when a view is going to insert an element into the DOM.
-     */
-    willInsertElement(): void;
-    /**
-     * Called when the element of the view has been inserted into the DOM.
-     * Override this function to do any set up that requires an element
-     * in the document body.
-     */
-    didInsertElement(): void;
-    /**
-     * Called when the view is about to rerender, but before anything has
-     * been torn down. This is a good opportunity to tear down any manual
-     * observers you have installed based on the DOM state
-     */
-    willClearRender(): void;
-    /**
-     * Called when the element of the view is going to be destroyed. Override
-     * this function to do any teardown that requires an element, like removing
-     * event listeners.
-     */
-    willDestroyElement(): void;
-  }
-  const ViewMixin: Mixin;
-
-  export default ViewMixin;
-}
diff --git a/types/preview/@ember/component/helper.d.ts b/types/preview/@ember/component/helper.d.ts
deleted file mode 100644
index d4c00902a8c..00000000000
--- a/types/preview/@ember/component/helper.d.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-declare module '@ember/component/helper' {
-  import EmberObject from '@ember/object';
-  import { Opaque } from 'ember/-private/type-utils';
-  import {
-    DefaultNamed,
-    DefaultPositional,
-    EmptyObject,
-    ExpandSignature,
-    NamedArgs,
-    PositionalArgs,
-    Return,
-  } from '@ember/component/-private/signature-utils';
-
-  // Immediately re-export these.
-  export { EmptyObject, ExpandSignature };
-
-  /**
-   * The public shape of a helper.
-   * @deprecated Do not use this directly. Instead, write a `Signature` with the
-   *   "normal" signature shape: `Args: { Named: { ... }, Positional: [...] }`.
-   */
-  export interface HelperSignature {
-    NamedArgs?: DefaultNamed;
-    PositionalArgs?: DefaultPositional;
-    Return?: unknown;
-  }
-
-  /**
-   * Ember Helpers are functions that can compute values, and are used in templates.
-   * For example, this code calls a helper named `format-currency`:
-   */
-  export default class Helper<S = unknown> extends EmberObject {
-    /**
-     * In many cases, the ceremony of a full `Ember.Helper` class is not required.
-     * The `helper` method create pure-function helpers without instances. For
-     * example:
-     */
-    static helper<P extends DefaultPositional, N = EmptyObject, R = unknown>(
-      helper: (positional: P, named: N) => R
-    ): Helper<{ Args: { Positional: P; Named: N }; Return: R }>;
-    /**
-     * Override this function when writing a class-based helper.
-     */
-    compute(positional: PositionalArgs<S>, named: NamedArgs<S>): Return<S>;
-    /**
-     * On a class-based helper, it may be useful to force a recomputation of that
-     * helpers value. This is akin to `rerender` on a component.
-     */
-    recompute(): void;
-  }
-
-  // The generic here is for a *signature*: a way to hang information for tools
-  // like Glint which can provide type checking for component templates using
-  // information supplied via this generic. While it may appear useless on this
-  // class definition and extension, it is used by external tools and should not
-  // be removed.
-  export default interface Helper<S> extends Opaque<S> {}
-
-  // This type exists to provide a non-user-constructible, non-subclassable
-  // type representing the conceptual "instance type" of a function helper.
-  // The abstract field of type `never` presents subclassing in userspace of
-  // the value returned from `helper()`. By extending `Helper<S>`, any
-  // augmentations of the `Helper` type performed by tools like Glint will
-  // also apply to function-based helpers as well.
-  export abstract class FunctionBasedHelperInstance<S> extends Helper<S> {
-    protected abstract __concrete__: never;
-  }
-
-  /**
-   * The type of a function-based helper.
-   *
-   * @note This is *not* user-constructible: it is exported only so that the type
-   *   returned by the `helper` function can be named (and indeed can be exported
-   *   like `export default helper(...)` safely).
-   */
-  // Making `FunctionBasedHelper` a bare constructor type allows for type
-  // parameters to be preserved when `helper()` is passed a generic function.
-  // By making it `abstract` and impossible to subclass (see above), we prevent
-  // users from attempting to instantiate a return value from `helper()`.
-  export type FunctionBasedHelper<S> = abstract new () => FunctionBasedHelperInstance<S>;
-
-  /**
-   * In many cases, the ceremony of a full `Helper` class is not required.
-   * The `helper` method create pure-function helpers without instances. For
-   * example:
-   * ```app/helpers/format-currency.js
-   * import { helper } from '@ember/component/helper';
-   * export default helper(function(params, hash) {
-   *   let cents = params[0];
-   *   let currency = hash.currency;
-   *   return `${currency}${cents * 0.01}`;
-   * });
-   * ```
-   */
-  // This overload allows users to write types directly on the callback passed to
-  // the `helper` function and infer the resulting type correctly.
-  export function helper<P extends DefaultPositional, N = EmptyObject, R = unknown>(
-    helperFn: (positional: P, named: N) => R
-  ): FunctionBasedHelper<{
-    Args: {
-      Positional: P;
-      Named: N;
-    };
-    Return: R;
-  }>;
-
-  // This overload allows users to provide a `Signature` type explicitly at the
-  // helper definition site, e.g. `helper<Sig>((pos, named) => {...})`. **Note:**
-  // this overload must appear second, since TS' inference engine will not
-  // correctly infer the type of `S` here from the types on the supplied callback.
-  export function helper<S>(
-    helperFn: (positional: PositionalArgs<S>, named: NamedArgs<S>) => Return<S>
-  ): FunctionBasedHelper<{
-    Args: {
-      Positional: PositionalArgs<S>;
-      Named: NamedArgs<S>;
-    };
-    Return: Return<S>;
-  }>;
-
-  export {};
-}
diff --git a/types/preview/@ember/component/index.d.ts b/types/preview/@ember/component/index.d.ts
deleted file mode 100644
index 4c0c824917d..00000000000
--- a/types/preview/@ember/component/index.d.ts
+++ /dev/null
@@ -1,164 +0,0 @@
-declare module '@ember/component' {
-  import CoreView from '@ember/component/-private/core-view';
-  import ClassNamesSupport from '@ember/component/-private/class-names-support';
-  import { TemplateFactory } from '@ember/component/-private/glimmer-interfaces';
-  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 };
-
-  // The generic here is for a *signature: a way to hang information for tools
-  // like Glint which can provide typey checking for component templates using
-  // information supplied via this generic. While it may appear useless on this
-  // class definition and extension, it is used by external tools and should not
-  // be removed.
-  export default interface Component<S = unknown> extends ViewMixin, ClassNamesSupport, Opaque<S> {}
-  export default class Component<S = unknown> extends CoreView {
-    // methods
-    readDOMAttr(name: string): string;
-    // properties
-    /**
-     * The WAI-ARIA role of the control represented by this view. For example, a button may have a
-     * role of type 'button', or a pane may have a role of type 'alertdialog'. This property is
-     * used by assistive software to help visually challenged users navigate rich web applications.
-     */
-    ariaRole: string;
-    /**
-     * The HTML id of the component's element in the DOM. You can provide this value yourself but
-     * it must be unique (just as in HTML):
-     *
-     * If not manually set a default value will be provided by the framework. Once rendered an
-     * element's elementId is considered immutable and you should never change it. If you need
-     * to compute a dynamic value for the elementId, you should do this when the component or
-     * element is being instantiated:
-     */
-    elementId: string;
-    /**
-     * A component may contain a layout. A layout is a regular template but supersedes the template
-     * property during rendering. It is the responsibility of the layout template to retrieve the
-     * template property from the component (or alternatively, call Handlebars.helpers.yield,
-     * {{yield}}) to render it in the correct location. This is useful for a component that has a
-     * shared wrapper, but which delegates the rendering of the contents of the wrapper to the
-     * template property on a subclass.
-     */
-    layout: TemplateFactory | string;
-    /**
-     * Enables components to take a list of parameters as arguments.
-     */
-    static positionalParams: string[] | string;
-    // events
-    /**
-     * Called when the attributes passed into the component have been updated. Called both during the
-     * initial render of a container and during a rerender. Can be used in place of an observer; code
-     * placed here will be executed every time any attribute updates.
-     */
-    didReceiveAttrs(): void;
-    /**
-     * Called after a component has been rendered, both on initial render and in subsequent rerenders.
-     */
-    didRender(): void;
-    /**
-     * Called when the component has updated and rerendered itself. Called only during a rerender,
-     * not during an initial render.
-     */
-    didUpdate(): void;
-    /**
-     * Called when the attributes passed into the component have been changed. Called only during a
-     * rerender, not during an initial render.
-     */
-    didUpdateAttrs(): void;
-    /**
-     * Called before a component has been rendered, both on initial render and in subsequent rerenders.
-     */
-    willRender(): void;
-    /**
-     * Called when the component is about to update and rerender itself. Called only during a rerender,
-     * not during an initial render.
-     */
-    willUpdate(): void;
-
-    /**
-     * `reopen()` was deprecated and removed from `Component`. It is given an
-     * illegitimate type in these types so that you cannot call it or use it!
-     * Unfortunately, it cannot actually be *removed* from this type, because TS
-     * rightly complains that `Component` is no longer a valid subtype of the
-     * `EmberObject` base class, and will not let you use it.
-     */
-    static reopen(): never;
-  }
-
-  /**
-   * Associate a class with a component manager (an object that is responsible for
-   * coordinating the lifecycle events that occurs when invoking, rendering and
-   * re-rendering a component).
-   *
-   * @param managerFactory a function to create the owner for an object
-   * @param object the object to associate with the componetn manager
-   * @return the same object passed in, now associated with the manager
-   */
-  export function setComponentManager<T>(
-    managerFactory: (owner: unknown) => ComponentManager<unknown>,
-    object: T
-  ): T;
-
-  /**
-   * Takes a component class and returns the template associated with the given component class,
-   * if any, or one of its superclasses, if any, or undefined if no template association was found.
-   *
-   * @param object the component object
-   * @return the template factory of the given component
-   */
-  export function getComponentTemplate(obj: object): TemplateFactory | undefined;
-
-  export function setComponentTemplate(factory: TemplateFactory, obj: object): object;
-
-  interface ComponentCapabilitiesVersions {
-    '3.4': {
-      asyncLifecycleCallbacks?: boolean;
-      destructor?: boolean;
-    };
-
-    '3.13': {
-      asyncLifecycleCallbacks?: boolean;
-      destructor?: boolean;
-      updateHook?: boolean;
-    };
-  }
-
-  interface ComponentCapabilities extends Capabilities {
-    asyncLifeCycleCallbacks: boolean;
-    destructor: boolean;
-    updateHook: boolean;
-  }
-
-  export function capabilities<Version extends keyof ComponentCapabilitiesVersions>(
-    managerAPI: Version,
-    options?: ComponentCapabilitiesVersions[Version]
-  ): ComponentCapabilities;
-
-  // 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
deleted file mode 100644
index 86762e3dab8..00000000000
--- a/types/preview/@ember/component/template-only.d.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-declare module '@ember/component/template-only' {
-  import { Opaque } from 'ember/-private/type-utils';
-
-  /**
-   * Template-only components have no backing class instance, so this in their
-   * templates is null. This means that you can only reference passed in arguments
-   * via named argument syntax (e.g. `{{@arg}}`):
-   *
-   * ```hbs
-   * {{!--
-   *   This does not work, since `this` does not exist
-   * --}}
-   * <label for="title">Title</label>
-   * <Input @value={{this.value}} id="title" />
-   * ```
-   *
-   * Additionally, the mut helper generally can't be used for the same reason:
-   *
-   * ```hbs
-   * {{!-- This does not work --}}
-   * <input
-   *   value={{this.value}}
-   *   onkeyup={{action (mut this.value) target="value"}}
-   * />
-   * ```
-   *
-   * Since Octane, a template-only component shares a subset of features that are
-   * available in `@glimmer/component`. Such component can be seamlessly
-   * "upgraded" to a Glimmer component, when you add a JavaScript file alongside
-   * the template.
-   */
-  export interface TemplateOnlyComponent<S = unknown> extends Opaque<S> {
-    toString(): string;
-  }
-
-  /**
-   * A convenience alias for {@link TemplateOnlyComponent}
-   */
-  export type TOC<S> = TemplateOnlyComponent<S>;
-
-  // The generic here is for a *signature: a way to hang information for tools
-  // like Glint which can provide typey checking for component templates using
-  // information supplied via this generic. While it may appear useless on this
-  // class definition and extension, it is used by external tools and should not
-  // be removed.
-  export default function templateOnly<S>(moduleName?: string): TemplateOnlyComponent<S>;
-}
diff --git a/types/preview/@ember/controller/index.d.ts b/types/preview/@ember/controller/index.d.ts
deleted file mode 100644
index 07e73ac7f2c..00000000000
--- a/types/preview/@ember/controller/index.d.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-declare module '@ember/controller' {
-  import ActionHandler from '@ember/object/-private/action-handler';
-  import Mixin from '@ember/object/mixin';
-  import EmberObject from '@ember/object';
-  import type { BasicComputedProperty } from '@ember/object/computed';
-
-  type QueryParamTypes = 'boolean' | 'number' | 'array' | 'string';
-  type QueryParamScopeTypes = 'controller' | 'model';
-
-  interface QueryParamConfig {
-    type?: QueryParamTypes | undefined;
-    scope?: QueryParamScopeTypes | undefined;
-    as?: string | undefined;
-  }
-
-  /**
-   * Additional methods for the Controller.
-   */
-  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: Readonly<Array<string | Record<string, QueryParamConfig | string | undefined>>>;
-    target: object;
-  }
-
-  export default class Controller extends EmberObject {}
-  export default interface Controller extends ControllerMixin {}
-
-  export function inject(): Controller;
-  export function inject<K extends keyof Registry>(name: K): Registry[K] & BasicComputedProperty;
-  export function inject(target: object, propertyKey: string | symbol): void;
-
-  // A type registry for Ember `Controller`s. Meant to be declaration-merged
-  // so string lookups resolve to the correct type.
-  export interface Registry {}
-}
diff --git a/types/preview/@ember/debug/container-debug-adapter.d.ts b/types/preview/@ember/debug/container-debug-adapter.d.ts
deleted file mode 100644
index 1f53af7855e..00000000000
--- a/types/preview/@ember/debug/container-debug-adapter.d.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-declare module '@ember/debug/container-debug-adapter' {
-  import EmberObject from '@ember/object';
-  import type { Resolver } from '@ember/owner';
-
-  /**
-   * 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 EmberObject {
-    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
deleted file mode 100644
index 0159212085b..00000000000
--- a/types/preview/@ember/debug/data-adapter.d.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-declare module '@ember/debug/data-adapter' {
-  import ContainerDebugAdapter from '@ember/debug/container-debug-adapter';
-  import EmberObject from '@ember/object';
-
-  namespace DataAdapter {
-    interface Column {
-      name: string;
-      desc: string;
-    }
-    interface WrappedRecord {
-      columnValues: object;
-      object: object;
-    }
-    interface WrappedType {
-      type: {
-        name: string;
-        count: number;
-        columns: Column[];
-        object: typeof Object;
-      };
-      release: () => void;
-    }
-  }
-
-  /**
-   * The `DataAdapter` helps a data persistence library
-   * interface with tools that debug Ember such as Chrome and Firefox.
-   */
-  export default class DataAdapter extends EmberObject {
-    /**
-     * The container-debug-adapter which is used
-     * to list all models.
-     */
-    containerDebugAdapter: ContainerDebugAdapter;
-    /**
-     * Ember Data > v1.0.0-beta.18
-     * requires string model names to be passed
-     * around instead of the actual factories.
-     */
-    acceptsModelName: boolean;
-    /**
-     * Specifies how records can be filtered.
-     * Records returned will need to have a `filterValues`
-     * property with a key for every name in the returned array.
-     */
-    getFilters(): DataAdapter.Column[];
-    /**
-     * Fetch the model types and observe them for changes.
-     */
-    watchModelTypes(
-      typesAdded: (types: DataAdapter.WrappedType[]) => void,
-      typesUpdated: (types: DataAdapter.WrappedType[]) => void
-    ): () => void;
-    /**
-     * Fetch the records of a given type and observe them for changes.
-     */
-    watchRecords(
-      modelName: string,
-      recordsAdded: (records: DataAdapter.WrappedRecord[]) => void,
-      recordsUpdated: (records: DataAdapter.WrappedRecord[]) => void,
-      recordsRemoved: (idx: number, count: number) => void
-    ): () => void;
-  }
-}
diff --git a/types/preview/@ember/debug/index.d.ts b/types/preview/@ember/debug/index.d.ts
deleted file mode 100644
index 6febb97a22d..00000000000
--- a/types/preview/@ember/debug/index.d.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-declare module '@ember/debug' {
-  /**
-   * Define an assertion that will throw an exception if the condition is not met.
-   */
-  export function assert(desc: string): never;
-  export function assert(desc: string, test: unknown): asserts test;
-
-  /**
-   * Display a debug notice.
-   */
-  export function debug(message: string): void;
-
-  /**
-   * Allows for runtime registration of handler functions that override the default deprecation behavior.
-   * Deprecations are invoked by calls to [Ember.deprecate](http://emberjs.com/api/classes/Ember.html#method_deprecate).
-   * The following example demonstrates its usage by registering a handler that throws an error if the
-   * message contains the word "should", otherwise defers to the default handler.
-   */
-  export function registerDeprecationHandler(
-    handler: (
-      message: string,
-      options: { id: string; until: string } | undefined,
-      next: (message: string, options?: { id: string; until: string }) => void
-    ) => void
-  ): void;
-  /**
-   * Allows for runtime registration of handler functions that override the default warning behavior.
-   * Warnings are invoked by calls made to [Ember.warn](http://emberjs.com/api/classes/Ember.html#method_warn).
-   * The following example demonstrates its usage by registering a handler that does nothing overriding Ember's
-   * default warning behavior.
-   */
-  export function registerWarnHandler(
-    handler: (
-      message: string,
-      options: { id: string } | undefined,
-      next: (message: string, options?: { id: string }) => void
-    ) => void
-  ): void;
-
-  /**
-   * Run a function meant for debugging.
-   */
-  export function runInDebug(func: () => unknown): void;
-
-  /**
-   * Display a warning with the provided message.
-   */
-  export function warn(message: string, test: boolean, options: { id: string }): void;
-  export function warn(message: string, options: { id: string }): void;
-
-  /**
-   * Display a deprecation warning with the provided message and a stack trace
-   * (Chrome and Firefox only).
-   *
-   * In a production build, this method is defined as an empty function (NOP).
-   * Uses of this method in Ember itself are stripped from the ember.prod.js build.
-   *
-   * @param message A description of the deprecation.
-   * @param test If falsy, the deprecation will be displayed.
-   * @param options The deprecation options.
-   */
-  export function deprecate(
-    message: string,
-    test: boolean,
-    options: {
-      /**
-       * A unique id for this deprecation. The id can be used by Ember debugging
-       * tools to change the behavior (raise, log or silence) for that specific
-       * deprecation. The id should be namespaced by dots, e.g.
-       * `"view.helper.select"`.
-       */
-      id: string;
-      /**
-       * The version of Ember when this deprecation warning will be removed.
-       */
-      until: string;
-      /**
-       * An optional url to the transition guide on the emberjs.com website.
-       */
-      url?: string | undefined;
-      /**
-       * A namespace for the deprecation, usually the package name.
-       */
-      for: string;
-      /**
-       * Describes when the deprecation became available and enabled.
-       */
-      since: Available | Enabled;
-    }
-  ): void;
-
-  export interface Available {
-    available: string;
-  }
-  export interface Enabled extends Available {
-    enabled: string;
-  }
-}
diff --git a/types/preview/@ember/destroyable/index.d.ts b/types/preview/@ember/destroyable/index.d.ts
deleted file mode 100644
index 302dd6d4240..00000000000
--- a/types/preview/@ember/destroyable/index.d.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-declare module '@ember/destroyable' {
-  export function associateDestroyableChild<T extends object>(parent: object, child: T): T;
-
-  export function isDestroying(destroyable: object): boolean;
-
-  export function isDestroyed(destroyable: object): boolean;
-
-  export function destroy(destroyable: object): void;
-
-  export function assertDestroyablesDestroyed(): void;
-
-  export function enableDestroyableTracking(): void;
-
-  export function registerDestructor<T extends object>(
-    destroyable: T,
-    destructor: (destroyable: T) => void
-  ): (destroyable: T) => void;
-
-  export function unregisterDestructor<T extends object>(
-    destroyable: T,
-    destructor: (destroyable: T) => void
-  ): void;
-}
diff --git a/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts b/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts
deleted file mode 100644
index 7c25fedea9d..00000000000
--- a/types/preview/@ember/engine/-private/container-proxy-mixin.d.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-declare module '@ember/engine/-private/container-proxy-mixin' {
-  import { ContainerProxy } from '@ember/-internals/owner';
-  import Mixin from '@ember/object/mixin';
-
-  /**
-   * Given a fullName return a factory manager.
-   */
-  interface ContainerProxyMixin extends ContainerProxy {}
-  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
deleted file mode 100644
index d3ed9552f88..00000000000
--- a/types/preview/@ember/engine/-private/registry-proxy-mixin.d.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-declare module '@ember/engine/-private/registry-proxy-mixin' {
-  import { RegistryProxy } from '@ember/-internals/owner';
-  import Mixin from '@ember/object/mixin';
-
-  /**
-   * RegistryProxyMixin is used to provide public access to specific
-   * registry functionality.
-   */
-  interface RegistryProxyMixin extends RegistryProxy {}
-  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
deleted file mode 100644
index 25953dee71b..00000000000
--- a/types/preview/@ember/engine/-private/types/initializer.d.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-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
deleted file mode 100644
index be32ad3ba9b..00000000000
--- a/types/preview/@ember/engine/index.d.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-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/owner';
-
-  /**
-   * 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
deleted file mode 100644
index b6594700ff1..00000000000
--- a/types/preview/@ember/engine/instance.d.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-declare module '@ember/engine/instance' {
-  import Owner, { FullName } from '@ember/owner';
-  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: FullName): 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, Owner {}
-}
diff --git a/types/preview/@ember/helper/index.d.ts b/types/preview/@ember/helper/index.d.ts
deleted file mode 100644
index 01977dc729c..00000000000
--- a/types/preview/@ember/helper/index.d.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-declare module '@ember/helper' {
-  import type { Opaque } from 'ember/-private/type-utils';
-
-  // In normal TypeScript, these helpers are essentially opaque tokens that just
-  // need to be importable. Declaring them with unique interfaces like this,
-  // however, gives tools like Glint (that DO have a richer notion of what they
-  // are) a place to install more detailed type information.
-  export interface ArrayHelper extends Opaque<'helper:array'> {}
-  export interface ConcatHelper extends Opaque<'helper:concat'> {}
-  export interface FnHelper extends Opaque<'helper:fn'> {}
-  export interface GetHelper extends Opaque<'helper:get'> {}
-  export interface HashHelper extends Opaque<'helper:hash'> {}
-
-  /**
-   * Use the `{{array}}` helper to create an array to pass as an option to your components.
-   *
-   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/array?anchor=array
-   */
-  export const array: ArrayHelper;
-
-  /**
-   * Concatenates the given arguments into a string.
-   *
-   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/concat?anchor=concat
-   */
-  export const concat: ConcatHelper;
-
-  /**
-   * The `fn` helper allows you to ensure a function that you are passing off to another component, helper, or modifier
-   * has access to arguments that are available in the template.
-   *
-   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/fn?anchor=fn
-   */
-  export const fn: FnHelper;
-
-  /**
-   * Dynamically look up a property on an object.
-   *
-   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/get?anchor=get
-   */
-  export const get: GetHelper;
-
-  /**
-   * Use the `{{hash}}` helper to create a hash to pass as an option to your components.
-   *
-   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/hash?anchor=hash
-   */
-  export const hash: HashHelper;
-}
diff --git a/types/preview/@ember/modifier/index.d.ts b/types/preview/@ember/modifier/index.d.ts
deleted file mode 100644
index 5a4f782b24d..00000000000
--- a/types/preview/@ember/modifier/index.d.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-declare module '@ember/modifier' {
-  import type Owner from '@ember/owner';
-  import type { Opaque } from 'ember/-private/type-utils';
-
-  // In normal TypeScript, this modifier is essentially an opaque token
-  // that just needs to be importable. Declaring it with a unique interface
-  // like this, however, gives tools like Glint (that DO have a richer
-  // notion of what it is) a place to install more detailed type information.
-  export interface OnModifier extends Opaque<'modifier:on'> {}
-
-  /**
-   * The `{{on}}` modifier lets you easily add event listeners.
-   *
-   * @see https://api.emberjs.com/ember/4.1/classes/Ember.Templates.helpers/methods/on?anchor=on
-   */
-  export const on: OnModifier;
-
-  /**
-   * Given a modifier manager factory and a modifier, tell Ember to set the
-   * manager returned by that factory as the manager for the modifier.
-   *
-   * @param factory A function which takes an `owner` and returns a [modifier
-   *   manager](https://emberjs.github.io/rfcs/0373-Element-Modifier-Managers.html).
-   * @param modifier The modifier definition to associate with the manager.
-   */
-  export function setModifierManager<T>(factory: (owner: Owner) => unknown, modifier: T): T;
-
-  /**
-   * Given a target version of Ember, return an opaque token which Ember can use
-   * to determine what a given modifier manager supports.
-   */
-  export function capabilities(version: string): unknown;
-}
diff --git a/types/preview/@ember/object/-private/action-handler.d.ts b/types/preview/@ember/object/-private/action-handler.d.ts
deleted file mode 100644
index 331207994f7..00000000000
--- a/types/preview/@ember/object/-private/action-handler.d.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-declare module '@ember/object/-private/action-handler' {
-  import { AnyFn } from 'ember/-private/type-utils';
-  import type Mixin from '@ember/object/mixin';
-
-  interface ActionsHash {
-    [index: string]: AnyFn;
-  }
-
-  /**
-   * Ember.ActionHandler is available on some familiar classes including Ember.Route,
-   * Ember.Component, and Ember.Controller. (Internally the mixin is used by Ember.CoreView,
-   * Ember.ControllerMixin, and Ember.Route and available to the above classes through inheritance.)
-   */
-  interface ActionHandler {
-    /**
-     * Triggers a named action on the ActionHandler. Any parameters supplied after the actionName
-     * string will be passed as arguments to the action target function.
-     *
-     * If the ActionHandler has its target property set, actions may bubble to the target.
-     * Bubbling happens when an actionName can not be found in the ActionHandler's actions
-     * hash or if the action target function returns true.
-     */
-    send(actionName: string, ...args: any[]): void;
-    /**
-     * The collection of functions, keyed by name, available on this ActionHandler as action targets.
-     */
-    actions: ActionsHash;
-  }
-  const ActionHandler: Mixin;
-  export default ActionHandler;
-}
diff --git a/types/preview/@ember/object/-private/types.d.ts b/types/preview/@ember/object/-private/types.d.ts
deleted file mode 100644
index efe9bb7a7b9..00000000000
--- a/types/preview/@ember/object/-private/types.d.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-declare module '@ember/object/-private/types' {
-  import type Mixin from '@ember/object/mixin';
-
-  /**
-   * Map type `T` to a plain object hash with the identity mapping.
-   *
-   * Discards any additional object identity like the ability to `new()` up the class.
-   * The `new()` capability is added back later by merging `EmberClassConstructor<T>`
-   *
-   * Implementation is carefully chosen for the reasons described in
-   * https://github.com/typed-ember/ember-typings/pull/29
-   */
-  export type Objectify<T> = Readonly<T>;
-
-  export type ExtractPropertyNamesOfType<T, S> = {
-    [K in keyof T]: T[K] extends S ? K : never;
-  }[keyof T];
-
-  export type Fix<T> = { [K in keyof T]: T[K] };
-
-  /**
-   * Used to infer the type of ember classes of type `T`.
-   *
-   * Generally you would use `EmberClass.create()` instead of `new EmberClass()`.
-   *
-   * The single-arg constructor is required by the typescript compiler.
-   * The multi-arg constructor is included for better ergonomics.
-   *
-   * Implementation is carefully chosen for the reasons described in
-   * https://github.com/typed-ember/ember-typings/pull/29
-   */
-  export type EmberClassConstructor<T> = (new (properties?: object) => T) &
-    (new (...args: any[]) => T);
-
-  /**
-   * Check that any arguments to `create()` match the type's properties.
-   *
-   * Accept any additional properties and add merge them into the instance.
-   */
-  export type EmberInstanceArguments<T> = Partial<T> & {
-    [key: string]: unknown;
-  };
-
-  /**
-   * Accept any additional properties and add merge them into the prototype.
-   */
-  export interface EmberClassArguments {
-    [key: string]: unknown;
-  }
-
-  /**
-   * Ember.Object.extend(...) accepts any number of mixins or literals.
-   */
-  export type MixinOrLiteral<T> = Mixin | T;
-
-  export type ObserverMethod<Target, Sender> =
-    | keyof Target
-    | ((this: Target, sender: Sender, key: string, value: any, rev: number) => void);
-
-  // This type looks weird, but is correct: from a list of "bottom" to "top", in
-  // type theory terms.
-  export type AnyFunction = (...args: never[]) => unknown;
-}
diff --git a/types/preview/@ember/object/compat.d.ts b/types/preview/@ember/object/compat.d.ts
deleted file mode 100644
index fbc5605ec02..00000000000
--- a/types/preview/@ember/object/compat.d.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-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
deleted file mode 100644
index 30fa4938739..00000000000
--- a/types/preview/@ember/object/computed.d.ts
+++ /dev/null
@@ -1,263 +0,0 @@
-declare module '@ember/object/computed' {
-  /**
-   * A computed property transforms an objects function into a property.
-   * By default the function backing the computed property will only be called once and the result
-   * will be cached. You can specify various properties that your computed property is dependent on.
-   * This will force the cached result to be recomputed if the dependencies are modified.
-   */
-  export default class ComputedProperty {
-    /**
-     * Call on a computed property to set it into read-only mode. When in this
-     * mode the computed property will throw an error when set.
-     */
-    readOnly(): this;
-    /**
-     * In some cases, you may want to annotate computed properties with additional
-     * metadata about how they function or what values they operate on. For example,
-     * computed property functions may close over variables that are then no longer
-     * available for introspection.
-     */
-    meta(meta: Record<string, unknown>): this;
-    meta(): Record<string, unknown>;
-  }
-
-  // Computed property definitions also act as property decorators, including those
-  // returned from "macros" in third-party code.
-  export type BasicComputedProperty = ComputedProperty & PropertyDecorator;
-
-  /**
-   * Creates a new property that is an alias for another property
-   * on an object. Calls to `get` or `set` this property behave as
-   * though they were called on the original property.
-   */
-  export function alias(dependentKey: string): BasicComputedProperty;
-  /**
-   * A computed property that performs a logical `and` on the
-   * original values for the provided dependent properties.
-   */
-  export function and(...dependentKeys: string[]): BasicComputedProperty;
-  /**
-   * A computed property that converts the provided dependent property
-   * into a boolean value.
-   */
-  export function bool(dependentKey: string): BasicComputedProperty;
-
-  /**
-   * A computed property that returns the array of values
-   * for the provided dependent properties.
-   */
-  export function collect(...dependentKeys: string[]): BasicComputedProperty;
-
-  /**
-   * Creates a new property that is an alias for another property
-   * on an object. Calls to `get` or `set` this property behave as
-   * though they were called on the original property, but also
-   * print a deprecation warning.
-   */
-  export function deprecatingAlias(
-    dependentKey: string,
-    options: { id: string; until: string }
-  ): BasicComputedProperty;
-
-  /**
-   * A computed property that returns true if the value of the dependent
-   * property is null, an empty string, empty array, or empty function.
-   */
-  export function empty(dependentKey: string): BasicComputedProperty;
-  /**
-   * A computed property that returns true if the provided dependent property
-   * is equal to the given value.
-   */
-  export function equal(dependentKey: string, value: unknown): BasicComputedProperty;
-  /**
-   * Expands `pattern`, invoking `callback` for each expansion.
-   */
-  export function expandProperties(pattern: string, callback: (expanded: string) => void): void;
-
-  /**
-   * Filters the array by the callback.
-   */
-  export function filter(
-    dependentKey: string,
-    callback: (value: unknown, index: number, array: unknown[]) => boolean
-  ): BasicComputedProperty;
-
-  /**
-   * Filters the array by the callback and an array of additional dependent keys.
-   */
-  export function filter(
-    dependentKey: string,
-    additionalDependentKeys: string[],
-    callback: (value: unknown, index: number, array: unknown[]) => boolean
-  ): BasicComputedProperty;
-
-  /**
-   * Filters the array by the property and value
-   */
-  export function filterBy(
-    dependentKey: string,
-    propertyKey: string,
-    value?: unknown
-  ): BasicComputedProperty;
-
-  /**
-   * A computed property that returns true if the provided dependent property
-   * is greater than the provided value.
-   */
-  export function gt(dependentKey: string, value: number): BasicComputedProperty;
-  /**
-   * A computed property that returns true if the provided dependent property
-   * is greater than or equal to the provided value.
-   */
-  export function gte(dependentKey: string, value: number): BasicComputedProperty;
-
-  /**
-   * A computed property which returns a new array with all the elements
-   * two or more dependent arrays have in common.
-   */
-  export function intersect(...propertyKeys: string[]): BasicComputedProperty;
-
-  /**
-   * A computed property that returns true if the provided dependent property
-   * is less than the provided value.
-   */
-  export function lt(dependentKey: string, value: number): BasicComputedProperty;
-  /**
-   * A computed property that returns true if the provided dependent property
-   * is less than or equal to the provided value.
-   */
-  export function lte(dependentKey: string, value: number): BasicComputedProperty;
-
-  /**
-   * Returns an array mapped via the callback
-   */
-  export function map(
-    dependentKey: string,
-    callback: (value: unknown, index: number, array: unknown[]) => unknown
-  ): BasicComputedProperty;
-
-  /**
-   * Returns an array mapped to the specified key.
-   */
-  export function mapBy(dependentKey: string, propertyKey: string): BasicComputedProperty;
-
-  /**
-   * A computed property which matches the original value for the
-   * dependent property against a given RegExp, returning `true`
-   * if the value matches the RegExp and `false` if it does not.
-   */
-  export function match(dependentKey: string, regexp: RegExp): BasicComputedProperty;
-
-  /**
-   * A computed property that calculates the maximum value in the
-   * dependent array. This will return `-Infinity` when the dependent
-   * array is empty.
-   */
-  export function max(dependentKey: string): BasicComputedProperty;
-
-  /**
-   * A computed property that calculates the minimum value in the
-   * dependent array. This will return `Infinity` when the dependent
-   * array is empty.
-   */
-  export function min(dependentKey: string): BasicComputedProperty;
-
-  /**
-   * A computed property that returns true if the value of the dependent
-   * property is null or undefined. This avoids errors from JSLint complaining
-   * about use of ==, which can be technically confusing.
-   */
-  export function none(dependentKey: string): BasicComputedProperty;
-  /**
-   * A computed property that returns the inverse boolean value
-   * of the original value for the dependent property.
-   */
-  export function not(dependentKey: string): BasicComputedProperty;
-  /**
-   * A computed property that returns true if the value of the dependent
-   * property is NOT null, an empty string, empty array, or empty function.
-   */
-  export function notEmpty(dependentKey: string): BasicComputedProperty;
-  /**
-   * Where `computed.alias` aliases `get` and `set`, and allows for bidirectional
-   * data flow, `computed.oneWay` only provides an aliased `get`. The `set` will
-   * not mutate the upstream property, rather causes the current property to
-   * become the value set. This causes the downstream property to permanently
-   * diverge from the upstream property.
-   */
-  export function oneWay(dependentKey: string): BasicComputedProperty;
-  /**
-   * A computed property which performs a logical `or` on the
-   * original values for the provided dependent properties.
-   */
-  export function or(...dependentKeys: string[]): BasicComputedProperty;
-  /**
-   * Where `computed.oneWay` provides oneWay bindings, `computed.readOnly` provides
-   * a readOnly one way binding. Very often when using `computed.oneWay` one does
-   * not also want changes to propagate back up, as they will replace the value.
-   */
-  export function readOnly(dependentKey: string): BasicComputedProperty;
-  /**
-   * This is a more semantically meaningful alias of `computed.oneWay`,
-   * whose name is somewhat ambiguous as to which direction the data flows.
-   */
-  export function reads(dependentKey: string): BasicComputedProperty;
-
-  /**
-   * A computed property which returns a new array with all the
-   * properties from the first dependent array that are not in the second
-   * dependent array.
-   */
-  export function setDiff(setAProperty: string, setBProperty: string): BasicComputedProperty;
-
-  /**
-   * A computed property which returns a new array with all the properties from
-   * the first dependent array sorted based on a property or sort function.
-   *
-   * If used with an array of sort properties, it must receive exactly two
-   * arguments: the key of the array to sort, and the key of the array of sort
-   * properties. Alternatively the key of the array to sort, and a the sort
-   * function may be used.
-   */
-  export function sort<T>(
-    itemsKey: string,
-    sortDefinition: string | ((itemA: T, itemB: T) => number)
-  ): BasicComputedProperty;
-
-  /**
-   * A computed property which returns a new array with all the properties from
-   * the first dependent array sorted based on a property or sort function.
-   *
-   * It may receive three arguments: the key of the array to sort, an array of
-   * dependent keys for the computed property, and the sort function.
-   */
-  export function sort<T>(
-    itemsKey: string,
-    dependentKeys: string[],
-    sortDefinition: string | ((itemA: T, itemB: T) => number)
-  ): BasicComputedProperty;
-
-  /**
-   * A computed property that returns the sum of the values
-   * in the dependent array.
-   */
-  export function sum(dependentKey: string): BasicComputedProperty;
-
-  /**
-   * A computed property which returns a new array with all the unique
-   * elements from one or more dependent arrays.
-   */
-  export function uniq(propertyKey: string): BasicComputedProperty;
-
-  /**
-   * A computed property which returns a new array with all the unique
-   * elements from one or more dependent arrays.
-   */
-  export function union(...propertyKeys: string[]): BasicComputedProperty;
-
-  /**
-   * A computed property which returns a new array with all the unique
-   * elements from an array, with uniqueness determined by specific key.
-   */
-  export function uniqBy(dependentKey: string, propertyKey: string): BasicComputedProperty;
-}
diff --git a/types/preview/@ember/object/core.d.ts b/types/preview/@ember/object/core.d.ts
deleted file mode 100644
index ea8506f9b01..00000000000
--- a/types/preview/@ember/object/core.d.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-declare module '@ember/object/core' {
-  import type { EmberClassConstructor, Objectify } from '@ember/object/-private/types';
-  import type Mixin from '@ember/object/mixin';
-
-  export default class CoreObject {
-    /**
-     * As of Ember 3.1, CoreObject constructor takes initial object properties as an argument.
-     * See: https://github.com/emberjs/ember.js/commit/4709935854d4c29b0d2c054614d53fa2c55309b1
-     */
-    constructor(properties?: object);
-
-    _super(...args: any[]): any;
-
-    /**
-     * An overridable method called when objects are instantiated. By default,
-     * does nothing unless it is overridden during class definition.
-     */
-    init(): void;
-
-    /**
-     * Defines the properties that will be concatenated from the superclass (instead of overridden).
-     * @default null
-     */
-    concatenatedProperties: string[] | null;
-
-    /**
-     * Destroyed object property flag. If this property is true the observers and bindings were
-     * already removed by the effect of calling the destroy() method.
-     * @default false
-     */
-    isDestroyed: boolean;
-    /**
-     * Destruction scheduled flag. The destroy() method has been called. The object stays intact
-     * until the end of the run loop at which point the isDestroyed flag is set.
-     * @default false
-     */
-    isDestroying: boolean;
-
-    /**
-     * Destroys an object by setting the `isDestroyed` flag and removing its
-     * metadata, which effectively destroys observers and bindings.
-     * If you try to set a property on a destroyed object, an exception will be
-     * raised.
-     * Note that destruction is scheduled for the end of the run loop and does not
-     * happen immediately.  It will set an isDestroying flag immediately.
-     * @return receiver
-     */
-    destroy(): CoreObject;
-
-    /**
-     * Override to implement teardown.
-     */
-    willDestroy(): void;
-
-    /**
-     * Returns a string representation which attempts to provide more information than Javascript's toString
-     * typically does, in a generic way for all Ember objects (e.g., "<App.Person:ember1024>").
-     * @return string representation
-     */
-    toString(): string;
-
-    static create<Class extends typeof CoreObject>(
-      this: Class,
-      ...initialValues: Array<Mixin | MembersOf<Class>>
-    ): InstanceType<Class>;
-
-    static extend<Statics, Instance>(
-      this: Statics & EmberClassConstructor<Instance>,
-      ...mixins: Array<Mixin | Record<string, unknown>>
-    ): Objectify<Statics> & EmberClassConstructor<Instance>;
-
-    static reopen<Statics, Instance>(
-      this: Statics & EmberClassConstructor<Instance>,
-      ...mixins: Array<Mixin | Record<string, unknown>>
-    ): Objectify<Statics> & EmberClassConstructor<Instance>;
-
-    static reopenClass<Statics>(
-      this: Statics,
-      ...extraStatics: Array<Mixin | Record<string, unknown>>
-    ): Statics;
-
-    static isClass: boolean;
-    static isMethod: boolean;
-  }
-
-  type MembersOf<Class extends typeof CoreObject> = {
-    [Key in keyof InstanceType<Class>]?: InstanceType<Class>[Key];
-  };
-}
diff --git a/types/preview/@ember/object/evented.d.ts b/types/preview/@ember/object/evented.d.ts
deleted file mode 100644
index d60f3524b00..00000000000
--- a/types/preview/@ember/object/evented.d.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-declare module '@ember/object/evented' {
-  import Mixin from '@ember/object/mixin';
-  import { AnyFn, EmberMethod } from 'ember/-private/type-utils';
-
-  /**
-   * This mixin allows for Ember objects to subscribe to and emit events.
-   */
-  interface Evented {
-    /**
-     * Subscribes to a named event with given function.
-     */
-    on<T>(name: string, target: T, method: EmberMethod<T>): this;
-    on(name: string, method: EmberMethod<this>): this;
-    /**
-     * Subscribes a function to a named event and then cancels the subscription
-     * after the first time the event is triggered. It is good to use ``one`` when
-     * you only care about the first time an event has taken place.
-     */
-    one<T>(name: string, target: T, method: EmberMethod<T>): this;
-    one(name: string, method: EmberMethod<this>): this;
-    /**
-     * Triggers a named event for the object. Any additional arguments
-     * will be passed as parameters to the functions that are subscribed to the
-     * event.
-     */
-    trigger(name: string, ...args: unknown[]): unknown;
-    /**
-     * Cancels subscription for given name, target, and method.
-     */
-    off<T>(name: string, target: T, method: EmberMethod<T>): this;
-    off(name: string, method: EmberMethod<this>): this;
-    /**
-     * Checks to see if object has any subscriptions for named event.
-     */
-    has(name: string): boolean;
-  }
-  const Evented: Mixin;
-  export default Evented;
-
-  /**
-   * Define a property as a function that should be executed when
-   * a specified event or events are triggered.
-   */
-  export function on<F extends AnyFn>(...args: [...eventNames: string[], func: F]): F;
-}
diff --git a/types/preview/@ember/object/events.d.ts b/types/preview/@ember/object/events.d.ts
deleted file mode 100644
index 281ec80aab4..00000000000
--- a/types/preview/@ember/object/events.d.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-declare module '@ember/object/events' {
-  import { AnyFunction } from '@ember/object/-private/types';
-
-  /**
-   * Add an event listener
-   */
-  export function addListener<Context>(
-    obj: Context,
-    eventName: string,
-    target: unknown,
-    method: keyof Context | AnyFunction,
-    once?: boolean
-  ): void;
-  export function addListener<Context>(
-    obj: Context,
-    eventName: string,
-    method: keyof Context | AnyFunction,
-    once?: boolean
-  ): void;
-
-  /**
-   * Remove an event listener
-   */
-  export function removeListener<Context>(
-    obj: Context,
-    eventName: string,
-    target: unknown,
-    method: keyof Context | AnyFunction
-  ): void;
-  export function removeListener<Context>(
-    obj: Context,
-    eventName: string,
-    method: keyof Context | AnyFunction
-  ): void;
-
-  /**
-   * Send an event. The execution of suspended listeners
-   * is skipped, and once listeners are removed. A listener without
-   * a target is executed on the passed object. If an array of actions
-   * is not passed, the actions stored on the passed object are invoked.
-   *
-   * @param eventName
-   * @param params Optional parameters for each listener.
-   * @returns if the event was delivered to one or more actions
-   */
-  export function sendEvent(obj: unknown, eventName: string, params?: unknown[]): boolean;
-}
diff --git a/types/preview/@ember/object/index.d.ts b/types/preview/@ember/object/index.d.ts
deleted file mode 100644
index 5eb4d03ce46..00000000000
--- a/types/preview/@ember/object/index.d.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-declare module '@ember/object' {
-  import CoreObject from '@ember/object/core';
-  import type Observable from '@ember/object/observable';
-  import type ComputedProperty from '@ember/object/computed';
-  import type { BasicComputedProperty } from '@ember/object/computed';
-  import type { AnyFunction } from '@ember/object/-private/types';
-
-  /**
-   * `Ember.Object` is the main base class for all Ember objects. It is a subclass
-   * of `Ember.CoreObject` with the `Ember.Observable` mixin applied. For details,
-   * see the documentation for each of these.
-   */
-  export default class EmberObject extends CoreObject {}
-  export default interface EmberObject extends Observable {}
-
-  /**
-   * This helper returns a new property descriptor that wraps the passed computed
-   * property function. You can use this helper to define properties with native
-   * decorator syntax, mixins, or via `defineProperty()`.
-   *
-   * @param dependentKeys Optional dependent keys that trigger this computed
-   *   property.
-   */
-  export function computed(...dependentKeys: string[]): ComputedProperty & MethodDecorator;
-
-  export function computed(
-    ...args: [...dependentKeys: string[], callback: AnyFunction]
-  ): BasicComputedProperty;
-
-  /**
-   * Specify a method that observes property changes.
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  export function observer<Fn extends (target: any, key: string) => void>(
-    ...args: [...propertyNames: string[], func: Fn]
-  ): Fn;
-
-  /**
-   * Gets the value of a property on an object. If the property is computed,
-   * the function will be invoked. If the property is not defined but the
-   * object implements the `unknownProperty` method then that will be invoked.
-   */
-  export function get<T, K extends keyof T>(obj: T, key: K): T[K];
-  export function get(obj: unknown, key: string): unknown;
-
-  /**
-   * Sets the value of a property on an object, respecting computed properties
-   * and notifying observers and other listeners of the change. If the
-   * property is not defined but the object implements the `setUnknownProperty`
-   * method then that will be invoked as well.
-   */
-  export function set<T, K extends keyof T, V extends T[K]>(obj: T, key: K, value: V): V;
-
-  /**
-   * To get multiple properties at once, call `getProperties` with an object
-   * followed by a list of strings or an array.
-   */
-  export function getProperties<T, K extends keyof T>(obj: T, list: K[]): Pick<T, K>;
-  export function getProperties<T, K extends keyof T>(obj: T, ...list: K[]): Pick<T, K>;
-
-  /**
-   * Set a list of properties on an object. These properties are set inside
-   * a single `beginPropertyChanges` and `endPropertyChanges` batch, so
-   * observers will be buffered.
-   */
-  export function setProperties<T, K extends keyof T>(obj: T, hash: Pick<T, K>): Pick<T, K>;
-
-  /**
-   * Error-tolerant form of `Ember.set`. Will not blow up if any part of the
-   * chain is `undefined`, `null`, or destroyed.
-   */
-  export function trySet(root: object, path: string, value: unknown): unknown;
-
-  /**
-   * NOTE: This is a low-level method used by other parts of the API. You almost
-   * never want to call this method directly. Instead you should use mixin() to
-   * define new properties.
-   *
-   * @param obj the object to define this property on. This may be a prototype.
-   * @param keyName the name of the property
-   * @param desc an instance of `Descriptor` (typically a computed property) or an
-   *   ES5 descriptor. You must provide this or `data` but not both.
-   * @param meta Normally this method takes only three parameters. However if you
-   *   pass an instance of Descriptor as the third param then you can pass an
-   *   optional value as the fourth parameter. This is often more efficient than
-   *   creating new descriptor hashes for each property.
-   */
-  export function defineProperty(
-    obj: object,
-    keyName: string,
-    desc: PropertyDescriptor | ComputedProperty,
-    meta?: unknown
-  ): void;
-
-  /**
-   * NOTE: This is a low-level method used by other parts of the API. You almost
-   * never want to call this method directly. Instead you should use mixin() to
-   * define new properties.
-   *
-   * @param obj the object to define this property on. This may be a prototype.
-   * @param keyName the name of the property
-   * @param desc an instance of `Descriptor` (typically a computed property) or an
-   *   ES5 descriptor. You must provide this or `data` but not both.
-   * @param data something other than a descriptor, that will become the explicit
-   *   value of this property.
-   */
-  export function defineProperty(
-    obj: object,
-    keyName: string,
-    desc: undefined,
-    data: unknown
-  ): void;
-
-  export function notifyPropertyChange(obj: object, keyName: string): void;
-
-  export const action: MethodDecorator;
-}
-
-declare module '@ember/utils/-private/types' {
-  import EmberObject from '@ember/object';
-
-  interface TypeLookup {
-    class: typeof EmberObject;
-    instance: EmberObject;
-  }
-}
diff --git a/types/preview/@ember/object/internals.d.ts b/types/preview/@ember/object/internals.d.ts
deleted file mode 100644
index 9d9ea53784b..00000000000
--- a/types/preview/@ember/object/internals.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-declare module '@ember/object/internals' {
-  /**
-   * Returns the cached value for a property, if one exists.
-   * This can be useful for peeking at the value of a computed
-   * property that is generated lazily, without accidentally causing
-   * it to be created.
-   */
-  export function cacheFor<T, K extends keyof T>(obj: T, key: K): T[K] | undefined;
-
-  /**
-   * Returns a unique id for the object. If the object does not yet have a guid,
-   * one will be assigned to it. You can call this on any object,
-   * `Ember.Object`-based or not, but be aware that it will add a `_guid`
-   * property.
-   */
-  export function guidFor(obj: unknown): string;
-}
diff --git a/types/preview/@ember/object/mixin.d.ts b/types/preview/@ember/object/mixin.d.ts
deleted file mode 100644
index af3475c7bfc..00000000000
--- a/types/preview/@ember/object/mixin.d.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-declare module '@ember/object/mixin' {
-  const __ember_mixin__: unique symbol;
-
-  /**
-   * The `Ember.Mixin` class allows you to create mixins, whose properties can be
-   * added to other classes.
-   */
-  export default class Mixin {
-    /**
-     * Mixin needs to have *something* on its prototype, otherwise it's treated
-     * like an empty interface. It cannot be private, sadly. We can use this to
-     * carry around the types of the mixin so they don't get lost, though, so
-     * that's... something?
-     */
-    [__ember_mixin__]: never;
-
-    static create(...args: Array<Record<string, unknown> | Mixin>): Mixin;
-  }
-}
diff --git a/types/preview/@ember/object/observable.d.ts b/types/preview/@ember/object/observable.d.ts
deleted file mode 100644
index e64774959c7..00000000000
--- a/types/preview/@ember/object/observable.d.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-declare module '@ember/object/observable' {
-  import { ObserverMethod } from '@ember/object/-private/types';
-  import Mixin from '@ember/object/mixin';
-  import CoreObject from '@ember/object/core';
-
-  /**
-   * This mixin provides properties and property observing functionality, core features of the Ember object model.
-   */
-  interface Observable extends CoreObject {
-    /**
-     * Retrieves the value of a property from the object.
-     */
-    get<K extends keyof this>(key: K): this[K];
-    get(key: string): unknown;
-    /**
-     * To get the values of multiple properties at once, call `getProperties`
-     * with a list of strings or an array:
-     */
-    getProperties<K extends keyof this>(list: K[]): Pick<this, K>;
-    getProperties<K extends keyof this>(...list: K[]): Pick<this, K>;
-    getProperties(list: string[]): Record<string, unknown>;
-    getProperties(...list: string[]): Record<string, unknown>;
-    /**
-     * Sets the provided key or path to the value.
-     */
-    set<K extends keyof this>(key: K, value: this[K]): this[K];
-    set<T>(key: keyof this, value: T): T;
-    set<T>(key: string, value: T): T;
-    /**
-     * Sets a list of properties at once. These properties are set inside
-     * a single `beginPropertyChanges` and `endPropertyChanges` batch, so
-     * observers will be buffered.
-     */
-    setProperties<K extends keyof this>(hash: Pick<this, K>): Pick<this, K>;
-    setProperties<K extends keyof this>(hash: Record<K, unknown>): Pick<this, K>;
-    setProperties<R extends Record<string, unknown>>(hash: R): R;
-    /**
-     * Notify the observer system that a property has just changed.
-     *
-     * Sometimes you need to change a value directly or indirectly without
-     * actually calling `get()` or `set()` on it. In this case, you can use this
-     * method instead. Calling this method will notify all observers that the
-     * property has potentially changed value.
-     */
-    notifyPropertyChange(keyName: string): this;
-    /**
-     * Adds an observer on a property.
-     */
-    addObserver<Target>(
-      key: keyof this,
-      target: Target,
-      method: ObserverMethod<Target, this>
-    ): this;
-    addObserver(key: keyof this, method: ObserverMethod<this, this>): this;
-    /**
-     * Remove an observer you have previously registered on this object. Pass
-     * the same key, target, and method you passed to `addObserver()` and your
-     * target will no longer receive notifications.
-     */
-    removeObserver<Target>(
-      key: keyof this,
-      target: Target,
-      method: ObserverMethod<Target, this>
-    ): this;
-    removeObserver(key: keyof this, method: ObserverMethod<this, this>): this;
-    /**
-     * Set the value of a property to the current value plus some amount.
-     */
-    incrementProperty(keyName: keyof this, increment?: number): number;
-    /**
-     * Set the value of a property to the current value minus some amount.
-     */
-    decrementProperty(keyName: keyof this, decrement?: number): number;
-    /**
-     * Set the value of a boolean property to the opposite of its
-     * current value.
-     */
-    toggleProperty(keyName: keyof this): boolean;
-    /**
-     * Returns the cached value of a computed property, if it exists.
-     * This allows you to inspect the value of a computed property
-     * without accidentally invoking it if it is intended to be
-     * generated lazily.
-     */
-    cacheFor<K extends keyof this>(key: K): this[K] | undefined;
-  }
-  const Observable: Mixin;
-  export default Observable;
-}
diff --git a/types/preview/@ember/object/observers.d.ts b/types/preview/@ember/object/observers.d.ts
deleted file mode 100644
index 36fb7de3325..00000000000
--- a/types/preview/@ember/object/observers.d.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-declare module '@ember/object/observers' {
-  import { ObserverMethod } from '@ember/object/-private/types';
-
-  /**
-   * Adds an observer on a property.
-   */
-  export function addObserver<Context, Target>(
-    obj: Context,
-    key: keyof Context,
-    target: Target,
-    method: ObserverMethod<Target, Context>
-  ): void;
-  export function addObserver<Context>(
-    obj: Context,
-    key: keyof Context,
-    method: ObserverMethod<Context, Context>
-  ): void;
-  /**
-   * Remove an observer you have previously registered on this object. Pass
-   * the same key, target, and method you passed to `addObserver()` and your
-   * target will no longer receive notifications.
-   */
-  export function removeObserver<Context, Target>(
-    obj: Context,
-    key: keyof Context,
-    target: Target,
-    method: ObserverMethod<Target, Context>
-  ): any;
-  export function removeObserver<Context>(
-    obj: Context,
-    key: keyof Context,
-    method: ObserverMethod<Context, Context>
-  ): any;
-}
diff --git a/types/preview/@ember/object/promise-proxy-mixin.d.ts b/types/preview/@ember/object/promise-proxy-mixin.d.ts
deleted file mode 100644
index a834447639f..00000000000
--- a/types/preview/@ember/object/promise-proxy-mixin.d.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-declare module '@ember/object/promise-proxy-mixin' {
-  import Mixin from '@ember/object/mixin';
-  import RSVP from 'rsvp';
-
-  /**
-   * A low level mixin making ObjectProxy promise-aware.
-   */
-  interface PromiseProxyMixin<T> extends RSVP.Promise<T> {
-    /**
-     * If the proxied promise is rejected this will contain the reason
-     * provided.
-     */
-    reason: unknown;
-    /**
-     * Once the proxied promise has settled this will become `false`.
-     */
-    isPending: boolean;
-    /**
-     * Once the proxied promise has settled this will become `true`.
-     */
-    isSettled: boolean;
-    /**
-     * Will become `true` if the proxied promise is rejected.
-     */
-    isRejected: boolean;
-    /**
-     * Will become `true` if the proxied promise is fulfilled.
-     */
-    isFulfilled: boolean;
-    /**
-     * The promise whose fulfillment value is being proxied by this object.
-     */
-    promise: RSVP.Promise<T>;
-  }
-  const PromiseProxyMixin: Mixin;
-  export default PromiseProxyMixin;
-}
diff --git a/types/preview/@ember/object/proxy.d.ts b/types/preview/@ember/object/proxy.d.ts
deleted file mode 100644
index a28ec6ebbda..00000000000
--- a/types/preview/@ember/object/proxy.d.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-declare module '@ember/object/proxy' {
-  import EmberObject from '@ember/object';
-
-  /**
-   * `Ember.ObjectProxy` forwards all properties not defined by the proxy itself
-   * to a proxied `content` object.
-   */
-  export default class ObjectProxy<T extends object = object> extends EmberObject {
-    /**
-     * The object whose properties will be forwarded.
-     */
-    content: T | undefined;
-
-    get<K extends keyof this>(key: K): this[K];
-    get<K extends keyof T>(key: K): T[K] | undefined;
-
-    getProperties<K extends keyof this>(list: K[]): Pick<this, K>;
-    getProperties<K extends keyof this>(...list: K[]): Pick<this, K>;
-    getProperties<K extends keyof T>(list: K[]): Pick<Partial<T>, K>;
-    getProperties<K extends keyof T>(...list: K[]): Pick<Partial<T>, K>;
-
-    set<K extends keyof this>(key: K, value: this[K]): this[K];
-    set<K extends keyof T>(key: K, value: T[K]): T[K];
-
-    setProperties<K extends keyof this | keyof T>(hash: Pick<this & T, K>): Pick<this & T, K>;
-  }
-}
diff --git a/types/preview/@ember/routing/-private/router-dsl.d.ts b/types/preview/@ember/routing/-private/router-dsl.d.ts
deleted file mode 100644
index 8499aec45c8..00000000000
--- a/types/preview/@ember/routing/-private/router-dsl.d.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-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/hash-location.d.ts b/types/preview/@ember/routing/hash-location.d.ts
deleted file mode 100644
index 8b6c8c3caaa..00000000000
--- a/types/preview/@ember/routing/hash-location.d.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-declare module '@ember/routing/hash-location' {
-  import EmberObject from '@ember/object';
-  import Location, { UpdateCallback } from '@ember/routing/location';
-
-  /**
-   * `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 implements Location {
-    getURL(): string;
-    setURL(url: string): void;
-    replaceURL?(url: string): void;
-    onUpdateURL(callback: UpdateCallback): void;
-    formatURL(url: string): string;
-    initState?(): void;
-  }
-}
-
-declare module '@ember/routing/location' {
-  import HashLocation from '@ember/routing/hash-location';
-
-  export interface Registry {
-    hash: HashLocation;
-  }
-}
diff --git a/types/preview/@ember/routing/history-location.d.ts b/types/preview/@ember/routing/history-location.d.ts
deleted file mode 100644
index ae00af354e0..00000000000
--- a/types/preview/@ember/routing/history-location.d.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-declare module '@ember/routing/history-location' {
-  import EmberObject from '@ember/object';
-  import Location, { UpdateCallback } from '@ember/routing/location';
-
-  /**
-   * Ember.HistoryLocation implements the location API using the browser's
-   * history.pushState API.
-   */
-  export default class HistoryLocation extends EmberObject implements Location {
-    getURL(): string;
-    setURL(url: string): void;
-    replaceURL(url: string): void;
-    onUpdateURL(callback: UpdateCallback): void;
-    formatURL(url: string): string;
-    initState(): void;
-  }
-}
-
-declare module '@ember/routing/location' {
-  import HistoryLocation from '@ember/routing/history-location';
-
-  export interface Registry {
-    history: HistoryLocation;
-  }
-}
diff --git a/types/preview/@ember/routing/index.d.ts b/types/preview/@ember/routing/index.d.ts
deleted file mode 100644
index 8c29c550b6d..00000000000
--- a/types/preview/@ember/routing/index.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-declare module '@ember/routing' {
-  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/location.d.ts b/types/preview/@ember/routing/location.d.ts
deleted file mode 100644
index d83002919f1..00000000000
--- a/types/preview/@ember/routing/location.d.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-declare module '@ember/routing/location' {
-  /**
-    `Location` defines an interface to be implemented by `location` APIs. It is
-    not user-constructible; the only valid way to get a `Location` is via one of
-    its concrete implementations.
-
-    ## Implementations
-
-    You can pass an implementation name (`hash`, `history`, `none`) to force a
-    particular implementation to be used in your application.
-
-    - See [HashLocation](/ember/release/classes/HashLocation).
-    - See [HistoryLocation](/ember/release/classes/HistoryLocation).
-    - See [NoneLocation](/ember/release/classes/NoneLocation).
-
-    ## Location API
-
-    Each location implementation must provide the following methods:
-
-    * `getURL`: returns the current URL.
-    * `setURL(path)`: sets the current URL.
-    * `replaceURL(path)`: replace the current URL (optional).
-    * `onUpdateURL(callback)`: triggers the callback when the URL changes.
-    * `formatURL(url)`: formats `url` to be placed into `href` attribute.
-
-    Calling `setURL` or `replaceURL` will not trigger onUpdateURL callbacks.
-
-    ## Custom implementation
-
-    Ember scans `app/locations/*` for extending the Location API.
-
-    Example:
-
-    ```javascript
-    import HistoryLocation from '@ember/routing/history-location';
-
-    export default class MyHistory {
-      implementation = 'my-custom-history';
-
-      constructor() {
-        this._history = HistoryLocation.create(...arguments);
-      }
-
-      create() {
-        return new this(...arguments);
-      }
-
-      pushState(path) {
-        this._history.pushState(path);
-      }
-    }
-    ```
-   */
-  export default interface Location {
-    /**
-     * If the location needs to redirect to a different URL, it can cancel routing
-     * by setting the `cancelRouterSetup` property on itself to false.
-     */
-    cancelRouterSetup?: boolean;
-
-    /**
-     * The current URL.
-     */
-    getURL(): string;
-
-    /**
-     * Sets the current URL. Calling `setURL` will not trigger `onUpdateURL`
-     * callbacks.
-     */
-    setURL(url: string): void;
-
-    /**
-     * Replace the current URL (optional). Calling `replaceURL` will not trigger
-     * `onUpdateURL` callbacks.
-     */
-    replaceURL?(url: string): void;
-
-    /**
-     * triggers the callback when the URL changes.
-     */
-    onUpdateURL(callback: UpdateCallback): void;
-
-    /**
-     * Formats url to be placed into href attribute.
-     */
-    formatURL(url: string): string;
-
-    initState?(): void;
-    destroy(): void;
-  }
-
-  export type UpdateCallback = (url: string) => void;
-
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface
-  export interface Registry extends Record<string, Location | undefined> {}
-}
-
-declare module '@ember/owner' {
-  import { Registry } from '@ember/routing/location';
-
-  export interface DIRegistry {
-    location: Registry;
-  }
-}
diff --git a/types/preview/@ember/routing/none-location.d.ts b/types/preview/@ember/routing/none-location.d.ts
deleted file mode 100644
index 5f1e4dfbb80..00000000000
--- a/types/preview/@ember/routing/none-location.d.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-declare module '@ember/routing/none-location' {
-  import EmberObject from '@ember/object';
-  import Location, { UpdateCallback } from '@ember/routing/location';
-
-  /**
-   * 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 implements Location {
-    getURL(): string;
-    setURL(url: string): void;
-    replaceURL?(url: string): void;
-    onUpdateURL(callback: UpdateCallback): void;
-    formatURL(url: string): string;
-    initState?(): void;
-  }
-}
-
-declare module '@ember/routing/location' {
-  import NoneLocation from '@ember/routing/none-location';
-
-  export interface Registry {
-    none: NoneLocation;
-  }
-}
diff --git a/types/preview/@ember/routing/route-info.d.ts b/types/preview/@ember/routing/route-info.d.ts
deleted file mode 100644
index 42e6bc98801..00000000000
--- a/types/preview/@ember/routing/route-info.d.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-declare module '@ember/routing/route-info' {
-  /**
-   * 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
deleted file mode 100644
index f6c472d7920..00000000000
--- a/types/preview/@ember/routing/route.d.ts
+++ /dev/null
@@ -1,532 +0,0 @@
-declare module '@ember/routing/route' {
-  import EmberObject from '@ember/object';
-  import ActionHandler from '@ember/object/-private/action-handler';
-  import Transition from '@ember/routing/transition';
-  import Evented from '@ember/object/evented';
-  import { RouteQueryParam } from '@ember/routing/types';
-  import Controller from '@ember/controller';
-
-  type RouteModel = object | string | number;
-
-  export default interface Route<Model, Params extends object> extends ActionHandler, Evented {}
-
-  /**
-   * 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 {
-    // 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
deleted file mode 100644
index 0d7a1ce318f..00000000000
--- a/types/preview/@ember/routing/router-service.d.ts
+++ /dev/null
@@ -1,359 +0,0 @@
-declare module '@ember/routing/router-service' {
-  import RouteInfo, { RouteInfoWithAttributes } from '@ember/routing/route-info';
-  import Transition from '@ember/routing/transition';
-  import Service from '@ember/service';
-
-  type RouteModel = object | string | number;
-
-  // https://emberjs.com/api/ember/release/classes/RouterService
-  /**
-   * The Router service is the public API that provides component/view layer access to the router.
-   */
-  export default class RouterService extends Service {
-    //
-    /**
-     * A `RouteInfo` that represents the current leaf route.
-     * It is guaranteed to change whenever a route transition happens
-     * (even when that transition only changes parameters and doesn't change the active route)
-     */
-    readonly currentRoute: RouteInfo;
-    /**
-     * Name of the current route.
-     * This property represent the logical name of the route,
-     * which is comma separated.
-     * For the following router:
-     * ```app/router.js
-     * Router.map(function() {
-     * this.route('about');
-     * this.route('blog', function () {
-     *     this.route('post', { path: ':post_id' });
-     * });
-     * });
-     * ```
-     * It will return:
-     * * `index` when you visit `/`
-     * * `about` when you visit `/about`
-     * * `blog.index` when you visit `/blog`
-     * * `blog.post` when you visit `/blog/some-post-id`
-     */
-    readonly currentRouteName: string;
-    //
-    /**
-     * Current URL for the application.
-     * This property represent the URL path for this route.
-     * For the following router:
-     * ```app/router.js
-     * Router.map(function() {
-     * this.route('about');
-     * this.route('blog', function () {
-     *     this.route('post', { path: ':post_id' });
-     * });
-     * });
-     * ```
-     * It will return:
-     * * `/` when you visit `/`
-     * * `/about` when you visit `/about`
-     * * `/blog` when you visit `/blog`
-     * * `/blog/some-post-id` when you visit `/blog/some-post-id`
-     */
-    readonly currentURL: string;
-
-    /**
-     * The `rootURL` property represents the URL of the root of
-     * the application, '/' by default.
-     * This prefix is assumed on all routes defined on this app.
-     * If you change the `rootURL` in your environment configuration
-     * like so:
-     * ```config/environment.js
-     * 'use strict';
-     * module.exports = function(environment) {
-     *   let ENV = {
-     *     modulePrefix: 'router-service',
-     *     environment,
-     *     rootURL: '/my-root',
-     *   …
-     *   }
-     * ]
-     * ```
-     * This property will return `/my-root`.
-     */
-    readonly rootURL: string;
-
-    /**
-     * Determines whether a route is active.
-     *
-     * @param routeName the name of the route
-     * @param models    the model(s) or identifier(s) to be used while
-     *                  transitioning to the route
-     * @param options   optional hash with a queryParams property containing a
-     *                  mapping of query parameters
-     */
-    isActive(routeName: string, options?: { queryParams: object }): boolean;
-    isActive(routeName: string, models: RouteModel, options?: { queryParams: object }): boolean;
-    isActive(
-      routeName: string,
-      modelsA: RouteModel,
-      modelsB: RouteModel,
-      options?: { queryParams: object }
-    ): boolean;
-    isActive(
-      routeName: string,
-      modelsA: RouteModel,
-      modelsB: RouteModel,
-      modelsC: RouteModel,
-      options?: { queryParams: object }
-    ): boolean;
-    isActive(
-      routeName: string,
-      modelsA: RouteModel,
-      modelsB: RouteModel,
-      modelsC: RouteModel,
-      modelsD: RouteModel,
-      options?: { queryParams: object }
-    ): boolean;
-
-    // https://emberjs.com/api/ember/4.0/classes/RouterService/methods/isActive?anchor=replaceWith
-    /**
-     * Transition into another route while replacing the current URL, if
-     * possible. The route may be either a single route or route path.
-     *
-     * @param routeNameOrUrl the name of the route or a URL
-     * @param models         the model(s) or identifier(s) to be used while
-     *                       transitioning to the route.
-     * @param options        optional hash with a queryParams property
-     *                       containing a mapping of query parameters
-     * @returns              the Transition object associated with this attempted transition
-     */
-    replaceWith(routeNameOrUrl: string, options?: { queryParams: object }): Transition;
-    replaceWith(
-      routeNameOrUrl: string,
-      models: RouteModel,
-      options?: { queryParams: object }
-    ): Transition;
-    replaceWith(
-      routeNameOrUrl: string,
-      modelsA: RouteModel,
-      modelsB: RouteModel,
-      options?: { queryParams: object }
-    ): Transition;
-    replaceWith(
-      routeNameOrUrl: string,
-      modelsA: RouteModel,
-      modelsB: RouteModel,
-      modelsC: RouteModel,
-      options?: { queryParams: object }
-    ): Transition;
-    replaceWith(
-      routeNameOrUrl: string,
-      modelsA: RouteModel,
-      modelsB: RouteModel,
-      modelsC: RouteModel,
-      modelsD: RouteModel,
-      options?: { queryParams: object }
-    ): Transition;
-
-    // https://emberjs.com/api/ember/release/classes/RouterService/methods/isActive?anchor=transitionTo
-    /**
-     * Transition the application into another route. The route may
-     * be either a single route or route path:
-     *
-     * See [transitionTo](https://api.emberjs.com/ember/release/classes/Route/methods/transitionTo?anchor=transitionTo) for more info.
-     *
-     * Calling `transitionTo` from the Router service will cause default query parameter values to be included in the URL.
-     * This behavior is different from calling `transitionTo` on a route or `transitionToRoute` on a controller.
-     * See the [Router Service RFC](https://github.com/emberjs/rfcs/blob/master/text/0095-router-service.md#query-parameter-semantics) for more info.
-     *
-     * In the following example we use the Router service to navigate to a route with a
-     * specific model from a Component.
-     *
-     * ```app/components/example.js
-     * import Component from '@glimmer/component';
-     * import { action } from '@ember/object';
-     * import { inject as service } from '@ember/service';
-     *
-     * export default class extends Component {
-     *   @service router;
-     *
-     *   @action
-     *   goToComments(post) {
-     *     this.router.transitionTo('comments', post);
-     *   }
-     * }
-     * ```
-     *
-     * @param routeNameOrUrl the name of the route or a URL
-     * @param models         the model(s) or identifier(s) to be used while
-     *                       transitioning to the route.
-     * @param options        optional hash with a queryParams property
-     *                       containing a mapping of query parameters. May be
-     *                       supplied as the only parameter to trigger a
-     *                       query-parameter-only transition.
-     * @returns              the Transition object associated with this attempted transition
-     */
-    transitionTo(routeNameOrUrl: string, options?: { queryParams: object }): Transition;
-    transitionTo(
-      routeNameOrUrl: string,
-      models: RouteModel,
-      options?: { queryParams: object }
-    ): Transition;
-    transitionTo(
-      routeNameOrUrl: string,
-      modelsA: RouteModel,
-      modelsB: RouteModel,
-      options?: { queryParams: object }
-    ): Transition;
-    transitionTo(
-      routeNameOrUrl: string,
-      modelsA: RouteModel,
-      modelsB: RouteModel,
-      modelsC: RouteModel,
-      options?: { queryParams: object }
-    ): Transition;
-    transitionTo(
-      routeNameOrUrl: string,
-      modelsA: RouteModel,
-      modelsB: RouteModel,
-      modelsC: RouteModel,
-      modelsD: RouteModel,
-      options?: { queryParams: object }
-    ): Transition;
-    transitionTo(options: { queryParams: object }): Transition;
-
-    // https://emberjs.com/api/ember/4.3.0/classes/RouterService/methods/isActive?anchor=urlFor
-    /**
-     * Generate a URL based on the supplied route name.
-     *
-     * @param routeName the name of the route or a URL
-     * @param models    the model(s) or identifier(s) to be used while
-     *                  transitioning to the route.
-     * @param options   optional hash with a queryParams property containing
-     *                  a mapping of query parameters
-     * @returns         the string representing the generated URL
-     */
-    urlFor(
-      routeName: string,
-      ...args: RouteModel[] | [...RouteModel[], { queryParams: object }]
-    ): string;
-
-    // https://api.emberjs.com/ember/3.6/classes/RouterService/events/routeDidChange?anchor=routeDidChange
-    /**
-     * Register a callback for an event.
-     *
-     * The `routeWillChange` event is fired at the beginning of any attempted transition with a `Transition` object as the sole argument.
-     * This action can be used for aborting, redirecting, or decorating the transition from the currently active routes.
-     *
-     * The `routeDidChange` event only fires once a transition has settled.
-     * This includes aborts and error substates.
-     * Like the `routeWillChange` event it recieves a `Transition` as the sole argument.
-     *
-     * @param name     the name of the event
-     * @param callback the callback to execute
-     */
-    on(
-      name: 'routeDidChange' | 'routeWillChange',
-      callback: (transition: Transition) => void
-    ): RouterService;
-
-    // https://api.emberjs.com/ember/3.28/classes/Evented/methods/off?anchor=off
-    /**
-     * Removes a callback for an event.
-     *
-     * The `routeWillChange` event is fired at the beginning of any attempted transition with a `Transition` object as the sole argument.
-     * This action can be used for aborting, redirecting, or decorating the transition from the currently active routes.
-     *
-     * The `routeDidChange` event only fires once a transition has settled.
-     * This includes aborts and error substates.
-     *
-     * @param name     the name of the event 'routeWillChange' | 'routeDidChange'
-     * @param callback the callback to remove
-     */
-    off(
-      name: 'routeDidChange' | 'routeWillChange',
-      callback: (transition: Transition) => void
-    ): RouterService;
-
-    /**
-     * https://api.emberjs.com/ember/3.28/classes/Evented/methods/off?anchor=has
-     *
-     * Checks to see if object has any subscriptions for named event.
-     *
-     * @param name
-     */
-    has(name: string): boolean;
-
-    /**
-     * https://api.emberjs.com/ember/3.28/classes/Evented/methods/off?anchor=one
-     *
-     * Subscribes a function to a named event and then cancels the subscription after the first time the
-     * event is triggered. It is good to use one when you only care about the first time an event has taken place.
-     *
-     * @param name     the name of the event
-     * @param callback the callback to execute
-     */
-    one(
-      name: 'routeDidChange' | 'routeWillChange',
-      callback: (transition: Transition) => void
-    ): RouterService;
-
-    /**
-     * https://api.emberjs.com/ember/3.28/classes/Evented/methods/off?anchor=trigger
-     *
-     * Triggers a named event for the object.
-     * Any additional arguments will be passed as parameters to the functions that are subscribed to the event.
-     *
-     * @param name the name of the event
-     * @param args arguments to pass to the event
-     */
-    trigger(name: string, args: any): void;
-
-    /**
-     * Takes a string URL and returns a `RouteInfo` for the leafmost route represented
-     * by the URL. Returns `null` if the URL is not recognized. This method expects to
-     * receive the actual URL as seen by the browser including the app's `rootURL`.
-     * See [RouteInfo](/ember/release/classes/RouteInfo) for more info.
-     * In the following example `recognize` is used to verify if a path belongs to our
-     * application before transitioning to it.
-     * ```
-     * import Component from '@ember/component';
-     * import { inject as service } from '@ember/service';
-     * export default class extends Component {
-     *   @service router;
-     *   path = '/';
-     *   click() {
-     *     if (this.router.recognize(this.path)) {
-     *       this.router.transitionTo(this.path);
-     *     }
-     *   }
-     * }
-     * ```
-     */
-    recognize(url: string): RouteInfo;
-
-    /**
-     * Takes a string URL and returns a promise that resolves to a
-     * `RouteInfoWithAttributes` for the leafmost route represented by the URL.
-     * The promise rejects if the URL is not recognized or an unhandled exception
-     * is encountered. This method expects to receive the actual URL as seen by
-     * the browser including the app's `rootURL`.
-     */
-    recognizeAndLoad(url: string): RouteInfoWithAttributes;
-
-    /**
-     * Refreshes all currently active routes, doing a full transition.
-     * If a route name is provided and refers to a currently active route,
-     * it will refresh only that route and its descendents.
-     * Returns a promise that will be resolved once the refresh is complete.
-     * All resetController, beforeModel, model, afterModel, redirect, and setupController
-     * hooks will be called again. You will get new data from the model hook.
-     */
-    refresh(pivotRouteName?: string): Transition;
-  }
-}
-
-declare module '@ember/service' {
-  import RouterService from '@ember/routing/router-service';
-
-  interface Registry {
-    router: RouterService;
-  }
-}
diff --git a/types/preview/@ember/routing/router.d.ts b/types/preview/@ember/routing/router.d.ts
deleted file mode 100644
index bba5ac4b9fb..00000000000
--- a/types/preview/@ember/routing/router.d.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-declare module '@ember/routing/router' {
-  import EmberObject from '@ember/object';
-  import Evented from '@ember/object/evented';
-  import RouterDSL from '@ember/routing/-private/router-dsl';
-  import Transition from '@ember/routing/transition';
-
-  /**
-   * The `Ember.Router` class manages the application state and URLs. Refer to
-   * the [routing guide](http://emberjs.com/guides/routing/) for documentation.
-   */
-  export default class Router extends EmberObject {
-    /**
-     * The `Router.map` function allows you to define mappings from URLs to routes
-     * in your application. These mappings are defined within the
-     * supplied callback function using `this.route`.
-     */
-    static map(callback: (this: RouterDSL) => void): void;
-    /**
-     * The `location` property determines the type of URL's that your
-     * application will use.
-     *
-     * @note the `'auto'` location is [deprecated](https://deprecations.emberjs.com/v4.x/#toc_deprecate-auto-location).
-     */
-    location: 'history' | 'hash' | 'none' | 'auto';
-    /**
-     * Represents the URL of the root of the application, often '/'. This prefix is
-     * assumed on all routes defined on this router.
-     */
-    rootURL: string;
-    /**
-     * Transition the application into another route. The route may
-     * be either a single route or route path:
-     */
-    transitionTo(name: string, options?: {}): Transition;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    transitionTo(name: string, ...models: any[]): Transition;
-    transitionTo(name: string, options: {}): Transition;
-  }
-
-  export default interface Router extends Evented {}
-}
diff --git a/types/preview/@ember/routing/transition.d.ts b/types/preview/@ember/routing/transition.d.ts
deleted file mode 100644
index 0d36e8437d8..00000000000
--- a/types/preview/@ember/routing/transition.d.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-declare module '@ember/routing/transition' {
-  import RouteInfo, { RouteInfoWithAttributes } from '@ember/routing/route-info';
-
-  /**
-   * A Transition is a thennable (a promise-like object) that represents an
-   * attempt to transition to another route. It can be aborted, either explicitly
-   * via `abort` or by attempting another transition while a previous one is still
-   * underway. An aborted transition can also be `retry()`d later.
-   *
-   * @note This is a non-user-constructible type. The only legal way to get a
-   *   transition is using one of the public API methods on routes, controllers,
-   *   the router service, etc.
-   */
-  export default interface Transition<T = unknown> extends Partial<Promise<T>> {
-    /**
-     * Custom state can be stored on a Transition's `data` object.
-     * This can be useful for decorating a Transition within an earlier hook and shared with a later hook.
-     * Properties set on `data` will be copied to new transitions generated by calling `retry` on this transition.
-     */
-    data: Record<string, unknown>;
-    /**
-     * This property is a `RouteInfo` object that represents where transition originated from.
-     * It's important to note that a `RouteInfo` is a linked list and this property is simply the head node of the list.
-     * In the case of an initial render, `from` will be set to `null`.
-     */
-    readonly from: RouteInfoWithAttributes | null;
-    /**
-     * The Transition's internal promise.
-     * Calling `.then` on this property is that same as calling `.then` on the Transition object itself,
-     * but this property is exposed for when you want to pass around a Transition's promise,
-     * but not the Transition object itself, since Transition object can be externally `abort`ed,
-     * while the promise cannot.
-     */
-    readonly promise: Promise<T>;
-    /**
-     * This property is a `RouteInfo` object that represents where the router is transitioning to.
-     * It's important to note that a `RouteInfo` is a linked list and this property is simply the leafmost route.
-     */
-    readonly to: RouteInfo | RouteInfoWithAttributes;
-    /**
-     * Aborts the Transition. Note you can also implicitly abort a transition
-     * by initiating another transition while a previous one is underway.
-     */
-    abort(): Transition<T>;
-    /**
-     * Forwards to the internal `promise` property which you can use in situations where you want to pass around a thennable,
-     * but not the Transition itself.
-     *
-     * @param onRejection
-     * @param label optional string for labeling the promise. Useful for tooling.
-     */
-    catch<TResult = never>(
-      onRejected?: (reason: unknown) => TResult | PromiseLike<TResult>,
-      label?: string
-    ): Promise<TResult | T>;
-    /**
-     * Forwards to the internal `promise` property which you can use in situations where you want to pass around a thennable,
-     * but not the Transition itself.
-     *
-     * @param onFinally
-     * @param label optional string for labeling the promise. Useful for tooling.
-     */
-    finally(onFinally?: () => void, label?: string): Promise<T>;
-    /**
-     * Transitions are aborted and their promises rejected when redirects occur;
-     * this method returns a promise that will follow any redirects that occur and
-     * fulfill with the value fulfilled by any redirecting transitions that occur.
-     *
-     * @return a promise that fulfills with the same value that the final redirecting transition fulfills with
-     */
-    followRedirects(): Promise<T>;
-    /**
-     * Sets the URL-changing method to be employed at the end of a successful transition.
-     * By default, a new Transition will just use `updateURL`,
-     * but passing 'replace' to this method will cause the URL to update using 'replaceWith' instead.
-     * Omitting a parameter will disable the URL change,
-     * allowing for transitions that don't update the URL at completion
-     * (this is also used for handleURL, since the URL has already changed before the transition took place).
-     *
-     * @param  method the type of URL-changing method to use at the end of a transition. Accepted values are 'replace',
-     *                falsy values, or any other non-falsy value (which is interpreted as an updateURL transition).
-     * @return        This transition
-     */
-    method(method?: string): Transition<T>;
-    /**
-     * Retries a previously-aborted transition (making sure to abort the
-     * transition if it's still active). Returns a new transition that
-     * represents the new attempt to transition.
-     */
-    retry(): Transition<T>;
-    /**
-     * A standard promise hook that resolves if the transition succeeds and rejects if it fails/redirects/aborts.
-     *
-     * Forwards to the internal `promise` property which you can use in situations where you want to pass around a thennable,
-     * but not the Transition itself.
-     *
-     * @param  onFulfilled
-     * @param  onRejected
-     * @param  label label optional string for labeling the promise. Useful for tooling.
-     */
-    then<TResult1 = T, TResult2 = never>(
-      onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>,
-      onrejected?: (reason: unknown) => TResult2 | PromiseLike<TResult2>,
-      label?: string
-    ): Promise<TResult1 | TResult2>;
-    /**
-     * Fires an event on the current list of resolved/resolving handlers within this transition.
-     * Useful for firing events on route hierarchies that haven't fully been entered yet.
-     *
-     * @param  ignoreFailure a boolean specifying whether unhandled events throw an error
-     * @param  name          the name of the event to fire
-     */
-    send(ignoreFailure: boolean, name: string): void;
-    /**
-     * Fires an event on the current list of resolved/resolving handlers within this transition.
-     * Useful for firing events on route hierarchies that haven't fully been entered yet.
-     * Note: This method is also aliased as `send`
-     *
-     * @alias send
-     *
-     * @param  ignoreFailure a boolean specifying whether unhandled events throw an error
-     * @param  name          the name of the event to fire
-     */
-    trigger(ignoreFailure: boolean, name: string): void;
-  }
-}
diff --git a/types/preview/@ember/routing/types.d.ts b/types/preview/@ember/routing/types.d.ts
deleted file mode 100644
index c8483e79e47..00000000000
--- a/types/preview/@ember/routing/types.d.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-declare module '@ember/routing/types' {
-  export interface RenderOptions {
-    into?: string | undefined;
-    controller?: string | undefined;
-    model?: unknown;
-    outlet?: string | undefined;
-    view?: string | undefined;
-  }
-
-  export interface RouteQueryParam {
-    refreshModel?: boolean | undefined;
-    replace?: boolean | undefined;
-    as?: string | undefined;
-  }
-}
diff --git a/types/preview/@ember/runloop/-private/backburner.d.ts b/types/preview/@ember/runloop/-private/backburner.d.ts
deleted file mode 100644
index 20fc9cff668..00000000000
--- a/types/preview/@ember/runloop/-private/backburner.d.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-declare module '@ember/runloop/-private/backburner' {
-  import { EmberMethod, EmberMethodParams } from 'ember/-private/type-utils';
-
-  export interface QueueItem {
-    method: string;
-    target: object;
-    args: object[];
-    stack: string | undefined;
-  }
-
-  export interface DeferredActionQueues {
-    [index: string]: unknown;
-    queues: object;
-    schedule<T, M extends EmberMethod<T>>(
-      ...args: [
-        queueName: string,
-        target: T,
-        method: M,
-        ...methodArgs: EmberMethodParams<T, M>,
-        onceFlag: boolean,
-        stack: unknown
-      ]
-    ): any;
-    flush(fromAutorun: boolean): any;
-  }
-
-  export interface DebugInfo {
-    autorun: Error | undefined | null;
-    counters: object;
-    timers: QueueItem[];
-    instanceStack: DeferredActionQueues[];
-  }
-
-  export interface Backburner {
-    join(...args: any[]): void;
-    on(...args: any[]): void;
-    scheduleOnce(...args: any[]): void;
-    schedule(queueName: string, target: object | null, method: () => void | string): void;
-    ensureInstance(): void;
-    DEBUG: boolean;
-    getDebugInfo(): DebugInfo;
-  }
-}
diff --git a/types/preview/@ember/runloop/-private/types.d.ts b/types/preview/@ember/runloop/-private/types.d.ts
deleted file mode 100644
index 8fa9ccf9bf2..00000000000
--- a/types/preview/@ember/runloop/-private/types.d.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-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
deleted file mode 100644
index 160276e858c..00000000000
--- a/types/preview/@ember/runloop/index.d.ts
+++ /dev/null
@@ -1,175 +0,0 @@
-declare module '@ember/runloop' {
-  import {
-    EmberMethod,
-    EmberMethodParams,
-    AnyFn,
-    EmberMethodReturn,
-  } from 'ember/-private/type-utils';
-  import { EmberRunQueues } from '@ember/runloop/-private/types';
-  import { EmberRunTimer } from '@ember/runloop/types';
-  import '@ember/runloop/-private/backburner';
-
-  /**
-   * Runs the passed target and method inside of a RunLoop, ensuring any
-   * deferred actions including bindings and views updates are flushed at the
-   * end.
-   */
-  export function run<M extends AnyFn>(method: M): ReturnType<M>;
-  export function run<T, M extends EmberMethod<T>>(
-    target: T,
-    method: M,
-    ...args: EmberMethodParams<T, M>
-  ): EmberMethodReturn<T, M>;
-
-  /**
-   * If no run-loop is present, it creates a new one. If a run loop is
-   * present it will queue itself to run on the existing run-loops action
-   * queue.
-   */
-  export function join<M extends AnyFn>(
-    method: M,
-    ...args: Parameters<M>
-  ): ReturnType<M> | undefined;
-  export function join<T, M extends EmberMethod<T>>(
-    target: T,
-    method: M,
-    ...args: EmberMethodParams<T, M>
-  ): EmberMethodReturn<T, M> | undefined;
-
-  /**
-   * Allows you to specify which context to call the specified function in while
-   * adding the execution of that function to the Ember run loop. This ability
-   * makes this method a great way to asynchronously integrate third-party libraries
-   * into your Ember application.
-   */
-  // NOTE: it would be nice to make this curry arguments, which is how it actually
-  // works, but that is a *lot* of type shenanigans, and also diverges from the
-  // `Function.prototype.bind` implementation. We should track the latter, despite
-  // the loss of safety, because it makes interop cleaner.
-  export function bind<T, M extends EmberMethod<T>>(
-    target: T,
-    method: M,
-    ...args: any[]
-  ): (...args: any[]) => EmberMethodReturn<T, M>;
-
-  /**
-   * Begins a new RunLoop. Any deferred actions invoked after the begin will
-   * be buffered until you invoke a matching call to `run.end()`. This is
-   * a lower-level way to use a RunLoop instead of using `run()`.
-   */
-  export function begin(): void;
-
-  /**
-   * Ends a RunLoop. This must be called sometime after you call
-   * `run.begin()` to flush any deferred actions. This is a lower-level way
-   * to use a RunLoop instead of using `run()`.
-   */
-  export function end(): void;
-
-  /**
-   * Adds the passed target/method and any optional arguments to the named
-   * queue to be executed at the end of the RunLoop. If you have not already
-   * started a RunLoop when calling this method one will be started for you
-   * automatically.
-   */
-  export function schedule<T, M extends EmberMethod<T>>(
-    queue: EmberRunQueues,
-    target: T,
-    method: M,
-    ...args: EmberMethodParams<T, M>
-  ): EmberRunTimer;
-  export function schedule<M extends AnyFn>(
-    queue: EmberRunQueues,
-    method: M,
-    ...args: Parameters<M>
-  ): EmberRunTimer;
-
-  /**
-   * Invokes the passed target/method and optional arguments after a specified
-   * period of time. The last parameter of this method must always be a number
-   * of milliseconds.
-   */
-  export function later(method: AnyFn, wait: number): EmberRunTimer;
-  export function later<T, M extends EmberMethod<T>>(
-    ...args: [target: T, method: M, ...args: EmberMethodParams<T, M>, wait: number]
-  ): EmberRunTimer;
-
-  /**
-   * Schedule a function to run one time during the current RunLoop. This is equivalent
-   * to calling `scheduleOnce` with the "actions" queue.
-   */
-  export function once<T, M extends EmberMethod<T>>(
-    target: T,
-    method: M,
-    ...args: EmberMethodParams<T, M>
-  ): EmberRunTimer;
-
-  export function once<T, M extends keyof T>(
-    target: T,
-    method: M,
-    ...args: EmberMethodParams<T, M>
-  ): EmberRunTimer;
-
-  /**
-   * Schedules a function to run one time in a given queue of the current RunLoop.
-   * Calling this method with the same queue/target/method combination will have
-   * no effect (past the initial call).
-   */
-  export function scheduleOnce<T, M extends EmberMethod<T>>(
-    queue: EmberRunQueues,
-    target: T,
-    method: M,
-    ...args: EmberMethodParams<T, M>
-  ): EmberRunTimer;
-
-  /**
-   * Schedules an item to run from within a separate run loop, after
-   * control has been returned to the system. This is equivalent to calling
-   * `run.later` with a wait time of 1ms.
-   */
-  export function next<T, M extends EmberMethod<T>>(
-    target: T,
-    method: M,
-    ...args: EmberMethodParams<T, M>
-  ): EmberRunTimer;
-  export function next<M extends AnyFn>(method: M, ...args: Parameters<M>): EmberRunTimer;
-
-  /**
-   * Cancels a scheduled item. Must be a value returned by `run.later()`,
-   * `run.once()`, `run.scheduleOnce()`, `run.next()`, `run.debounce()`, or
-   * `run.throttle()`.
-   */
-  export function cancel(timer?: EmberRunTimer): boolean;
-
-  /**
-   * Delay calling the target method until the debounce period has elapsed
-   * with no additional debounce calls. If `debounce` is called again before
-   * the specified time has elapsed, the timer is reset and the entire period
-   * must pass again before the target method is called.
-   */
-  export function debounce(method: AnyFn, wait: number, immediate?: boolean): EmberRunTimer;
-  export function debounce<Target, M extends EmberMethod<Target>>(
-    ...args: [
-      target: Target,
-      method: M,
-      ...args: EmberMethodParams<Target, M>,
-      wait: number,
-      immediate?: boolean
-    ]
-  ): EmberRunTimer;
-
-  /**
-   * Ensure that the target method is never called more frequently than
-   * the specified spacing period. The target method is called immediately.
-   */
-  export function throttle(method: AnyFn, spacing: number, immediate?: boolean): EmberRunTimer;
-  export function throttle<T, M extends EmberMethod<T>>(
-    ...args: [
-      target: T,
-      method: M,
-      ...methodArgs: EmberMethodParams<T, M>,
-      spacing: number,
-      immediate?: boolean
-    ]
-  ): EmberRunTimer;
-}
diff --git a/types/preview/@ember/runloop/types.d.ts b/types/preview/@ember/runloop/types.d.ts
deleted file mode 100644
index f1c79f14c6c..00000000000
--- a/types/preview/@ember/runloop/types.d.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-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
deleted file mode 100644
index 93c85048fe7..00000000000
--- a/types/preview/@ember/service/index.d.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-declare module '@ember/service' {
-  import EmberObject from '@ember/object';
-  import type { BasicComputedProperty } from '@ember/object/computed';
-
-  export default class Service extends EmberObject {}
-  /**
-   * Creates a property that lazily looks up a service in the container. There
-   * are no restrictions as to what objects a service can be injected into.
-   */
-  export function inject(): Service; // @inject() foo, foo: inject()
-  export function inject(target: object, propertyKey: string | symbol): void; // @inject foo
-  export function inject<K extends keyof Registry>(name: K): Registry[K] & BasicComputedProperty; // @inject('store') foo      @inject() foo
-
-  /**
-   * Creates a property that lazily looks up a service in the container. There
-   * are no restrictions as to what objects a service can be injected into.
-   */
-  export function service(): Service; // @service() foo, foo: service()
-  export function service(target: object, propertyKey: string | symbol): void; // @service foo
-  export function service<K extends keyof Registry>(name: K): Registry[K] & BasicComputedProperty; // @service('store') foo      @service() foo
-
-  // A type registry for Ember `Service`s. Meant to be declaration-merged so
-  // string lookups resolve to the correct type.
-  export interface Registry extends Record<string, Service> {}
-}
-
-declare module '@ember/owner' {
-  import { Registry } from '@ember/service';
-  export interface DIRegistry {
-    service: Registry;
-  }
-}
diff --git a/types/preview/@ember/template-compilation/index.d.ts b/types/preview/@ember/template-compilation/index.d.ts
deleted file mode 100644
index 8e97b083e62..00000000000
--- a/types/preview/@ember/template-compilation/index.d.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * References:
- *  - https://github.com/emberjs/rfcs/pull/496
- *  - https://github.com/emberjs/rfcs/pull/779
- */
-declare module '@ember/template-compilation' {
-  import type { TemplateFactory } from '@ember/component/-private/glimmer-interfaces';
-
-  interface MaybeModuleName {
-    moduleName?: string;
-  }
-
-  interface LooseMode extends MaybeModuleName {
-    strictMode?: false;
-  }
-
-  interface StrictMode extends MaybeModuleName {
-    strictMode: true;
-    scope: () => Record<string, unknown>;
-  }
-
-  type PrecompileTemplateOptions = LooseMode | StrictMode;
-
-  export function precompileTemplate(
-    template: string,
-    options?: PrecompileTemplateOptions
-  ): TemplateFactory;
-}
diff --git a/types/preview/@ember/template/-private/handlebars.d.ts b/types/preview/@ember/template/-private/handlebars.d.ts
deleted file mode 100644
index 6b4d0985f92..00000000000
--- a/types/preview/@ember/template/-private/handlebars.d.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-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
deleted file mode 100644
index be2c034b66e..00000000000
--- a/types/preview/@ember/template/index.d.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-declare module '@ember/template' {
-  import { SafeString } from '@ember/template/-private/handlebars';
-  export type { SafeString };
-  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
deleted file mode 100644
index ac38cd059ba..00000000000
--- a/types/preview/@ember/test/adapter.d.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-declare module '@ember/test/adapter' {
-  /**
-   * The primary purpose of this class is to create hooks that can be implemented
-   * by an adapter for various test frameworks.
-   */
-  export default class Adapter {
-    /**
-     * This callback will be called whenever an async operation is about to start.
-     */
-    asyncStart(): unknown;
-    /**
-     * This callback will be called whenever an async operation has completed.
-     */
-    asyncEnd(): unknown;
-    /**
-     * Override this method with your testing framework's false assertion.
-     * This function is called whenever an exception occurs causing the testing
-     * promise to fail.
-     */
-    exception(error: string): unknown;
-  }
-}
diff --git a/types/preview/@ember/test/index.d.ts b/types/preview/@ember/test/index.d.ts
deleted file mode 100644
index 8d754a27286..00000000000
--- a/types/preview/@ember/test/index.d.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-declare module '@ember/test' {
-  import Application from '@ember/application';
-
-  /**
-   * `registerHelper` is used to register a test helper that will be injected
-   * when `App.injectTestHelpers` is called.
-   */
-  export function registerHelper(
-    name: string,
-    helperMethod: (app: Application, ...args: any[]) => unknown,
-    options?: object
-  ): unknown;
-  /**
-   * `registerAsyncHelper` is used to register an async test helper that will be injected
-   * when `App.injectTestHelpers` is called.
-   */
-  export function registerAsyncHelper(
-    name: string,
-    helperMethod: (app: Application, ...args: any[]) => unknown
-  ): void;
-
-  /**
-   * Remove a previously added helper method.
-   */
-  export function unregisterHelper(name: string): void;
-
-  /**
-   * This allows ember-testing to play nicely with other asynchronous
-   * events, such as an application that is waiting for a CSS3
-   * transition or an IndexDB transaction. The waiter runs periodically
-   * after each async helper (i.e. `click`, `andThen`, `visit`, etc) has executed,
-   * until the returning result is truthy. After the waiters finish, the next async helper
-   * is executed and the process repeats.
-   */
-  export function registerWaiter(callback: () => boolean): unknown;
-  export function registerWaiter<Context>(
-    context: Context,
-    callback: (this: Context) => boolean
-  ): unknown;
-  /**
-   * `unregisterWaiter` is used to unregister a callback that was
-   * registered with `registerWaiter`.
-   */
-  export function unregisterWaiter(callback: () => boolean): unknown;
-  export function unregisterWaiter<Context>(
-    context: Context,
-    callback: (this: Context) => boolean
-  ): unknown;
-}
diff --git a/types/preview/@ember/utils/-private/types.d.ts b/types/preview/@ember/utils/-private/types.d.ts
deleted file mode 100644
index de5bf83173a..00000000000
--- a/types/preview/@ember/utils/-private/types.d.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-declare module '@ember/utils/-private/types' {
-  import type { AnyFn } from 'ember/-private/type-utils';
-  import NativeArray from '@ember/array/-private/native-array';
-
-  // prettier-ignore
-  type _KeysOfType<Key extends keyof TypeLookup, Type> =
-    // Checks non-`const` versions, and correctly resolves those types
-    // constructed via e.g. the `Number` constructor.
-    TypeLookup[Key] extends Type ? Key :
-    // Checks `const` versions, e.g. handling strict function types when also
-    // using a const-valued function like `const x = () => 4 as const`.
-    Type extends TypeLookup[Key] ? Key : never;
-
-  // prettier-ignore
-  type KeysOfType<Type> =
-    { [Key in keyof TypeLookup]: _KeysOfType<Key, Type> }[keyof TypeLookup];
-
-  // Since `TypeLookup` resolves all *other* types, including `null` and
-  // `undefined`, we can assume that if the type does *not* resolve from
-  // `KeysOfType`, it is safe to treat it as 'object'.
-  export type TypeOf<T> = KeysOfType<T> extends never ? 'object' : KeysOfType<T>;
-
-  export interface TypeLookup {
-    string: string;
-    number: number;
-    boolean: boolean;
-    regexp: RegExp;
-    function: AnyFn;
-    array: Array<unknown> | NativeArray<unknown>;
-    error: Error;
-    filelist: FileList;
-    date: Date;
-    null: null;
-    undefined: undefined;
-  }
-
-  // Don't export anything but the required type util
-  export {};
-}
diff --git a/types/preview/@ember/utils/index.d.ts b/types/preview/@ember/utils/index.d.ts
deleted file mode 100644
index 1f762ae0f99..00000000000
--- a/types/preview/@ember/utils/index.d.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-declare module '@ember/utils' {
-  import { TypeOf } from '@ember/utils/-private/types';
-
-  /**
-   * Compares two javascript values and returns:
-   */
-  export function compare(v: unknown, w: unknown): number;
-
-  /**
-   * A value is blank if it is empty or a whitespace string.
-   */
-  export function isBlank(obj?: unknown): boolean;
-
-  /**
-   * Verifies that a value is `null` or `undefined`, an empty string,
-   * or an empty array.
-   */
-  export function isEmpty(obj?: unknown): boolean;
-
-  /**
-   * Compares two objects, returning true if they are equal.
-   */
-  export function isEqual(a: unknown, b: unknown): boolean;
-
-  /**
-   * Returns true if the passed value is null or undefined. This avoids errors
-   * from JSLint complaining about use of ==, which can be technically
-   * confusing.
-   */
-  export function isNone(obj?: unknown): obj is null | undefined;
-
-  /**
-   * A value is present if it not `isBlank`.
-   */
-  export function isPresent(obj?: unknown): boolean;
-
-  /**
-   * Returns a consistent type for the passed object.
-   */
-  export function typeOf<T>(value: T): TypeOf<T>;
-  export function typeOf(): 'undefined';
-}
diff --git a/types/preview/ember/-private/type-utils.d.ts b/types/preview/ember/-private/type-utils.d.ts
deleted file mode 100644
index f47c00631f4..00000000000
--- a/types/preview/ember/-private/type-utils.d.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-declare module 'ember/-private/type-utils' {
-  // These are utility types used throughout the Ember type definitions. They
-  // should *never* be used in end user code.
-
-  /** A safe-ish type representing any function. */
-  export type AnyFn = (...args: any[]) => unknown;
-
-  export type AnyMethod<Target> = (this: Target, ...args: any[]) => unknown;
-
-  // The formatting here is designed to help make this type actually be
-  // comprehensible to mortals, including the mortals who came up with it.
-  // prettier-ignore
-  export type MethodsOf<T> = {
-    // This `keyof` check is the thing which gives us *only* these keys, and no
-    // `foo: never` appears in the final type.
-    [K in keyof T as T[K] extends AnyFn ? K : never]:
-      // While this makes sure the resolved type only has `AnyFn` in it, so that
-      // the resulting type is known to be only function types.
-      T[K] extends AnyFn ? T[K] : never;
-  };
-
-  export type MethodNamesOf<T> = keyof MethodsOf<T>;
-
-  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>> =
-    // For a basic method, we can just use the direct accessor.
-    M extends AnyMethod<T> ? Parameters<M> :
-    M extends MethodNamesOf<T> ? Parameters<MethodsOf<T>[M]> : 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 MethodNamesOf<T> ? ReturnType<MethodsOf<T>[M]> : never;
-
-  /**
-   * A type utility for Ember's common name-of-object-on-target-or-function
-   * pattern for e.g. event handlers.
-   */
-  export type EmberMethod<Target> = AnyMethod<Target> | keyof Target;
-
-  // A way of representing non-user-constructible types. You can conveniently use
-  // this by doing `interface Type extends Data<'some-type-name'> { ... }` for
-  // simple types, and/or you can type-parameterize it as makes sense for your use
-  // case (see e.g. `@ember/component/helper`'s use with functional helpers).
-  const Data: unique symbol;
-  export class Opaque<Data> {
-    private declare [Data]: Data;
-  }
-
-  export {};
-}
diff --git a/types/preview/ember/index.d.ts b/types/preview/ember/index.d.ts
deleted file mode 100755
index cd19bb07f82..00000000000
--- a/types/preview/ember/index.d.ts
+++ /dev/null
@@ -1,347 +0,0 @@
-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 EmberTemplateNs from '@ember/template';
-  import * as EmberTemplateHandlebarsNs from '@ember/template/-private/handlebars';
-  import type * as EmberServiceNs from '@ember/service';
-  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 EmberTestNs from '@ember/test';
-  import * as EmberControllerNs from '@ember/controller';
-  import EmberMixin from '@ember/object/mixin';
-  import type EmberObservable from '@ember/object/observable';
-  // @ember/array
-  import type * as EmberArrayNs from '@ember/array';
-  import type EmberMutableArray from '@ember/array/mutable';
-  import type EmberNativeArray from '@ember/array/-private/native-array';
-  import EmberArrayProxy from '@ember/array/proxy';
-  import type EmberEnumerable from '@ember/array/-private/enumerable';
-  import type EmberMutableEnumerable from '@ember/array/-private/mutable-enumerable';
-
-  type EmberArray<T> = EmberArrayNs.default<T>;
-  import type EmberActionHandler from '@ember/object/-private/action-handler';
-  import EmberComponent from '@ember/component';
-  import EmberHelper from '@ember/component/helper';
-  // @ember/routing
-  import EmberRoutingRouter from '@ember/routing/router';
-  import EmberRoutingRoute from '@ember/routing/route';
-  import EmberRoutingHashLocation from '@ember/routing/hash-location';
-  import EmberRoutingHistoryLocation from '@ember/routing/history-location';
-  import EmberRoutingNoneLocation from '@ember/routing/none-location';
-  // @ember/application
-  import EmberEventDispatcher from '@ember/application/-private/event-dispatcher';
-  import EmberRegistry from '@ember/application/-private/registry';
-  // @ember/test
-  import EmberTestAdapter from '@ember/test/adapter';
-
-  namespace Ember {
-    export const A: typeof EmberArrayNs.A;
-    export const isArray: typeof EmberArrayNs.isArray;
-    export type Enumerable = EmberEnumerable;
-    export const Enumerable: typeof EmberEnumerable;
-    export class ArrayProxy<T> extends EmberArrayProxy<T> {}
-    export type Array<T> = EmberArray<T>;
-    export const Array: typeof EmberArrayNs.default;
-    export type MutableArray<T> = EmberMutableArray<T>;
-    export const MutableArray: typeof EmberMutableArray;
-    export type NativeArray<T> = EmberNativeArray<T>;
-    export const NativeArray: typeof EmberNativeArray;
-    export type MutableEnumerable = EmberMutableEnumerable;
-    export const MutableEnumerable: typeof EmberMutableEnumerable;
-    export class Router extends EmberRoutingRouter {}
-    export class Route extends EmberRoutingRoute {}
-    export const ActionHandler: typeof EmberActionHandler;
-    export class Controller extends EmberControllerNs.default {}
-    export class Component extends EmberComponent {}
-    export class Helper extends EmberHelper {}
-
-    export class HashLocation extends EmberRoutingHashLocation {}
-    export class NoneLocation extends EmberRoutingNoneLocation {}
-    export class HistoryLocation extends EmberRoutingHistoryLocation {}
-    export const deprecate: typeof EmberDebugNs.deprecate;
-    export const getOwner: typeof EmberApplicationNs.getOwner;
-    export const setOwner: typeof EmberApplicationNs.setOwner;
-    export class EventDispatcher extends EmberEventDispatcher {}
-    export class Registry extends EmberRegistry {}
-
-    /**
-     * Implements some standard methods for comparing objects. Add this mixin to
-     * any class you create that can compare its instances.
-     */
-    export interface Comparable {
-      compare(a: unknown, b: unknown): number;
-    }
-    const Comparable: EmberMixin;
-    class ComputedProperty extends EmberObjectComputedNs.default {}
-    /**
-     * A container used to instantiate and cache objects.
-     */
-    class Container {
-      /**
-       * Given a fullName, return the corresponding factory. The consumer of the factory
-       * is responsible for the destruction of any factory instances, as there is no
-       * way for the container to ensure instances are destroyed when it itself is
-       * destroyed.
-       */
-      factoryFor(fullName: string, options?: {}): unknown;
-    }
-    class ContainerDebugAdapter extends _ContainerDebugAdapter {}
-
-    class Object extends EmberObjectNs.default {}
-    class ObjectProxy extends EmberObjectProxyNs.default {}
-    const Observable: typeof EmberObservable;
-    const PromiseProxyMixin: typeof EmberObjectPromiseProxyNs.default;
-    interface PromiseProxyMixin<T> extends EmberObjectPromiseProxyNs.default<T> {}
-    class CoreObject extends EmberCoreObject {}
-    class DataAdapter extends EmberDataAdapter {}
-    const Debug: {
-      registerDeprecationHandler: typeof EmberDebugNs.registerDeprecationHandler;
-      registerWarnHandler: typeof EmberDebugNs.registerWarnHandler;
-    };
-    class EngineInstance extends EmberEngineInstanceNs.default {}
-    class Engine extends EmberEngineNs.default {}
-
-    const Evented: typeof EmberObjectEventedNs.default;
-    interface Evented extends EmberObjectEventedNs.default {}
-
-    class Mixin extends EmberMixin {}
-
-    /**
-     * A Namespace is an object usually used to contain other objects or methods
-     * such as an application or framework. Create a namespace anytime you want
-     * to define one of these new containers.
-     */
-    class Namespace extends Object {}
-
-    class Service extends Object {}
-
-    interface ViewTargetActionSupport {
-      target: unknown;
-      actionContext: unknown;
-    }
-    const ViewTargetActionSupport: Mixin;
-    const ViewUtils: {
-      isSimpleClick(event: Event): boolean;
-    };
-
-    // FYI - RSVP source comes from https://github.com/tildeio/rsvp.js/blob/master/lib/rsvp/promise.js
-    const RSVP: typeof Rsvp;
-    namespace RSVP {
-      type Promise<T> = Rsvp.Promise<T>;
-    }
-    class Application extends EmberApplicationNs.default {}
-    class ApplicationInstance extends EmberApplicationInstanceNs.default {}
-    /**
-     * This is a container for an assortment of testing related functionality
-     */
-    namespace Test {
-      class Adapter extends EmberTestAdapter {}
-      const registerHelper: typeof EmberTestNs.registerHelper;
-      const unregisterHelper: typeof EmberTestNs.unregisterHelper;
-      const registerWaiter: typeof EmberTestNs.registerWaiter;
-      const unregisterWaiter: typeof EmberTestNs.unregisterWaiter;
-      const registerAsyncHelper: typeof EmberTestNs.registerAsyncHelper;
-      /**
-       * Used to register callbacks to be fired whenever `App.injectTestHelpers`
-       * is called.
-       */
-      function onInjectHelpers(callback: (app: Application) => void): void;
-      /**
-       * This returns a thenable tailored for testing.  It catches failed
-       * `onSuccess` callbacks and invokes the `Ember.Test.adapter.exception`
-       * callback in the last chained then.
-       */
-      function promise<T>(
-        resolver: (
-          resolve: (value?: T | PromiseLike<T>) => void,
-          reject: (reason?: unknown) => void
-        ) => void,
-        label?: string
-      ): Promise<T>;
-      /**
-       * Replacement for `Ember.RSVP.resolve`
-       * The only difference is this uses
-       * an instance of `Ember.Test.Promise`
-       */
-      function resolve<T>(value?: T | PromiseLike<T>, label?: string): Promise<T>;
-
-      /**
-       * Iterates through each registered test waiter, and invokes
-       * its callback. If any waiter returns false, this method will return
-       * true indicating that the waiters have not settled yet.
-       */
-      function checkWaiters(): boolean;
-      /**
-       * Used to allow ember-testing to communicate with a specific testing
-       * framework.
-       */
-      const adapter: EmberTestAdapter;
-
-      /**
-       * This class implements the methods defined by Ember.Test.Adapter for the
-       * QUnit testing framework.
-       */
-      class QUnitAdapter extends EmberTestAdapter {}
-      class Promise<T> extends Rsvp.Promise<T> {
-        constructor(
-          executor: (
-            resolve: (value?: T | PromiseLike<T>) => void,
-            reject: (reason?: unknown) => void
-          ) => void
-        );
-      }
-    }
-    /**
-     * Namespace for injection helper methods.
-     */
-    namespace inject {
-      /**
-       * Creates a property that lazily looks up another controller in the container.
-       * Can only be used when defining another controller.
-       */
-      function controller(): Controller;
-      function controller<K extends keyof ControllerRegistry>(
-        name: K
-      ): ControllerRegistry[K] & EmberObjectComputedNs.BasicComputedProperty;
-      const service: typeof EmberServiceNs.inject;
-    }
-    namespace ENV {
-      const EXTEND_PROTOTYPES:
-        | boolean
-        | {
-            Array: 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 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;
-
-    /**
-     * `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;
-    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/index.d.ts b/types/preview/index.d.ts
deleted file mode 100644
index 31a858f3f3f..00000000000
--- a/types/preview/index.d.ts
+++ /dev/null
@@ -1,121 +0,0 @@
-/**
-  *Provides **preview** type definitions for Ember.js.*
-
-  These types are maintained by hand and the types provided here are unstable
-  and subject to change without warning, though we make a best effort to keep
-  churn to a minimum while we work to stabilize Ember's types.
-
-  To use these type definitions, add these import to any TypeScript file in your
-  Ember app or addon:
-
-  ```ts
-  import 'ember-source/types';
-  import 'ember-source/types/preview';
-  ```
-
-  As Ember's types become more stable, this will automatically give you the
-  latest mix of stable and preview types, with no effort from you.
-
-  @module
- */
-
-// This works because each of these modules presents `declare module` definition
-// of the module and *only* that, so importing this file in turn makes those
-// module declarations "visible" automatically throughout a consuming project.
-// Combined with use of `typesVersions` (or, in the future, possibly `exports`)
-// in `package.json`, this allows users to import the types without knowing the
-// exact layout details.
-//
-// Somewhat annoyingly, every single module in the graph must appear here. For
-// now, while we are publishing ambient types, that means we must maintain this
-// by hand. When we start emitting types from the source, we will need to do the
-// same work, but automatically.
-
-import './ember';
-import './ember/-private/type-utils';
-
-import './@ember/application';
-import './@ember/application/-private/event-dispatcher';
-import './@ember/application/-private/registry';
-import './@ember/application/instance';
-import './@ember/application/types';
-
-import './@ember/array';
-import './@ember/array/-private/enumerable';
-import './@ember/array/-private/mutable-enumerable';
-import './@ember/array/-private/native-array';
-import './@ember/array/mutable';
-import './@ember/array/proxy';
-
-import './@ember/component';
-import './@ember/component/-private/class-names-support';
-import './@ember/component/-private/core-view';
-import './@ember/component/-private/glimmer-interfaces';
-import './@ember/component/-private/signature-utils';
-import './@ember/component/-private/view-mixin';
-import './@ember/component/helper';
-import './@ember/component/template-only';
-
-import './@ember/controller';
-
-import './@ember/debug';
-import './@ember/debug/container-debug-adapter';
-import './@ember/debug/data-adapter';
-
-import './@ember/destroyable';
-
-import './@ember/engine';
-import './@ember/engine/-private/container-proxy-mixin';
-import './@ember/engine/-private/registry-proxy-mixin';
-import './@ember/engine/-private/types/initializer';
-import './@ember/engine/instance';
-
-import './@ember/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/routing';
-import './@ember/routing/-private/router-dsl';
-import './@ember/routing/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/template';
-import './@ember/template/-private/handlebars';
-
-import './@ember/template-compilation';
-
-import './@ember/test';
-import './@ember/test/adapter';
-
-import './@ember/utils';
-import './@ember/utils/-private/types';
diff --git a/types/publish.mjs b/types/publish.mjs
index 4018823c8c2..affc2d0ab74 100755
--- a/types/publish.mjs
+++ b/types/publish.mjs
@@ -21,7 +21,9 @@
      eventually be the list of *all* modules, but this allows us to publish
      iteratively as we gain confidence in the stability of the types.
 
-  This is *not* an optimal long-term publishing strategy. We would prefer to
+  This is *not* an optimal long-term publishing strategy. (To the contrary: it
+  is an underspecified and _ad hoc_ implementation of a module resolver, and is
+  likely to fall over if you so much as breathe on it.) We would prefer to
   generate per-package roll-ups, using a Rollup plugin or some such, but we are
   currently blocked on a number of internal circular dependencies as well as the
   difficulty of avoiding multiple definitions of the same types reused across
@@ -32,321 +34,18 @@
 
 import glob from 'glob';
 import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
+import fs from 'node:fs/promises';
 import path from 'node:path';
 import * as parser from 'recast/parsers/babel-ts.js';
 import {
   isClassDeclaration,
   isStringLiteral,
   isVariableDeclaration,
-  isTSDeclareFunction,
   isTSEnumDeclaration,
 } from '@babel/types';
 import { builders as b, visit } from 'ast-types';
 import { parse, print } from 'recast';
 
-/**
-  Modules we know we are not ready to expose yet, mostly because they do not
-  have enough annotations on their internals to make the generated types clear
-  about what is public and what is private.
-
-  Notably, the modules will still be published, but they won't be visible to
-  consumers because the only way they *become* visible is by being included in
-  the set of type-only side effect imports, which excludes exactly these
-  modules.
- */
-const PREVIEW_MODULES = [
-  '@ember/-internals/bootstrap/index.d.ts',
-  '@ember/-internals/browser-environment/index.d.ts',
-  '@ember/-internals/browser-environment/lib/has-dom.d.ts',
-  '@ember/-internals/container/index.d.ts',
-  '@ember/-internals/container/lib/container.d.ts',
-  '@ember/-internals/container/lib/registry.d.ts',
-  '@ember/-internals/environment/index.d.ts',
-  '@ember/-internals/environment/lib/context.d.ts',
-  '@ember/-internals/environment/lib/env.d.ts',
-  '@ember/-internals/environment/lib/global.d.ts',
-  '@ember/-internals/error-handling/index.d.ts',
-  '@ember/-internals/glimmer/index.d.ts',
-  '@ember/-internals/glimmer/lib/component-managers/curly.d.ts',
-  '@ember/-internals/glimmer/lib/component-managers/mount.d.ts',
-  '@ember/-internals/glimmer/lib/component-managers/outlet.d.ts',
-  '@ember/-internals/glimmer/lib/component-managers/root.d.ts',
-  '@ember/-internals/glimmer/lib/component.d.ts',
-  '@ember/-internals/glimmer/lib/components/abstract-input.d.ts',
-  '@ember/-internals/glimmer/lib/components/input.d.ts',
-  '@ember/-internals/glimmer/lib/components/internal.d.ts',
-  '@ember/-internals/glimmer/lib/components/link-to.d.ts',
-  '@ember/-internals/glimmer/lib/components/textarea.d.ts',
-  '@ember/-internals/glimmer/lib/dom.d.ts',
-  '@ember/-internals/glimmer/lib/environment.d.ts',
-  '@ember/-internals/glimmer/lib/glimmer-component-docs.d.ts',
-  '@ember/-internals/glimmer/lib/glimmer-tracking-docs.d.ts',
-  '@ember/-internals/glimmer/lib/helper.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/-disallow-dynamic-resolution.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/-in-element-null-check.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/-normalize-class.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/-resolve.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/-track-array.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/action.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/array.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/component.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/concat.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/each-in.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/fn.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/get.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/hash.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/helper.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/if-unless.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/internal-helper.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/log.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/modifier.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/mut.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/page-title.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/readonly.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/unbound.d.ts',
-  '@ember/-internals/glimmer/lib/helpers/unique-id.d.ts',
-  '@ember/-internals/glimmer/lib/modifiers/action.d.ts',
-  '@ember/-internals/glimmer/lib/modifiers/internal.d.ts',
-  '@ember/-internals/glimmer/lib/modifiers/on.d.ts',
-  '@ember/-internals/glimmer/lib/renderer.d.ts',
-  '@ember/-internals/glimmer/lib/resolver.d.ts',
-  '@ember/-internals/glimmer/lib/setup-registry.d.ts',
-  '@ember/-internals/glimmer/lib/syntax/in-element.d.ts',
-  '@ember/-internals/glimmer/lib/syntax/let.d.ts',
-  '@ember/-internals/glimmer/lib/syntax/mount.d.ts',
-  '@ember/-internals/glimmer/lib/syntax/outlet.d.ts',
-  '@ember/-internals/glimmer/lib/syntax/utils.d.ts',
-  '@ember/-internals/glimmer/lib/template_registry.d.ts',
-  '@ember/-internals/glimmer/lib/template.d.ts',
-  '@ember/-internals/glimmer/lib/utils/bindings.d.ts',
-  '@ember/-internals/glimmer/lib/utils/curly-component-state-bucket.d.ts',
-  '@ember/-internals/glimmer/lib/utils/debug-render-message.d.ts',
-  '@ember/-internals/glimmer/lib/utils/iterator.d.ts',
-  '@ember/-internals/glimmer/lib/utils/managers.d.ts',
-  '@ember/-internals/glimmer/lib/utils/outlet.d.ts',
-  '@ember/-internals/glimmer/lib/utils/process-args.d.ts',
-  '@ember/-internals/glimmer/lib/utils/serialization-first-node-helpers.d.ts',
-  '@ember/-internals/glimmer/lib/utils/string.d.ts',
-  '@ember/-internals/glimmer/lib/utils/to-bool.d.ts',
-  '@ember/-internals/glimmer/lib/views/outlet.d.ts',
-  '@ember/-internals/meta/index.d.ts',
-  '@ember/-internals/meta/lib/meta.d.ts',
-  '@ember/-internals/metal/index.d.ts',
-  '@ember/-internals/metal/lib/alias.d.ts',
-  '@ember/-internals/metal/lib/array_events.d.ts',
-  '@ember/-internals/metal/lib/array.d.ts',
-  '@ember/-internals/metal/lib/cache.d.ts',
-  '@ember/-internals/metal/lib/cached.d.ts',
-  '@ember/-internals/metal/lib/chain-tags.d.ts',
-  '@ember/-internals/metal/lib/change_event.d.ts',
-  '@ember/-internals/metal/lib/computed_cache.d.ts',
-  '@ember/-internals/metal/lib/computed.d.ts',
-  '@ember/-internals/metal/lib/decorator.d.ts',
-  '@ember/-internals/metal/lib/dependent_keys.d.ts',
-  '@ember/-internals/metal/lib/deprecate_property.d.ts',
-  '@ember/-internals/metal/lib/each_proxy_events.d.ts',
-  '@ember/-internals/metal/lib/events.d.ts',
-  '@ember/-internals/metal/lib/expand_properties.d.ts',
-  '@ember/-internals/metal/lib/get_properties.d.ts',
-  '@ember/-internals/metal/lib/injected_property.d.ts',
-  '@ember/-internals/metal/lib/libraries.d.ts',
-  '@ember/-internals/metal/lib/namespace_search.d.ts',
-  '@ember/-internals/metal/lib/observer.d.ts',
-  '@ember/-internals/metal/lib/path_cache.d.ts',
-  '@ember/-internals/metal/lib/properties.d.ts',
-  '@ember/-internals/metal/lib/property_events.d.ts',
-  '@ember/-internals/metal/lib/property_get.d.ts',
-  '@ember/-internals/metal/lib/property_set.d.ts',
-  '@ember/-internals/metal/lib/set_properties.d.ts',
-  '@ember/-internals/metal/lib/tags.d.ts',
-  '@ember/-internals/metal/lib/tracked.d.ts',
-  '@ember/-internals/overrides/index.d.ts',
-  '@ember/-internals/routing/index.d.ts',
-  '@ember/-internals/runtime/index.d.ts',
-  '@ember/-internals/runtime/lib/ext/rsvp.d.ts',
-  '@ember/-internals/runtime/lib/mixins/-proxy.d.ts',
-  '@ember/-internals/runtime/lib/mixins/action_handler.d.ts',
-  '@ember/-internals/runtime/lib/mixins/comparable.d.ts',
-  '@ember/-internals/runtime/lib/mixins/container_proxy.d.ts',
-  '@ember/-internals/runtime/lib/mixins/registry_proxy.d.ts',
-  '@ember/-internals/runtime/lib/mixins/target_action_support.d.ts',
-  '@ember/-internals/utils/index.d.ts',
-  '@ember/-internals/utils/lib/cache.d.ts',
-  '@ember/-internals/utils/lib/dictionary.d.ts',
-  '@ember/-internals/utils/lib/get-debug-name.d.ts',
-  '@ember/-internals/utils/lib/guid.d.ts',
-  '@ember/-internals/utils/lib/intern.d.ts',
-  '@ember/-internals/utils/lib/invoke.d.ts',
-  '@ember/-internals/utils/lib/is_proxy.d.ts',
-  '@ember/-internals/utils/lib/lookup-descriptor.d.ts',
-  '@ember/-internals/utils/lib/mandatory-setter.d.ts',
-  '@ember/-internals/utils/lib/name.d.ts',
-  '@ember/-internals/utils/lib/spec.d.ts',
-  '@ember/-internals/utils/lib/super.d.ts',
-  '@ember/-internals/utils/lib/symbol.d.ts',
-  '@ember/-internals/utils/lib/to-string.d.ts',
-  '@ember/-internals/utility-types.d.ts',
-  '@ember/-internals/views/index.d.ts',
-  '@ember/-internals/views/lib/compat/attrs.d.ts',
-  '@ember/-internals/views/lib/compat/fallback-view-registry.d.ts',
-  '@ember/-internals/views/lib/component_lookup.d.ts',
-  '@ember/-internals/views/lib/mixins/action_support.d.ts',
-  '@ember/-internals/views/lib/mixins/child_views_support.d.ts',
-  '@ember/-internals/views/lib/mixins/class_names_support.d.ts',
-  '@ember/-internals/views/lib/mixins/view_state_support.d.ts',
-  '@ember/-internals/views/lib/mixins/view_support.d.ts',
-  '@ember/-internals/views/lib/system/action_manager.d.ts',
-  '@ember/-internals/views/lib/system/event_dispatcher.d.ts',
-  '@ember/-internals/views/lib/system/utils.d.ts',
-  '@ember/-internals/views/lib/views/core_view.d.ts',
-  '@ember/-internals/views/lib/views/states.d.ts',
-  '@ember/-internals/views/lib/views/states/default.d.ts',
-  '@ember/-internals/views/lib/views/states/destroying.d.ts',
-  '@ember/-internals/views/lib/views/states/has_element.d.ts',
-  '@ember/-internals/views/lib/views/states/in_dom.d.ts',
-  '@ember/-internals/views/lib/views/states/pre_render.d.ts',
-  '@ember/application/index.d.ts',
-  '@ember/application/instance.d.ts',
-  '@ember/application/lib/lazy_load.d.ts',
-  '@ember/application/namespace.d.ts',
-  '@ember/array/index.d.ts',
-  '@ember/array/mutable.d.ts',
-  '@ember/array/proxy.d.ts',
-  '@ember/array/-internals.d.ts',
-  '@ember/array/lib/make-array.d.ts',
-  '@ember/canary-features/index.d.ts',
-  '@ember/component/helper.d.ts',
-  '@ember/component/index.d.ts',
-  '@ember/component/template-only.d.ts',
-  '@ember/controller/index.d.ts',
-  '@ember/debug/container-debug-adapter.d.ts',
-  '@ember/debug/data-adapter.d.ts',
-  '@ember/debug/index.d.ts',
-  '@ember/debug/lib/capture-render-tree.d.ts',
-  '@ember/debug/lib/deprecate.d.ts',
-  '@ember/debug/lib/handlers.d.ts',
-  '@ember/debug/lib/inspect.d.ts',
-  '@ember/debug/lib/testing.d.ts',
-  '@ember/debug/lib/warn.d.ts',
-  '@ember/deprecated-features/index.d.ts',
-  '@ember/destroyable/index.d.ts',
-  '@ember/engine/index.d.ts',
-  '@ember/engine/instance.d.ts',
-  '@ember/engine/lib/engine-parent.d.ts',
-  '@ember/enumerable/index.d.ts',
-  '@ember/enumerable/mutable.d.ts',
-  '@ember/helper/index.d.ts',
-  '@ember/instrumentation/index.d.ts',
-  '@ember/modifier/index.d.ts',
-  '@ember/object/-internals.d.ts',
-  '@ember/object/compat.d.ts',
-  '@ember/object/computed.d.ts',
-  '@ember/object/core.d.ts',
-  '@ember/object/evented.d.ts',
-  '@ember/object/events.d.ts',
-  '@ember/object/index.d.ts',
-  '@ember/object/internals.d.ts',
-  '@ember/object/lib/computed/computed_macros.d.ts',
-  '@ember/object/lib/computed/reduce_computed_macros.d.ts',
-  '@ember/object/mixin.d.ts',
-  '@ember/object/observable.d.ts',
-  '@ember/object/observers.d.ts',
-  '@ember/object/promise-proxy-mixin.d.ts',
-  '@ember/object/proxy.d.ts',
-  '@ember/renderer/index.d.ts',
-  '@ember/routing/-internals.d.ts',
-  '@ember/routing/auto-location.d.ts',
-  '@ember/routing/hash-location.d.ts',
-  '@ember/routing/history-location.d.ts',
-  '@ember/routing/index.d.ts',
-  '@ember/routing/lib/cache.d.ts',
-  '@ember/routing/lib/controller_for.d.ts',
-  '@ember/routing/lib/dsl.d.ts',
-  '@ember/routing/lib/engines.d.ts',
-  '@ember/routing/lib/generate_controller.d.ts',
-  '@ember/routing/lib/location-utils.d.ts',
-  '@ember/routing/lib/query_params.d.ts',
-  '@ember/routing/lib/route-info.d.ts',
-  '@ember/routing/lib/router_state.d.ts',
-  '@ember/routing/lib/routing-service.d.ts',
-  '@ember/routing/lib/transition.d.ts',
-  '@ember/routing/lib/utils.d.ts',
-  '@ember/routing/location.d.ts',
-  '@ember/routing/none-location.d.ts',
-  '@ember/routing/route-info.d.ts',
-  '@ember/routing/route.d.ts',
-  '@ember/routing/router-service.d.ts',
-  '@ember/routing/router.d.ts',
-  '@ember/routing/transition.d.ts',
-  '@ember/runloop/index.d.ts',
-  '@ember/service/index.d.ts',
-  '@ember/string/index.d.ts',
-  '@ember/string/lib/string_registry.d.ts',
-  '@ember/template-compilation/index.d.ts',
-  '@ember/template-factory/index.d.ts',
-  '@ember/template/index.d.ts',
-  '@ember/test/adapter.d.ts',
-  '@ember/test/index.d.ts',
-  '@ember/utils/index.d.ts',
-  '@ember/utils/lib/compare.d.ts',
-  '@ember/utils/lib/is_blank.d.ts',
-  '@ember/utils/lib/is_empty.d.ts',
-  '@ember/utils/lib/is_none.d.ts',
-  '@ember/utils/lib/is_present.d.ts',
-  '@ember/utils/lib/is-equal.d.ts',
-  '@ember/utils/lib/type-of.d.ts',
-  '@ember/version/index.d.ts',
-  '@glimmer/tracking/index.d.ts',
-  '@glimmer/tracking/primitives/cache.d.ts',
-  'ember-template-compiler/index.d.ts',
-  'ember-template-compiler/lib/plugins/assert-against-attrs.d.ts',
-  'ember-template-compiler/lib/plugins/assert-against-named-outlets.d.ts',
-  'ember-template-compiler/lib/plugins/assert-input-helper-without-block.d.ts',
-  'ember-template-compiler/lib/plugins/assert-reserved-named-arguments.d.ts',
-  'ember-template-compiler/lib/plugins/assert-splattribute-expression.d.ts',
-  'ember-template-compiler/lib/plugins/index.d.ts',
-  'ember-template-compiler/lib/plugins/transform-action-syntax.d.ts',
-  'ember-template-compiler/lib/plugins/transform-each-in-into-each.d.ts',
-  'ember-template-compiler/lib/plugins/transform-each-track-array.d.ts',
-  'ember-template-compiler/lib/plugins/transform-in-element.d.ts',
-  'ember-template-compiler/lib/plugins/transform-quoted-bindings-into-just-bindings.d.ts',
-  'ember-template-compiler/lib/plugins/transform-resolutions.d.ts',
-  'ember-template-compiler/lib/plugins/transform-wrap-mount-and-outlet.d.ts',
-  'ember-template-compiler/lib/plugins/utils.d.ts',
-  'ember-template-compiler/lib/system/bootstrap.d.ts',
-  'ember-template-compiler/lib/system/calculate-location-display.d.ts',
-  'ember-template-compiler/lib/system/compile-options.d.ts',
-  'ember-template-compiler/lib/system/compile.d.ts',
-  'ember-template-compiler/lib/system/dasherize-component-name.d.ts',
-  'ember-template-compiler/lib/system/initializer.d.ts',
-  'ember-template-compiler/lib/system/precompile.d.ts',
-  'ember-testing/index.d.ts',
-  'ember-testing/lib/adapters/adapter.d.ts',
-  'ember-testing/lib/adapters/qunit.d.ts',
-  'ember-testing/lib/ext/application.d.ts',
-  'ember-testing/lib/ext/rsvp.d.ts',
-  'ember-testing/lib/helpers.d.ts',
-  'ember-testing/lib/helpers/and_then.d.ts',
-  'ember-testing/lib/helpers/current_path.d.ts',
-  'ember-testing/lib/helpers/current_route_name.d.ts',
-  'ember-testing/lib/helpers/current_url.d.ts',
-  'ember-testing/lib/helpers/pause_test.d.ts',
-  'ember-testing/lib/helpers/visit.d.ts',
-  'ember-testing/lib/helpers/wait.d.ts',
-  'ember-testing/lib/initializers.d.ts',
-  'ember-testing/lib/setup_for_testing.d.ts',
-  'ember-testing/lib/test.d.ts',
-  'ember-testing/lib/test/adapter.d.ts',
-  'ember-testing/lib/test/helpers.d.ts',
-  'ember-testing/lib/test/on_inject_helpers.d.ts',
-  'ember-testing/lib/test/pending_requests.d.ts',
-  'ember-testing/lib/test/promise.d.ts',
-  'ember-testing/lib/test/run.d.ts',
-  'ember-testing/lib/test/waiters.d.ts',
-  'ember/index.d.ts',
-];
-
 const MODULES_PLACEHOLDER = '~~~MODULES GO HERE~~~';
 
 const BASE_INDEX_D_TS = `\
@@ -399,53 +98,59 @@ ${MODULES_PLACEHOLDER}
 
 const TYPES_DIR = path.join('types', 'stable');
 
+// These modules need to be copied over *and* post-processed: they need to be
+// locally-importable as regular modules, but `tsc` will not move them over
+// itself, but unlike some modules which need to be left unchanged (e.g. the
+// `*-ext.d.ts` modules) these still need the module wrapper added.
+const HAND_COPIED_BUT_NEEDS_POSTPROCESSING = [
+  'ember/version.d.ts',
+  '@ember/-internals/glimmer/lib/templates/empty.d.ts',
+  '@ember/-internals/glimmer/lib/templates/input.d.ts',
+  '@ember/-internals/glimmer/lib/templates/link-to.d.ts',
+  '@ember/-internals/glimmer/lib/templates/outlet.d.ts',
+  '@ember/-internals/glimmer/lib/templates/root.d.ts',
+  '@ember/-internals/glimmer/lib/templates/textarea.d.ts',
+];
+
 async function main() {
-  fs.rmSync(TYPES_DIR, { recursive: true, force: true });
-  fs.mkdirSync(TYPES_DIR, { recursive: true });
+  await fs.rm(TYPES_DIR, { recursive: true, force: true });
+  await fs.mkdir(TYPES_DIR, { recursive: true });
+
+  doOrDie(() => spawnSync('yarn', ['tsc', '--project', 'tsconfig/publish-types.json']));
+
+  let remappedLocationExcludes = await doOrDie(copyHandwrittenDefinitions);
+  let sideEffectExcludes = await doOrDie(copyRemappedLocationModules);
 
-  spawnSync('yarn', ['tsc', '--project', 'tsconfig/publish-types.json']);
+  // The majority of those items should be excluded entirely, but in some cases
+  // we still need to post-process them.
+  let excludes = remappedLocationExcludes
+    .concat(sideEffectExcludes)
+    .filter((excluded) => !HAND_COPIED_BUT_NEEDS_POSTPROCESSING.includes(excluded));
 
   // This is rooted in the `TYPES_DIR` so that the result is just the names of
-  // the modules, as generated directly from the tsconfig above.
-  let moduleNames = glob.sync('**/*.d.ts', {
+  // the modules, as generated directly from the tsconfig above. These must
+  // *all* appear in the final set of `/// <reference ...>`s we emit.
+  let allModules = glob.sync('**/*.d.ts', {
     ignore: 'index.d.ts', // ignore the root file itself if it somehow exists
     cwd: TYPES_DIR,
   });
 
-  let status = 'success';
-  for (let moduleName of moduleNames) {
-    let result = processModule(moduleName);
-    if (result !== 'success') {
-      status = result;
-    }
-  }
+  let missing = excludes.filter((excluded) => !allModules.includes(excluded));
+  if (missing.length) console.error('Did not capture modules:', ...missing);
 
-  let sideEffectModules = moduleNames
-    .filter((moduleName) => !PREVIEW_MODULES.includes(moduleName))
-    .map((moduleName) => {
-      // We need to import "package root" types as such, *not* via the actual
-      // module which provides them, or TS does not see them correctly via the
-      // side effect imports, so transform them accordingly:
-      //
-      //     `@ember/owner/index.d.ts` -> `@ember/owner`
-      //
-      // We also need to replace `.d.ts` entirely:
-      //
-      //     `@ember/utils/lib/compare.d.ts` -> `@ember/utils/lib/compare`
-      //
-      // Otherwise, the modules won't be resolved correctly via the side-effect
-      // imports.
-      let moduleOrPackagePath = moduleName.replace(/\/index.d.ts$/, '').replace('.d.ts', '');
-
-      // Then create a relative path *to* the path on disk so that the
-      // side-effect import is e.g. `import './@ember/owner';`, which makes it
-      // resolve the actual local file, *not* go looking for some other package.
-      return `import './${moduleOrPackagePath}';`;
-    })
+  // However, we only want to process (i.e. rewrite) a subset of the modules.
+  let modulesToProcess = allModules.filter((moduleName) => !excludes.includes(moduleName));
+  let status = await doOrDie(async () => {
+    let values = await Promise.all(modulesToProcess.map(processModule));
+    return values.some((value) => value === 'failure') ? 'failure' : 'success';
+  });
+
+  let moduleReferences = allModules
+    .map((moduleName) => `/// <reference path="./${moduleName}" />`)
     .join('\n');
 
-  let stableIndexDTsContents = BASE_INDEX_D_TS.replace(MODULES_PLACEHOLDER, sideEffectModules);
-  fs.writeFileSync(path.join(TYPES_DIR, 'index.d.ts'), stableIndexDTsContents);
+  let stableIndexDTsContents = BASE_INDEX_D_TS.replace(MODULES_PLACEHOLDER, moduleReferences);
+  await fs.writeFile(path.join(TYPES_DIR, 'index.d.ts'), stableIndexDTsContents);
 
   // Make the generated types easier to read!
   spawnSync('prettier', ['--write', 'types/stable/**/*.ts']);
@@ -453,19 +158,81 @@ async function main() {
   process.exit(status === 'success' ? 0 : 1);
 }
 
+const REMAPPED_LOCATION_MODULES = [
+  {
+    input: 'packages/loader/lib/index.d.ts',
+    output: 'require.d.ts',
+  },
+];
+
+/**
+  "Emit" hand-authored `.d.ts` modules for modules which need to live in a
+  different location in the output than in the input tree, e.g. for the loader,
+  which creates runtime modules at a different location than its source location
+  naturally corresponds to. These represent modules which need to be copied over
+  and then *left exactly as they are*.
+
+  @returns {Promise<string[]>} an array of module names to exclude from the rest of the
+    post-processing steps
+ */
+function copyRemappedLocationModules() {
+  return doOrDie(() => {
+    return Promise.all(
+      REMAPPED_LOCATION_MODULES.map(async ({ input, output }) => {
+        await fs.cp(input, path.join(TYPES_DIR, output), { recursive: true });
+        return output;
+      })
+    );
+  });
+}
+
+/**
+  "Emit" hand-authored `.d.ts` file representing runtime JS modules which are
+  generated by the build system, like the `.d.ts` files for templates. Since
+  `tsc` ignores loose `.d.ts` files in the source of a project, these must
+  simply be copied over manually.
+
+  Exclude from this list any items we also copy via `copySideEffectModules`() so
+  we do not end up with duplicates (while that *should* still work given our
+  current design for publishing, it is a "happens to" rather than "is naturally
+  correct", so we want to avoid that).
+
+  @returns {Promise<Array<string>>} The modules copied over by hand.
+*/
+async function copyHandwrittenDefinitions() {
+  let inputDir = 'packages';
+  let definitionModules = glob
+    .sync('**/*.d.ts', {
+      cwd: inputDir,
+    })
+    .filter((moduleName) => !REMAPPED_LOCATION_MODULES.some(({ input }) => input === moduleName));
+
+  await doOrDie(() =>
+    Promise.all(
+      definitionModules.map((moduleName) => {
+        let input = path.join(inputDir, moduleName);
+        let output = path.join(TYPES_DIR, moduleName);
+        return fs.cp(input, output, { recursive: true });
+      })
+    )
+  );
+
+  return definitionModules;
+}
+
 /**
   Load the module, rewrite it, and write it back to disk.
 
   @param {string} moduleName
-  @return {'success' | 'failure'}
+  @return {Promise<'success' | 'failure'>}
  */
-function processModule(moduleName) {
+async function processModule(moduleName) {
   let modulePath = path.join(TYPES_DIR, moduleName);
 
   /** @type {string} */
   let contents;
   try {
-    contents = fs.readFileSync(modulePath, { encoding: 'utf-8' });
+    contents = await fs.readFile(modulePath, { encoding: 'utf-8' });
   } catch (e) {
     console.error(`Error reading ${modulePath}: ${e}`);
     return 'failure';
@@ -482,7 +249,7 @@ function processModule(moduleName) {
   }
 
   try {
-    fs.writeFileSync(modulePath, rewrittenModule);
+    await fs.writeFile(modulePath, rewrittenModule);
   } catch (e) {
     console.error(`Error writing ${modulePath}: ${e}`);
     return 'failure';
@@ -517,8 +284,18 @@ export function rewriteModule(code, moduleName) {
     // things which rely on declaration merging can work, but they need to be
     // emitted *outside* the `declare module` we are introducing.
     visitTSModuleDeclaration(path) {
-      otherModuleDeclarations.push(path.node);
-      path.prune(path.node);
+      // ...but we need to *avoid* doing this for namespace declarations! So we
+      // *only* do it for cases where we are sure, since `declare module` will
+      // always have a string literal, while `declare namespace` will have an
+      // actual identifier instead.
+      if (path.node.id.type == 'StringLiteral') {
+        otherModuleDeclarations.push(path.node);
+        path.prune(path.node);
+      } else {
+        // Where we have a `declare namespace` type, we need to emit it without
+        // the `declare`, as with other items.
+        path.node.declare = false;
+      }
       this.traverse(path);
     },
 
@@ -572,7 +349,7 @@ export function rewriteModule(code, moduleName) {
         // This makes it so that the types we publish point to the types defined
         // by `backburner.js`, basically doing the type-time equivalent of the
         // no good, very bad runtime shenanigans Ember does... *somewhere*... in
-        // the build to make `import Backburner from 'backburner'` work.
+        // the build to make `import Backburner from 'backburner.js'` work.
         if (source.value === 'backburner') {
           source.value = 'backburner.js';
         }
@@ -680,10 +457,7 @@ function normalizeSpecifier(moduleName, specifier) {
     // chunks comprising host module, because we need to *not* treat the current
     // module itself as a parent. If we're not in a "root" module, we need to
     // do it an extra time to get rid of the terminal `foo.d.ts` as well.
-    let terminal = parentPathChunks.pop();
-    if (terminal?.endsWith('.d.ts')) {
-      parentPathChunks.pop();
-    }
+    parentPathChunks.pop();
 
     // Walk back from the end of the specifier, replacing `..` with chunks from
     // the parent paths.
@@ -697,7 +471,12 @@ function normalizeSpecifier(moduleName, specifier) {
             `Could not generate a valid path for relative path specifier ${specifier} in ${moduleName}`
           );
         }
-        merged.push(parent);
+
+        // If we get to `@ember`, we know we're at the root and we *need* to
+        // retain it. Otherwise, we're not there yet and should keep moving up.
+        if (parent === '@ember') {
+          merged.push(parent);
+        }
       } else {
         merged.push(chunk);
       }
@@ -714,5 +493,19 @@ function normalizeSpecifier(moduleName, specifier) {
   }
 }
 
-// Run it!
+/**
+ * @template T
+ * @param {() => T} fn
+ * @returns {T}
+ */
+function doOrDie(fn) {
+  try {
+    return fn();
+  } catch (e) {
+    console.log(e);
+    process.exit(1);
+  }
+}
+
+// --- Actually execute the program! --- //
 main();