@venok/core 1.0.0

package/injector/module/container.d.ts

@@ -0,0 +1,6 @@
+import { Module } from "./module";
+export declare class ModulesContainer extends Map<string, Module> {
+    #private;
+    get applicationId(): string;
+    getById(id: string): Module | undefined;
+}

package/injector/module/container.js

@@ -0,0 +1,24 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ModulesContainer_applicationId;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModulesContainer = void 0;
+const uid_1 = require("uid");
+class ModulesContainer extends Map {
+    constructor() {
+        super(...arguments);
+        _ModulesContainer_applicationId.set(this, (0, uid_1.uid)(21));
+    }
+    get applicationId() {
+        return __classPrivateFieldGet(this, _ModulesContainer_applicationId, "f");
+    }
+    getById(id) {
+        return Array.from(this.values()).find((moduleRef) => moduleRef.id === id);
+    }
+}
+exports.ModulesContainer = ModulesContainer;
+_ModulesContainer_applicationId = new WeakMap();

package/injector/module/lazy/loader.d.ts

@@ -0,0 +1,21 @@
+import { InstanceLoader } from "@venok/core/injector/instance/loader";
+import { ModuleCompiler } from "@venok/core/injector/module/compiler";
+import { ModulesContainer } from "@venok/core/injector/module/container";
+import { DynamicModule } from "@venok/core/interfaces/modules";
+import { Type } from "@venok/core/interfaces";
+import { ModuleRef } from "@venok/core/injector/module/ref";
+import { LazyModuleLoaderLoadOptions } from "@venok/core/injector/module/lazy/options";
+import { ModuleOverride } from "@venok/core/interfaces/modules/override.interface";
+import { DependenciesScanner } from "@venok/core/scanner";
+export declare class LazyModuleLoader {
+    private readonly dependenciesScanner;
+    private readonly instanceLoader;
+    private readonly moduleCompiler;
+    private readonly modulesContainer;
+    private readonly moduleOverrides?;
+    constructor(dependenciesScanner: DependenciesScanner, instanceLoader: InstanceLoader, moduleCompiler: ModuleCompiler, modulesContainer: ModulesContainer, moduleOverrides?: ModuleOverride[] | undefined);
+    load(loaderFn: () => Promise<Type<unknown> | DynamicModule> | Type<unknown> | DynamicModule, loadOpts?: LazyModuleLoaderLoadOptions): Promise<ModuleRef>;
+    private registerLoggerConfiguration;
+    private createLazyModulesContainer;
+    private getTargetModuleRef;
+}

package/injector/module/lazy/loader.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyModuleLoader = void 0;
+const ref_1 = require("@venok/core/injector/module/ref");
+const silent_helper_1 = require("@venok/core/helpers/silent.helper");
+class LazyModuleLoader {
+    constructor(dependenciesScanner, instanceLoader, moduleCompiler, modulesContainer, moduleOverrides) {
+        this.dependenciesScanner = dependenciesScanner;
+        this.instanceLoader = instanceLoader;
+        this.moduleCompiler = moduleCompiler;
+        this.modulesContainer = modulesContainer;
+        this.moduleOverrides = moduleOverrides;
+    }
+    async load(loaderFn, loadOpts) {
+        this.registerLoggerConfiguration(loadOpts);
+        const moduleClassOrDynamicDefinition = await loaderFn();
+        const moduleInstances = await this.dependenciesScanner.scanForModules({
+            moduleDefinition: moduleClassOrDynamicDefinition,
+            overrides: this.moduleOverrides,
+            lazy: true,
+        });
+        if (moduleInstances.length === 0) {
+            // The module has been loaded already. In this case, we must
+            // retrieve a module reference from the existing container.
+            const { token } = await this.moduleCompiler.compile(moduleClassOrDynamicDefinition);
+            const moduleInstance = this.modulesContainer.get(token);
+            return moduleInstance && this.getTargetModuleRef(moduleInstance);
+        }
+        const lazyModulesContainer = this.createLazyModulesContainer(moduleInstances);
+        await this.dependenciesScanner.scanModulesForDependencies(lazyModulesContainer);
+        await this.instanceLoader.createInstancesOfDependencies(lazyModulesContainer);
+        const [targetModule] = moduleInstances;
+        return this.getTargetModuleRef(targetModule);
+    }
+    registerLoggerConfiguration(loadOpts) {
+        if (loadOpts?.logger === false) {
+            this.instanceLoader.setLogger(new silent_helper_1.SilentLogger());
+        }
+    }
+    createLazyModulesContainer(moduleInstances) {
+        moduleInstances = Array.from(new Set(moduleInstances));
+        return new Map(moduleInstances.map((ref) => [ref.token, ref]));
+    }
+    getTargetModuleRef(moduleInstance) {
+        const moduleRefInstanceWrapper = moduleInstance.getProviderByKey(ref_1.ModuleRef);
+        return moduleRefInstanceWrapper.instance;
+    }
+}
+exports.LazyModuleLoader = LazyModuleLoader;

