ember-source 5.0.0 → 5.1.0-alpha.2

package/types/stable/ember/index.d.ts

@@ -4,17 +4,29 @@ declare module 'ember' {
     */
   import require from 'require';
   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 * as metal from '@ember/-internals/metal';
   import { isEnabled } from '@ember/canary-features';
   import * as EmberDebug from '@ember/debug';
   import Backburner from 'backburner.js';
-  import Controller, { inject as injectController } from '@ember/controller';
-  import Service from '@ember/service';
-  import EmberObject, { action, observer } from '@ember/object';
+  import EmberController, {
+    inject as injectController,
+    ControllerMixin as EmberControllerMixin,
+  } from '@ember/controller';
+  import EmberService from '@ember/service';
+  import EmberObject, { action, observer as emberObserver } from '@ember/object';
   import { dependentKeyCompat } from '@ember/object/compat';
-  import { RSVP } from '@ember/-internals/runtime';
+  import EmberComputedProperty from '@ember/object/computed';
+  function define(path: string, deps: string[], module: () => void): void;
+  import {
+    RSVP as _RSVP,
+    Comparable as InternalComparable,
+    ActionHandler as InternalActionHandler,
+  } from '@ember/-internals/runtime';
   import {
     setComponentManager,
     escapeExpression,
@@ -23,33 +35,54 @@ declare module 'ember' {
     type TemplatesRegistry,
   } from '@ember/-internals/glimmer';
   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 { NativeArray, isArray, makeArray } from '@ember/array';
-  import ArrayProxy from '@ember/array/proxy';
-  import Application, { onLoad, runLoadHooks } from '@ember/application';
-  import ApplicationInstance from '@ember/application/instance';
-  import Namespace from '@ember/application/namespace';
-  import Component from '@ember/component';
-  import Helper from '@ember/component/helper';
-  import Engine from '@ember/engine';
-  import EngineInstance from '@ember/engine/instance';
-  import CoreObject from '@ember/object/core';
-  import Mixin, { mixin } from '@ember/object/mixin';
-  import ObjectProxy from '@ember/object/proxy';
-  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 EmberContainerDebugAdapter from '@ember/debug/container-debug-adapter';
+  import EmberDataAdapter from '@ember/debug/data-adapter';
+  import { run as emberRun } from '@ember/runloop';
+  import EmberArray, {
+    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, {
+    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 from '@ember/object/evented';
+  import EmberMixin, { mixin as emberMixin } from '@ember/object/mixin';
+  import EmberObservable from '@ember/object/observable';
+  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,
-    generateController,
-    generateControllerFactory,
-    DSL as RouterDSL,
+    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';
   import {
     helperCapabilities,
@@ -65,160 +98,200 @@ declare module 'ember' {
   } from '@ember/destroyable';
   import type { precompile, compile } from 'ember-template-compiler';
   import type * as EmberTesting from 'ember-testing';
-  /**
-      Namespace for injection helper methods.
-
-      @class inject
-      @namespace Ember
-      @static
-      @public
-    */
-  function inject(): void;
-  const PartialEmber: {
-    readonly isNamespace: true;
-    readonly toString: () => string;
-    readonly Container: typeof Container;
-    readonly Registry: typeof Registry;
-    readonly _setComponentManager: typeof setComponentManager;
-    readonly _componentManagerCapabilities: typeof import('@glimmer/manager').componentCapabilities;
-    readonly _modifierManagerCapabilities: typeof import('@glimmer/manager').modifierCapabilities;
-    readonly meta: {
+  namespace Ember {
+    const isNamespace = true;
+    function toString(): string;
+    const Container: typeof InternalContainer;
+    type Container = InternalContainer;
+    const Registry: typeof InternalRegistry;
+    type Registry = InternalRegistry;
+    const _setComponentManager: typeof setComponentManager;
+    const _componentManagerCapabilities: typeof import('@glimmer/manager').componentCapabilities;
+    const _modifierManagerCapabilities: typeof import('@glimmer/manager').modifierCapabilities;
+    const meta: {
       (obj: object): import('@ember/-internals/meta').Meta;
       _counters?: import('@ember/-internals/meta').MetaCounters | undefined;
     };
-    readonly _createCache: typeof metal.createCache;
-    readonly _cacheGetValue: typeof metal.getValue;
-    readonly _cacheIsConst: typeof metal.isConst;
-    readonly _descriptor: typeof metal.nativeDescDecorator;
-    readonly _getPath: typeof metal._getPath;
-    readonly _setClassicDecorator: typeof metal.setClassicDecorator;
-    readonly _tracked: typeof metal.tracked;
-    readonly beginPropertyChanges: typeof metal.beginPropertyChanges;
-    readonly changeProperties: typeof metal.changeProperties;
-    readonly endPropertyChanges: typeof metal.endPropertyChanges;
-    readonly hasListeners: typeof metal.hasListeners;
-    readonly libraries: metal.Libraries;
-    readonly _ContainerProxyMixin: Mixin;
-    readonly _ProxyMixin: Mixin;
-    readonly _RegistryProxyMixin: Mixin;
-    readonly ActionHandler: Mixin;
-    readonly Comparable: Mixin;
-    readonly RSVP: typeof RSVP;
-    readonly ComponentLookup: Readonly<typeof EmberObject> &
-      (new (owner?: import('@ember/owner').default | undefined) => EmberObject);
-    readonly EventDispatcher: typeof views.EventDispatcher;
-    readonly _Cache: typeof utils.Cache;
-    readonly GUID_KEY: `__ember${number}`;
-    readonly canInvoke: typeof utils.canInvoke;
-    readonly generateGuid: typeof utils.generateGuid;
-    readonly guidFor: typeof utils.guidFor;
-    readonly uuid: typeof utils.uuid;
-    readonly wrap: typeof utils.wrap;
-    readonly getOwner: (object: object) => import('@ember/owner').default | undefined;
-    readonly onLoad: typeof onLoad;
-    readonly runLoadHooks: typeof runLoadHooks;
-    readonly setOwner: typeof import('@ember/owner').setOwner;
-    readonly Application: typeof Application;
-    readonly ApplicationInstance: typeof ApplicationInstance;
-    readonly Namespace: typeof Namespace;
-    readonly A: <T>(arr?: T[] | undefined) => NativeArray<T>;
-    readonly Array: Mixin;
-    readonly NativeArray: Mixin;
-    readonly isArray: typeof isArray;
-    readonly makeArray: typeof makeArray;
-    readonly MutableArray: Mixin;
-    readonly ArrayProxy: typeof ArrayProxy;
-    readonly FEATURES: {
-      readonly isEnabled: typeof isEnabled;
+    const _createCache: typeof metal.createCache;
+    const _cacheGetValue: typeof metal.getValue;
+    const _cacheIsConst: typeof metal.isConst;
+    const _descriptor: typeof metal.nativeDescDecorator;
+    const _getPath: typeof metal._getPath;
+    const _setClassicDecorator: typeof metal.setClassicDecorator;
+    const _tracked: typeof metal.tracked;
+    const beginPropertyChanges: typeof metal.beginPropertyChanges;
+    const changeProperties: typeof metal.changeProperties;
+    const endPropertyChanges: typeof metal.endPropertyChanges;
+    const hasListeners: typeof metal.hasListeners;
+    const libraries: metal.Libraries;
+    const _ContainerProxyMixin: EmberMixin;
+    const _ProxyMixin: EmberMixin;
+    const _RegistryProxyMixin: EmberMixin;
+    const ActionHandler: EmberMixin;
+    type ActionHandler = InternalActionHandler;
+    const Comparable: EmberMixin;
+    type Comparable = InternalComparable;
+    export import RSVP = _RSVP;
+    const ComponentLookup: Readonly<typeof EmberObject> &
+      (new (owner?: import('@ember/owner').default | undefined) => EmberObject) & {
+        componentFor(
+          name: string,
+          owner: import('@ember/-internals/owner').InternalOwner
+        ): import('@ember/owner').FactoryManager<object> | undefined;
+        layoutFor(
+          name: string,
+          owner: import('@ember/-internals/owner').InternalOwner,
+          options: import('@ember/owner').RegisterOptions
+        ): unknown;
+      };
+    const EventDispatcher: typeof views.EventDispatcher;
+    const _Cache: typeof utils.Cache;
+    const GUID_KEY: `__ember${number}`;
+    const canInvoke: typeof utils.canInvoke;
+    const generateGuid: typeof utils.generateGuid;
+    const guidFor: typeof utils.guidFor;
+    const uuid: typeof utils.uuid;
+    const wrap: typeof utils.wrap;
+    const getOwner: (object: object) => import('@ember/owner').default | undefined;
+    const onLoad: typeof applicationOnLoad;
+    const runLoadHooks: typeof applicationRunLoadHooks;
+    const setOwner: typeof import('@ember/owner').setOwner;
+    const Application: typeof EmberApplication;
+    type Application = EmberApplication;
+    const ApplicationInstance: typeof EmberApplicationInstance;
+    type ApplicationInstance = EmberApplicationInstance;
+    const Namespace: typeof EmberNamespace;
+    type Namespace = EmberNamespace;
+    const A: <T>(arr?: T[] | undefined) => EmberNativeArray<T>;
+    const Array: EmberMixin;
+    type Array<T> = EmberArray<T>;
+    const NativeArray: EmberMixin;
+    type NativeArray<T> = EmberNativeArray<T>;
+    const isArray: typeof emberIsArray;
+    const makeArray: typeof emberMakeArray;
+    const MutableArray: EmberMixin;
+    type MutableArray<T> = EmberMutableArray<T>;
+    const ArrayProxy: typeof EmberArrayProxy;
+    type ArrayProxy<T> = EmberArrayProxy<T>;
+    const FEATURES: {
+      isEnabled: typeof isEnabled;
     };
-    readonly _Input: import('@ember/-internals/glimmer/lib/components/internal').OpaqueInternalComponentConstructor;
-    readonly Component: typeof Component;
-    readonly Helper: typeof Helper;
-    readonly Controller: typeof Controller;
-    readonly ControllerMixin: Mixin;
-    readonly _captureRenderTree: typeof EmberDebug.captureRenderTree;
-    readonly assert: EmberDebug.AssertFunc;
-    readonly warn: import('@ember/debug/lib/warn').WarnFunc;
-    readonly debug: EmberDebug.DebugFunc;
-    readonly deprecate: import('@ember/debug/lib/deprecate').DeprecateFunc;
-    readonly deprecateFunc: EmberDebug.DeprecateFuncFunc;
-    readonly runInDebug: EmberDebug.RunInDebugFunc;
-    readonly inspect: typeof EmberDebug.inspect;
-    readonly Debug: {
-      readonly registerDeprecationHandler: (
+    const _Input: EmberInput;
+    const Component: typeof EmberComponent;
+    type Component<S = unknown> = EmberComponent<S>;
+    const Helper: typeof EmberHelper;
+    type Helper<S = unknown> = EmberHelper<S>;
+    const Controller: typeof EmberController;
+    type Controller<T = unknown> = EmberController<T>;
+    const ControllerMixin: EmberMixin;
+    type ControllerMixin<T> = EmberControllerMixin<T>;
+    const _captureRenderTree: typeof EmberDebug.captureRenderTree;
+    const assert: EmberDebug.AssertFunc;
+    const warn: import('@ember/debug/lib/warn').WarnFunc;
+    const debug: EmberDebug.DebugFunc;
+    const deprecate: import('@ember/debug/lib/deprecate').DeprecateFunc;
+    const deprecateFunc: EmberDebug.DeprecateFuncFunc;
+    const runInDebug: EmberDebug.RunInDebugFunc;
+    const inspect: typeof EmberDebug.inspect;
+    const Debug: {
+      registerDeprecationHandler: (
         handler: import('@ember/debug/lib/handlers').HandlerCallback<EmberDebug.DeprecationOptions>
       ) => void;
-      readonly registerWarnHandler: import('@ember/debug/lib/warn').RegisterHandlerFunc;
-      readonly isComputed: typeof metal.isComputed;
+      registerWarnHandler: import('@ember/debug/lib/warn').RegisterHandlerFunc;
+      isComputed: typeof metal.isComputed;
     };
-    readonly ContainerDebugAdapter: typeof ContainerDebugAdapter;
-    readonly DataAdapter: typeof DataAdapter;
-    readonly _assertDestroyablesDestroyed: (() => void) | undefined;
-    readonly _associateDestroyableChild: typeof associateDestroyableChild;
-    readonly _enableDestroyableTracking: (() => void) | undefined;
-    readonly _isDestroying: typeof glimmerRuntime.isDestroying;
-    readonly _isDestroyed: typeof glimmerRuntime.isDestroyed;
-    readonly _registerDestructor: typeof registerDestructor;
-    readonly _unregisterDestructor: typeof unregisterDestructor;
-    readonly destroy: typeof glimmerRuntime.destroy;
-    readonly Engine: typeof Engine;
-    readonly EngineInstance: typeof EngineInstance;
-    readonly Enumerable: Mixin;
-    readonly MutableEnumerable: Mixin;
-    readonly instrument: typeof instrumentation.instrument;
-    readonly subscribe: typeof instrumentation.subscribe;
-    readonly Instrumentation: {
-      readonly instrument: typeof instrumentation.instrument;
-      readonly subscribe: typeof instrumentation.subscribe;
-      readonly unsubscribe: typeof instrumentation.unsubscribe;
-      readonly reset: typeof instrumentation.reset;
+    const ContainerDebugAdapter: typeof EmberContainerDebugAdapter;
+    type ContainerDebugAdapter = EmberContainerDebugAdapter;
+    const DataAdapter: typeof EmberDataAdapter;
+    type DataAdapter<T> = EmberDataAdapter<T>;
+    const _assertDestroyablesDestroyed: (() => void) | undefined;
+    const _associateDestroyableChild: typeof associateDestroyableChild;
+    const _enableDestroyableTracking: (() => void) | undefined;
+    const _isDestroying: typeof glimmerRuntime.isDestroying;
+    const _isDestroyed: typeof glimmerRuntime.isDestroyed;
+    const _registerDestructor: typeof registerDestructor;
+    const _unregisterDestructor: typeof unregisterDestructor;
+    const destroy: typeof glimmerRuntime.destroy;
+    const Engine: typeof EmberEngine;
+    type Engine = EmberEngine;
+    const EngineInstance: typeof EmberEngineInstance;
+    type EngineInstance = EmberEngineInstance;
+    const Enumerable: EmberMixin;
+    type Enumerable = EmberEnumerable;
+    const MutableEnumerable: EmberMixin;
+    type MutableEnumerable = EmberMutableEnumerable;
+    /** @private */
+    const instrument: typeof instrumentation.instrument;
+    /** @private */
+    const subscribe: typeof instrumentation.subscribe;
+    /** @private */
+    const Instrumentation: {
+      instrument: typeof instrumentation.instrument;
+      subscribe: typeof instrumentation.subscribe;
+      unsubscribe: typeof instrumentation.unsubscribe;
+      reset: typeof instrumentation.reset;
     };
-    readonly Object: typeof EmberObject;
-    readonly _action: typeof action;
-    readonly computed: typeof metal.computed;
-    readonly defineProperty: typeof metal.defineProperty;
-    readonly get: typeof metal.get;
-    readonly getProperties: typeof metal.getProperties;
-    readonly notifyPropertyChange: typeof metal.notifyPropertyChange;
-    readonly observer: typeof observer;
-    readonly set: typeof metal.set;
-    readonly trySet: typeof metal.trySet;
-    readonly setProperties: typeof metal.setProperties;
-    readonly cacheFor: typeof metal.getCachedValueFor;
-    readonly _dependentKeyCompat: typeof dependentKeyCompat;
-    readonly ComputedProperty: typeof metal.ComputedProperty;
-    readonly expandProperties: typeof metal.expandProperties;
-    readonly CoreObject: typeof CoreObject;
-    readonly Evented: Mixin;
-    readonly on: typeof metal.on;
-    readonly addListener: typeof metal.addListener;
-    readonly removeListener: typeof metal.removeListener;
-    readonly sendEvent: typeof metal.sendEvent;
-    readonly Mixin: typeof Mixin;
-    readonly mixin: typeof mixin;
-    readonly Observable: Mixin;
-    readonly addObserver: typeof metal.addObserver;
-    readonly removeObserver: typeof metal.removeObserver;
-    readonly PromiseProxyMixin: Mixin;
-    readonly ObjectProxy: typeof ObjectProxy;
-    readonly RouterDSL: typeof RouterDSL;
-    readonly controllerFor: typeof controllerFor;
-    readonly generateController: typeof generateController;
-    readonly generateControllerFactory: typeof generateControllerFactory;
-    readonly HashLocation: typeof HashLocation;
-    readonly HistoryLocation: typeof HistoryLocation;
-    readonly NoneLocation: typeof NoneLocation;
-    readonly Route: typeof Route;
-    readonly Router: typeof Router;
-    readonly run: typeof run;
-    readonly Service: typeof Service;
-    readonly compare: typeof compare;
-    readonly isBlank: typeof isBlank;
-    readonly isEmpty: typeof isEmpty;
-    readonly isEqual: typeof isEqual;
-    readonly isNone: typeof isNone;
-    readonly isPresent: typeof isPresent;
-    readonly typeOf: typeof typeOf;
+    const Object: typeof EmberObject;
+    type Object = EmberObject;
+    const _action: typeof action;
+    const computed: typeof metal.computed;
+    const defineProperty: typeof metal.defineProperty;
+    const get: typeof metal.get;
+    const getProperties: typeof metal.getProperties;
+    const notifyPropertyChange: typeof metal.notifyPropertyChange;
+    const observer: typeof emberObserver;
+    const set: typeof metal.set;
+    const trySet: typeof metal.trySet;
+    const setProperties: typeof metal.setProperties;
+    const cacheFor: typeof metal.getCachedValueFor;
+    const _dependentKeyCompat: typeof dependentKeyCompat;
+    const ComputedProperty: typeof metal.ComputedProperty;
+    type ComputedProperty = EmberComputedProperty;
+    const expandProperties: typeof metal.expandProperties;
+    const CoreObject: typeof EmberCoreObject;
+    type CoreObject = EmberCoreObject;
+    const Evented: EmberMixin;
+    type Evented = EmberEvented;
+    const on: typeof metal.on;
+    const addListener: typeof metal.addListener;
+    const removeListener: typeof metal.removeListener;
+    const sendEvent: typeof metal.sendEvent;
+    const Mixin: typeof EmberMixin;
+    type Mixin = EmberMixin;
+    const mixin: typeof emberMixin;
+    const Observable: EmberMixin;
+    type Observable = EmberObservable;
+    const addObserver: typeof metal.addObserver;
+    const removeObserver: typeof metal.removeObserver;
+    const PromiseProxyMixin: EmberMixin;
+    type PromiseProxyMixin<T> = EmberPromiseProxyMixin<T>;
+    const ObjectProxy: typeof EmberObjectProxy;
+    type ObjectProxy = EmberObjectProxy;
+    const RouterDSL: typeof EmberRouterDSL;
+    type RouterDSL = EmberRouterDSL;
+    const controllerFor: typeof emberControllerFor;
+    const generateController: typeof emberGenerateController;
+    const generateControllerFactory: typeof emberGenerateControllerFactory;
+    const HashLocation: typeof EmberHashLocation;
+    type HashLocation = EmberHashLocation;
+    const HistoryLocation: typeof EmberHistoryLocation;
+    type HistoryLocation = EmberHistoryLocation;
+    const NoneLocation: typeof EmberNoneLocation;
+    type NoneLocation = EmberNoneLocation;
+    const Route: typeof EmberRoute;
+    type Route = EmberRoute;
+    const Router: typeof EmberRouter;
+    type Router = EmberRouter;
+    const run: typeof emberRun;
+    const Service: typeof EmberService;
+    type Service = EmberService;
+    const compare: typeof emberCompare;
+    const isBlank: typeof emberIsBlank;
+    const isEmpty: typeof emberIsEmpty;
+    const isEqual: typeof emberIsEqual;
+    const isNone: typeof emberIsNone;
+    const isPresent: typeof emberIsPresent;
+    const typeOf: typeof emberTypeOf;
     /**
           The semantic version
       
@@ -226,57 +299,53 @@ declare module 'ember' {
           @type String
           @public
         */
-    readonly VERSION: string;
-    readonly ViewUtils: {
-      readonly getChildViews: typeof views.getChildViews;
-      readonly getElementView: typeof views.getElementView;
-      readonly getRootViews: typeof views.getRootViews;
-      readonly getViewBounds: typeof views.getViewBounds;
-      readonly getViewBoundingClientRect: typeof views.getViewBoundingClientRect;
-      readonly getViewClientRects: typeof views.getViewClientRects;
-      readonly getViewElement: typeof views.getViewElement;
-      readonly isSimpleClick: typeof views.isSimpleClick;
-      readonly isSerializationFirstNode: typeof isSerializationFirstNode;
+    const VERSION: string;
+    const ViewUtils: {
+      getChildViews: typeof views.getChildViews;
+      getElementView: typeof views.getElementView;
+      getRootViews: typeof views.getRootViews;
+      getViewBounds: typeof views.getViewBounds;
+      getViewBoundingClientRect: typeof views.getViewBoundingClientRect;
+      getViewClientRects: typeof views.getViewClientRects;
+      getViewElement: typeof views.getViewElement;
+      isSimpleClick: typeof views.isSimpleClick;
+      isSerializationFirstNode: typeof isSerializationFirstNode;
     };
-    readonly _getComponentTemplate: typeof getComponentTemplate;
-    readonly _helperManagerCapabilities: typeof helperCapabilities;
-    readonly _setComponentTemplate: typeof setComponentTemplate;
-    readonly _setHelperManager: typeof setHelperManager;
-    readonly _setModifierManager: typeof setModifierManager;
-    readonly _templateOnlyComponent: typeof glimmerRuntime.templateOnlyComponent;
-    readonly _invokeHelper: typeof glimmerRuntime.invokeHelper;
-    readonly _hash: object;
-    readonly _array: object;
-    readonly _concat: object;
-    readonly _get: object;
-    readonly _on: {};
-    readonly _fn: object;
-    readonly _Backburner: typeof Backburner;
-    readonly inject: typeof inject;
-    readonly __loader: {
-      readonly require: typeof require;
-      readonly define: typeof define;
-      readonly registry: any;
-    };
-  };
-  interface EmberHandlebars {
-    template: typeof template;
-    Utils: {
-      escapeExpression: typeof escapeExpression;
+    const _getComponentTemplate: typeof getComponentTemplate;
+    const _helperManagerCapabilities: typeof helperCapabilities;
+    const _setComponentTemplate: typeof setComponentTemplate;
+    const _setHelperManager: typeof setHelperManager;
+    const _setModifierManager: typeof setModifierManager;
+    const _templateOnlyComponent: typeof glimmerRuntime.templateOnlyComponent;
+    const _invokeHelper: typeof glimmerRuntime.invokeHelper;
+    const _hash: object;
+    const _array: object;
+    const _concat: object;
+    const _get: object;
+    const _on: {};
+    const _fn: object;
+    const _Backburner: typeof Backburner;
+    type _Backburner = Backburner;
+    /**
+          Namespace for injection helper methods.
+      
+          @class inject
+          @namespace Ember
+          @static
+          @public
+        */
+    function inject(): void;
+    namespace inject {
+      var controller: typeof injectController;
+      var service: typeof import('@ember/service').service;
+    }
+    const __loader: {
+      require: typeof require;
+      define: typeof define;
+      registry: any;
     };
-    compile?: typeof compile;
-    precompile?: typeof precompile;
-  }
-  interface EmberHTMLBars {
-    template: typeof template;
-    compile?: typeof compile;
-    precompile?: typeof precompile;
-  }
-  type PartialEmber = typeof PartialEmber;
-  interface Ember extends PartialEmber {
-    get ENV(): object;
-    get lookup(): Record<string, unknown>;
-    set lookup(value: Record<string, unknown>);
+    const ENV: Readonly<object>;
+    let lookup: Record<string, unknown>;
     /**
           A function may be assigned to `Ember.onerror` to be called when Ember
           internals encounter an error. This is useful for specialized error handling
@@ -301,13 +370,11 @@ declare module 'ember' {
       
           @event onerror
           @for Ember
-          @param {Exception} error the error object
+          @param {Error} error the error object
           @public
         */
-    get onerror(): Function | undefined;
-    set onerror(handler: Function | undefined);
-    get testing(): boolean;
-    set testing(value: boolean);
+    let onerror: ((error: Error) => unknown) | undefined;
+    let testing: boolean;
     /**
           Whether searching on the global for new Namespace instances is enabled.
       
@@ -322,8 +389,7 @@ declare module 'ember' {
           @type Boolean
           @private
         */
-    get BOOTED(): boolean;
-    set BOOTED(flag: boolean);
+    let BOOTED: boolean;
     /**
           Global hash of shared templates. This will automatically be populated
           by the build tools so that you can store your Handlebars templates in
@@ -334,23 +400,31 @@ declare module 'ember' {
           @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'];
+    let TEMPLATES: TemplatesRegistry;
+    let HTMLBars: EmberHTMLBars;
+    let Handlebars: EmberHandlebars;
+    let Test:
+      | (typeof EmberTesting['Test'] & {
+          Adapter: typeof EmberTesting['Adapter'];
+          QUnitAdapter: typeof EmberTesting['QUnitAdapter'];
+        })
+      | undefined;
+    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: Ember;
   let EmberHandlebars: EmberHandlebars;
   let EmberHTMLBars: EmberHTMLBars;
   export default Ember;
 }
-
-declare namespace inject {
-  var controller: typeof injectController;
-  var service: typeof import('@ember/service').service;
-}