declare module '@ember/engine/instance' {
    /**
    @module @ember/engine
    */
    import EmberObject from "@ember/object";
    import { RSVP } from "@ember/-internals/runtime";
    import { Registry } from "@ember/-internals/container";
    import { ENGINE_PARENT } from "@ember/engine/parent";
    import { ContainerProxyMixin, RegistryProxyMixin } from "@ember/-internals/runtime";
    import type { InternalOwner } from "@ember/-internals/owner";
    import type Owner from "@ember/-internals/owner";
    import { type FullName } from "@ember/-internals/owner";
    import type Engine from "@ember/engine";
    import type Application from "@ember/application";
    import type { SimpleElement } from "@simple-dom/interface";
    export interface BootOptions {
        isBrowser?: boolean;
        shouldRender?: boolean;
        document?: Document | null;
        rootElement?: string | SimpleElement | null;
        location?: string | null;
        isInteractive?: boolean;
        _renderMode?: string;
    }
    export interface EngineInstanceOptions {
        mountPoint?: string;
        routable?: boolean;
    }
    /**
      The `EngineInstance` encapsulates all of the stateful aspects of a
      running `Engine`.

      @public
      @class EngineInstance
      @extends EmberObject
      @uses RegistryProxyMixin
      @uses ContainerProxyMixin
    */
    interface EngineInstance extends RegistryProxyMixin, ContainerProxyMixin, InternalOwner, Owner {
    }
    const EngineInstance_base: Readonly<typeof EmberObject> & (new (owner?: Owner) => EmberObject) & import("@ember/object/mixin").default;
    class EngineInstance extends EngineInstance_base {
        /**
         @private
         @method setupRegistry
         @param {Registry} registry
         @param {BootOptions} options
         */
        static setupRegistry(_registry: Registry, _options?: BootOptions): void;
        /**
          The base `Engine` for which this is an instance.
      
          @property {Engine} engine
          @private
        */
        base: Engine;
        application: Application;
        mountPoint?: string;
        routable?: boolean;
        [ENGINE_PARENT]?: EngineInstance;
        _booted: boolean;
        init(properties: object | undefined): void;
        _bootPromise: RSVP.Promise<this> | null;
        /**
          Initialize the `EngineInstance` and return a promise that resolves
          with the instance itself when the boot process is complete.
      
          The primary task here is to run any registered instance initializers.
      
          See the documentation on `BootOptions` for the options it takes.
      
          @public
          @method boot
          @param options {Object}
          @return {Promise<EngineInstance,Error>}
        */
        boot(options?: BootOptions): Promise<this>;
        /**
          Unfortunately, a lot of existing code assumes booting an instance is
          synchronous – specifically, a lot of tests assume the last call to
          `app.advanceReadiness()` or `app.reset()` will result in a new instance
          being fully-booted when the current runloop completes.
      
          We would like new code (like the `visit` API) to stop making this
          assumption, so we created the asynchronous version above that returns a
          promise. But until we have migrated all the code, we would have to expose
          this method for use *internally* in places where we need to boot an instance
          synchronously.
      
          @private
        */
        _bootSync(options?: BootOptions): this;
        setupRegistry(options?: BootOptions): void;
        /**
         Unregister a factory.
      
         Overrides `RegistryProxy#unregister` in order to clear any cached instances
         of the unregistered factory.
      
         @public
         @method unregister
         @param {String} fullName
         */
        unregister(fullName: FullName): void;
        /**
          Build a new `EngineInstance` that's a child of this instance.
      
          Engines must be registered by name with their parent engine
          (or application).
      
          @private
          @method buildChildEngineInstance
          @param name {String} the registered name of the engine.
          @param options {Object} options provided to the engine instance.
          @return {EngineInstance,Error}
        */
        buildChildEngineInstance(name: string, options?: EngineInstanceOptions): EngineInstance;
        /**
          Clone dependencies shared between an engine instance and its parent.
      
          @private
          @method cloneParentDependencies
        */
        cloneParentDependencies(): void;
    }
    export default EngineInstance;
}