@depup/nestjs__core 11.1.17-depup.0

package/hooks/before-app-shutdown.hook.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callBeforeAppShutdownHook = callBeforeAppShutdownHook;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const transient_instances_1 = require("../injector/helpers/transient-instances");
+/**
+ * Checks if the given instance has the `beforeApplicationShutdown` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasBeforeApplicationShutdownHook(instance) {
+    return (0, shared_utils_1.isFunction)(instance.beforeApplicationShutdown);
+}
+/**
+ * Calls the given instances
+ */
+function callOperator(instances, signal) {
+    return (0, iterare_1.iterate)(instances)
+        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+        .filter(hasBeforeApplicationShutdownHook)
+        .map(async (instance) => instance.beforeApplicationShutdown(signal))
+        .toArray();
+}
+/**
+ * Calls the `beforeApplicationShutdown` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ * @param signal The signal which caused the shutdown
+ */
+async function callBeforeAppShutdownHook(module, signal) {
+    const providers = module.getNonAliasProviders();
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [
+        ...module.controllers,
+        ...providers,
+        ...module.injectables,
+        ...module.middlewares,
+    ];
+    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances, signal));
+    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances, signal));
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance &&
+        hasBeforeApplicationShutdownHook(moduleClassInstance) &&
+        moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.beforeApplicationShutdown(signal);
+    }
+}

package/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './on-app-bootstrap.hook';
+export * from './on-app-shutdown.hook';
+export * from './on-module-destroy.hook';
+export * from './on-module-init.hook';
+export * from './before-app-shutdown.hook';

package/hooks/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./on-app-bootstrap.hook"), exports);
+tslib_1.__exportStar(require("./on-app-shutdown.hook"), exports);
+tslib_1.__exportStar(require("./on-module-destroy.hook"), exports);
+tslib_1.__exportStar(require("./on-module-init.hook"), exports);
+tslib_1.__exportStar(require("./before-app-shutdown.hook"), exports);

package/hooks/on-app-bootstrap.hook.d.ts

@@ -0,0 +1,8 @@
+import { Module } from '../injector/module';
+/**
+ * Calls the `onApplicationBootstrap` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+export declare function callModuleBootstrapHook(module: Module): Promise<any>;

package/hooks/on-app-bootstrap.hook.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callModuleBootstrapHook = callModuleBootstrapHook;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const transient_instances_1 = require("../injector/helpers/transient-instances");
+/**
+ * Checks if the given instance has the `onApplicationBootstrap` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasOnAppBootstrapHook(instance) {
+    return (0, shared_utils_1.isFunction)(instance.onApplicationBootstrap);
+}
+/**
+ * Calls the given instances
+ */
+function callOperator(instances) {
+    return (0, iterare_1.iterate)(instances)
+        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+        .filter(hasOnAppBootstrapHook)
+        .map(async (instance) => instance.onApplicationBootstrap())
+        .toArray();
+}
+/**
+ * Calls the `onApplicationBootstrap` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+async function callModuleBootstrapHook(module) {
+    const providers = module.getNonAliasProviders();
+    // Module (class) instance is the first element of the providers array
+    // Lifecycle hook has to be called once all classes are properly initialized
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [
+        ...module.controllers,
+        ...providers,
+        ...module.injectables,
+        ...module.middlewares,
+    ];
+    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances));
+    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances));
+    // Call the instance itself
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance &&
+        hasOnAppBootstrapHook(moduleClassInstance) &&
+        moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.onApplicationBootstrap();
+    }
+}

package/hooks/on-app-shutdown.hook.d.ts

@@ -0,0 +1,9 @@
+import { Module } from '../injector/module';
+/**
+ * Calls the `onApplicationShutdown` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ * @param signal
+ */
+export declare function callAppShutdownHook(module: Module, signal?: string): Promise<any>;

