diff --git a/packages/@ember/-internals/container/lib/container.ts b/packages/@ember/-internals/container/lib/container.ts
index 1b7c596c74e..da224b31077 100644
--- a/packages/@ember/-internals/container/lib/container.ts
+++ b/packages/@ember/-internals/container/lib/container.ts
@@ -1,8 +1,8 @@
-import { Factory, LookupOptions, Owner, setOwner } from '@ember/-internals/owner';
+import { Factory, FactoryClass, Owner, setOwner } from '@ember/-internals/owner';
 import { dictionary, symbol } from '@ember/-internals/utils';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
-import Registry, { DebugRegistry } from './registry';
+import Registry, { DebugRegistry, TypeOptions } from './registry';
 
 interface LeakTracking {
   hasContainers(): boolean;
@@ -143,7 +143,7 @@ export default class Container {
    @param {String} [options.source] The fullname of the request source (used for local lookup)
    @return {any}
    */
-  lookup(fullName: string, options: LookupOptions): any {
+  lookup(fullName: string, options?: TypeOptions): unknown {
     if (this.isDestroyed) {
       throw new Error(`Cannot call \`.lookup\` after the owner has been destroyed`);
     }
@@ -206,11 +206,9 @@ export default class Container {
     @public
    @method factoryFor
    @param {String} fullName
-   @param {Object} [options]
-   @param {String} [options.source] The fullname of the request source (used for local lookup)
    @return {any}
    */
-  factoryFor<T, C>(fullName: string): Factory<T, C> | undefined {
+  factoryFor(fullName: string): Factory<unknown> | undefined {
     if (this.isDestroyed) {
       throw new Error(`Cannot call \`.factoryFor\` after the owner has been destroyed`);
     }
@@ -218,7 +216,9 @@ export default class Container {
 
     assert('fullName must be a proper full name', this.registry.isValidFullName(normalizedName));
 
-    return factoryFor<T, C>(this, normalizedName, fullName) as Factory<T, C> | undefined;
+    // TODO: This needs to return a Factory to be compatible with Owner.
+    // We should correctly the types so that this cast is not necessary.
+    return factoryFor(this, normalizedName, fullName) as Factory<unknown>;
   }
 }
 
@@ -261,7 +261,7 @@ function isInstantiatable(container: Container, fullName: string) {
   return container.registry.getOption(fullName, 'instantiate') !== false;
 }
 
-function lookup(container: Container, fullName: string, options: LookupOptions = {}) {
+function lookup(container: Container, fullName: string, options: TypeOptions = {}) {
   let normalizedName = fullName;
 
   if (
@@ -277,14 +277,18 @@ function lookup(container: Container, fullName: string, options: LookupOptions =
   return instantiateFactory(container, normalizedName, fullName, options);
 }
 
-function factoryFor<T, C>(container: Container, normalizedName: string, fullName: string) {
+function factoryFor(
+  container: Container,
+  normalizedName: string,
+  fullName: string
+): FactoryManager<unknown> | undefined {
   let cached = container.factoryManagerCache[normalizedName];
 
   if (cached !== undefined) {
     return cached;
   }
 
-  let factory = container.registry.resolve(normalizedName) as DebugFactory<T, C> | undefined;
+  let factory = container.registry.resolve(normalizedName) as DebugFactory<unknown> | undefined;
 
   if (factory === undefined) {
     return;
@@ -442,7 +446,8 @@ export interface LazyInjection {
   specifier: string;
 }
 
-declare interface DebugFactory<T, C> extends Factory<T, C> {
+declare interface DebugFactory<T, C extends FactoryClass | object = FactoryClass>
+  extends Factory<T, C> {
   _onLookup?: (fullName: string) => void;
   _initFactory?: (factoryManager: FactoryManager<T, C>) => void;
   _lazyInjections(): { [key: string]: LazyInjection };
@@ -458,7 +463,7 @@ export function setFactoryFor(obj: any, factory: FactoryManager<any, any>): void
   obj[INIT_FACTORY] = factory;
 }
 
-export class FactoryManager<T, C> {
+export class FactoryManager<T, C extends FactoryClass | object = FactoryClass> {
   readonly container: Container;
   readonly owner: Owner | null;
   readonly class: Factory<T, C> & DebugFactory<T, C>;
diff --git a/packages/@ember/-internals/container/lib/registry.ts b/packages/@ember/-internals/container/lib/registry.ts
index 5b11d49b083..d976f984756 100644
--- a/packages/@ember/-internals/container/lib/registry.ts
+++ b/packages/@ember/-internals/container/lib/registry.ts
@@ -79,12 +79,12 @@ export default class Registry implements IRegistry {
   readonly _failSet: Set<string>;
   resolver: Resolver | (Resolve & NotResolver) | null;
   readonly fallback: IRegistry | null;
-  readonly registrations: { [key: string]: object };
-  _localLookupCache: { [key: string]: object };
-  readonly _normalizeCache: { [key: string]: string };
-  readonly _options: { [key: string]: TypeOptions };
-  readonly _resolveCache: { [key: string]: object };
-  readonly _typeOptions: { [key: string]: TypeOptions };
+  readonly registrations: Record<string, object>;
+  _localLookupCache: Record<string, object>;
+  readonly _normalizeCache: Record<string, string>;
+  readonly _options: Record<string, TypeOptions>;
+  readonly _resolveCache: Record<string, object>;
+  readonly _typeOptions: Record<string, TypeOptions>;
 
   constructor(options: RegistryOptions = {}) {
     this.fallback = options.fallback || null;
@@ -182,7 +182,7 @@ export default class Registry implements IRegistry {
    @param {Function} factory
    @param {Object} options
    */
-  register<T, C>(fullName: string, factory: Factory<T, C>, options: object = {}): void {
+  register(fullName: string, factory: Factory<unknown>, options: TypeOptions = {}): void {
     assert('fullName must be a proper full name', this.isValidFullName(fullName));
     assert(`Attempting to register an unknown factory: '${fullName}'`, factory !== undefined);
 
diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts b/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
index 3f164ef7506..2cc64543431 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
@@ -133,7 +133,7 @@ export default class CurlyComponentManager
 
     if (layout === undefined) {
       if (layoutName !== undefined) {
-        let _factory = owner.lookup<TemplateFactory>(`template:${layoutName}`);
+        let _factory = owner.lookup(`template:${layoutName}`) as TemplateFactory;
         assert(`Layout \`${layoutName}\` not found!`, _factory !== undefined);
         factory = _factory;
       } else {
diff --git a/packages/@ember/-internals/glimmer/lib/component.ts b/packages/@ember/-internals/glimmer/lib/component.ts
index 9901ba079b2..d838f613beb 100644
--- a/packages/@ember/-internals/glimmer/lib/component.ts
+++ b/packages/@ember/-internals/glimmer/lib/component.ts
@@ -710,8 +710,8 @@ const Component = CoreView.extend(
         let owner = getOwner(this);
         assert('Component is unexpectedly missing an owner', owner);
 
-        if (owner.lookup<Environment>('-environment:main')!.isInteractive) {
-          this.__dispatcher = owner.lookup<EventDispatcher>('event_dispatcher:main');
+        if ((owner.lookup('-environment:main') as Environment)!.isInteractive) {
+          this.__dispatcher = owner.lookup('event_dispatcher:main') as EventDispatcher;
         } else {
           // In FastBoot we have no EventDispatcher. Set to null to not try again to look it up.
           this.__dispatcher = null;
diff --git a/packages/@ember/-internals/glimmer/lib/components/link-to.ts b/packages/@ember/-internals/glimmer/lib/components/link-to.ts
index 17aa8eeb239..0320e62a57c 100644
--- a/packages/@ember/-internals/glimmer/lib/components/link-to.ts
+++ b/packages/@ember/-internals/glimmer/lib/components/link-to.ts
@@ -2,7 +2,8 @@ import { Owner } from '@ember/-internals/owner';
 import { Route, RouterState, RoutingService } from '@ember/-internals/routing';
 import { isSimpleClick } from '@ember/-internals/views';
 import { assert, debugFreeze, inspect, warn } from '@ember/debug';
-import { EngineInstance, getEngineParent } from '@ember/engine';
+import { getEngineParent } from '@ember/engine';
+import EngineInstance from '@ember/engine/instance';
 import { flaggedInstrument } from '@ember/instrumentation';
 import { action } from '@ember/object';
 import { service } from '@ember/service';
diff --git a/packages/@ember/-internals/glimmer/lib/modifiers/action.ts b/packages/@ember/-internals/glimmer/lib/modifiers/action.ts
index ec23c0ceff6..aabb2b59c9c 100644
--- a/packages/@ember/-internals/glimmer/lib/modifiers/action.ts
+++ b/packages/@ember/-internals/glimmer/lib/modifiers/action.ts
@@ -265,7 +265,7 @@ class ActionModifierManager implements InternalModifierManager<ActionState, obje
   }
 
   ensureEventSetup(actionState: ActionState): void {
-    let dispatcher = actionState.owner.lookup<EventDispatcher>('event_dispatcher:main');
+    let dispatcher = actionState.owner.lookup('event_dispatcher:main') as EventDispatcher;
     dispatcher?.setupHandlerForEmberEvent(actionState.eventName);
   }
 
diff --git a/packages/@ember/-internals/glimmer/lib/resolver.ts b/packages/@ember/-internals/glimmer/lib/resolver.ts
index 96071ae14c5..ffd80103b21 100644
--- a/packages/@ember/-internals/glimmer/lib/resolver.ts
+++ b/packages/@ember/-internals/glimmer/lib/resolver.ts
@@ -1,6 +1,7 @@
 import { privatize as P } from '@ember/-internals/container';
+import { TypeOptions } from '@ember/-internals/container/lib/registry';
 import { ENV } from '@ember/-internals/environment';
-import { Factory, FactoryClass, LookupOptions, Owner } from '@ember/-internals/owner';
+import { Factory, Owner } from '@ember/-internals/owner';
 import { assert } from '@ember/debug';
 import { _instrumentStart } from '@ember/instrumentation';
 import { DEBUG } from '@glimmer/env';
@@ -56,28 +57,24 @@ function instrumentationPayload(name: string) {
   return { object: `component:${name}` };
 }
 
-function componentFor(
-  name: string,
-  owner: Owner,
-  options?: LookupOptions
-): Option<Factory<{}, {}>> {
+function componentFor(name: string, owner: Owner): Option<Factory<unknown>> {
   let fullName = `component:${name}`;
-  return owner.factoryFor(fullName, options) || null;
+  return owner.factoryFor(fullName) || null;
 }
 
-function layoutFor(name: string, owner: Owner, options?: LookupOptions): Option<Template> {
+function layoutFor(name: string, owner: Owner, options?: TypeOptions): Option<Template> {
   let templateFullName = `template:components/${name}`;
 
-  return owner.lookup(templateFullName, options) || null;
+  return (owner.lookup(templateFullName, options) as Template) || null;
 }
 
 type LookupResult =
   | {
-      component: Factory<{}, {}>;
+      component: Factory<unknown>;
       layout: TemplateFactory;
     }
   | {
-      component: Factory<{}, {}>;
+      component: Factory<unknown>;
       layout: null;
     }
   | {
@@ -88,9 +85,9 @@ type LookupResult =
 function lookupComponentPair(
   owner: Owner,
   name: string,
-  options?: LookupOptions
+  options?: TypeOptions
 ): Option<LookupResult> {
-  let component = componentFor(name, owner, options);
+  let component = componentFor(name, owner);
 
   if (component !== null && component.class !== undefined) {
     let layout = getComponentTemplate(component.class);
@@ -176,10 +173,9 @@ export default class ResolverImpl implements RuntimeResolver<Owner>, CompileTime
       return helper;
     }
 
-    const factory = owner.factoryFor<
-      SimpleHelper | HelperInstance,
-      HelperFactory<SimpleHelper | HelperInstance>
-    >(`helper:${name}`);
+    const factory = owner.factoryFor(`helper:${name}`) as
+      | Factory<SimpleHelper, HelperFactory<SimpleHelper>>
+      | Factory<HelperInstance, HelperFactory<HelperInstance>>;
 
     if (factory === undefined) {
       return null;
@@ -224,7 +220,7 @@ export default class ResolverImpl implements RuntimeResolver<Owner>, CompileTime
       return builtin;
     }
 
-    let modifier = owner.factoryFor<unknown, FactoryClass>(`modifier:${name}`);
+    let modifier = owner.factoryFor(`modifier:${name}`);
 
     if (modifier === undefined) {
       return null;
diff --git a/packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts b/packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts
index e8298831fb8..05cde32219d 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts
+++ b/packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts
@@ -198,7 +198,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             Resolver = ModuleBasedTestResolver;
 
             init() {
-              super.init(...arguments);
+              super.init();
               this.register(
                 'template:application',
                 compileTemplate(
@@ -234,7 +234,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             Resolver = ModuleBasedTestResolver;
 
             init() {
-              super.init(...arguments);
+              super.init();
               this.register(
                 'template:application',
                 compileTemplate(
@@ -579,7 +579,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             Resolver = ModuleBasedTestResolver;
 
             init() {
-              super.init(...arguments);
+              super.init();
               this.register(
                 'template:application',
                 compileTemplate(
@@ -670,7 +670,7 @@ if (ENV._DEBUG_RENDER_TREE) {
         ]);
 
         runTask(() => {
-          let controller = instance!.lookup<Controller>('controller:application')!;
+          let controller = (instance!.lookup('controller:application') as Controller)!;
           controller.set('message', 'World');
         });
 
@@ -716,7 +716,7 @@ if (ENV._DEBUG_RENDER_TREE) {
         ]);
 
         runTask(() => {
-          let controller = instance!.lookup<Controller>('controller:application')!;
+          let controller = (instance!.lookup('controller:application') as Controller)!;
           controller.set('message', undefined);
         });
 
diff --git a/packages/@ember/-internals/owner/index.ts b/packages/@ember/-internals/owner/index.ts
index 88a5d334243..b355f45ea5d 100644
--- a/packages/@ember/-internals/owner/index.ts
+++ b/packages/@ember/-internals/owner/index.ts
@@ -4,11 +4,6 @@ import { getOwner as glimmerGetOwner, setOwner as glimmerSetOwner } from '@glimm
 @module @ember/application
 */
 
-export interface LookupOptions {
-  singleton?: boolean;
-  instantiate?: boolean;
-}
-
 export interface FactoryClass {
   positionalParams?: string | string[] | undefined | null;
 }
@@ -27,11 +22,12 @@ export interface EngineInstanceOptions {
 }
 
 import EngineInstance from '@ember/engine/instance';
+import { TypeOptions } from '../container/lib/registry';
 export interface Owner {
-  lookup<T>(fullName: string, options?: LookupOptions): T | undefined;
-  factoryFor<T, C>(fullName: string, options?: LookupOptions): Factory<T, C> | undefined;
-  register<T, C>(fullName: string, factory: Factory<T, C>, options?: LookupOptions): void;
-  hasRegistration(name: string, options?: LookupOptions): boolean;
+  lookup(fullName: string, options?: TypeOptions): unknown;
+  factoryFor(fullName: string): Factory<unknown> | undefined;
+  register(fullName: string, factory: Factory<unknown>, options?: TypeOptions): void;
+  hasRegistration(name: string): boolean;
 
   /** @internal */
   mountPoint?: string;
diff --git a/packages/@ember/-internals/routing/lib/location/auto_location.ts b/packages/@ember/-internals/routing/lib/location/auto_location.ts
index 3ad97c299f7..20306c4a3bd 100644
--- a/packages/@ember/-internals/routing/lib/location/auto_location.ts
+++ b/packages/@ember/-internals/routing/lib/location/auto_location.ts
@@ -182,7 +182,7 @@ export default class AutoLocation extends EmberObject implements EmberLocation {
 
     let owner = getOwner(this);
     assert('AutoLocation is unexpectedly missing an owner', owner);
-    let concrete = owner.lookup<EmberLocation>(`location:${implementation}`);
+    let concrete = owner.lookup(`location:${implementation}`) as EmberLocation;
     assert(`Could not find location '${implementation}'.`, concrete !== undefined);
 
     set(concrete, 'rootURL', rootURL);
diff --git a/packages/@ember/-internals/routing/lib/system/controller_for.ts b/packages/@ember/-internals/routing/lib/system/controller_for.ts
index 678812ff578..3a04cea3303 100644
--- a/packages/@ember/-internals/routing/lib/system/controller_for.ts
+++ b/packages/@ember/-internals/routing/lib/system/controller_for.ts
@@ -1,5 +1,5 @@
 import { Container } from '@ember/-internals/container';
-import { LookupOptions } from '@ember/-internals/owner';
+import { TypeOptions } from '@ember/-internals/container/lib/registry';
 /**
 @module ember
 */
@@ -14,7 +14,7 @@ import { LookupOptions } from '@ember/-internals/owner';
 export default function controllerFor(
   container: Container,
   controllerName: string,
-  lookupOptions: LookupOptions
+  lookupOptions: TypeOptions
 ) {
   return container.lookup(`controller:${controllerName}`, lookupOptions);
 }
diff --git a/packages/@ember/-internals/routing/lib/system/generate_controller.ts b/packages/@ember/-internals/routing/lib/system/generate_controller.ts
index 4737766ae7d..1b65a61e5f5 100644
--- a/packages/@ember/-internals/routing/lib/system/generate_controller.ts
+++ b/packages/@ember/-internals/routing/lib/system/generate_controller.ts
@@ -16,7 +16,7 @@ import { DEBUG } from '@glimmer/env';
 */
 
 export function generateControllerFactory(owner: Owner, controllerName: string): Factory<{}> {
-  let Factory = owner.factoryFor<any, any>('controller:basic')!.class;
+  let Factory = (owner.factoryFor('controller:basic') as Factory<any, any>).class;
 
   Factory = Factory.extend({
     toString() {
@@ -44,7 +44,7 @@ export default function generateController(owner: Owner, controllerName: string)
   generateControllerFactory(owner, controllerName);
 
   let fullName = `controller:${controllerName}`;
-  let instance = owner.lookup<Controller>(fullName)!;
+  let instance = (owner.lookup(fullName) as Controller)!;
 
   if (DEBUG) {
     if (get(instance, 'namespace.LOG_ACTIVE_GENERATION')) {
diff --git a/packages/@ember/-internals/routing/lib/system/route.ts b/packages/@ember/-internals/routing/lib/system/route.ts
index 66387720f9c..6cc78f42568 100644
--- a/packages/@ember/-internals/routing/lib/system/route.ts
+++ b/packages/@ember/-internals/routing/lib/system/route.ts
@@ -278,8 +278,8 @@ class Route<T = unknown>
     super(owner);
 
     if (owner) {
-      let router = owner.lookup<EmberRouter>('router:main');
-      let bucketCache = owner.lookup<BucketCache>(P`-bucket-cache:main`);
+      let router = owner.lookup('router:main') as EmberRouter;
+      let bucketCache = owner.lookup(P`-bucket-cache:main`) as BucketCache;
 
       assert(
         'ROUTER BUG: Expected route injections to be defined on the route. This is an internal bug, please open an issue on Github if you see this message!',
@@ -658,7 +658,7 @@ class Route<T = unknown>
   paramsFor(name: string): Record<string, unknown> {
     let owner = getOwner(this);
     assert('Route is unexpectedly missing an owner', owner);
-    let route = owner.lookup<Route>(`route:${name}`);
+    let route = owner.lookup(`route:${name}`) as Route;
 
     if (route === undefined) {
       return {};
@@ -1587,13 +1587,13 @@ class Route<T = unknown>
   controllerFor(name: string, _skipAssert = false): Controller | undefined {
     let owner = getOwner(this);
     assert('Route is unexpectedly missing an owner', owner);
-    let route = owner.lookup<Route>(`route:${name}`);
+    let route = owner.lookup(`route:${name}`) as Route;
 
     if (route && route.controllerName) {
       name = route.controllerName;
     }
 
-    let controller = owner.lookup<Controller>(`controller:${name}`);
+    let controller = owner.lookup(`controller:${name}`) as Controller;
 
     // NOTE: We're specifically checking that skipAssert is true, because according
     //   to the old API the second parameter was model. We do not want people who
@@ -1693,7 +1693,7 @@ class Route<T = unknown>
       name = _name;
     }
 
-    let route = owner.lookup<Route>(`route:${name}`);
+    let route = owner.lookup(`route:${name}`) as Route;
     // If we are mid-transition, we want to try and look up
     // resolved parent contexts on the current transitionEvent.
     if (transition !== undefined && transition !== null) {
@@ -1874,7 +1874,7 @@ class Route<T = unknown>
     let controllerName = this.controllerName || this.routeName;
     let owner = getOwner(this);
     assert('Route is unexpectedly missing an owner', owner);
-    let controller = owner.lookup<Controller>(`controller:${controllerName}`);
+    let controller = owner.lookup(`controller:${controllerName}`) as Controller;
     let queryParameterConfiguraton = get(this, 'queryParams');
     let hasRouterDefinedQueryParams = Object.keys(queryParameterConfiguraton).length > 0;
 
@@ -2127,16 +2127,18 @@ function buildRenderOptions(
 
   if (controller === undefined) {
     if (isDefaultRender) {
-      controller = route.controllerName || owner.lookup<Controller>(`controller:${name}`);
+      controller = route.controllerName || (owner.lookup(`controller:${name}`) as Controller);
     } else {
       controller =
-        owner.lookup<Controller>(`controller:${name}`) || route.controllerName || route.routeName;
+        (owner.lookup(`controller:${name}`) as Controller) ||
+        route.controllerName ||
+        route.routeName;
     }
   }
 
   if (typeof controller === 'string') {
     let controllerName = controller;
-    controller = owner.lookup<Controller>(`controller:${controllerName}`);
+    controller = owner.lookup(`controller:${controllerName}`) as Controller;
     assert(
       `You passed \`controller: '${controllerName}'\` into the \`render\` method, but no such controller could be found.`,
       isDefaultRender || controller !== undefined
@@ -2149,7 +2151,7 @@ function buildRenderOptions(
     (controller! as any).set('model', model);
   }
 
-  let template = owner.lookup<TemplateFactory>(`template:${templateName}`);
+  let template = owner.lookup(`template:${templateName}`) as TemplateFactory;
   assert(
     `Could not find "${templateName}" template, view, or component.`,
     isDefaultRender || template !== undefined
diff --git a/packages/@ember/-internals/routing/lib/system/router.ts b/packages/@ember/-internals/routing/lib/system/router.ts
index 2155f10b986..bf2907212d7 100644
--- a/packages/@ember/-internals/routing/lib/system/router.ts
+++ b/packages/@ember/-internals/routing/lib/system/router.ts
@@ -1,7 +1,7 @@
 import { privatize as P } from '@ember/-internals/container';
 import { OutletState as GlimmerOutletState, OutletView } from '@ember/-internals/glimmer';
 import { computed, get, set } from '@ember/-internals/metal';
-import { FactoryClass, getOwner, Owner } from '@ember/-internals/owner';
+import { Factory, FactoryClass, getOwner, Owner } from '@ember/-internals/owner';
 import { BucketCache } from '@ember/-internals/routing';
 import RouterService from '@ember/-internals/routing/lib/services/router';
 import { A as emberA, Evented, Object as EmberObject, typeOf } from '@ember/-internals/runtime';
@@ -312,11 +312,11 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     this._resetQueuedQueryParameterChanges();
     this.namespace = owner.lookup('application:main');
 
-    let bucketCache: BucketCache | undefined = owner.lookup(P`-bucket-cache:main`);
+    let bucketCache = owner.lookup(P`-bucket-cache:main`) as BucketCache | undefined;
     assert('BUG: BucketCache should always be present', bucketCache !== undefined);
     this._bucketCache = bucketCache;
 
-    let routerService: RouterService<R> | undefined = owner.lookup('service:router');
+    let routerService = owner.lookup('service:router') as RouterService<R> | undefined;
     assert('BUG: RouterService should always be present', routerService !== undefined);
     this._routerService = routerService;
   }
@@ -345,7 +345,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
 
         assert('Route is unexpectedly missing an owner', routeOwner);
 
-        let route = routeOwner.lookup<R>(fullRouteName);
+        let route = routeOwner.lookup(fullRouteName) as R;
 
         if (seen[name]) {
           assert('seen routes should exist', route);
@@ -357,7 +357,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
         if (!route) {
           let DefaultRoute: any = routeOwner.factoryFor('route:basic')!.class;
           routeOwner.register(fullRouteName, DefaultRoute.extend());
-          route = routeOwner.lookup(fullRouteName);
+          route = routeOwner.lookup(fullRouteName) as R;
 
           if (DEBUG) {
             if (router.namespace.LOG_ACTIVE_GENERATION) {
@@ -642,7 +642,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     if (!this._toplevelView) {
       let owner = getOwner(this);
       assert('Router is unexpectedly missing an owner', owner);
-      let OutletView = owner.factoryFor<OutletView, FactoryClass>('view:-outlet')!;
+      let OutletView = owner.factoryFor('view:-outlet') as Factory<OutletView, FactoryClass>;
       let application = owner.lookup('application:main');
       let environment = owner.lookup('-environment:main');
       let template = owner.lookup('template:-outlet');
@@ -866,7 +866,7 @@ class EmberRouter<R extends Route = Route> extends EmberObject.extend(Evented) i
     assert('Router is unexpectedly missing an owner', owner);
 
     if ('string' === typeof location) {
-      let resolvedLocation = owner.lookup<IEmberLocation>(`location:${location}`);
+      let resolvedLocation = owner.lookup(`location:${location}`) as IEmberLocation;
 
       if (location === 'auto') {
         deprecate(
@@ -1788,7 +1788,7 @@ function updatePaths(router: EmberRouter) {
 
   let owner = getOwner(router);
   assert('Router is unexpectedly missing an owner', owner);
-  let appController = owner.lookup<Controller>('controller:application');
+  let appController = owner.lookup('controller:application') as Controller;
 
   if (!appController) {
     // appController might not exist when top-level loading/error
diff --git a/packages/@ember/-internals/runtime/lib/mixins/container_proxy.d.ts b/packages/@ember/-internals/runtime/lib/mixins/container_proxy.d.ts
new file mode 100644
index 00000000000..31d9dbee6b1
--- /dev/null
+++ b/packages/@ember/-internals/runtime/lib/mixins/container_proxy.d.ts
@@ -0,0 +1,11 @@
+import { Container } from '@ember/-internals/container';
+import Mixin from '../../types/mixin';
+
+interface ContainerProxy {
+  ownerInjection: Container['ownerInjection'];
+  lookup: Container['lookup'];
+  factoryFor: Container['factoryFor'];
+}
+declare const ContainerProxy: Mixin;
+
+export default ContainerProxy;
diff --git a/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.d.ts b/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.d.ts
new file mode 100644
index 00000000000..b18c207573b
--- /dev/null
+++ b/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.d.ts
@@ -0,0 +1,17 @@
+import { Registry } from '@ember/-internals/container';
+import Mixin from '../../types/mixin';
+
+interface RegistryProxyMixin {
+  resolveRegistration: Registry['resolve'];
+  register: Registry['register'];
+  unregister: Registry['unregister'];
+  hasRegistration: Registry['has'];
+  registeredOption: Registry['getOption'];
+  registerOptions: Registry['options'];
+  registeredOptions: Registry['getOptions'];
+  registerOptionsForType: Registry['optionsForType'];
+  registeredOptionsForType: Registry['getOptionsForType'];
+}
+declare const RegistryProxyMixin: Mixin;
+
+export default RegistryProxyMixin;
diff --git a/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.js b/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.js
index da3e416ef17..5f7a011dca9 100644
--- a/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.js
+++ b/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.js
@@ -23,9 +23,9 @@ export default Mixin.create({
    @param {String} fullName
    @return {Function} fullName's factory
    */
-  resolveRegistration(fullName, options) {
+  resolveRegistration(fullName) {
     assert('fullName must be a proper full name', this.__registry__.isValidFullName(fullName));
-    return this.__registry__.resolve(fullName, options);
+    return this.__registry__.resolve(fullName);
   },
 
   /**
diff --git a/packages/@ember/-internals/views/lib/system/utils.ts b/packages/@ember/-internals/views/lib/system/utils.ts
index 95eceb7d390..975af3d1f81 100644
--- a/packages/@ember/-internals/views/lib/system/utils.ts
+++ b/packages/@ember/-internals/views/lib/system/utils.ts
@@ -44,7 +44,7 @@ interface View {
   @param {Object} owner
 */
 export function getRootViews(owner: Owner): View[] {
-  let registry = owner.lookup<Dict<View>>('-view-registry:main')!;
+  let registry = owner.lookup('-view-registry:main') as Dict<View>;
 
   let rootViews: View[] = [];
 
@@ -120,7 +120,7 @@ const CHILD_VIEW_IDS: WeakMap<View, Set<string>> = new WeakMap();
 export function getChildViews(view: View): View[] {
   let owner = getOwner(view);
   assert('View is unexpectedly missing an owner', owner);
-  let registry = owner.lookup<Dict<View>>('-view-registry:main')!;
+  let registry = owner.lookup('-view-registry:main') as Dict<View>;
   return collectChildViews(view, registry);
 }
 
diff --git a/packages/@ember/application/instance.d.ts b/packages/@ember/application/instance.d.ts
index a04c11955d2..d5bb40458c3 100644
--- a/packages/@ember/application/instance.d.ts
+++ b/packages/@ember/application/instance.d.ts
@@ -1,4 +1,4 @@
-import { EngineInstance } from '@ember/engine';
+import EngineInstance from '@ember/engine/instance';
 
 export class BootOptions {
   isBrowser: boolean;
@@ -19,8 +19,4 @@ export class BootOptions {
   toEnvironment(): Record<string, unknown>;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-interface ApplicationInstance extends EngineInstance {}
-declare class ApplicationInstance {}
-
-export default ApplicationInstance;
+export default class ApplicationInstance extends EngineInstance {}
diff --git a/packages/@ember/application/type-tests/index.test.ts b/packages/@ember/application/type-tests/index.test.ts
index c4a7c8cd114..1416a3be6f6 100644
--- a/packages/@ember/application/type-tests/index.test.ts
+++ b/packages/@ember/application/type-tests/index.test.ts
@@ -5,6 +5,8 @@ import { Owner } from '@ember/-internals/owner';
 
 import { expectTypeOf } from 'expect-type';
 
+let owner = {} as Owner;
+
 class App extends Application {
   rootElement = '#ember-application';
   customEvents = {
@@ -16,7 +18,7 @@ class App extends Application {
   }
 }
 
-const app = new App();
+const app = new App(owner);
 
 // You shouldn't really be setting this, so let's at least check that we can read it
 expectTypeOf(app.eventDispatcher).toEqualTypeOf<EventDispatcher>();
@@ -34,7 +36,7 @@ class App2 extends Application {
   rootElement = 1;
 }
 
-new App2();
+new App2(owner);
 
 expectTypeOf(getOwner('foo')).toEqualTypeOf<Owner | undefined>();
 
diff --git a/packages/@ember/application/type-tests/instance.test.ts b/packages/@ember/application/type-tests/instance.test.ts
index 1ac6e63baf4..12eb726167c 100644
--- a/packages/@ember/application/type-tests/instance.test.ts
+++ b/packages/@ember/application/type-tests/instance.test.ts
@@ -1,11 +1,15 @@
+import { Owner } from '@ember/-internals/owner';
 import Application from '@ember/application';
 import ApplicationInstance, { BootOptions } from '@ember/application/instance';
-import { EngineInstance } from '@ember/engine';
+import EngineInstance from '@ember/engine/instance';
 import EmberObject from '@ember/object';
 
 import { expectTypeOf } from 'expect-type';
 
-const app = new Application();
+// Good enough for tests
+let owner = {} as Owner;
+
+const app = new Application(owner);
 const instance = app.buildInstance();
 
 expectTypeOf(instance).toEqualTypeOf<ApplicationInstance>();
@@ -19,15 +23,14 @@ expectTypeOf(
   instance.register('service:store-singleton', Store, { singleton: true, instantiate: true })
 ).toEqualTypeOf<void>();
 
-expectTypeOf(instance.lookup<Store>('service:store')).toEqualTypeOf<Store | undefined>();
+expectTypeOf(instance.lookup('service:store')).toEqualTypeOf<unknown>();
 expectTypeOf(
-  instance.lookup<Store>('service:store', { singleton: true, instantiate: true })
-).toEqualTypeOf<Store | undefined>();
+  instance.lookup('service:store', { singleton: true, instantiate: true })
+).toEqualTypeOf<unknown>();
 
 expectTypeOf(instance.hasRegistration('service:store')).toEqualTypeOf<boolean>();
-expectTypeOf(
-  instance.hasRegistration('service:store', { singleton: true, instantiate: true })
-).toEqualTypeOf<boolean>();
+// @ts-expect-error requires name
+instance.hasRegistration();
 
 expectTypeOf(instance.boot()).toEqualTypeOf<void>();
 
diff --git a/packages/@ember/debug/lib/capture-render-tree.ts b/packages/@ember/debug/lib/capture-render-tree.ts
index 7a58e68be7c..196701c0725 100644
--- a/packages/@ember/debug/lib/capture-render-tree.ts
+++ b/packages/@ember/debug/lib/capture-render-tree.ts
@@ -20,7 +20,7 @@ import { expect } from '@glimmer/util';
   @since 3.14.0
 */
 export default function captureRenderTree(app: Owner): CapturedRenderNode[] {
-  let renderer = expect(app.lookup<Renderer>('renderer:-dom'), `BUG: owner is missing renderer`);
+  let renderer = expect(app.lookup('renderer:-dom') as Renderer, `BUG: owner is missing renderer`);
 
   return renderer.debugRenderTree.capture();
 }
diff --git a/packages/@ember/engine/index.d.ts b/packages/@ember/engine/index.d.ts
index 5d0bcebb6ca..36a691b14a1 100644
--- a/packages/@ember/engine/index.d.ts
+++ b/packages/@ember/engine/index.d.ts
@@ -1,13 +1,16 @@
 import EngineInstance from './instance';
-import { EngineInstanceOptions, Factory } from '@ember/-internals/owner';
+import { EngineInstanceOptions } from '@ember/-internals/owner';
+import { Namespace, RegistryProxyMixin } from '@ember/-internals/runtime';
 
-export function getEngineParent(instance: EngineInstance): EngineInstance | undefined;
+export { getEngineParent } from '@ember/engine/lib/engine-parent';
 
-export { EngineInstance };
-
-export default class Engine {
-  constructor(...args: any[]);
-  init(...args: any[]): void;
-  register<T, C>(fullName: string, factory: Factory<T, C>, options?: object): void;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface Engine extends RegistryProxyMixin {}
+declare class Engine extends Namespace {
   buildInstance(options?: EngineInstanceOptions): EngineInstance;
+  initializer: (initializer: unknown) => void;
+  instanceInitializer: (initializer: unknown) => void;
+  Resolver: unknown | null;
 }
+
+export { Engine as default };
diff --git a/packages/@ember/engine/instance.d.ts b/packages/@ember/engine/instance.d.ts
index ab41cf52477..76516f6f970 100644
--- a/packages/@ember/engine/instance.d.ts
+++ b/packages/@ember/engine/instance.d.ts
@@ -1,10 +1,14 @@
+import { ContainerProxyMixin, RegistryProxyMixin } from '@ember/-internals/runtime';
 import { Owner } from '@ember/-internals/owner';
+import { BootOptions } from '@ember/application/instance';
 import EmberObject from '@ember/object';
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-interface EngineInstance extends Owner {}
+interface EngineInstance extends RegistryProxyMixin, ContainerProxyMixin, Owner {}
+
 declare class EngineInstance extends EmberObject {
-  boot(): void;
+  init(...args: unknown[]): void;
+  boot(options?: BootOptions): void;
+  unregister(fullName: string): void;
 }
 
 export default EngineInstance;
diff --git a/packages/@ember/engine/lib/engine-parent.js b/packages/@ember/engine/lib/engine-parent.ts
similarity index 75%
rename from packages/@ember/engine/lib/engine-parent.js
rename to packages/@ember/engine/lib/engine-parent.ts
index e6e70748fdb..924b9d54d5b 100644
--- a/packages/@ember/engine/lib/engine-parent.js
+++ b/packages/@ember/engine/lib/engine-parent.ts
@@ -2,6 +2,7 @@
 @module @ember/engine
 */
 import { symbol } from '@ember/-internals/utils';
+import EngineInstance from '../instance';
 
 const ENGINE_PARENT = symbol('ENGINE_PARENT');
 
@@ -15,7 +16,7 @@ const ENGINE_PARENT = symbol('ENGINE_PARENT');
   @static
   @private
 */
-export function getEngineParent(engine) {
+export function getEngineParent(engine: EngineInstance): EngineInstance | undefined {
   return engine[ENGINE_PARENT];
 }
 
@@ -27,6 +28,6 @@ export function getEngineParent(engine) {
   @param {EngineInstance} parent The parent engine instance.
   @private
 */
-export function setEngineParent(engine, parent) {
+export function setEngineParent(engine: EngineInstance, parent: EngineInstance): void {
   engine[ENGINE_PARENT] = parent;
 }
diff --git a/packages/@ember/engine/type-tests/index.test.ts b/packages/@ember/engine/type-tests/index.test.ts
new file mode 100644
index 00000000000..74581a0863d
--- /dev/null
+++ b/packages/@ember/engine/type-tests/index.test.ts
@@ -0,0 +1,96 @@
+import { TypeOptions } from '@ember/-internals/container/lib/registry';
+import { Factory, Owner } from '@ember/-internals/owner';
+import Namespace from '@ember/application/namespace';
+import Engine from '@ember/engine';
+import EngineInstance from '@ember/engine/instance';
+import EmberObject from '@ember/object';
+import { expectTypeOf } from 'expect-type';
+
+// Good enough for tests
+let owner = {} as Owner;
+
+class Foo extends EmberObject {}
+class Bar {}
+
+let engine = new Engine(owner);
+
+expectTypeOf(engine).toMatchTypeOf<Namespace>();
+
+expectTypeOf(engine.buildInstance()).toEqualTypeOf<EngineInstance>();
+engine.buildInstance({ mountPoint: 'foo', routable: true });
+// @ts-expect-error Invalid argument
+engine.buildInstance(1);
+// @ts-expect-error Invalid argument
+engine.buildInstance({});
+// @ts-expect-error Invalid argument
+engine.buildInstance({ mountPoint: 1, routable: true });
+// @ts-expect-error Invalid argument
+engine.buildInstance({ mountPoint: 'foo' });
+
+expectTypeOf(engine.initializer).toEqualTypeOf<(initializer: unknown) => void>();
+
+expectTypeOf(engine.instanceInitializer).toEqualTypeOf<(initializer: unknown) => void>();
+
+expectTypeOf(engine.Resolver).toEqualTypeOf<unknown | null>();
+
+// RegistryProxy
+
+expectTypeOf(engine.resolveRegistration<unknown, object>('foo')).toEqualTypeOf<
+  Factory<unknown, object> | undefined
+>();
+// @ts-expect-error Requires name
+engine.resolveRegistration();
+// @ts-expect-error Only takes one arg
+engine.resolveRegistration('foo', {});
+
+expectTypeOf(engine.register('fruit:favorite', Foo)).toMatchTypeOf<void>();
+engine.register('fruit:favorite', Foo, { singleton: true, instantiate: true });
+// @ts-expect-error requires a Factory object
+engine.register('fruit:foo', Bar);
+// @ts-expect-error requires a string name
+engine.register(1, Foo);
+// @ts-expect-error requires a Factory
+engine.register('fruit:foo');
+// @ts-expect-error requires valid options
+engine.register('fruit:favorite', Foo, { singleton: 1 });
+
+expectTypeOf(engine.unregister('model:user')).toEqualTypeOf<void>();
+// @ts-expect-error Requires a name
+engine.unregister();
+
+expectTypeOf(engine.hasRegistration('fruit:favorite')).toEqualTypeOf<boolean>();
+// @ts-expect-error Requires a name
+engine.hasRegistration();
+
+expectTypeOf(engine.registeredOption('fruit:favorite', 'instantiate')).toEqualTypeOf<
+  boolean | undefined
+>();
+engine.registeredOption('fruit:favorite', 'singleton');
+// @ts-expect-error verifies key
+engine.registeredOption('fruit:favorite', 'invalid');
+
+expectTypeOf(engine.registerOptions('fruit:favorite', { instantiate: true })).toEqualTypeOf<void>();
+// @ts-expect-error requires options
+engine.registerOptions('fruit:favorite');
+// @ts-expect-error requires valid options
+engine.registerOptions('fruit:favorite', 1);
+// @ts-expect-error requires valid options
+engine.registerOptions('fruit:favorite', { singleton: 1 });
+
+expectTypeOf(engine.registeredOptions('fruit:favorite')).toEqualTypeOf<TypeOptions | undefined>();
+// @ts-expect-error requires string name
+engine.registeredOption(1);
+
+expectTypeOf(
+  engine.registerOptionsForType('fruit:favorite', { singleton: true, instantiate: false })
+).toEqualTypeOf<void>();
+// @ts-expect-error requires options
+engine.registerOptionsForType('fruit:favorite');
+// @ts-expect-error requires valid options
+engine.registerOptionsForType('fruit:favorite', 1);
+// @ts-expect-error requires valid options
+engine.registerOptionsForType('fruit:favorite', { singleton: 1 });
+
+expectTypeOf(engine.registeredOptionsForType('my-type')).toEqualTypeOf<TypeOptions | undefined>();
+// @ts-expect-error requires type
+engine.registeredOptionsForType();