@nexus-ioc/core 0.6.2 → 0.7.0

package/dist/types/decorators/{nsModule.d.ts → module.d.ts}

@@ -3,7 +3,7 @@ import type { ModuleMetadata } from "../interfaces";
 /**
  * Defines a module in the application.
  *
- * A module is a class annotated with @NsModule() decorator that organizes
+ * A module is a class annotated with @Module() decorator that organizes
  * the application structure. Modules can:
  * - Declare providers that will be instantiated by the container
  * - Import other modules to use their exported providers
@@ -13,20 +13,21 @@ import type { ModuleMetadata } from "../interfaces";
  * @param metadata.imports - Modules whose exported providers should be available in this module
  * @param metadata.providers - Providers that belong to this module
  * @param metadata.exports - Providers or modules to export (make available to importing modules)
+ * @param metadata.children - Modules (or lazy refs) that may be created as child containers; not compiled into this graph
  * @returns A class decorator
  * @throws {Error} If invalid metadata keys are provided
  *
  * @example
  * ```typescript
  * // Basic module
- * @NsModule({
+ * @Module({
  *   providers: [UserService, UserRepository],
  *   exports: [UserService]
  * })
  * class UserModule {}
  *
  * // Module with imports
- * @NsModule({
+ * @Module({
  *   imports: [DatabaseModule, LoggerModule],
  *   providers: [ProductService],
  *   exports: [ProductService]
@@ -34,11 +35,11 @@ import type { ModuleMetadata } from "../interfaces";
  * class ProductModule {}
  *
  * // Root module
- * @NsModule({
+ * @Module({
  *   imports: [UserModule, ProductModule],
  *   providers: [AppService]
  * })
  * class AppModule {}
  * ```
  */
-export declare function NsModule(metadata: ModuleMetadata): ClassDecorator;
+export declare function Module(metadata: ModuleMetadata): ClassDecorator;

package/dist/types/errors/bootstrap-error.d.ts

@@ -0,0 +1,6 @@
+import type { GraphError } from "../interfaces";
+export declare function formatGraphErrors(errors: GraphError[]): string;
+export declare class BootstrapError extends Error {
+    readonly errors: GraphError[];
+    constructor(errors: GraphError[]);
+}

package/dist/types/errors/child-errors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `createChild()` was called with a module that no module of the parent
+ * graph lists in `@Module({ children })`, or (`reason: "unloaded"`) the
+ * lazy module declaring it was unloaded while the child was being created.
+ */
+export declare class ChildModuleNotDeclaredError extends Error {
+    readonly moduleName: string;
+    readonly reason: "not-declared" | "unloaded";
+    constructor(moduleName: string, reason?: "not-declared" | "unloaded");
+}

package/dist/types/errors/index.d.ts

@@ -0,0 +1,5 @@
+export { BootstrapError, formatGraphErrors } from "./bootstrap-error";
+export { ChildModuleNotDeclaredError } from "./child-errors";
+export { CircularInjectionError, InjectionContextError, } from "./injection-errors";
+export { LazyModuleGraphError, LazyModuleLoadError, } from "./lazy-module-errors";
+export { AsyncFactoryError, ContainerClosedError, formatToken, InvalidScopeError, ProviderNotFoundError, ProviderNotInstantiatedError, ProviderScopeError, ProviderUnloadedError, } from "./provider-errors";

package/dist/types/errors/injection-errors.d.ts

@@ -0,0 +1,11 @@
+import type { ProviderToken } from "../interfaces";
+/** inject() was called while no provider was being created. */
+export declare class InjectionContextError extends Error {
+    readonly token: ProviderToken;
+    constructor(token: ProviderToken);
+}
+/** A dependency cycle that passes through inject() or the synchronous creation path. */
+export declare class CircularInjectionError extends Error {
+    readonly path: ProviderToken[];
+    constructor(path: ProviderToken[]);
+}

package/dist/types/errors/lazy-module-errors.d.ts