package/hooks/on-app-shutdown.hook.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callAppShutdownHook = callAppShutdownHook;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const transient_instances_1 = require("../injector/helpers/transient-instances");
+/**
+ * Checks if the given instance has the `onApplicationShutdown` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasOnAppShutdownHook(instance) {
+    return (0, shared_utils_1.isFunction)(instance.onApplicationShutdown);
+}
+/**
+ * Calls the given instances
+ */
+function callOperator(instances, signal) {
+    return (0, iterare_1.iterate)(instances)
+        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+        .filter(hasOnAppShutdownHook)
+        .map(async (instance) => instance.onApplicationShutdown(signal))
+        .toArray();
+}
+/**
+ * Calls the `onApplicationShutdown` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ * @param signal
+ */
+async function callAppShutdownHook(module, signal) {
+    const providers = module.getNonAliasProviders();
+    // Module (class) instance is the first element of the providers array
+    // Lifecycle hook has to be called once all classes are properly initialized
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [
+        ...module.controllers,
+        ...providers,
+        ...module.injectables,
+        ...module.middlewares,
+    ];
+    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances, signal));
+    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances, signal));
+    // Call the instance itself
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance &&
+        hasOnAppShutdownHook(moduleClassInstance) &&
+        moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.onApplicationShutdown(signal);
+    }
+}

package/hooks/on-module-destroy.hook.d.ts