package/injector/module/lazy/options.d.ts

@@ -0,0 +1,6 @@
+export interface LazyModuleLoaderLoadOptions {
+    /**
+     * If `false`, no logs will be generated when loading some module lazily.
+     */
+    logger?: boolean;
+}

package/injector/module/lazy/options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/injector/module/module.d.ts

@@ -0,0 +1,74 @@
+import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+import { ClassProvider, DynamicModule, ExistingProvider, FactoryProvider, InjectionToken, Provider, ValueProvider, VenokModule } from "@venok/core/interfaces/modules";
+import { Type } from "@venok/core/interfaces";
+import { EnhancerSubtype } from "@venok/core/constants";
+import { ModuleRef } from "@venok/core/injector/module/ref";
+import { VenokContainer } from "@venok/core/injector/container";
+import { Injectable } from "@venok/core/interfaces/injectable.interface";
+export declare class Module {
+    private readonly _metatype;
+    private readonly container;
+    private readonly _id;
+    private readonly _imports;
+    private readonly _providers;
+    private readonly _injectables;
+    private readonly _entryProviderKeys;
+    private readonly _exports;
+    private _distance;
+    private _initOnPreview;
+    private _isGlobal;
+    private _token;
+    constructor(_metatype: Type<any>, container: VenokContainer);
+    get id(): string;
+    get token(): string;
+    set token(token: string);
+    get name(): string;
+    get isGlobal(): boolean;
+    set isGlobal(global: boolean);
+    get initOnPreview(): boolean;
+    set initOnPreview(initOnPreview: boolean);
+    get providers(): Map<InjectionToken, InstanceWrapper<Injectable>>;
+    get imports(): Set<Module>;
+    get injectables(): Map<InjectionToken, InstanceWrapper<Injectable>>;
+    get entryProviders(): Array<InstanceWrapper<Injectable>>;
+    get exports(): Set<InjectionToken>;
+    get instance(): VenokModule;
+    get metatype(): Type<any>;
+    get distance(): number;
+    set distance(value: number);
+    addCoreProviders(): void;
+    addModuleRef(): void;
+    addModuleAsProvider(): void;
+    addApplicationConfig(): void;
+    addInjectable<T extends Injectable>(injectable: Provider, enhancerSubtype: EnhancerSubtype, host?: Type<T>): string | symbol | Function | InstanceWrapper<unknown>;
+    addProvider(provider: Provider, enhancerSubtype?: EnhancerSubtype): InjectionToken;
+    isCustomProvider(provider: Provider): provider is ClassProvider | FactoryProvider | ValueProvider | ExistingProvider;
+    addCustomProvider(provider: ClassProvider | FactoryProvider | ValueProvider | ExistingProvider, collection: Map<Function | string | symbol, any>, enhancerSubtype?: EnhancerSubtype): InjectionToken;
+    isCustomClass(provider: any): provider is ClassProvider;
+    isCustomValue(provider: any): provider is ValueProvider;
+    isCustomFactory(provider: any): provider is FactoryProvider;
+    isCustomUseExisting(provider: any): provider is ExistingProvider;
+    isDynamicModule(exported: any): exported is DynamicModule;
+    addCustomClass(provider: ClassProvider, collection: Map<InjectionToken, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
+    addCustomValue(provider: ValueProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
+    addCustomFactory(provider: FactoryProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
+    addCustomUseExisting(provider: ExistingProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
+    addExportedProvider(provider: Provider | string | symbol | DynamicModule): Set<InjectionToken> | undefined;
+    addCustomExportedProvider(provider: FactoryProvider | ValueProvider | ClassProvider | ExistingProvider): Set<InjectionToken> | undefined;
+    validateExportedProvider(token: InjectionToken): InjectionToken;
+    addImport(moduleRef: Module): void;
+    /**
+     * @deprecated
+     */
+    addRelatedModule(module: Module): void;
+    replace(toReplace: InjectionToken, options: any): void;
+    hasProvider(token: InjectionToken): boolean;
+    hasInjectable(token: InjectionToken): boolean;
+    getProviderByKey<T = any>(name: InjectionToken): InstanceWrapper<T>;
+    getProviderById<T = any>(id: string): InstanceWrapper<T> | undefined;
+    getInjectableById<T = any>(id: string): InstanceWrapper<T> | undefined;
+    getNonAliasProviders(): Array<[InjectionToken, InstanceWrapper<Injectable>]>;
+    createModuleReferenceType(): Type<ModuleRef>;
+    private isEntryProvider;
+    private generateUuid;
+}

package/injector/module/module.js

@@ -0,0 +1,383 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = void 0;
+const wrapper_1 = require("@venok/core/injector/instance/wrapper");
+const exceptions_1 = require("@venok/core/errors/exceptions");
+const constants_1 = require("@venok/core/constants");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const uuid_helper_1 = require("@venok/core/helpers/uuid.helper");
+const random_string_generator_helper_1 = require("@venok/core/helpers/random-string-generator.helper");
+const ref_1 = require("@venok/core/injector/module/ref");
+const class_scope_helper_1 = require("@venok/core/injector/helpers/class-scope.helper");
+const is_durable_helper_1 = require("@venok/core/injector/helpers/is-durable.helper");
+const config_1 = require("@venok/core/application/config");
+const context_id_factory_helper_1 = require("@venok/core/helpers/context-id-factory.helper");
+class Module {
+    constructor(_metatype, container) {
+        this._metatype = _metatype;
+        this.container = container;
+        this._imports = new Set();
+        this._providers = new Map();
+        this._injectables = new Map();
+        this._entryProviderKeys = new Set();
+        this._exports = new Set();
+        this._distance = 0;
+        this._initOnPreview = false;
+        this._isGlobal = false;
+        this.addCoreProviders();
+        this._id = this.generateUuid();
+    }
+    get id() {
+        return this._id;
+    }
+    get token() {
+        return this._token;
+    }
+    set token(token) {
+        this._token = token;
+    }
+    get name() {
+        return this.metatype.name;
+    }
+    get isGlobal() {
+        return this._isGlobal;
+    }
+    set isGlobal(global) {
+        this._isGlobal = global;
+    }
+    get initOnPreview() {
+        return this._initOnPreview;
+    }
+    set initOnPreview(initOnPreview) {
+        this._initOnPreview = initOnPreview;
+    }
+    get providers() {
+        return this._providers;
+    }
+    get imports() {
+        return this._imports;
+    }
+    get injectables() {
+        return this._injectables;
+    }
+    get entryProviders() {
+        return Array.from(this._entryProviderKeys)
+            .map((token) => this.providers.get(token))
+            .filter(Boolean);
+    }
+    get exports() {
+        return this._exports;
+    }
+    get instance() {
+        if (!this._providers.has(this._metatype)) {
+            throw new exceptions_1.RuntimeException();
+        }
+        const module = this._providers.get(this._metatype);
+        return module.instance;
+    }
+    get metatype() {
+        return this._metatype;
+    }
+    get distance() {
+        return this._distance;
+    }
+    set distance(value) {
+        this._distance = value;
+    }
+    addCoreProviders() {
+        this.addModuleAsProvider();
+        this.addModuleRef();
+        this.addApplicationConfig();
+    }
+    addModuleRef() {
+        const moduleRef = this.createModuleReferenceType();
+        this._providers.set(ref_1.ModuleRef, new wrapper_1.InstanceWrapper({
+            token: ref_1.ModuleRef,
+            name: ref_1.ModuleRef.name,
+            metatype: ref_1.ModuleRef,
+            isResolved: true,
+            instance: new moduleRef(),
+            host: this,
+        }));
+    }
+    addModuleAsProvider() {
+        this._providers.set(this._metatype, new wrapper_1.InstanceWrapper({
+            token: this._metatype,
+            name: this._metatype.name,
+            metatype: this._metatype,
+            isResolved: false,
+            instance: null,
+            host: this,
+        }));
+    }
+    addApplicationConfig() {
+        this._providers.set(config_1.ApplicationConfig, new wrapper_1.InstanceWrapper({
+            token: config_1.ApplicationConfig,
+            name: config_1.ApplicationConfig.name,
+            isResolved: true,
+            instance: this.container.applicationConfig,
+            host: this,
+        }));
+    }
+    addInjectable(injectable, enhancerSubtype, host) {
+        if (this.isCustomProvider(injectable)) {
+            return this.addCustomProvider(injectable, this._injectables, enhancerSubtype);
+        }
+        let instanceWrapper = this.injectables.get(injectable);
+        if (!instanceWrapper) {
+            instanceWrapper = new wrapper_1.InstanceWrapper({
+                token: injectable,
+                name: injectable.name,
+                metatype: injectable,
+                instance: null,
+                isResolved: false,
+                scope: (0, class_scope_helper_1.getClassScope)(injectable),
+                durable: (0, is_durable_helper_1.isDurable)(injectable),
+                subtype: enhancerSubtype,
+                host: this,
+            });
+            this._injectables.set(injectable, instanceWrapper);
+        }
+        if (host) {
+            const hostWrapper = this._providers.get(host);
+            hostWrapper && hostWrapper.addEnhancerMetadata(instanceWrapper);
+        }
+        return instanceWrapper;
+    }
+    // public addProvider(provider: Provider): InjectionToken;
+    // public addProvider(provider: Provider, enhancerSubtype: EnhancerSubtype): InjectionToken;
+    addProvider(provider, enhancerSubtype) {
+        if (this.isCustomProvider(provider)) {
+            if (this.isEntryProvider(provider.provide)) {
+                this._entryProviderKeys.add(provider.provide);
+            }
+            return this.addCustomProvider(provider, this._providers, enhancerSubtype);
+        }
+        this._providers.set(provider, new wrapper_1.InstanceWrapper({
+            token: provider,
+            name: provider.name,
+            metatype: provider,
+            instance: null,
+            isResolved: false,
+            scope: (0, class_scope_helper_1.getClassScope)(provider),
+            durable: (0, is_durable_helper_1.isDurable)(provider),
+            host: this,
+        }));
+        if (this.isEntryProvider(provider)) {
+            this._entryProviderKeys.add(provider);
+        }
+        return provider;
+    }
+    isCustomProvider(provider) {
+        return !(0, shared_helper_1.isNull)(provider.provide);
+    }
+    addCustomProvider(provider, collection, enhancerSubtype) {
+        if (this.isCustomClass(provider)) {
+            this.addCustomClass(provider, collection, enhancerSubtype);
+        }
+        else if (this.isCustomValue(provider)) {
+            this.addCustomValue(provider, collection, enhancerSubtype);
+        }
+        else if (this.isCustomFactory(provider)) {
+            this.addCustomFactory(provider, collection, enhancerSubtype);
+        }
+        else if (this.isCustomUseExisting(provider)) {
+            this.addCustomUseExisting(provider, collection, enhancerSubtype);
+        }
+        return provider.provide;
+    }
+    isCustomClass(provider) {
+        return !(0, shared_helper_1.isUndefined)(provider.useClass);
+    }
+    isCustomValue(provider) {
+        return (0, shared_helper_1.isObject)(provider) && Object.prototype.hasOwnProperty.call(provider, "useValue");
+    }
+    isCustomFactory(provider) {
+        return !(0, shared_helper_1.isUndefined)(provider.useFactory);
+    }
+    isCustomUseExisting(provider) {
+        return !(0, shared_helper_1.isUndefined)(provider.useExisting);
+    }
+    isDynamicModule(exported) {
+        return exported && exported.module;
+    }
+    addCustomClass(provider, collection, enhancerSubtype) {
+        let { scope, durable } = provider;
+        const { useClass } = provider;
+        if ((0, shared_helper_1.isUndefined)(scope)) {
+            scope = (0, class_scope_helper_1.getClassScope)(useClass);
+        }
+        if ((0, shared_helper_1.isUndefined)(durable)) {
+            durable = (0, is_durable_helper_1.isDurable)(useClass);
+        }
+        const token = provider.provide;
+        collection.set(token, new wrapper_1.InstanceWrapper({
+            token,
+            name: useClass?.name ?? useClass,
+            metatype: useClass,
+            instance: null,
+            isResolved: false,
+            scope,
+            durable,
+            host: this,
+            subtype: enhancerSubtype,
+        }));
+    }
+    addCustomValue(provider, collection, enhancerSubtype) {
+        const { useValue: value, provide: providerToken } = provider;
+        collection.set(providerToken, new wrapper_1.InstanceWrapper({
+            token: providerToken,
+            name: providerToken?.name ?? providerToken,
+            metatype: null,
+            instance: value,
+            isResolved: true,
+            async: value instanceof Promise,
+            host: this,
+            subtype: enhancerSubtype,
+        }));
+    }
+    addCustomFactory(provider, collection, enhancerSubtype) {
+        const { useFactory: factory, inject, scope, durable, provide: providerToken } = provider;
+        collection.set(providerToken, new wrapper_1.InstanceWrapper({
+            token: providerToken,
+            name: providerToken?.name ?? providerToken,
+            metatype: factory,
+            instance: null,
+            isResolved: false,
+            inject: inject || [],
+            scope,
+            durable,
+            host: this,
+            subtype: enhancerSubtype,
+        }));
+    }
+    addCustomUseExisting(provider, collection, enhancerSubtype) {
+        const { useExisting, provide: providerToken } = provider;
+        collection.set(providerToken, new wrapper_1.InstanceWrapper({
+            token: providerToken,
+            name: providerToken?.name ?? providerToken,
+            metatype: ((instance) => instance),
+            instance: null,
+            isResolved: false,
+            inject: [useExisting],
+            host: this,
+            isAlias: true,
+            subtype: enhancerSubtype,
+        }));
+    }
+    addExportedProvider(provider) {
+        const addExportedUnit = (token) => this._exports.add(this.validateExportedProvider(token));
+        if (this.isCustomProvider(provider)) {
+            return this.addCustomExportedProvider(provider);
+        }
+        else if ((0, shared_helper_1.isString)(provider) || (0, shared_helper_1.isSymbol)(provider)) {
+            return addExportedUnit(provider);
+        }
+        else if (this.isDynamicModule(provider)) {
+            const { module: moduleClassRef } = provider;
+            return addExportedUnit(moduleClassRef);
+        }
+        addExportedUnit(provider);
+    }
+    addCustomExportedProvider(provider) {
+        const provide = provider.provide;
+        if ((0, shared_helper_1.isString)(provide) || (0, shared_helper_1.isSymbol)(provide)) {
+            return this._exports.add(this.validateExportedProvider(provide));
+        }
+        this._exports.add(this.validateExportedProvider(provide));
+    }
+    validateExportedProvider(token) {
+        if (this._providers.has(token)) {
+            return token;
+        }
+        const imports = Array.from(this._imports.values())
+            .filter(Boolean)
+            .map(({ metatype }) => metatype)
+            .filter(Boolean);
+        if (!imports.includes(token)) {
+            const { name } = this.metatype;
+            const providerName = (0, shared_helper_1.isFunction)(token) ? token.name : token;
+            throw new exceptions_1.UnknownExportException(providerName, name);
+        }
+        return token;
+    }
+    addImport(moduleRef) {
+        this._imports.add(moduleRef);
+    }
+    /**
+     * @deprecated
+     */
+    addRelatedModule(module) {
+        this._imports.add(module);
+    }
+    replace(toReplace, options) {
+        if (options.isProvider && this.hasProvider(toReplace)) {
+            const originalProvider = this._providers.get(toReplace);
+            return originalProvider.mergeWith({ provide: toReplace, ...options });
+        }
+        else if (!options.isProvider && this.hasInjectable(toReplace)) {
+            const originalInjectable = this._injectables.get(toReplace);
+            return originalInjectable.mergeWith({
+                provide: toReplace,
+                ...options,
+            });
+        }
+    }
+    hasProvider(token) {
+        return this._providers.has(token);
+    }
+    hasInjectable(token) {
+        return this._injectables.has(token);
+    }
+    getProviderByKey(name) {
+        return this._providers.get(name);
+    }
+    getProviderById(id) {
+        return Array.from(this._providers.values()).find((item) => item.id === id);
+    }
+    getInjectableById(id) {
+        return Array.from(this._injectables.values()).find((item) => item.id === id);
+    }
+    getNonAliasProviders() {
+        return [...this._providers].filter(([_, wrapper]) => !wrapper.isAlias);
+    }
+    createModuleReferenceType() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        return class extends ref_1.ModuleRef {
+            constructor() {
+                super(self.container);
+            }
+            get(typeOrToken, options = {}) {
+                options.strict ??= true;
+                options.each ??= false;
+                return this.find(typeOrToken, options.strict
+                    ? {
+                        moduleId: self.id,
+                        each: options.each,
+                    }
+                    : options);
+            }
+            resolve(typeOrToken, contextId = (0, context_id_factory_helper_1.createContextId)(), options = {}) {
+                options.strict ??= true;
+                options.each ??= false;
+                return this.resolvePerContext(typeOrToken, self, contextId, options);
+            }
+            async create(type, contextId) {
+                if (!(type && (0, shared_helper_1.isFunction)(type) && type.prototype)) {
+                    throw new exceptions_1.InvalidClassException(type);
+                }
+                return this.instantiateClass(type, self, contextId);
+            }
+        };
+    }
+    isEntryProvider(metatype) {
+        return typeof metatype === "function" ? !!Reflect.getMetadata(constants_1.ENTRY_PROVIDER_WATERMARK, metatype) : false;
+    }
+    generateUuid() {
+        const prefix = "M_";
+        const key = this.name?.toString() ?? this.token?.toString();
+        return key ? uuid_helper_1.UuidFactory.get(`${prefix}_${key}`) : (0, random_string_generator_helper_1.randomStringGenerator)();
+    }
+}
+exports.Module = Module;

package/injector/module/ref.d.ts

@@ -0,0 +1,106 @@
+import { Injector } from "@venok/core/injector/injector";
+import { Type } from "@venok/core/interfaces";
+import { ContextId } from "@venok/core/injector/instance/wrapper";
+import { IntrospectionResult } from "@venok/core/interfaces/modules";
+import { Module } from "@venok/core/injector/module/module";
+import { AbstractInstanceResolver } from "@venok/core/injector/instance/resolver";
+import { InstanceLinksHost } from "@venok/core/injector/instance/links-host";
+import { VenokContainer } from "@venok/core/injector/container";
+export interface ModuleRefGetOrResolveOpts {
+    /**
+     * If enabled, lookup will only be performed in the host module.
+     * @default true
+     */
+    strict?: boolean;
+    /**
+     * If enabled, instead of returning a first instance registered under a given token,
+     * a list of instances will be returned.
+     * @default false
+     */
+    each?: boolean;
+}
+export declare abstract class ModuleRef extends AbstractInstanceResolver {
+    protected readonly container: VenokContainer;
+    protected readonly injector: Injector;
+    private _instanceLinksHost;
+    protected get instanceLinksHost(): InstanceLinksHost;
+    constructor(container: VenokContainer);
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): TResult;
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        /**
+         * If enabled, lookup will only be performed in the host module.
+         * @default true
+         */
+        strict?: boolean;
+        /** This indicates that only the first instance registered will be returned. */
+        each?: undefined | false;
+    }): TResult;
+    /**
+     * Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        /**
+         * If enabled, lookup will only be performed in the host module.
+         * @default true
+         */
+        strict?: boolean;
+        /** This indicates that a list of instances will be returned. */
+        each: true;
+    }): Array<TResult>;
+    /**
+     * Retrieves an instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult | Array<TResult>}
+     */
+    abstract get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options?: ModuleRefGetOrResolveOpts): TResult | Array<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: {
+        strict?: boolean;
+        each?: undefined | false;
+    }): Promise<TResult>;
+    /**
+     * Resolves transient or request-scoped instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: {
+        strict?: boolean;
+        each: true;
+    }): Promise<Array<TResult>>;
+    /**
+     * Resolves transient or request-scoped instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
+     * @returns {Promise<TResult | Array<TResult>>}
+     */
+    abstract resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: ModuleRefGetOrResolveOpts): Promise<TResult | Array<TResult>>;
+    abstract create<T = any>(type: Type<T>, contextId?: ContextId): Promise<T>;
+    introspect<T = any>(token: Type<T> | string | symbol): IntrospectionResult;
+    protected instantiateClass<T = any>(type: Type<T>, moduleRef: Module, contextId?: ContextId): Promise<T>;
+}