@@ -0,0 +1,12 @@
+import type { GraphError } from "../interfaces";
+/** The loader rejected or returned something that is not a @Module() class. */
+export declare class LazyModuleLoadError extends Error {
+    readonly lazyModuleName: string;
+    constructor(lazyModuleName: string, reason: string);
+}
+/** The loaded module compiled with graph errors; the segment was rolled back. */
+export declare class LazyModuleGraphError extends Error {
+    readonly lazyModuleName: string;
+    readonly errors: GraphError[];
+    constructor(lazyModuleName: string, errors: GraphError[]);
+}

package/dist/types/errors/provider-errors.d.ts

@@ -0,0 +1,47 @@
+import type { ProviderToken } from "../interfaces";
+import { Scope } from "../interfaces";
+export declare function formatToken(token: ProviderToken): string;
+/** No provider with this token exists in the container or any parent. */
+export declare class ProviderNotFoundError extends Error {
+    readonly token: ProviderToken;
+    readonly requestedBy?: ProviderToken | undefined;
+    constructor(token: ProviderToken, requestedBy?: ProviderToken | undefined);
+}
+/**
+ * The singleton exists but has not been created yet (lazy mode or not
+ * loaded), or inject() met it while another resolution is still creating it.
+ */
+export declare class ProviderNotInstantiatedError extends Error {
+    readonly token: ProviderToken;
+    constructor(token: ProviderToken, reason?: "not-created" | "creation-in-flight");
+}
+/**
+ * The provider's module was unloaded while `resolve()` was still creating
+ * it. The half-finished instance was destroyed instead of cached; load the
+ * module again and resolve the provider anew.
+ */
+export declare class ProviderUnloadedError extends Error {
+    readonly token: ProviderToken;
+    constructor(token: ProviderToken);
+}
+/** get() only serves singletons; Transient providers are created per call. */
+export declare class ProviderScopeError extends Error {
+    readonly token: ProviderToken;
+    readonly scope: Scope;
+    constructor(token: ProviderToken, scope: Scope);
+}
+/** A provider declares a scope that is not a member of `Scope`. */
+export declare class InvalidScopeError extends Error {
+    readonly token: ProviderToken;
+    readonly scope: unknown;
+    constructor(token: ProviderToken, scope: unknown);
+}
+/** The application was closed; it can no longer provide instances. */
+export declare class ContainerClosedError extends Error {
+    constructor();
+}
+/** A useFactory returned a promise; factories must be synchronous. */
+export declare class AsyncFactoryError extends Error {
+    readonly token: ProviderToken;
+    constructor(token: ProviderToken);
+}

package/dist/types/index.d.ts

@@ -1,10 +1,19 @@
-export { ContainerNotCompiledError } from "@nexus-ioc/shared";
-export { Container } from "./core/modules/container";
-export { NexusApplications } from "./core/nexus-applications";
+export { ContainerNotCompiledError, InjectionToken } from "@nexus-ioc/shared";
+export type { InjectOptions } from "./core/injection/injection-context";
+export { inject } from "./core/injection/injection-context";
+export { LazyModuleLoader } from "./core/lazy-module-loader";
+export type { ModuleRefGetOptions } from "./core/module-ref";
+export { ModuleRef } from "./core/module-ref";
+export { NexusApplication } from "./core/nexus-applications";
 export { Global } from "./decorators/global";
 export { Inject } from "./decorators/inject";
 export { Injectable } from "./decorators/injectable";
-export { NsModule } from "./decorators/nsModule";
+export { Module } from "./decorators/module";
 export { Optional } from "./decorators/optional";
+export { AsyncFactoryError, BootstrapError, ChildModuleNotDeclaredError, CircularInjectionError, ContainerClosedError, InjectionContextError, InvalidScopeError, LazyModuleGraphError, LazyModuleLoadError, ProviderNotFoundError, ProviderNotInstantiatedError, ProviderScopeError, ProviderUnloadedError, } from "./errors";
 export * from "./interfaces";
+export type { ForwardRef } from "./utils/forward-ref";
+export { forwardRef } from "./utils/forward-ref";
 export * from "./utils/helpers";
+export type { LazyModuleOptions } from "./utils/lazy-module";
+export { isLazyModule, lazy } from "./utils/lazy-module";