@@ -0,0 +1,8 @@
+import { Module } from '../injector/module';
+/**
+ * Calls the `onModuleDestroy` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+export declare function callModuleDestroyHook(module: Module): Promise<any>;

package/hooks/on-module-destroy.hook.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callModuleDestroyHook = callModuleDestroyHook;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const transient_instances_1 = require("../injector/helpers/transient-instances");
+/**
+ * Returns true or false if the given instance has a `onModuleDestroy` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasOnModuleDestroyHook(instance) {
+    return (0, shared_utils_1.isFunction)(instance.onModuleDestroy);
+}
+/**
+ * Calls the given instances onModuleDestroy hook
+ */
+function callOperator(instances) {
+    return (0, iterare_1.iterate)(instances)
+        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+        .filter(hasOnModuleDestroyHook)
+        .map(async (instance) => instance.onModuleDestroy())
+        .toArray();
+}
+/**
+ * Calls the `onModuleDestroy` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+async function callModuleDestroyHook(module) {
+    const providers = module.getNonAliasProviders();
+    // Module (class) instance is the first element of the providers array
+    // Lifecycle hook has to be called once all classes are properly destroyed
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [
+        ...module.controllers,
+        ...providers,
+        ...module.injectables,
+        ...module.middlewares,
+    ];
+    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances));
+    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances));
+    // Call the module instance itself
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance &&
+        hasOnModuleDestroyHook(moduleClassInstance) &&
+        moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.onModuleDestroy();
+    }
+}

package/hooks/on-module-init.hook.d.ts

@@ -0,0 +1,8 @@
+import { Module } from '../injector/module';
+/**
+ * Calls the `onModuleInit` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+export declare function callModuleInitHook(module: Module): Promise<void>;

package/hooks/on-module-init.hook.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callModuleInitHook = callModuleInitHook;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const transient_instances_1 = require("../injector/helpers/transient-instances");
+/**
+ * Returns true or false if the given instance has a `onModuleInit` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasOnModuleInitHook(instance) {
+    return (0, shared_utils_1.isFunction)(instance.onModuleInit);
+}
+/**
+ * Calls the given instances
+ */
+function callOperator(instances) {
+    return (0, iterare_1.iterate)(instances)
+        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+        .filter(hasOnModuleInitHook)
+        .map(async (instance) => instance.onModuleInit())
+        .toArray();
+}
+/**
+ * Calls the `onModuleInit` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+async function callModuleInitHook(module) {
+    const providers = module.getNonAliasProviders();
+    // Module (class) instance is the first element of the providers array
+    // Lifecycle hook has to be called once all classes are properly initialized
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [
+        ...module.controllers,
+        ...providers,
+        ...module.injectables,
+        ...module.middlewares,
+    ];
+    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances));
+    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances));
+    // Call the instance itself
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance &&
+        hasOnModuleInitHook(moduleClassInstance) &&
+        moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.onModuleInit();
+    }
+}

package/hooks/utils/get-instances-grouped-by-hierarchy-level.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@nestjs/common';
+import { InstanceWrapper } from '../../injector/instance-wrapper.js';
+export declare function getInstancesGroupedByHierarchyLevel(...collections: Array<Map<InjectionToken, InstanceWrapper> | Array<[InjectionToken, InstanceWrapper]>>): Map<number, unknown[]>;

package/hooks/utils/get-instances-grouped-by-hierarchy-level.js

@@ -0,0 +1,27 @@
+export function getInstancesGroupedByHierarchyLevel(...collections) {
+    const groupedByHierarchyLevel = new Map();
+    for (const collection of collections) {
+        for (const [_, wrapper] of collection) {
+            if (!wrapper.isDependencyTreeStatic()) {
+                continue;
+            }
+            const level = wrapper.hierarchyLevel;
+            if (!groupedByHierarchyLevel.has(level)) {
+                groupedByHierarchyLevel.set(level, []);
+            }
+            const byHierarchyLevelGroup = groupedByHierarchyLevel.get(level);
+            if (wrapper.isTransient) {
+                const staticTransientInstances = wrapper
+                    .getStaticTransientInstances()
+                    .filter(i => !!i)
+                    .map(i => i.instance);
+                byHierarchyLevelGroup.push(...staticTransientInstances);
+                continue;
+            }
+            if (wrapper.instance) {
+                byHierarchyLevelGroup.push(wrapper.instance);
+            }
+        }
+    }
+    return groupedByHierarchyLevel;
+}

package/hooks/utils/get-sorted-hierarchy-levels.d.ts

@@ -0,0 +1 @@
+export declare function getSortedHierarchyLevels(groups: Map<number, unknown[]>, order?: 'ASC' | 'DESC'): number[];

package/hooks/utils/get-sorted-hierarchy-levels.js

@@ -0,0 +1,7 @@
+export function getSortedHierarchyLevels(groups, order = 'ASC') {
+    const comparator = order === 'ASC'
+        ? (a, b) => a - b
+        : (a, b) => b - a;
+    const levels = Array.from(groups.keys()).sort(comparator);
+    return levels;
+}

package/index.d.ts

@@ -0,0 +1,17 @@
+import 'reflect-metadata';
+export * from './adapters';
+export * from './application-config';
+export { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_PIPE } from './constants';
+export * from './discovery';
+export * from './exceptions';
+export * from './helpers';
+export * from './injector';
+export * from './inspector';
+export * from './metadata-scanner';
+export * from './middleware';
+export * from './nest-application';
+export * from './nest-application-context';
+export { NestFactory } from './nest-factory';
+export * from './repl';
+export * from './router';
+export * from './services';

package/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestFactory = exports.APP_PIPE = exports.APP_INTERCEPTOR = exports.APP_GUARD = exports.APP_FILTER = void 0;
+const tslib_1 = require("tslib");
+/*
+ * Nest @core
+ * Copyright(c) 2017 - 2025 Kamil Mysliwiec
+ * https://nestjs.com
+ * MIT Licensed
+ */
+require("reflect-metadata");
+tslib_1.__exportStar(require("./adapters"), exports);
+tslib_1.__exportStar(require("./application-config"), exports);
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "APP_FILTER", { enumerable: true, get: function () { return constants_1.APP_FILTER; } });
+Object.defineProperty(exports, "APP_GUARD", { enumerable: true, get: function () { return constants_1.APP_GUARD; } });
+Object.defineProperty(exports, "APP_INTERCEPTOR", { enumerable: true, get: function () { return constants_1.APP_INTERCEPTOR; } });
+Object.defineProperty(exports, "APP_PIPE", { enumerable: true, get: function () { return constants_1.APP_PIPE; } });
+tslib_1.__exportStar(require("./discovery"), exports);
+tslib_1.__exportStar(require("./exceptions"), exports);
+tslib_1.__exportStar(require("./helpers"), exports);
+tslib_1.__exportStar(require("./injector"), exports);
+tslib_1.__exportStar(require("./inspector"), exports);
+tslib_1.__exportStar(require("./metadata-scanner"), exports);
+tslib_1.__exportStar(require("./middleware"), exports);
+tslib_1.__exportStar(require("./nest-application"), exports);
+tslib_1.__exportStar(require("./nest-application-context"), exports);
+var nest_factory_1 = require("./nest-factory");
+Object.defineProperty(exports, "NestFactory", { enumerable: true, get: function () { return nest_factory_1.NestFactory; } });
+tslib_1.__exportStar(require("./repl"), exports);
+tslib_1.__exportStar(require("./router"), exports);
+tslib_1.__exportStar(require("./services"), exports);

package/injector/abstract-instance-resolver.d.ts

@@ -0,0 +1,16 @@
+import { Abstract, Type } from '@nestjs/common';
+import { GetOrResolveOptions } from '@nestjs/common/interfaces';
+import { Injector } from './injector';
+import { InstanceLinksHost } from './instance-links-host';
+import { ContextId } from './instance-wrapper';
+import { Module } from './module';
+export declare abstract class AbstractInstanceResolver {
+    protected abstract instanceLinksHost: InstanceLinksHost;
+    protected abstract injector: Injector;
+    protected abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options?: GetOrResolveOptions): TResult | Array<TResult>;
+    protected find<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Abstract<TInput> | string | symbol, options: {
+        moduleId?: string;
+        each?: boolean;
+    }): TResult | Array<TResult>;
+    protected resolvePerContext<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Abstract<TInput> | string | symbol, contextModule: Module, contextId: ContextId, options?: GetOrResolveOptions): Promise<TResult | Array<TResult>>;
+}

package/injector/abstract-instance-resolver.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractInstanceResolver = void 0;
+const common_1 = require("@nestjs/common");
+const exceptions_1 = require("../errors/exceptions");
+class AbstractInstanceResolver {
+    find(typeOrToken, options) {
+        const instanceLinkOrArray = this.instanceLinksHost.get(typeOrToken, options);
+        const pluckInstance = ({ wrapperRef }) => {
+            if (wrapperRef.scope === common_1.Scope.REQUEST ||
+                wrapperRef.scope === common_1.Scope.TRANSIENT ||
+                !wrapperRef.isDependencyTreeStatic()) {
+                throw new exceptions_1.InvalidClassScopeException(typeOrToken);
+            }
+            return wrapperRef.instance;
+        };
+        if (Array.isArray(instanceLinkOrArray)) {
+            return instanceLinkOrArray.map(pluckInstance);
+        }
+        return pluckInstance(instanceLinkOrArray);
+    }
+    async resolvePerContext(typeOrToken, contextModule, contextId, options) {
+        const instanceLinkOrArray = options?.strict
+            ? this.instanceLinksHost.get(typeOrToken, {
+                moduleId: contextModule.id,
+                each: options.each,
+            })
+            : this.instanceLinksHost.get(typeOrToken, {
+                each: options?.each,
+            });
+        const pluckInstance = async (instanceLink) => {
+            const { wrapperRef, collection } = instanceLink;
+            if (wrapperRef.isDependencyTreeStatic() && !wrapperRef.isTransient) {
+                return wrapperRef.instance;
+            }
+            const ctorHost = wrapperRef.instance || { constructor: typeOrToken };
+            const instance = await this.injector.loadPerContext(ctorHost, wrapperRef.host, collection, contextId, wrapperRef);
+            if (!instance) {
+                throw new exceptions_1.UnknownElementException();
+            }
+            return instance;
+        };
+        if (Array.isArray(instanceLinkOrArray)) {
+            return Promise.all(instanceLinkOrArray.map(instanceLink => pluckInstance(instanceLink)));
+        }
+        return pluckInstance(instanceLinkOrArray);
+    }
+}
+exports.AbstractInstanceResolver = AbstractInstanceResolver;