package/dist/types/interfaces/abstract.interface.d.ts

@@ -1,3 +1 @@
-export interface Abstract<T> extends Function {
-    prototype: T;
-}
+export type { Abstract } from "@nexus-ioc/shared";

package/dist/types/interfaces/dynamic-module.interface.d.ts

@@ -1,13 +1,15 @@
-import type { InjectionToken } from "./injection-token.interface";
-import type { Module, Provider } from "./module-types.interface";
+import type { LazyModule } from "@nexus-ioc/shared";
+import type { ProviderToken } from "./injection-token.interface";
+import type { Provider } from "./module-types.interface";
+import type { Type } from "./type.interface";
 export interface DynamicModule {
-    module: Module & {
+    module: Type & {
         forRoot?: () => DynamicModule;
         forRootAsync?: () => DynamicModule;
         forFeature?: () => DynamicModule;
         forFeatureAsync?: () => DynamicModule;
     };
     providers?: Provider[];
-    exports?: InjectionToken[];
-    imports?: (Module | DynamicModule)[];
+    exports?: ProviderToken[];
+    imports?: (Type | DynamicModule | LazyModule)[];
 }

package/dist/types/interfaces/index.d.ts

@@ -7,6 +7,7 @@ export * from "./module-metadata.interface";
 export * from "./module-types.interface";
 export * from "./modules";
 export * from "./nexus-application.interface";
+export * from "./on-module-destroy.interface";
 export * from "./on-module-init.interface";
 export * from "./plugins";
 export * from "./scope.interface";

package/dist/types/interfaces/injection-token.interface.d.ts

@@ -1,3 +1 @@
-import type { Abstract } from "./abstract.interface";
-import type { Type } from "./type.interface";
-export type InjectionToken<T = any> = string | symbol | Type<T> | Abstract<T> | Function;
+export type { ProviderToken } from "@nexus-ioc/shared";

package/dist/types/interfaces/module-metadata.interface.d.ts

@@ -1,8 +1,16 @@
+import type { LazyModule } from "@nexus-ioc/shared";
 import type { DynamicModule } from "./dynamic-module.interface";
-import type { InjectionToken } from "./injection-token.interface";
-import type { Module, Provider } from "./module-types.interface";
+import type { ProviderToken } from "./injection-token.interface";
+import type { Provider } from "./module-types.interface";
+import type { Type } from "./type.interface";
+export type { LazyModule } from "@nexus-ioc/shared";
 export interface ModuleMetadata {
-    imports?: (Module | DynamicModule)[];
-    exports?: (InjectionToken | Module)[];
+    imports?: (Type | DynamicModule | LazyModule)[];
+    exports?: (ProviderToken | Type)[];
     providers?: Provider[];
+    /**
+     * Modules that are not part of this graph but may later be instantiated as
+     * child containers. Static declaration only; never compiled into the parent.
+     */
+    children?: (Type | LazyModule)[];
 }

package/dist/types/interfaces/module-types.interface.d.ts

@@ -1,10 +1,7 @@
-import type { InjectionToken } from "./injection-token.interface";
+import type { ForwardRef } from "../utils/forward-ref";
+import type { ProviderToken } from "./injection-token.interface";
 import type { Scope } from "./scope.interface";
 import type { Type } from "./type.interface";
-/**
- * Represents a module class.
- */
-export type Module = Type;
 /**
  * Represents a provider that can be registered in a module.
  *
@@ -19,26 +16,26 @@ export type Module = Type;
  * @example
  * ```typescript
  * // Class provider (shorthand)
- * @NsModule({
+ * @Module({
  *   providers: [UserService]
  * })
  *
  * // ClassProvider (explicit)
- * @NsModule({
+ * @Module({
  *   providers: [
  *     { provide: UserService, useClass: MockUserService }
  *   ]
  * })
  *
  * // ValueProvider
- * @NsModule({
+ * @Module({
  *   providers: [
  *     { provide: 'CONFIG', useValue: { apiUrl: 'https://api.example.com' } }
  *   ]
  * })
  *
  * // FactoryProvider
- * @NsModule({
+ * @Module({
  *   providers: [
  *     {
  *       provide: 'DATABASE',
@@ -62,7 +59,7 @@ export type Provider<T = any> = ClassProvider<T> | ValueProvider<T> | FactoryPro
  *
  * @example
  * ```typescript
- * @NsModule({
+ * @Module({
  *   providers: [
  *     // Provide MockUserService when UserService is requested
  *     {
@@ -76,7 +73,7 @@ export type Provider<T = any> = ClassProvider<T> | ValueProvider<T> | FactoryPro
  */
 export interface ClassProvider<T = any> {
     /** The injection token to register this provider under */
-    provide: InjectionToken;
+    provide: ProviderToken;
     /** The class to instantiate */
     useClass: Type<T>;
     /** The lifecycle scope (default: Singleton) */
@@ -97,7 +94,7 @@ export interface ClassProvider<T = any> {
  *
  * @example
  * ```typescript
- * @NsModule({
+ * @Module({
  *   providers: [
  *     { provide: 'API_URL', useValue: 'https://api.example.com' },
  *     { provide: 'MAX_RETRIES', useValue: 3 },
@@ -109,7 +106,7 @@ export interface ClassProvider<T = any> {
  */
 export interface ValueProvider<T = any> {
     /** The injection token to register this provider under */
-    provide: InjectionToken;
+    provide: ProviderToken;
     /** The value to provide */
     useValue: T;
 }
@@ -120,21 +117,21 @@ export interface ValueProvider<T = any> {
  * - The value requires complex initialization logic
  * - The value depends on other providers
  * - You need to create the value dynamically
- * - You want to return a Promise for async initialization
+ * - You need to compute the value synchronously from other providers
+ *
+ * The factory must return the value synchronously. Returning a promise throws
+ * `AsyncFactoryError`; move async setup into `onModuleInit` of the provided
+ * class, or create the value before bootstrap and register it with `useValue`.
  *
  * @template T - The type of value the factory creates
  *
  * @example
  * ```typescript
- * @NsModule({
+ * @Module({
  *   providers: [
  *     {
  *       provide: 'DATABASE',
- *       useFactory: async (config: Config) => {
- *         const db = await createConnection(config.dbUrl);
- *         await db.migrate();
- *         return db;
- *       },
+ *       useFactory: (config: Config) => createDatabase(config),
  *       inject: ['CONFIG'],
  *       scope: Scope.Singleton
  *     },
@@ -148,11 +145,11 @@ export interface ValueProvider<T = any> {
  */
 export interface FactoryProvider<T = any> {
     /** The injection token to register this provider under */
-    provide: InjectionToken;
-    /** The factory function that creates the value */
-    useFactory: (...args: any[]) => T | Promise<T>;
+    provide: ProviderToken;
+    /** Synchronous factory that creates the value; a returned promise throws AsyncFactoryError */
+    useFactory: (...args: any[]) => T;
     /** Tokens of dependencies to inject into the factory function */
-    inject?: InjectionToken[];
+    inject?: (ProviderToken | ForwardRef)[];
     /** The lifecycle scope (default: Singleton) */
     scope?: Scope;
 }

package/dist/types/interfaces/modules/container.interface.d.ts

@@ -1,8 +1,14 @@
-import type { ContainerBaseInterface } from "@nexus-ioc/shared";
-import type { Module } from "../module-types.interface";
-import type { ModuleGraphInterface } from "./module-graph.interface";
+import type { ContainerBaseInterface, LazyModule } from "@nexus-ioc/shared";
+import type { DynamicModule } from "../dynamic-module.interface";
+import type { Type } from "../type.interface";
+import type { GraphSegment, ModuleGraphInterface, UnloadResult } from "./module-graph.interface";
+import type { ParentLink } from "./parent-link.interface";
 export type { ContainerBaseInterface } from "@nexus-ioc/shared";
 export interface ContainerInterface extends ContainerBaseInterface {
-    run(rootModule: Module): Promise<void>;
+    run(rootModule: Type | DynamicModule, internalModules?: DynamicModule[], options?: {
+        link?: ParentLink;
+    }): Promise<void>;
+    load(lazyModule: LazyModule): Promise<GraphSegment>;
+    unload(lazyModule: LazyModule): Promise<UnloadResult>;
     graph: ModuleGraphInterface;
 }

package/dist/types/interfaces/modules/index.d.ts

@@ -4,4 +4,5 @@ export * from "./module-container-factory.interface";
 export * from "./module-graph.interface";
 export * from "./module-token-factory.interface";
 export * from "./modules-container.interface";
+export * from "./parent-link.interface";
 export * from "./provider-token-factory.interface";

package/dist/types/interfaces/modules/module-container-factory.interface.d.ts

@@ -1,7 +1,7 @@
 import type { DynamicModule } from "../dynamic-module.interface";
-import type { Module } from "../module-types.interface";
+import type { Type } from "../type.interface";
 import type { ContainerBaseInterface } from "./container.interface";
 import type { ModuleContainerInterface } from "./module-container.interface";
 export interface ModuleContainerFactoryInterface {
-    create(module: Module | DynamicModule, container: ContainerBaseInterface): Promise<ModuleContainerInterface>;
+    create(module: Type | DynamicModule, container: ContainerBaseInterface): Promise<ModuleContainerInterface>;
 }

package/dist/types/interfaces/modules/module-graph.interface.d.ts

@@ -1,39 +1,112 @@
-import type { GraphError } from "@nexus-ioc/shared";
+import type { GraphError, LazyModule, ModuleContainerInterface } from "@nexus-ioc/shared";
+import type { AnalyzeLazyModule } from "../../core/graph/analyze-lazy-module";
 import type { AnalyzeModule } from "../../core/graph/analyze-module";
 import type { AnalyzeProvider } from "../../core/graph/analyze-provider";
-import type { InjectionToken } from "../injection-token.interface";
+import type { ProviderToken } from "../injection-token.interface";
+import type { Type } from "../type.interface";
 export type { GraphError } from "@nexus-ioc/shared";
 export declare enum NodeTypeEnum {
     MODULE = "module",
-    PROVIDER = "provider"
+    PROVIDER = "provider",
+    LAZY = "lazy"
 }
 export declare enum EdgeTypeEnum {
     IMPORT = "import",
     EXPORT = "export",
     PROVIDER = "provider",
-    DEPENDENCY = "dependency"
+    DEPENDENCY = "dependency",
+    LAZY = "lazy"
 }
-export type Node = AnalyzeModule | AnalyzeProvider;
+export type Node = AnalyzeModule | AnalyzeProvider | AnalyzeLazyModule;
 export type Edge = {
     type: EdgeTypeEnum;
-    source: InjectionToken;
-    target: InjectionToken;
+    source: ProviderToken;
+    target: ProviderToken;
     metadata: {
         index?: number;
         key?: string;
-        inject?: "constructor" | "property";
+        inject?: "constructor" | "property" | "runtime";
         lazy?: boolean;
         isCircular?: boolean;
         unreached?: boolean;
+        /**
+         * The dependency is satisfied by the parent container chain (a child
+         * graph only); its target is not resolved in this graph.
+         */
+        external?: boolean;
+        /**
+         * An `@Optional()` dependency whose target was not visible from the
+         * source's module when the edge was compiled (it may not have existed
+         * yet). Set only when true. The resolver injects the target only
+         * while it exists and is visible from the source's module.
+         */
+        lateBound?: boolean;
     };
 };
+export interface ModuleGraphOptions {
+    /**
+     * Whether the parent container chain can provide `token`. Consulted only
+     * when a dependency is not visible locally.
+     */
+    externalLookup?: (token: ProviderToken) => boolean;
+}
+/**
+ * The part of the graph added by a single lazy module load.
+ * A non-empty `errors` list means the segment was rolled back and none of
+ * its nodes or edges remain in the graph.
+ */
+export interface GraphSegment {
+    lazyModule: LazyModule;
+    moduleContainer: ModuleContainerInterface;
+    /** Module node ids added by this segment. */
+    moduleTokens: string[];
+    /** Provider node ids added by this segment. */
+    providerTokens: ProviderToken[];
+    errors: GraphError[];
+}
+/** What `ModuleGraph.unloadSegment` removed from the graph. */
+export interface SegmentUnloadResult {
+    destroyedModules: string[];
+    destroyedProviders: ProviderToken[];
+}
+/** What unloading a lazy module did. */
+export interface UnloadResult extends SegmentUnloadResult {
+    /**
+     * Child applications this unload started closing because the module
+     * that declared them in `@Module({ children })` was destroyed. A child
+     * whose close failed still counts; a child that was already closing
+     * (its own `close()`) does not, though the unload still waits for it.
+     */
+    closedChildren: number;
+}
 export interface ModuleGraphInterface {
     compile(): Promise<void>;
-    getNode(token: InjectionToken): Node | undefined;
-    getEdge(token: InjectionToken): Edge[];
+    compileSegment(root: ModuleContainerInterface, lazyModule: LazyModule): Promise<GraphSegment>;
+    unloadSegment(lazyModule: LazyModule, protectedRoots: Set<string>): SegmentUnloadResult;
+    isProviderVisible(moduleContainer: ModuleContainerInterface, token: ProviderToken): boolean;
+    isProviderExported(moduleContainer: ModuleContainerInterface, token: ProviderToken): Promise<boolean>;
+    /**
+     * Records a dependency discovered at runtime by `inject()`. Idempotent;
+     * keeps the target's module alive while the source's module is loaded.
+     */
+    addRuntimeDependency(source: ProviderToken, target: ProviderToken): void;
+    /**
+     * The container of the module that declares `child` in `@Module({ children })`,
+     * including modules of loaded lazy segments.
+     */
+    findChildDeclaration(child: Type | LazyModule): ModuleContainerInterface | undefined;
+    getNode(token: ProviderToken): Node | undefined;
+    getEdge(token: ProviderToken): Edge[];
     getAllNodes(): Node[];
     getAllEdges(): Edge[][];
-    nodes: Map<InjectionToken, Node>;
-    edges: Map<InjectionToken, Edge[]>;
+    nodes: Map<ProviderToken, Node>;
+    edges: Map<ProviderToken, Edge[]>;
+    rootToken: string;
+    internalRootTokens: string[];
     errors: GraphError[];
+    /**
+     * Changes whenever a compile, segment load or unload may have changed
+     * which providers exist or are visible; lets callers cache visibility.
+     */
+    readonly version: number;
 }

package/dist/types/interfaces/modules/module-token-factory.interface.d.ts

@@ -1,5 +1,5 @@
 import type { DynamicModule } from "../dynamic-module.interface";
-import type { Module } from "../module-types.interface";
+import type { Type } from "../type.interface";
 export interface ModuleTokenFactoryInterface {
-    create(metatype: Module | DynamicModule): Promise<string>;
+    create(metatype: Type | DynamicModule): Promise<string>;
 }

package/dist/types/interfaces/modules/modules-container.interface.d.ts

@@ -1,8 +1,9 @@
 import type { DynamicModule } from "../dynamic-module.interface";
-import type { Module } from "../module-types.interface";
+import type { Type } from "../type.interface";
 import type { ModuleContainerInterface } from "./module-container.interface";
 export interface ModulesContainerInterface {
-    addModule(module: Module | DynamicModule): Promise<ModuleContainerInterface>;
-    replaceModule(moduleToReplace: Module, newModule: Module): Promise<ModuleContainerInterface>;
-    getModule(module: Module): ModuleContainerInterface | undefined;
+    addModule(module: Type | DynamicModule): Promise<ModuleContainerInterface>;
+    replaceModule(moduleToReplace: Type, newModule: Type): Promise<ModuleContainerInterface>;
+    getModule(module: Type): ModuleContainerInterface | undefined;
+    removeModule(token: string): void;
 }

package/dist/types/interfaces/modules/parent-link.interface.d.ts

@@ -0,0 +1,12 @@
+import type { ProviderToken } from "../injection-token.interface";
+import type { Provider } from "../module-types.interface";
+/** What a child container may take from its parent chain. */
+export interface ParentLink {
+    canProvide(token: ProviderToken): boolean;
+    get<T>(token: ProviderToken<T>): T;
+    resolve<T>(token: ProviderToken<T>): Promise<T>;
+}
+export interface CreateChildOptions {
+    /** Extra providers appended to the child root module (e.g. per-instance config). */
+    providers?: Provider[];
+}

package/dist/types/interfaces/nexus-application.interface.d.ts

@@ -1,10 +1,53 @@
-import type { InjectionToken } from "./injection-token.interface";
-import type { GraphError } from "./modules";
+import type { GetOptions, LazyModule } from "@nexus-ioc/shared";
+import type { ModuleRef } from "../core/module-ref";
+import type { DynamicModule } from "./dynamic-module.interface";
+import type { ProviderToken } from "./injection-token.interface";
+import type { CreateChildOptions, GraphError, UnloadResult } from "./modules";
 import type { ModulePluginInterface } from "./plugins";
+import type { Type } from "./type.interface";
+export interface BootstrapOptions {
+    throwOnError?: boolean;
+}
+export type { GetOptions } from "@nexus-ioc/shared";
 export interface NexusApplicationInterface extends ModulePluginInterface {
-    bootstrap(): Promise<this>;
-    get<T>(token: InjectionToken): Promise<T | undefined>;
-    setParent(parentContainer: NexusApplicationInterface): this;
-    async(): this;
+    bootstrap(options?: BootstrapOptions): Promise<this>;
+    close(): Promise<void>;
+    /**
+     * Returns an already created singleton. `T` is inferred from class and
+     * `InjectionToken<T>` tokens; string and symbol tokens give `unknown`
+     * unless `<T>` is passed or the expected type supplies it.
+     *
+     * @param token - The provider token: class, InjectionToken, string or symbol
+     */
+    get<T>(token: ProviderToken<T>): T;
+    get<T>(token: ProviderToken<T>, options: {
+        optional: true;
+    }): T | undefined;
+    get<T>(token: ProviderToken<T>, options: {
+        optional?: false;
+    }): T;
+    get<T>(token: ProviderToken<T>, options: GetOptions): T | undefined;
+    /**
+     * Resolves a provider, creating it on demand (Transient, lazy
+     * mode). `T` is inferred from the token as for `get()`.
+     *
+     * @param token - The provider token: class, InjectionToken, string or symbol
+     */
+    resolve<T>(token: ProviderToken<T>): Promise<T>;
+    resolve<T>(token: ProviderToken<T>, options: {
+        optional: true;
+    }): Promise<T | undefined>;
+    resolve<T>(token: ProviderToken<T>, options: {
+        optional?: false;
+    }): Promise<T>;
+    resolve<T>(token: ProviderToken<T>, options: GetOptions): Promise<T | undefined>;
+    load(lazyModule: LazyModule): Promise<ModuleRef>;
+    unload(ref: ModuleRef): Promise<UnloadResult>;
+    /**
+     * Creates a bootstrapped child application for a module declared in
+     * `@Module({ children })` of this application's graph.
+     */
+    createChild(child: Type | DynamicModule | LazyModule, options?: CreateChildOptions): Promise<NexusApplicationInterface>;
+    lazy(): this;
     errors: GraphError[];
 }

package/dist/types/interfaces/on-module-destroy.interface.d.ts

@@ -0,0 +1,3 @@
+export interface OnModuleDestroy {
+    onModuleDestroy(): void | Promise<void>;
+}

package/dist/types/interfaces/plugins/scanner-plugin.interface.d.ts

@@ -1,5 +1,5 @@
 import type { ModuleGraphInterface } from "../modules";
-export interface ScannerGraphInterface extends Omit<ModuleGraphInterface, "compile" | "nodes" | "edges"> {
+export interface ScannerGraphInterface extends Omit<ModuleGraphInterface, "compile" | "compileSegment" | "unloadSegment" | "nodes" | "edges"> {
 }
 export interface ScannerPluginInterface {
     scan(graph: ScannerGraphInterface): Promise<void>;