package/injector/compiler.d.ts

@@ -0,0 +1,18 @@
+import { DynamicModule, ForwardReference, Type } from '@nestjs/common/interfaces';
+import { ModuleOpaqueKeyFactory } from './opaque-key-factory/interfaces/module-opaque-key-factory.interface';
+export interface ModuleFactory {
+    type: Type<any>;
+    token: string;
+    dynamicMetadata?: Partial<DynamicModule>;
+}
+export declare class ModuleCompiler {
+    private readonly _moduleOpaqueKeyFactory;
+    constructor(_moduleOpaqueKeyFactory: ModuleOpaqueKeyFactory);
+    get moduleOpaqueKeyFactory(): ModuleOpaqueKeyFactory;
+    compile(moduleClsOrDynamic: Type | DynamicModule | ForwardReference | Promise<DynamicModule>): Promise<ModuleFactory>;
+    extractMetadata(moduleClsOrDynamic: Type | ForwardReference | DynamicModule): {
+        type: Type;
+        dynamicMetadata: Omit<DynamicModule, 'module'> | undefined;
+    };
+    isDynamicModule(moduleClsOrDynamic: Type | DynamicModule | ForwardReference): moduleClsOrDynamic is DynamicModule;
+}

package/injector/compiler.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleCompiler = void 0;
+class ModuleCompiler {
+    constructor(_moduleOpaqueKeyFactory) {
+        this._moduleOpaqueKeyFactory = _moduleOpaqueKeyFactory;
+    }
+    get moduleOpaqueKeyFactory() {
+        return this._moduleOpaqueKeyFactory;
+    }
+    async compile(moduleClsOrDynamic) {
+        moduleClsOrDynamic = await moduleClsOrDynamic;
+        const { type, dynamicMetadata } = this.extractMetadata(moduleClsOrDynamic);
+        const token = dynamicMetadata
+            ? this._moduleOpaqueKeyFactory.createForDynamic(type, dynamicMetadata, moduleClsOrDynamic)
+            : this._moduleOpaqueKeyFactory.createForStatic(type, moduleClsOrDynamic);
+        return { type, dynamicMetadata, token };
+    }
+    extractMetadata(moduleClsOrDynamic) {
+        if (!this.isDynamicModule(moduleClsOrDynamic)) {
+            return {
+                type: moduleClsOrDynamic?.forwardRef
+                    ? moduleClsOrDynamic.forwardRef()
+                    : moduleClsOrDynamic,
+                dynamicMetadata: undefined,
+            };
+        }
+        const { module: type, ...dynamicMetadata } = moduleClsOrDynamic;
+        return { type, dynamicMetadata };
+    }
+    isDynamicModule(moduleClsOrDynamic) {
+        return !!moduleClsOrDynamic.module;
+    }
+}
+exports.ModuleCompiler = ModuleCompiler;

package/injector/constants.d.ts

@@ -0,0 +1,3 @@
+import { ContextId } from './instance-wrapper';
+export declare const CONTROLLER_ID_KEY = "CONTROLLER_ID";
+export declare const STATIC_CONTEXT: ContextId;

package/injector/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATIC_CONTEXT = exports.CONTROLLER_ID_KEY = void 0;
+exports.CONTROLLER_ID_KEY = 'CONTROLLER_ID';
+const STATIC_CONTEXT_ID = 1;
+exports.STATIC_CONTEXT = Object.freeze({
+    id: STATIC_CONTEXT_ID,
+});

package/injector/container.d.ts

@@ -0,0 +1,67 @@
+import { DynamicModule, Provider } from '@nestjs/common';
+import { EnhancerSubtype } from '@nestjs/common/constants';
+import { Injectable, Type } from '@nestjs/common/interfaces';
+import { NestApplicationContextOptions } from '@nestjs/common/interfaces/nest-application-context-options.interface';
+import { ApplicationConfig } from '../application-config';
+import { SerializedGraph } from '../inspector/serialized-graph';
+import { ModuleCompiler } from './compiler';
+import { ContextId } from './instance-wrapper';
+import { Module } from './module';
+import { ModulesContainer } from './modules-container';
+import { ModuleOpaqueKeyFactory } from './opaque-key-factory/interfaces/module-opaque-key-factory.interface';
+type ModuleMetatype = Type<any> | DynamicModule | Promise<DynamicModule>;
+type ModuleScope = Type<any>[];
+export declare class NestContainer {
+    private readonly _applicationConfig;
+    private readonly _contextOptions;
+    private readonly globalModules;
+    private readonly modules;
+    private readonly dynamicModulesMetadata;
+    private readonly internalProvidersStorage;
+    private readonly _serializedGraph;
+    private moduleCompiler;
+    private internalCoreModule;
+    constructor(_applicationConfig?: ApplicationConfig | undefined, _contextOptions?: NestApplicationContextOptions | undefined);
+    get serializedGraph(): SerializedGraph;
+    get applicationConfig(): ApplicationConfig | undefined;
+    get contextOptions(): NestApplicationContextOptions | undefined;
+    setHttpAdapter(httpAdapter: any): void;
+    getHttpAdapterRef(): import("..").AbstractHttpAdapter<any, any, any>;
+    getHttpAdapterHostRef(): import("..").HttpAdapterHost<import("..").AbstractHttpAdapter<any, any, any>>;
+    addModule(metatype: ModuleMetatype, scope: ModuleScope): Promise<{
+        moduleRef: Module;
+        inserted: boolean;
+    } | undefined>;
+    replaceModule(metatypeToReplace: ModuleMetatype, newMetatype: ModuleMetatype, scope: ModuleScope): Promise<{
+        moduleRef: Module;
+        inserted: boolean;
+    } | undefined>;
+    private setModule;
+    addDynamicMetadata(token: string, dynamicModuleMetadata: Partial<DynamicModule>, scope: Type<any>[]): Promise<void>;
+    addDynamicModules(modules: any[], scope: Type<any>[]): Promise<void>;
+    isGlobalModule(metatype: Type<any>, dynamicMetadata?: Partial<DynamicModule>): boolean;
+    addGlobalModule(module: Module): void;
+    getModules(): ModulesContainer;
+    getModuleCompiler(): ModuleCompiler;
+    getModuleByKey(moduleKey: string): Module | undefined;
+    getInternalCoreModuleRef(): Module | undefined;
+    addImport(relatedModule: Type<any> | DynamicModule, token: string): Promise<void>;
+    addProvider(provider: Provider, token: string, enhancerSubtype?: EnhancerSubtype): string | symbol | Function;
+    addInjectable(injectable: Provider, token: string, enhancerSubtype: EnhancerSubtype, host?: Type<Injectable>): string | symbol | Function | import("./instance-wrapper").InstanceWrapper<unknown>;
+    addExportedProviderOrModule(toExport: Type<any> | DynamicModule, token: string): void;
+    addController(controller: Type<any>, token: string): void;
+    clear(): void;
+    replace(toReplace: any, options: {
+        scope: any[] | null;
+    }): void;
+    bindGlobalScope(): void;
+    bindGlobalsToImports(moduleRef: Module): void;
+    bindGlobalModuleToModule(target: Module, globalModule: Module): void;
+    getDynamicMetadataByToken(token: string): Partial<DynamicModule>;
+    getDynamicMetadataByToken<K extends Exclude<keyof DynamicModule, 'global' | 'module'>>(token: string, metadataKey: K): DynamicModule[K];
+    registerCoreModuleRef(moduleRef: Module): void;
+    getModuleTokenFactory(): ModuleOpaqueKeyFactory;
+    registerRequestProvider<T = any>(request: T, contextId: ContextId): void;
+    private shouldInitOnPreview;
+}
+export {};