@venok/core 1.0.1-canary.5 → 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,3142 @@
+/**
+* Thanks for using Venloc Venok <3
+* https://github.com/venloc-tech/svm
+*/
+import { Observable } from 'rxjs';
+import { InspectOptions } from 'util';
+
+/**
+ * SettlementSignal is used to signal the resolution of a provider/instance.
+ * Calling `complete` or `error` will resolve the promise returned by `asPromise`.
+ * Can be used to detect circular dependencies.
+ */
+declare class SettlementSignal {
+    private readonly _refs;
+    private readonly settledPromise;
+    private settleFn;
+    private completed;
+    constructor();
+    /**
+     * Resolves the promise returned by `asPromise`.
+     */
+    complete(): void;
+    /**
+     * Rejects the promise returned by `asPromise` with the given error.
+     * @param err Error to reject the promise returned by `asPromise` with.
+     */
+    error(err: unknown): void;
+    /**
+     * Returns a promise that will be resolved when `complete` or `error` is called.
+     * @returns Promise that will be resolved when `complete` or `error` is called.
+     */
+    asPromise(): Promise<unknown>;
+    /**
+     * Inserts a wrapper id that the host of this signal depends on.
+     * @param wrapperId Wrapper id to insert.
+     */
+    insertRef(wrapperId: string): void;
+    /**
+     * Check if relationship is circular.
+     * @param wrapperId Wrapper id to check.
+     * @returns True if relationship is circular, false otherwise.
+     */
+    isCycle(wrapperId: string): boolean;
+}
+
+declare const MESSAGES: {
+    APPLICATION_START: string;
+    APPLICATION_READY: string;
+    UNKNOWN_EXCEPTION_MESSAGE: string;
+    ERROR_DURING_SHUTDOWN: string;
+};
+declare const FORBIDDEN_MESSAGE = "Forbidden resource";
+declare const MODULE_METADATA: {
+    IMPORTS: string;
+    PROVIDERS: string;
+    EXPORTS: string;
+};
+declare const PIPES_METADATA = "__pipes__";
+declare const GUARDS_METADATA = "__guards__";
+declare const INTERCEPTORS_METADATA = "__interceptors__";
+declare const EXCEPTION_FILTERS_METADATA = "__exceptionFilters__";
+declare const ENHANCER_KEY_TO_SUBTYPE_MAP: {
+    readonly __guards__: "guard";
+    readonly __interceptors__: "interceptor";
+    readonly __pipes__: "pipe";
+    readonly __exceptionFilters__: "filter";
+};
+type EnhancerSubtype = (typeof ENHANCER_KEY_TO_SUBTYPE_MAP)[keyof typeof ENHANCER_KEY_TO_SUBTYPE_MAP];
+declare const APP_INTERCEPTOR = "APP_INTERCEPTOR";
+declare const APP_PIPE = "APP_PIPE";
+declare const APP_GUARD = "APP_GUARD";
+declare const APP_FILTER = "APP_FILTER";
+declare const ENHANCER_TOKEN_TO_SUBTYPE_MAP: Record<typeof APP_GUARD | typeof APP_PIPE | typeof APP_FILTER | typeof APP_INTERCEPTOR, EnhancerSubtype>;
+declare const REQUEST = "REQUEST";
+declare const GLOBAL_MODULE_METADATA = "__module:global__";
+declare const PARAMTYPES_METADATA = "design:paramtypes";
+declare const SELF_DECLARED_DEPS_METADATA = "self:paramtypes";
+declare const OPTIONAL_DEPS_METADATA = "optional:paramtypes";
+declare const PROPERTY_DEPS_METADATA = "self:properties_metadata";
+declare const OPTIONAL_PROPERTY_DEPS_METADATA = "optional:properties_metadata";
+declare const SCOPE_OPTIONS_METADATA = "scope:options";
+declare const MODULE_PATH = "__module_path__";
+declare const ROUTE_ARGS_METADATA = "__routeArguments__";
+declare const CUSTOM_ROUTE_ARGS_METADATA = "__customRouteArgs__";
+declare const FILTER_CATCH_EXCEPTIONS = "__filterCatchExceptions__";
+declare const INJECTABLE_WATERMARK = "__injectable__";
+declare const CATCH_WATERMARK = "__catch__";
+declare const ENTRY_PROVIDER_WATERMARK = "__entryProvider__";
+declare const INQUIRER = "INQUIRER";
+declare const REQUEST_CONTEXT_ID: unique symbol;
+
+type InjectableToken = unknown;
+
+interface InstanceLink<T = any> {
+    token: InjectionToken;
+    wrapperRef: InstanceWrapper<T>;
+    collection: Map<InjectionToken, InstanceWrapper>;
+    moduleId: string;
+}
+declare class InstanceLinksHost {
+    private readonly container;
+    private readonly instanceLinks;
+    constructor(container: VenokContainer);
+    get<T = any>(token: InjectionToken): InstanceLink<T>;
+    get<T = any>(token: InjectionToken, options?: {
+        moduleId?: string;
+        each?: boolean;
+    }): InstanceLink<T> | Array<InstanceLink<T>>;
+    private initialize;
+    private addLink;
+    private getInstanceNameByToken;
+}
+
+declare class Injector {
+    private readonly options?;
+    private logger;
+    constructor(options?: {
+        preview: boolean;
+    } | undefined);
+    loadPrototype<T>({ token }: InstanceWrapper<T>, collection: Map<InjectionToken, InstanceWrapper<T>>, contextId?: ContextId): void;
+    loadInstance<T>(wrapper: InstanceWrapper<T>, collection: Map<InjectionToken, InstanceWrapper>, moduleRef: Module$1, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    loadInjectable<T = any>(wrapper: InstanceWrapper<T>, moduleRef: Module$1, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    loadProvider(wrapper: InstanceWrapper<InjectableToken>, moduleRef: Module$1, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    applySettlementSignal<T>(instancePerContext: InstancePerContext<T>, host: InstanceWrapper<T>): SettlementSignal;
+    resolveConstructorParams<T>(wrapper: InstanceWrapper<T>, moduleRef: Module$1, inject: InjectorDependency[] | null, callback: (args: unknown[]) => void | Promise<void>, contextId?: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<void>;
+    getClassDependencies<T>(wrapper: InstanceWrapper<T>): [InjectorDependency[], number[]];
+    getFactoryProviderDependencies<T>(wrapper: InstanceWrapper<T>): [InjectorDependency[], number[]];
+    reflectConstructorParams<T>(type: Type<T>): any[];
+    reflectOptionalParams<T>(type: Type<T>): any[];
+    reflectSelfParams<T>(type: Type<T>): any[];
+    resolveSingleParam<T>(wrapper: InstanceWrapper<T>, param: Type | string | symbol, dependencyContext: InjectorDependencyContext, moduleRef: Module$1, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<any>>;
+    resolveParamToken<T>(wrapper: InstanceWrapper<T>, param: Type | string | symbol | any): InjectionToken;
+    resolveComponentWrapper<T>(moduleRef: Module$1, token: InjectionToken, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper>;
+    resolveComponentHost<T>(moduleRef: Module$1, instanceWrapper: InstanceWrapper<T | Promise<T>>, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<InstanceWrapper>;
+    lookupComponent<T = any>(providers: Map<Function | string | symbol, InstanceWrapper>, moduleRef: Module$1, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<T>>;
+    lookupComponentInParentModules<T = any>(dependencyContext: InjectorDependencyContext, moduleRef: Module$1, wrapper: InstanceWrapper<T>, contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number): Promise<InstanceWrapper<any>>;
+    lookupComponentInImports(moduleRef: Module$1, name: InjectionToken, wrapper: InstanceWrapper, moduleRegistry?: any[], contextId?: ContextId, inquirer?: InstanceWrapper, keyOrIndex?: symbol | string | number, isTraversing?: boolean): Promise<InstanceWrapper | null>;
+    resolveProperties<T>(wrapper: InstanceWrapper<T>, moduleRef: Module$1, inject?: InjectorDependency[], contextId?: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<PropertyDependency[]>;
+    reflectProperties<T>(type: Type<T>): PropertyDependency[];
+    applyProperties<T = any>(instance: T, properties: PropertyDependency[]): void;
+    instantiateClass<T = any>(instances: any[], wrapper: InstanceWrapper, targetMetatype: InstanceWrapper, contextId?: ContextId, inquirer?: InstanceWrapper): Promise<T>;
+    loadPerContext<T = any>(instance: T, moduleRef: Module$1, collection: Map<InjectionToken, InstanceWrapper>, ctx: ContextId, wrapper?: InstanceWrapper): Promise<T>;
+    loadEnhancersPerContext(wrapper: InstanceWrapper, ctx: ContextId, inquirer?: InstanceWrapper): Promise<void>;
+    loadCtorMetadata(metadata: InstanceWrapper<any>[], contextId: ContextId, inquirer?: InstanceWrapper, parentInquirer?: InstanceWrapper): Promise<any[]>;
+    loadPropertiesMetadata(metadata: PropertyMetadata[], contextId: ContextId, inquirer?: InstanceWrapper): Promise<PropertyDependency[]>;
+    private getInquirerId;
+    private resolveScopedComponentHost;
+    private isInquirerRequest;
+    private isInquirer;
+    protected addDependencyMetadata(keyOrIndex: symbol | string | number, hostWrapper: InstanceWrapper, instanceWrapper: InstanceWrapper): void;
+    private getTokenName;
+    private printResolvingDependenciesLog;
+    private printLookingForProviderLog;
+    private printFoundInModuleLog;
+    private isDebugMode;
+    private getContextId;
+    private getNowTimestamp;
+}
+
+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$1, contextId: ContextId, options?: GetOrResolveOptions): Promise<TResult | Array<TResult>>;
+}
+
+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$1, contextId?: ContextId): Promise<T>;
+}
+
+declare class Module$1 {
+    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, 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<InjectableToken>>;
+    get imports(): Set<Module$1>;
+    get injectables(): Map<InjectionToken, InstanceWrapper<InjectableToken>>;
+    get entryProviders(): Array<InstanceWrapper<InjectableToken>>;
+    get exports(): Set<InjectionToken>;
+    get instance(): VenokModule;
+    get metatype(): Type;
+    get distance(): number;
+    set distance(value: number);
+    addCoreProviders(): void;
+    addModuleRef(): void;
+    addModuleAsProvider(): void;
+    addApplicationConfig(): void;
+    addInjectable<T extends InjectableToken>(injectable: Provider, enhancerSubtype: EnhancerSubtype, host?: Type<T>): string | symbol | Function | InstanceWrapper<unknown>;
+    assignProviderUniqueId(provider: Type): void;
+    addProvider(provider: Provider, enhancerSubtype?: EnhancerSubtype): InjectionToken;
+    isCustomProvider(provider: Provider): provider is ClassProvider | FactoryProvider | ValueProvider | ExistingProvider;
+    addCustomProvider(provider: ClassProvider | FactoryProvider | ValueProvider | ExistingProvider, collection: Map<InjectionToken, InstanceWrapper>, 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;
+    addExportedProviderOrModule(toExport: Provider | string | symbol | DynamicModule): Set<InjectionToken> | undefined;
+    addCustomExportedProvider(provider: FactoryProvider | ValueProvider | ClassProvider | ExistingProvider): Set<InjectionToken> | undefined;
+    validateExportedProvider(token: InjectionToken): InjectionToken;
+    addImport(moduleRef: Module$1): 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<InjectableToken>]>;
+    createModuleReferenceType(): Type<ModuleRef>;
+    private isEntryProvider;
+    private generateUuid;
+}
+
+/**
+ * @publicApi
+ */
+declare enum Scope {
+    /**
+     * The provider can be shared across multiple classes. The provider lifetime
+     * is strictly tied to the application lifecycle. Once the application has
+     * bootstrapped, all providers have been instantiated.
+     */
+    DEFAULT = 0,
+    /**
+     * A new private instance of the provider is instantiated for every use
+     */
+    TRANSIENT = 1,
+    /**
+     * A new instance is instantiated for each request processing pipeline
+     */
+    REQUEST = 2
+}
+
+declare const INSTANCE_METADATA_SYMBOL: unique symbol;
+declare const INSTANCE_ID_SYMBOL: unique symbol;
+interface PropertyMetadata {
+    key: symbol | string;
+    wrapper: InstanceWrapper;
+}
+declare class InstanceWrapper<T = any> {
+    readonly isAlias: boolean;
+    scope?: Scope;
+    readonly name: string;
+    readonly token: InjectionToken;
+    readonly async?: boolean;
+    readonly host?: Module$1;
+    readonly subtype?: EnhancerSubtype;
+    metatype?: Type<T> | Function | null;
+    inject?: FactoryProvider["inject"] | null;
+    forwardRef?: boolean;
+    durable?: boolean;
+    initTime?: number;
+    settlementSignal?: SettlementSignal;
+    private static logger;
+    private readonly values;
+    private readonly [INSTANCE_METADATA_SYMBOL];
+    private readonly [INSTANCE_ID_SYMBOL];
+    private transientMap;
+    private isTreeStatic;
+    private isTreeDurable;
+    /**
+     * The root inquirer reference. Present only if child instance wrapper
+     * is transient and has a parent inquirer.
+     */
+    private rootInquirer;
+    constructor(metadata?: Partial<InstanceWrapper<T>> & Partial<InstancePerContext<T>>);
+    get id(): string;
+    set instance(value: T);
+    get instance(): T | undefined;
+    get isNotMetatype(): boolean;
+    get isFactory(): boolean;
+    get isTransient(): boolean;
+    getInstanceByContextId(contextId: ContextId, inquirerId?: string): InstancePerContext<T>;
+    getInstanceByInquirerId(contextId: ContextId, inquirerId: string): InstancePerContext<T>;
+    setInstanceByContextId(contextId: ContextId, value: InstancePerContext<T>, inquirerId?: string): void;
+    setInstanceByInquirerId(contextId: ContextId, inquirerId: string, value: InstancePerContext<T>): void;
+    removeInstanceByContextId(contextId: ContextId, inquirerId?: string): void;
+    removeInstanceByInquirerId(contextId: ContextId, inquirerId: string): void;
+    addCtorMetadata(index: number, wrapper: InstanceWrapper): void;
+    getCtorMetadata(): InstanceWrapper[];
+    addPropertiesMetadata(key: symbol | string, wrapper: InstanceWrapper): void;
+    getPropertiesMetadata(): PropertyMetadata[];
+    addEnhancerMetadata(wrapper: InstanceWrapper): void;
+    getEnhancersMetadata(): InstanceWrapper[];
+    isDependencyTreeDurable(lookupRegistry?: string[]): boolean;
+    introspectDepsAttribute(callback: (collection: InstanceWrapper[], lookupRegistry: string[]) => boolean, lookupRegistry?: string[]): boolean;
+    isDependencyTreeStatic(lookupRegistry?: string[]): boolean;
+    cloneStaticInstance(contextId: ContextId): InstancePerContext<T>;
+    cloneTransientInstance(contextId: ContextId, inquirerId: string): InstancePerContext<T>;
+    createPrototype(contextId: ContextId): any;
+    isInRequestScope(contextId: ContextId, inquirer?: InstanceWrapper): boolean;
+    isLazyTransient(contextId: ContextId, inquirer: InstanceWrapper | undefined): boolean;
+    isExplicitlyRequested(contextId: ContextId, inquirer?: InstanceWrapper): boolean;
+    isStatic(contextId: ContextId, inquirer: InstanceWrapper | undefined): boolean;
+    attachRootInquirer(inquirer: InstanceWrapper): void;
+    getRootInquirer(): InstanceWrapper | undefined;
+    getStaticTransientInstances(): InstancePerContext<T>[];
+    mergeWith(provider: Provider): void;
+    private isNewable;
+    private initialize;
+    private printIntrospectedAsRequestScoped;
+    private printIntrospectedAsDurable;
+    private isDebugMode;
+    private generateUuid;
+}
+
+declare class TokenFactory {
+    private readonly moduleTokenCache;
+    private readonly moduleIdsCache;
+    create(metatype: Type, dynamicModuleMetadata?: Partial<DynamicModule>): string;
+    getStaticModuleToken(moduleId: string, moduleName: string): string;
+    getStringifiedOpaqueToken(opaqueToken: object | undefined): string;
+    getModuleId(metatype: Type): string;
+    getModuleName(metatype: Type): string;
+    private hashString;
+    private replacer;
+}
+
+declare class ModuleCompiler {
+    private readonly moduleTokenFactory;
+    constructor(moduleTokenFactory?: TokenFactory);
+    compile(metatype: Type | DynamicModule | Promise<DynamicModule>): Promise<ModuleFactory>;
+    extractMetadata(metatype: Type | ForwardReference | DynamicModule): {
+        type: Type;
+        dynamicMetadata?: Partial<DynamicModule> | undefined;
+    };
+    isDynamicModule(module: Type | DynamicModule | ForwardReference): module is DynamicModule;
+}
+
+declare class ModulesContainer extends Map<string, Module$1> {
+    #private;
+    get applicationId(): string;
+    getById(id: string): Module$1 | undefined;
+}
+
+type WithOptionalId<T extends Record<"id", string>> = Omit<T, "id"> & Partial<Pick<T, "id">>;
+declare class SerializedGraph {
+    private readonly nodes;
+    private readonly edges;
+    private readonly entrypoints;
+    private readonly extras;
+    private _status;
+    private _metadata?;
+    private static readonly INTERNAL_PROVIDERS;
+    set status(status: SerializedGraphStatus);
+    set metadata(metadata: SerializedGraphMetadata);
+    insertNode(nodeDefinition: Node): Node | undefined;
+    insertEdge(edgeDefinition: WithOptionalId<Edge>): {
+        id: string;
+        source: string;
+        target: string;
+        metadata: ({
+            type: "module-to-module";
+        } & {
+            sourceModuleName: string;
+            targetModuleName: string;
+        }) | ({
+            type: "class-to-class";
+            sourceClassName: string;
+            targetClassName: string;
+            sourceClassToken: InjectionToken;
+            targetClassToken: InjectionToken;
+            injectionType: "constructor" | "property" | "decorator";
+            keyOrIndex?: string | number | symbol;
+            internal?: boolean;
+        } & {
+            sourceModuleName: string;
+            targetModuleName: string;
+        });
+    };
+    insertEntrypoint<T>(definition: Entrypoint<T>, parentId: string): void;
+    insertOrphanedEnhancer(entry: OrphanedEnhancerDefinition): void;
+    insertAttachedEnhancer(nodeId: string): void;
+    getNodeById(id: string): Node | undefined;
+    toJSON(): SerializedGraphJson;
+    toString(): string;
+    private generateUuidByEdgeDefinition;
+}
+
+type ModuleMetatype = Type | DynamicModule | Promise<DynamicModule>;
+type ModuleScope = Type[];
+declare class VenokContainer {
+    private readonly _applicationConfig;
+    private readonly globalModules;
+    private readonly moduleTokenFactory;
+    private readonly moduleCompiler;
+    private readonly modules;
+    private readonly dynamicModulesMetadata;
+    private readonly _serializedGraph;
+    private internalCoreModule;
+    constructor(_applicationConfig?: ApplicationConfig);
+    get serializedGraph(): SerializedGraph;
+    get applicationConfig(): ApplicationConfig;
+    addModule(metatype: ModuleMetatype | undefined, scope: ModuleScope): Promise<{
+        moduleRef: Module$1;
+        inserted: boolean;
+    } | undefined>;
+    replaceModule(metatypeToReplace: ModuleMetatype, newMetatype: ModuleMetatype, scope: ModuleScope): Promise<{
+        moduleRef: Module$1;
+        inserted: boolean;
+    } | undefined>;
+    private setModule;
+    addDynamicMetadata(token: string, dynamicModuleMetadata: Partial<DynamicModule> | undefined, scope: Type[]): Promise<void>;
+    addDynamicModules(modules: any[] | undefined, scope: Type[]): Promise<void>;
+    isGlobalModule(metatype: Type, dynamicMetadata?: Partial<DynamicModule>): boolean;
+    addGlobalModule(module: Module$1): void;
+    getModules(): ModulesContainer;
+    getModuleCompiler(): ModuleCompiler;
+    getModuleByKey(moduleKey: string): Module$1;
+    getInternalCoreModuleRef(): Module$1 | undefined;
+    addImport(relatedModule: Type | DynamicModule, token: string): Promise<void>;
+    addProvider(provider: Provider, token: string, enhancerSubtype?: EnhancerSubtype): string | symbol | Function;
+    addInjectable(injectable: Provider, token: string, enhancerSubtype: EnhancerSubtype, host?: Type<InjectableToken>): string | symbol | Function | InstanceWrapper<unknown>;
+    addExportedProviderOrModule(provider: Type, token: string): void;
+    clear(): void;
+    replace(toReplace: any, options: any & {
+        scope: any[] | null;
+    }): void;
+    bindGlobalScope(): void;
+    bindGlobalsToImports(moduleRef: Module$1): void;
+    bindGlobalModuleToModule(target: Module$1, globalModule: Module$1): void;
+    getDynamicMetadataByToken(token: string): Partial<DynamicModule>;
+    getDynamicMetadataByToken<K extends Exclude<keyof DynamicModule, "global" | "module">>(token: string, metadataKey: K): DynamicModule[K];
+    registerCoreModuleRef(moduleRef: Module$1): void;
+    getModuleTokenFactory(): TokenFactory;
+    getContextId<T extends Record<any, unknown> = any>(request: T, isTreeDurable: boolean): ContextId;
+    registerRequestProvider<T = any>(request: T, contextId: ContextId): void;
+    private shouldInitOnPreview;
+}
+
+/**
+ * System signals which shut down a process
+ */
+declare enum ShutdownSignal {
+    SIGHUP = "SIGHUP",
+    SIGINT = "SIGINT",
+    SIGQUIT = "SIGQUIT",
+    SIGILL = "SIGILL",
+    SIGTRAP = "SIGTRAP",
+    SIGABRT = "SIGABRT",
+    SIGBUS = "SIGBUS",
+    SIGFPE = "SIGFPE",
+    SIGSEGV = "SIGSEGV",
+    SIGUSR2 = "SIGUSR2",
+    SIGTERM = "SIGTERM"
+}
+
+interface GetOrResolveOptions {
+    /**
+     * If enabled, lookup will only be performed in the host module.
+     * @default false
+     */
+    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;
+}
+/**
+ * Interface defining ApplicationContext.
+ *
+ * @publicApi
+ */
+interface VenokApplicationContext {
+    container: VenokContainer;
+    /**
+     * Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
+     * @returns {VenokApplicationContext}
+     */
+    select<T>(module: Type<T> | DynamicModule): VenokApplicationContext;
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    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}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each?: undefined | false;
+    }): TResult;
+    /**
+     * Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each: true;
+    }): Array<TResult>;
+    /**
+     * Retrieves an instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult | Array<TResult>}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options?: GetOrResolveOptions): TResult | Array<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    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>}
+     */
+    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>}
+     */
+    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>}
+     */
+    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>>}
+     */
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: GetOrResolveOptions): Promise<TResult | Array<TResult>>;
+    /**
+     * Registers the request/context object for a given context ID (DI container sub-tree).
+     * @returns {void}
+     */
+    registerRequestByContextId<T = any>(request: T, contextId: {
+        id: number;
+    }): void;
+    /**
+     * Terminates the application
+     * @returns {Promise<void>}
+     */
+    close(): Promise<void>;
+    /**
+     * Sets custom logger service.
+     * Flushes buffered logs if auto flush is on.
+     * @returns {void}
+     */
+    useLogger(logger: LoggerService | LogLevel[] | false): void;
+    /**
+     * Registers exception filters as global filters (will be used within
+     * every route handler)
+     *
+     * @param {...ExceptionFilter} filters
+     */
+    useGlobalFilters(...filters: ExceptionFilter[]): this;
+    /**
+     * Registers pipes as global pipes (will be used within every route handler)
+     *
+     * @param {...PipeTransform} pipes
+     */
+    useGlobalPipes(...pipes: PipeTransform<any>[]): this;
+    /**
+     * Registers interceptors as global interceptors (will be used within
+     * every route handler)
+     *
+     * @param {...VenokInterceptor} interceptors
+     */
+    useGlobalInterceptors(...interceptors: VenokInterceptor[]): this;
+    /**
+     * Registers guards as global guards (will be used within every route handler)
+     *
+     * @param {...CanActivate} guards
+     */
+    useGlobalGuards(...guards: CanActivate[]): this;
+    /**
+     * Prints buffered logs and detaches buffer.
+     * @returns {void}
+     */
+    flushLogs(): void;
+    /**
+     * Enables the usage of shutdown hooks. Will call the
+     * `onApplicationShutdown` function of a provider if the
+     * process receives a shutdown signal.
+     *
+     * @returns {this} The Venok application context instance
+     */
+    enableShutdownHooks(signals?: ShutdownSignal[] | string[]): this;
+    /**
+     * Initializes the Venok application.
+     * Calls the Venok lifecycle events.
+     * It isn't mandatory to call this method directly.
+     *
+     * @returns {Promise<this>} The ApplicationContext instance as Promise
+     */
+    init(): Promise<this>;
+}
+
+type SelectOptions = Pick<ApplicationContextOptions, "abortOnError">;
+/**
+ * @publicApi
+ */
+declare class ApplicationContextOptions {
+    /**
+     * Specifies the logger to use.  Pass `false` to turn off logging.
+     */
+    logger?: LoggerService | LogLevel[] | false;
+    /**
+     * Whether to abort the process on Error. By default, the process is exited.
+     * Pass `false` to override the default behavior. If `false` is passed, Venok will not exit
+     * the application and instead will rethrow the exception.
+     * @default true
+     */
+    abortOnError?: boolean | undefined;
+    /**
+     * If enabled, logs will be buffered until the "Logger#flush" method is called.
+     * @default false
+     */
+    bufferLogs?: boolean;
+    /**
+     * If enabled, logs will be automatically flushed and buffer detached when
+     * application initialization process either completes or fails.
+     * @default true
+     */
+    autoFlushLogs?: boolean;
+    /**
+     * Whether to run application in the preview mode.
+     * In the preview mode, providers/controllers are not instantiated & resolved.
+     *
+     * @default false
+     */
+    preview?: boolean;
+    /**
+     * Whether to generate a serialized graph snapshot.
+     *
+     * @default false
+     */
+    snapshot?: boolean;
+    /**
+     * If enabled, will force the use of console.log/console.error instead of process.stdout/stderr.write
+     * in the default ConsoleLogger. This is useful for test environments like Jest that can buffer console calls.
+     * @default false
+     */
+    forceConsole?: boolean;
+}
+
+type ContextType = "native" | string;
+/**
+ * Provides methods for retrieving the arguments being passed to a handler.
+ * Allows choosing the appropriate execution context to retrieve the arguments from.
+ *
+ * @publicApi
+ */
+interface ArgumentsHost {
+    /**
+     * Returns the array of arguments being passed to the handler.
+     */
+    getArgs<T extends Array<any> = any[]>(): T;
+    /**
+     * Returns a particular argument by index.
+     * @param index index of argument to retrieve
+     */
+    getArgByIndex<T = any>(index: number): T;
+    /**
+     * Returns the current execution context type (string)
+     */
+    getType<TContext extends string = ContextType>(): TContext;
+}
+
+interface ExternalHandlerMetadata {
+    argsLength: number;
+    paramtypes: any[];
+    getParamsMetadata: GetParamsMetadata;
+}
+interface ExternalContextOptions {
+    guards?: boolean;
+    interceptors?: boolean;
+    filters?: boolean;
+    callback?: (result: any | Observable<any>, ...args: any[]) => void;
+}
+
+type ContextIdResolverFn = (info: HostComponentInfo) => ContextId;
+interface ContextIdResolver {
+    /**
+     * Payload associated with the custom context id
+     */
+    payload: unknown;
+    /**
+     * A context id resolver function
+     */
+    resolve: ContextIdResolverFn;
+}
+interface ContextIdStrategy<T = any> {
+    /**
+     * Allows to attach a parent context id to the existing child context id.
+     * This lets you construct durable DI subtrees that can be shared between contexts.
+     * @param contextId auto-generated child context id
+     * @param request request object
+     */
+    attach(contextId: ContextId, request: T): ContextIdResolverFn | ContextIdResolver | undefined;
+}
+
+interface VenokContextCreatorInterface {
+    create: (...args: any[]) => any;
+}
+
+/**
+ * Interface describing details about the current request pipeline.
+ *
+ * @publicApi
+ */
+interface ExecutionContext extends ArgumentsHost {
+    /**
+     * Returns the *type* of the controller class which the current handler belongs to.
+     */
+    getClass<T = any>(): Type<T>;
+    /**
+     * Returns a reference to the handler (method) that will be invoked next in the
+     * request pipeline.
+     */
+    getHandler(): Function;
+}
+
+type ParamData = object | string | number;
+interface ParamProperties<T = any, IExtractor extends Function = any> {
+    index: number;
+    type: T | string;
+    data: ParamData;
+    pipes: PipeTransform[];
+    extractValue: IExtractor;
+}
+interface VenokParamsFactoryInterface<TKey = unknown> {
+    exchangeKeyForValue(key: TKey | string, data: any, args: any[]): any;
+}
+type ParamsMetadata = Record<number, ParamMetadata>;
+interface ParamMetadata {
+    index: number;
+    data?: ParamData;
+}
+type ParamPropertiesWithMetatype<T = any> = ParamProperties & {
+    metatype?: T;
+};
+type GetParamsMetadata = (moduleKey: string, contextId?: ContextId, inquirerId?: string) => ParamPropertiesWithMetatype[];
+
+/**
+ * Interface describing implementation of an exception filter.
+ *
+ * @publicApi
+ */
+interface ExceptionFilter<T = any> {
+    /**
+     * Method to implement a custom exception filter.
+     *
+     * @param exception the class of the exception being handled
+     * @param host used to access an array of arguments for
+     * the in-flight request
+     */
+    catch(exception: T, host: ArgumentsHost): any;
+}
+interface ExceptionFilterMetadata {
+    func: ExceptionFilter["catch"];
+    exceptionMetatypes: Type[];
+}
+
+/**
+ * Interface defining the `canActivate()` function that must be implemented
+ * by a guard.  Return value indicates whether the current request is
+ * allowed to proceed.  Return can be either synchronous (`boolean`)
+ * or asynchronous (`Promise` or `Observable`).
+ *
+ * @publicApi
+ */
+interface CanActivate {
+    /**
+     * @param context Current execution context. Provides access to details about
+     * the current request pipeline.
+     *
+     * @returns Value indicating whether the current request is allowed to
+     * proceed.
+     */
+    canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean>;
+}
+
+/**
+ * Interface providing access to the response stream.
+ *
+ * @publicApi
+ */
+interface CallHandler<T = any> {
+    /**
+     * Returns an `Observable` representing the response stream from the route
+     * handler.
+     */
+    handle(): Observable<T>;
+}
+/**
+ * Interface describing implementation of an interceptor.
+ *
+ * @publicApi
+ */
+interface VenokInterceptor<T = any, R = any> {
+    /**
+     * Method to implement a custom interceptor.
+     *
+     * @param context an `ExecutionContext` object providing methods to access the
+     * route handler and class about to be invoked.
+     * @param next a reference to the `CallHandler`, which provides access to an
+     * `Observable` representing the response stream from the route handler.
+     */
+    intercept(context: ExecutionContext, next: CallHandler<T>): Observable<R> | Promise<Observable<R>>;
+}
+
+type Transform<T = any> = (value: T, metadata: ArgumentMetadata) => any;
+/**
+ * Interface describing a pipe implementation's `transform()` method metadata argument.
+ *
+ * @publicApi
+ */
+interface ArgumentMetadata {
+    /**
+     * Indicates whether custom parameter
+     */
+    readonly type: string;
+    /**
+     * Underlying base type (e.g., `String`) of the parameter, based on the type
+     * definition in the route handler.
+     */
+    readonly metatype?: Type | undefined;
+    /**
+     * String passed as an argument to the decorator.
+     * Example: `@Body('userId')` would yield `userId`
+     */
+    readonly data?: string | undefined;
+    /**
+     * Current execution context type (string)
+     * */
+    readonly contextType: string;
+}
+/**
+ * Interface describing implementation of a pipe.
+ *
+ * @publicApi
+ */
+interface PipeTransform<T = any, R = any> {
+    /**
+     * Method to implement a custom pipe.  Called with two parameters
+     *
+     * @param value argument before it is received by route handler method
+     * @param metadata contains metadata about the value
+     */
+    transform(value: T, metadata: ArgumentMetadata): R;
+}
+
+interface BeforeApplicationShutdown {
+    beforeApplicationShutdown(signal?: string): any;
+}
+
+/**
+ * Interface defining method called once the application has fully started and
+ * is bootstrapped.
+ *
+ * @publicApi
+ */
+interface OnApplicationBootstrap {
+    onApplicationBootstrap(): any;
+}
+
+/**
+ * Interface defining method to respond to system signals (when application gets
+ * shutdown by, e.g., SIGTERM)
+ *
+ * @publicApi
+ */
+interface OnApplicationShutdown {
+    onApplicationShutdown(signal?: string): any;
+}
+
+/**
+ * Interface defining method called just before Venok destroys the host module
+ * (`app.close()` method has been evaluated).  Use to perform cleanup on
+ * resources (e.g., Database connections).
+ *
+ * @publicApi
+ */
+interface OnModuleDestroy {
+    onModuleDestroy(): any;
+}
+
+/**
+ * Interface defining method called once the host module has been initialized.
+ *
+ * @publicApi
+ */
+interface OnModuleInit {
+    onModuleInit(): any;
+}
+
+/**
+ * The type of injectable dependency
+ */
+type InjectorDependency = InjectionToken;
+/**
+ * The property-based dependency
+ */
+interface PropertyDependency {
+    key: symbol | string;
+    name: InjectorDependency;
+    isOptional?: boolean;
+    instance?: any;
+}
+/**
+ * Context of a dependency which gets injected by
+ * the injector
+ */
+interface InjectorDependencyContext {
+    /**
+     * The name of the property key (property-based injection)
+     */
+    key?: string | symbol;
+    /**
+     * The function itself, the name of the function, or injection token.
+     */
+    name?: Function | string | symbol;
+    /**
+     * The index of the dependency which gets injected
+     * from the dependencies array
+     */
+    index?: number;
+    /**
+     * The dependency array which gets injected
+     */
+    dependencies?: InjectorDependency[];
+}
+
+interface HostComponentInfo {
+    /**
+     * Injection token (or class reference)
+     */
+    token: InjectionToken;
+    /**
+     * Flag that indicates whether DI subtree is durable
+     */
+    isTreeDurable: boolean;
+}
+interface ContextId {
+    readonly id: number;
+    payload?: unknown;
+    getParent?(info: HostComponentInfo): ContextId;
+}
+interface InstancePerContext<T> {
+    instance: T | undefined;
+    isResolved?: boolean;
+    isPending?: boolean;
+    donePromise?: Promise<unknown>;
+    isConstructorCalled?: boolean;
+}
+
+interface LazyModuleLoaderLoadOptions {
+    /**
+     * If `false`, no logs will be generated when loading some module lazily.
+     */
+    logger?: boolean;
+}
+
+interface ModuleFactory {
+    type: Type;
+    token: string;
+    dynamicMetadata?: Partial<DynamicModule>;
+}
+
+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;
+}
+
+type CommonEdgeMetadata = {
+    sourceModuleName: string;
+    targetModuleName: string;
+};
+type ModuleToModuleEdgeMetadata = {
+    type: "module-to-module";
+} & CommonEdgeMetadata;
+type ClassToClassEdgeMetadata = {
+    type: "class-to-class";
+    sourceClassName: string;
+    targetClassName: string;
+    sourceClassToken: InjectionToken;
+    targetClassToken: InjectionToken;
+    injectionType: "constructor" | "property" | "decorator";
+    keyOrIndex?: string | number | symbol;
+    /**
+     * If true, indicates that this edge represents an internal providers connection
+     */
+    internal?: boolean;
+} & CommonEdgeMetadata;
+interface Edge {
+    id: string;
+    source: string;
+    target: string;
+    metadata: ModuleToModuleEdgeMetadata | ClassToClassEdgeMetadata;
+}
+
+interface EnhancerMetadataCacheEntry {
+    targetNodeId?: string;
+    moduleToken: string;
+    classRef: Type;
+    methodKey: string | undefined;
+    enhancerRef?: unknown;
+    enhancerInstanceWrapper?: InstanceWrapper;
+    subtype: EnhancerSubtype;
+}
+
+type Entrypoint<T> = {
+    id?: string;
+    type: string;
+    methodName: string;
+    className: string;
+    classNodeId: string;
+    metadata: {
+        key: string;
+    } & T;
+};
+
+/**
+ * Enhancers attached through APP_PIPE, APP_GUARD, APP_INTERCEPTOR, and APP_FILTER tokens.
+ */
+interface AttachedEnhancerDefinition {
+    nodeId: string;
+}
+/**
+ * Enhancers registered through "app.useGlobalPipes()", "app.useGlobalGuards()", "app.useGlobalInterceptors()", and "app.useGlobalFilters()" methods.
+ */
+interface OrphanedEnhancerDefinition {
+    subtype: EnhancerSubtype;
+    ref: unknown;
+}
+interface Extras {
+    orphanedEnhancers: Array<OrphanedEnhancerDefinition>;
+    attachedEnhancers: Array<AttachedEnhancerDefinition>;
+}
+
+type ModuleNode = {
+    metadata: {
+        type: "module";
+        global: boolean;
+        dynamic: boolean;
+        internal: boolean;
+    };
+};
+type ClassNode = {
+    parent: string;
+    metadata: {
+        type: "provider" | "controller" | "middleware" | "injectable";
+        subtype?: EnhancerSubtype;
+        sourceModuleName: string;
+        durable: boolean;
+        static: boolean;
+        transient: boolean;
+        exported: boolean;
+        scope: Scope;
+        token: InjectionToken;
+        initTime: number;
+        /**
+         * Enhancers metadata collection
+         */
+        enhancers?: Array<{
+            id: string;
+            subtype: EnhancerSubtype;
+        } | {
+            name: string;
+            methodKey?: string;
+            subtype: EnhancerSubtype;
+        }>;
+        /**
+         * If true, node is a globally registered enhancer
+         */
+        global?: boolean;
+        /**
+         * If true, indicates that this node represents an internal provider
+         */
+        internal?: boolean;
+    };
+};
+type Node = {
+    id: string;
+    label: string;
+} & (ClassNode | ModuleNode);
+
+interface SerializedGraphMetadata {
+    cause: {
+        type: "unknown-dependencies" | "unknown";
+        context?: InjectorDependencyContext;
+        moduleId?: string;
+        nodeId?: string;
+        error?: any;
+    };
+}
+
+type SerializedGraphStatus = "partial" | "complete";
+interface SerializedGraphJson {
+    nodes: Record<string, Node>;
+    edges: Record<string, Edge>;
+    entrypoints: Record<string, Entrypoint<unknown>[]>;
+    extras: Extras;
+    status?: SerializedGraphStatus;
+    metadata?: SerializedGraphMetadata;
+}
+
+type ModuleDefinition = ForwardReference | Type | DynamicModule | Promise<DynamicModule>;
+
+/**
+ * Interface defining a Dynamic Module.
+ *
+ * @publicApi
+ */
+interface DynamicModule extends ModuleMetadata {
+    /**
+     * A module reference
+     */
+    module: Type;
+    /**
+     * When "true", makes a module global-scoped.
+     *
+     * Once imported into any module, a global-scoped module will be visible
+     * in all modules. Thereafter, modules that wish to inject a service exported
+     * from a global module do not need to import the provider module.
+     *
+     * @default false
+     */
+    global?: boolean;
+}
+
+interface ForwardReference<T = any> {
+    forwardRef: T;
+}
+
+/**
+ * @publicApi
+ */
+type InjectionToken<T = any> = string | symbol | Type<T> | Abstract<T> | Function;
+
+/**
+ * @publicApi
+ */
+interface IntrospectionResult {
+    /**
+     * Enum defining lifetime of host class or factory.
+     */
+    scope: Scope;
+}
+
+interface VenokModule {
+}
+
+/**
+ * Interface defining the property object that describes the module.
+ *
+ * @publicApi
+ */
+interface ModuleMetadata {
+    /**
+     * Optional list of imported modules that export the providers which are
+     * required in this module.
+     */
+    imports?: Array<Type | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    /**
+     * Optional list of providers that will be instantiated by the Venok injector
+     * and that may be shared at least across this module.
+     */
+    providers?: Provider[];
+    /**
+     * Optional list of the subset of providers that are provided by this module
+     * and should be available in other modules which import this module.
+     */
+    exports?: Array<DynamicModule | Promise<DynamicModule> | string | symbol | Provider | ForwardReference | Abstract<any> | Function>;
+}
+
+/**
+ * @publicApi
+ */
+type OptionalFactoryDependency = {
+    token: InjectionToken;
+    optional: boolean;
+};
+
+/**
+ *
+ * @publicApi
+ */
+type Provider<T = any> = Type | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | ExistingProvider;
+/**
+ * Interface defining a *Class* type provider.
+ *
+ * For example:
+ * ```typescript
+ * const configServiceProvider = {
+ * provide: ConfigService,
+ * useClass:
+ *   process.env.NODE_ENV === 'development'
+ *     ? DevelopmentConfigService
+ *     : ProductionConfigService,
+ * };
+ * ```
+ *
+ * @publicApi
+ */
+interface ClassProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Type (class name) of provider (instance to be injected).
+     */
+    useClass: Type<T>;
+    /**
+     * Optional enum defining lifetime of the provider that is injected.
+     */
+    scope?: Scope;
+    /**
+     * This option is only available on factory providers!
+     *
+     */
+    inject?: never;
+    /**
+     * Flags provider as durable. This flag can be used in combination with custom context id
+     * factory strategy to construct lazy DI subtrees.
+     *
+     * This flag can be used only in conjunction with scope = Scope.REQUEST.
+     */
+    durable?: boolean;
+}
+/**
+ * Interface defining a *Value* type provider.
+ *
+ * For example:
+ * ```typescript
+ * const connectionProvider = {
+ *   provide: 'CONNECTION',
+ *   useValue: connection,
+ * };
+ * ```
+ *
+ * @publicApi
+ */
+interface ValueProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Instance of a provider to be injected.
+     */
+    useValue: T;
+    /**
+     * This option is only available on factory providers!
+     *
+     */
+    inject?: never;
+}
+/**
+ * Interface defining a *Factory* type provider.
+ *
+ * For example:
+ * ```typescript
+ * const connectionFactory = {
+ *   provide: 'CONNECTION',
+ *   useFactory: (optionsProvider: OptionsProvider) => {
+ *     const options = optionsProvider.get();
+ *     return new DatabaseConnection(options);
+ *   },
+ *   inject: [OptionsProvider],
+ * };
+ * ```
+ *
+ * @publicApi
+ */
+interface FactoryProvider<T = any> {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Factory function that returns an instance of the provider to be injected.
+     */
+    useFactory: (...args: any[]) => T | Promise<T>;
+    /**
+     * Optional list of providers to be injected into the context of the Factory function.
+     */
+    inject?: Array<InjectionToken | OptionalFactoryDependency>;
+    /**
+     * Optional enum defining lifetime of the provider that is returned by the Factory function.
+     */
+    scope?: Scope;
+    /**
+     * Flags provider as durable. This flag can be used in combination with custom context id
+     * factory strategy to construct lazy DI subtrees.
+     *
+     * This flag can be used only in conjunction with scope = Scope.REQUEST.
+     */
+    durable?: boolean;
+}
+/**
+ * Interface defining an *Existing* (aliased) type provider.
+ *
+ * For example:
+ * ```typescript
+ * const loggerAliasProvider = {
+ *   provide: 'AliasedLoggerService',
+ *   useExisting: LoggerService
+ * };
+ * ```
+ *
+ * @publicApi
+ */
+interface ExistingProvider {
+    /**
+     * Injection token
+     */
+    provide: InjectionToken;
+    /**
+     * Provider to be aliased by the Injection token.
+     */
+    useExisting: any;
+}
+
+/**
+ * @publicApi
+ */
+interface ConsoleLoggerOptions {
+    /**
+     * Enabled log levels.
+     */
+    logLevels?: LogLevel[];
+    /**
+     * If enabled, will print timestamp (time difference) between current and previous log message.
+     * Note: This option is not used when `json` is enabled.
+     */
+    timestamp?: boolean;
+    /**
+     * A prefix to be used for each log message.
+     * Note: This option is not used when `json` is enabled.
+     */
+    prefix?: string;
+    /**
+     * If enabled, will print the log message in JSON format.
+     */
+    json?: boolean;
+    /**
+     * If enabled, will print the log message in color.
+     * Default true if json is disabled, false otherwise
+     */
+    colors?: boolean;
+    /**
+     * The context of the logger.
+     */
+    context?: string;
+    /**
+     * If enabled, will force the use of console.log/console.error instead of process.stdout/stderr.write.
+     * This is useful for test environments like Jest that can buffer console calls.
+     * @default false
+     */
+    forceConsole?: boolean;
+    /**
+     * If enabled, will print the log message in a single line, even if it is an object with multiple properties.
+     * If set to a number, the most n inner elements are united on a single line as long as all properties fit into breakLength. Short array elements are also grouped together.
+     * Default true when `json` is enabled, false otherwise.
+     */
+    compact?: boolean | number;
+    /**
+     * Specifies the maximum number of Array, TypedArray, Map, Set, WeakMap, and WeakSet elements to include when formatting.
+     * Set to null or Infinity to show all elements. Set to 0 or negative to show no elements.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     * @default 100
+     */
+    maxArrayLength?: number;
+    /**
+     * Specifies the maximum number of characters to include when formatting.
+     * Set to null or Infinity to show all elements. Set to 0 or negative to show no characters.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     * @default 10000.
+     */
+    maxStringLength?: number;
+    /**
+     * If enabled, will sort keys while formatting objects.
+     * Can also be a custom sorting function.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     * @default false
+     */
+    sorted?: boolean | ((a: string, b: string) => number);
+    /**
+     * Specifies the number of times to recurse while formatting object.
+     * This is useful for inspecting large objects. To recurse up to the maximum call stack size pass Infinity or null.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     * @default 5
+     */
+    depth?: number;
+    /**
+     * If true, object's non-enumerable symbols and properties are included in the formatted result.
+     * WeakMap and WeakSet entries are also included as well as user defined prototype properties
+     * @default false
+     */
+    showHidden?: boolean;
+    /**
+     * The length at which input values are split across multiple lines. Set to Infinity to format the input as a single line (in combination with "compact" set to true).
+     * Default Infinity when "compact" is true, 80 otherwise.
+     * Ignored when `json` is enabled, colors are disabled, and `compact` is set to true as it produces a parseable JSON output.
+     */
+    breakLength?: number;
+}
+
+declare const LOG_LEVELS: ["verbose", "debug", "log", "warn", "error", "fatal"];
+interface LogBufferRecord {
+    /**
+     * Method to execute.
+     */
+    methodRef: Function;
+    /**
+     * Arguments to pass to the method.
+     */
+    arguments: unknown[];
+}
+/**
+ * @publicApi
+ */
+declare class Logger implements LoggerService {
+    protected context?: string | undefined;
+    protected options: {
+        timestamp?: boolean;
+    };
+    protected static logBuffer: LogBufferRecord[];
+    protected static staticInstanceRef?: LoggerService;
+    protected static logLevels?: LogLevel[];
+    private static isBufferAttached;
+    protected localInstanceRef?: LoggerService;
+    private static WrapBuffer;
+    constructor();
+    constructor(context: string);
+    constructor(context: string, options?: {
+        timestamp?: boolean;
+    });
+    get localInstance(): LoggerService;
+    /**
+     * Write an 'error' level log.
+     */
+    error(message: any, stack?: string, context?: string): void;
+    error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'log' level log.
+     */
+    log(message: any, context?: string): void;
+    log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'warn' level log.
+     */
+    warn(message: any, context?: string): void;
+    warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log.
+     */
+    debug(message: any, context?: string): void;
+    debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log.
+     */
+    verbose(message: any, context?: string): void;
+    verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log.
+     */
+    fatal(message: any, context?: string): void;
+    fatal(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write an 'error' level log.
+     */
+    static error(message: any, stackOrContext?: string): void;
+    static error(message: any, context?: string): void;
+    static error(message: any, stack?: string, context?: string): void;
+    static error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'log' level log.
+     */
+    static log(message: any, context?: string): void;
+    static log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'warn' level log.
+     */
+    static warn(message: any, context?: string): void;
+    static warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    static debug(message: any, context?: string): void;
+    static debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log.
+     */
+    static verbose(message: any, context?: string): void;
+    static verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log.
+     */
+    static fatal(message: any, context?: string): void;
+    static fatal(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Print buffered logs and detach buffer.
+     */
+    static flush(): void;
+    /**
+     * Attach buffer.
+     * Turns on initialization logs buffering.
+     */
+    static attachBuffer(): void;
+    /**
+     * Detach buffer.
+     * Turns off initialization logs buffering.
+     */
+    static detachBuffer(): void;
+    static getTimestamp(): string;
+    static overrideLogger(logger: LoggerService | LogLevel[] | boolean): any;
+    static isLevelEnabled(level: LogLevel): boolean;
+    private registerLocalInstanceRef;
+}
+
+/**
+ * @publicApi
+ */
+type LogLevel = (typeof LOG_LEVELS)[number];
+/**
+ * @publicApi
+ */
+interface LoggerService {
+    /**
+     * Write a 'log' level log.
+     */
+    log(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write an 'error' level log.
+     */
+    error(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'warn' level log.
+     */
+    warn(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'debug' level log.
+     */
+    debug?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'verbose' level log.
+     */
+    verbose?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'fatal' level log.
+     */
+    fatal?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Set log levels.
+     * @param levels log levels
+     */
+    setLogLevels?(levels: LogLevel[]): any;
+}
+
+interface DecoratorOptions<Options = any, Transformed = Options> {
+    /**
+     * The key for the metadata.
+     * @default uid(21)
+     */
+    key?: string;
+    /**
+     * The transform function to apply to the metadata value.
+     * @default value => value
+     */
+    transform?: (value: Options) => Transformed;
+}
+interface ClassDecoratorOptions<Options = any, Transformed = Options> extends DecoratorOptions<Options, Transformed> {
+    type: "class";
+}
+interface MethodDecoratorOptions<Options = any, Transformed = Options> extends DecoratorOptions<Options, Transformed> {
+    type: "method";
+}
+interface CreateDecoratorOptions<Options = any, Transformed = Options> extends DecoratorOptions<Options, Transformed> {
+    /**
+     * The decorator type (class or method)
+     * @default class & method
+     */
+    type?: DecoratorsType;
+}
+type WithRequired$1<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+type WithTransform<T extends DecoratorOptions> = WithRequired$1<T, "transform">;
+type ReflectableDecorator<Options, Transformed = Options> = ((opts?: Options) => ClassDecorator & MethodDecorator) & {
+    KEY: string;
+};
+type ReflectableClassDecorator<Options, Transformed = Options> = ((opts?: Options) => ClassDecorator) & {
+    KEY: string;
+};
+type ReflectableMethodDecorator<Options, Transformed = Options> = ((opts?: Options) => MethodDecorator) & {
+    KEY: string;
+};
+type ReflectableDecorators<Options, Transformed = any> = ReflectableDecorator<Options, Transformed> | ReflectableClassDecorator<Options, Transformed> | ReflectableMethodDecorator<Options, Transformed>;
+
+interface Abstract<T> extends Function {
+    prototype: T;
+}
+
+type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+
+type ParamDecoratorEnhancer = ParameterDecorator;
+/**
+ * @publicApi
+ */
+type CustomParamFactory<TData = any, TContext = any, TOutput = any> = (data: TData, context: TContext) => TOutput;
+
+/**
+ * @publicApi
+ */
+interface ScopeOptions {
+    /**
+     * Specifies the lifetime of an injected Provider or Controller.
+     */
+    scope?: Scope;
+    /**
+     * Flags provider as durable. This flag can be used in combination with custom context id
+     * factory strategy to construct lazy DI subtrees.
+     *
+     * This flag can be used only in conjunction with scope = Scope.REQUEST.
+     */
+    durable?: boolean;
+}
+
+type CustomClassDecorator = <TFunction extends Object | Function>(target: TFunction, ...args: any) => TFunction | void;
+type CustomDecorator<TKey = string> = MethodDecorator & CustomClassDecorator & {
+    KEY: TKey;
+};
+type DecoratorsType = "class" | "method";
+type SetMetadataType = {
+    /**
+     * Decorator that assigns metadata to the class using the specified `key`.
+     *
+     * Requires three parameters:
+     * - `key` - a value defining the key under which the metadata is stored
+     * - `value` - metadata to be associated with `key`
+     * - `type` - decorator type (class)
+     *
+     * This metadata can be reflected using the `Reflector` class.
+     *
+     * Example: `@SetMetadata('roles', ['admin'], "class")`
+     *
+     * @publicApi
+     */
+    <K = string, V = any>(metadataKey: K, metadataValue: V, type: "class"): CustomClassDecorator & {
+        KEY: K;
+    };
+    /**
+     * Decorator that assigns metadata to the method using the specified `key`.
+     *
+     * Requires three parameters:
+     * - `key` - a value defining the key under which the metadata is stored
+     * - `value` - metadata to be associated with `key`
+     * - `type` - decorator type (method)
+     *
+     * This metadata can be reflected using the `Reflector` class.
+     *
+     * Example: `@SetMetadata('roles', ['admin'], "method")`
+     *
+     * @publicApi
+     */
+    <K = string, V = any>(metadataKey: K, metadataValue: V, type: "method"): MethodDecorator & {
+        KEY: K;
+    };
+    /**
+     * Decorator that assigns metadata to the class/method using the specified `key`.
+     *
+     * Requires two parameters:
+     * - `key` - a value defining the key under which the metadata is stored
+     * - `value` - metadata to be associated with `key`
+     *
+     * This metadata can be reflected using the `Reflector` class.
+     *
+     * Example: `@SetMetadata('roles', ['admin'])`
+     *
+     * @publicApi
+     */
+    <K = string, V = any>(metadataKey: K, metadataValue: V, type?: DecoratorsType): CustomDecorator<K>;
+};
+
+interface Type<T = any> extends Function {
+    new (...args: any[]): T;
+}
+
+declare class ApplicationConfig {
+    private globalPipes;
+    private globalFilters;
+    private globalInterceptors;
+    private globalGuards;
+    private readonly globalRequestPipes;
+    private readonly globalRequestFilters;
+    private readonly globalRequestInterceptors;
+    private readonly globalRequestGuards;
+    addGlobalPipe(pipe: PipeTransform<any>): void;
+    useGlobalPipes(...pipes: PipeTransform<any>[]): void;
+    getGlobalFilters(): ExceptionFilter[];
+    addGlobalFilter(filter: ExceptionFilter): void;
+    useGlobalFilters(...filters: ExceptionFilter[]): void;
+    getGlobalPipes(): PipeTransform<any>[];
+    getGlobalInterceptors(): VenokInterceptor[];
+    addGlobalInterceptor(interceptor: VenokInterceptor): void;
+    useGlobalInterceptors(...interceptors: VenokInterceptor[]): void;
+    getGlobalGuards(): CanActivate[];
+    addGlobalGuard(guard: CanActivate): void;
+    useGlobalGuards(...guards: CanActivate[]): void;
+    addGlobalRequestInterceptor(wrapper: InstanceWrapper<VenokInterceptor>): void;
+    getGlobalRequestInterceptors(): InstanceWrapper<VenokInterceptor>[];
+    addGlobalRequestPipe(wrapper: InstanceWrapper<PipeTransform>): void;
+    getGlobalRequestPipes(): InstanceWrapper<PipeTransform>[];
+    addGlobalRequestFilter(wrapper: InstanceWrapper<ExceptionFilter>): void;
+    getGlobalRequestFilters(): InstanceWrapper<ExceptionFilter>[];
+    addGlobalRequestGuard(wrapper: InstanceWrapper<CanActivate>): void;
+    getGlobalRequestGuards(): InstanceWrapper<CanActivate>[];
+}
+
+/**
+ * @publicApi
+ */
+declare class ApplicationContext<TOptions extends ApplicationContextOptions = ApplicationContextOptions> extends AbstractInstanceResolver implements VenokApplicationContext {
+    readonly container: VenokContainer;
+    protected readonly config: ApplicationConfig;
+    protected readonly appOptions: TOptions;
+    private contextModule;
+    private readonly scope;
+    protected isInitialized: boolean;
+    protected injector: Injector;
+    protected readonly logger: Logger;
+    private shouldFlushLogsOnOverride;
+    private readonly activeShutdownSignals;
+    private readonly moduleCompiler;
+    private shutdownCleanupRef?;
+    private _instanceLinksHost;
+    private _moduleRefsForHooksByDistance?;
+    private initializationPromise?;
+    protected get instanceLinksHost(): InstanceLinksHost;
+    constructor(container: VenokContainer, config: ApplicationConfig, appOptions?: TOptions, contextModule?: Module$1, scope?: Type<any>[]);
+    selectContextModule(): void;
+    /**
+     * Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
+     * @returns {VenokApplicationContext}
+     */
+    select<T>(moduleType: Type<T> | DynamicModule, selectOptions?: SelectOptions): VenokApplicationContext;
+    /**
+     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
+     * @returns {TResult}
+     */
+    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}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each?: undefined | false;
+    }): TResult;
+    /**
+     * Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
+        strict?: boolean;
+        each: true;
+    }): Array<TResult>;
+    /**
+     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
+     * @returns {Array<TResult>}
+     */
+    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>}
+     */
+    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>}
+     */
+    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>}
+     */
+    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
+        id: number;
+    }, options?: {
+        strict?: boolean;
+        each: true;
+    }): Promise<Array<TResult>>;
+    /**
+     * Registers the request/context object for a given context ID (DI container sub-tree).
+     * @returns {void}
+     */
+    registerRequestByContextId<T = any>(request: T, contextId: ContextId): void;
+    /**
+     * Initializes the Venok application.
+     * Calls the Venok lifecycle events.
+     *
+     * @returns {Promise<this>} The ApplicationContext instance as Promise
+     */
+    init(): Promise<this>;
+    /**
+     * Terminates the application
+     * @returns {Promise<void>}
+     */
+    close(signal?: string): Promise<void>;
+    /**
+     * Sets custom logger service.
+     * Flushes buffered logs if auto flush is on.
+     * @returns {void}
+     */
+    useLogger(logger: LoggerService | LogLevel[] | false): void;
+    useGlobalFilters(...filters: ExceptionFilter[]): this;
+    useGlobalPipes(...pipes: PipeTransform<any>[]): this;
+    useGlobalInterceptors(...interceptors: VenokInterceptor[]): this;
+    useGlobalGuards(...guards: CanActivate[]): this;
+    /**
+     * Prints buffered logs and detaches buffer.
+     * @returns {void}
+     */
+    flushLogs(): void;
+    /**
+     * Define that it must flush logs right after defining a custom logger.
+     */
+    flushLogsOnOverride(): void;
+    /**
+     * Enables the usage of shutdown hooks. Will call the
+     * `onApplicationShutdown` function of a provider if the
+     * process receives a shutdown signal.
+     *
+     * @param {ShutdownSignal[]} [signals=[]] The system signals it should listen to
+     *
+     * @returns {this} The Venok application context instance
+     */
+    enableShutdownHooks(signals?: (ShutdownSignal | string)[]): this;
+    protected dispose(): Promise<void>;
+    /**
+     * Listens to shutdown signals by listening to
+     * process events
+     *
+     * @param {string[]} signals The system signals it should listen to
+     */
+    protected listenToShutdownSignals(signals: string[]): void;
+    /**
+     * Unsubscribes from shutdown signals (process events)
+     */
+    protected unsubscribeFromProcessSignals(): void;
+    /**
+     * Calls the `onModuleInit` function on the registered
+     * modules and its children.
+     */
+    protected callInitHook(): Promise<void>;
+    /**
+     * Calls the `onModuleDestroy` function on the registered
+     * modules and its children.
+     */
+    protected callDestroyHook(): Promise<void>;
+    /**
+     * Calls the `onApplicationBootstrap` function on the registered
+     * modules and its children.
+     */
+    protected callBootstrapHook(): Promise<void>;
+    /**
+     * Calls the `onApplicationShutdown` function on the registered
+     * modules and children.
+     */
+    protected callShutdownHook(signal?: string): Promise<void>;
+    /**
+     * Calls the `beforeApplicationShutdown` function on the registered
+     * modules and children.
+     */
+    protected callBeforeShutdownHook(signal?: string): Promise<void>;
+    protected assertNotInPreviewMode(methodName: string): void;
+    private getModulesToTriggerHooksOn;
+    private printInPreviewModeWarning;
+}
+
+/**
+ * A valid Venok entry (or 'root') module reference.
+ */
+type IEntryVenokModule = Type<any> | DynamicModule | ForwardReference | Promise<IEntryVenokModule>;
+/**
+ * @publicApi
+ */
+declare class VenokFactoryStatic {
+    private readonly logger;
+    private abortOnError;
+    private autoFlushLogs;
+    /**
+     * Creates an instance of VenokApplicationContext.
+     *
+     * @param moduleCls Entry (root) application module class
+     * @param options Optional Venok application configuration
+     *
+     * @returns A promise that, when resolved,
+     * contains a reference to the VenokApplicationContext instance.
+     */
+    createApplicationContext(moduleCls: IEntryVenokModule, options?: ApplicationContextOptions): Promise<VenokApplicationContext>;
+    private createVenokInstance;
+    private setAbortOnError;
+    private initialize;
+    private handleInitializationError;
+    private createProxy;
+    private createExceptionProxy;
+    private createExceptionZone;
+    private registerLoggerConfiguration;
+    private createGraphInspector;
+}
+/**
+ * Use VenokFactory to create an application instance.
+ *
+ * ### Specifying an entry module
+ *
+ * Pass the required *root module* for the application via the module parameter.
+ * By convention, it is usually called `ApplicationModule`.  Starting with this
+ * module, Venok assembles the dependency graph and begins the process of
+ * Dependency Injection and instantiates the classes needed to launch your
+ * application.
+ *
+ * @publicApi
+ */
+declare const VenokFactory: VenokFactoryStatic;
+
+declare class ExecutionContextHost implements ExecutionContext {
+    private readonly args;
+    private readonly constructorRef;
+    private readonly handler;
+    private contextType;
+    constructor(args: any[], constructorRef?: Type, handler?: Function);
+    setType<TContext extends string = ContextType>(type: TContext): void;
+    getType<TContext extends string = ContextType>(): TContext;
+    getClass<T = any>(): Type<T>;
+    getHandler(): Function;
+    getArgs<T extends Array<any> = any[]>(): T;
+    getArgByIndex<T = any>(index: number): T;
+}
+
+declare class ContextUtils {
+    mapParamType(key: string): string;
+    reflectCallbackParamtypes(instance: object, methodName: string): any[];
+    reflectCallbackMetadata<T = any>(instance: object, methodName: string, metadataKey: string): T;
+    getArgumentsLength<T extends {
+        [key: string]: {
+            index: number;
+        };
+    }>(keys: string[], metadata: T): number;
+    createNullArray(length: number): any[];
+    mergeParamsMetatypes(paramsProperties: ParamProperties[], paramtypes: any[]): (ParamProperties & {
+        metatype?: any;
+    })[];
+    getCustomFactory(factory: (...args: unknown[]) => void, data: unknown, contextFactory: (args: unknown[]) => ExecutionContextHost): (...args: unknown[]) => unknown;
+    getContextFactory<TContext extends string = ContextType>(contextType: TContext, instance?: object, callback?: Function): (args: unknown[]) => ExecutionContextHost;
+}
+
+declare class InterceptorsConsumer {
+    intercept<TContext extends string = ContextType>(interceptors: VenokInterceptor[], args: unknown[], instance: object, callback: (...args: unknown[]) => unknown, next: () => Promise<unknown>, type?: TContext): Promise<unknown>;
+    createContext(args: unknown[], instance: object, callback: (...args: unknown[]) => unknown): ExecutionContextHost;
+    transformDeferred(next: () => Promise<any>): Observable<any>;
+}
+
+declare abstract class ContextCreator {
+    abstract createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: ContextId, inquirerId?: string): R;
+    getGlobalMetadata?<T extends any[]>(contextId?: ContextId, inquirerId?: string): T;
+    createContext<T extends unknown[] = any, R extends unknown[] = any>(instance: object, callback: (...args: any[]) => void, metadataKey: string, contextId?: ContextId, inquirerId?: string): R;
+    reflectClassMetadata<T>(instance: object, metadataKey: string): T;
+    reflectMethodMetadata<T>(callback: (...args: unknown[]) => unknown, metadataKey: string): T;
+    protected getContextId(contextId: ContextId, instanceWrapper: InstanceWrapper): ContextId;
+}
+
+declare class InterceptorsContextCreator extends ContextCreator {
+    private readonly container;
+    private readonly config?;
+    private moduleContext;
+    constructor(container: VenokContainer, config?: ApplicationConfig | undefined);
+    create(instance: object, callback: (...args: unknown[]) => unknown, module: string, contextId?: ContextId, inquirerId?: string): VenokInterceptor[];
+    createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: ContextId, inquirerId?: string): R;
+    getInterceptorInstance(metatype: Function | VenokInterceptor, contextId?: ContextId, inquirerId?: string): VenokInterceptor | null;
+    getInstanceByMetatype(metatype: Type): InstanceWrapper | undefined;
+    getGlobalMetadata<T extends unknown[]>(contextId?: ContextId, inquirerId?: string): T;
+}
+
+declare class GuardsConsumer {
+    tryActivate<TContext extends string = ContextType>(guards: CanActivate[], args: unknown[], instance: object, callback: (...args: unknown[]) => unknown, type?: TContext): Promise<boolean>;
+    createContext(args: unknown[], instance: object, callback: (...args: unknown[]) => unknown): ExecutionContextHost;
+    pickResult(result: boolean | Promise<boolean> | Observable<boolean>): Promise<boolean>;
+}
+
+declare class GuardsContextCreator extends ContextCreator {
+    private readonly container;
+    private readonly config?;
+    private moduleContext;
+    constructor(container: VenokContainer, config?: ApplicationConfig | undefined);
+    create(instance: object, callback: (...args: unknown[]) => unknown, module: string, contextId?: ContextId, inquirerId?: string): CanActivate[];
+    createConcreteContext<T extends unknown[], R extends unknown[]>(metadata: T, contextId?: ContextId, inquirerId?: string): R;
+    getGuardInstance(metatype: Function | CanActivate, contextId?: ContextId, inquirerId?: string): CanActivate | null;
+    getInstanceByMetatype(metatype: Type): InstanceWrapper | undefined;
+    getGlobalMetadata<T extends unknown[]>(contextId?: ContextId, inquirerId?: string): T;
+}
+
+declare class PipesConsumer {
+    apply<TInput = unknown>(value: TInput, metadata: ArgumentMetadata, pipes: PipeTransform[]): Promise<any>;
+    applyPipes<TInput = unknown>(value: TInput, metadata: ArgumentMetadata, transforms: PipeTransform[]): Promise<any>;
+}
+
+declare class PipesContextCreator extends ContextCreator {
+    private readonly container;
+    private readonly config?;
+    private moduleContext;
+    constructor(container: VenokContainer, config?: ApplicationConfig | undefined);
+    create(instance: object, callback: (...args: unknown[]) => unknown, moduleKey: string, contextId?: ContextId, inquirerId?: string): PipeTransform[];
+    createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: ContextId, inquirerId?: string): R;
+    getPipeInstance(pipe: Function | PipeTransform, contextId?: ContextId, inquirerId?: string): PipeTransform | null;
+    getInstanceByMetatype(metatype: Type): InstanceWrapper | undefined;
+    getGlobalMetadata<T extends unknown[]>(contextId?: ContextId, inquirerId?: string): T;
+    setModuleContext(context: string): void;
+}
+
+declare class ExceptionFilterContextCreator extends ContextCreator {
+    protected readonly container: VenokContainer;
+    protected moduleContext: string;
+    constructor(container: VenokContainer);
+    createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: ContextId, inquirerId?: string): R;
+    getFilterInstance(filter: Function | ExceptionFilter, contextId?: ContextId, inquirerId?: string): ExceptionFilter | null;
+    getInstanceByMetatype(metatype: Type): InstanceWrapper | undefined;
+    reflectCatchExceptions(instance: ExceptionFilter): Type[];
+}
+
+declare class VenokExceptionsHandler {
+    private readonly exceptionsFilter;
+    private filters;
+    constructor(exceptionsFilter: ExceptionFilter);
+    next(exception: Error | any, host: ArgumentsHost): any;
+    setCustomFilters(filters: ExceptionFilterMetadata[]): void;
+    invokeCustomFilters<T = any>(exception: T, host: ArgumentsHost): boolean;
+    protected selectExceptionFilterMetadata<T = any>(filters: ExceptionFilterMetadata[], exception: T): ExceptionFilterMetadata | undefined;
+}
+
+declare class VenokExceptionFilterContext extends ExceptionFilterContextCreator {
+    private readonly config?;
+    constructor(container: VenokContainer, config?: ApplicationConfig | undefined);
+    create(instance: object, callback: (...args: any) => void, module: string, contextId?: ContextId, inquirerId?: string): VenokExceptionsHandler;
+    getExceptionFilter(): ExceptionFilter;
+    getGlobalMetadata<T extends any[]>(contextId?: ContextId, inquirerId?: string): T;
+}
+
+declare class VenokProxy {
+    createProxy<TContext extends string = ContextType>(targetCallback: (...args: any[]) => any, exceptionsHandler: VenokExceptionsHandler, type?: ContextType): (...args: any[]) => Promise<any>;
+    private handleError;
+    createExceptionLayerProxy<TContext extends string = ContextType>(targetCallback: <TError>(err: TError, ...args: any[]) => void | Promise<void>, exceptionsHandler: VenokExceptionsHandler, type?: TContext): <TError>(err: TError, req: any, res: any, next: any) => Promise<any>;
+}
+
+/**
+ * Helper class providing Venok reflection capabilities.
+ *
+ * @publicApi
+ */
+declare class Reflector {
+    static reflector: Reflector;
+    /**
+     * Creates a decorator that can be used to decorate classes and methods with metadata.
+     * Can be used as a strongly-typed alternative to `@SetMetadata`.
+     * @param options Decorator options.
+     * @returns A decorator function.
+     */
+    static createDecorator<Options>(options?: DecoratorOptions<Options>): ReflectableDecorator<Options>;
+    static createDecorator<Options>(options?: ClassDecoratorOptions<Options>): ReflectableClassDecorator<Options>;
+    static createDecorator<Options>(options?: MethodDecoratorOptions<Options>): ReflectableMethodDecorator<Options>;
+    static createDecorator<Options, Transformed = Options>(options: WithTransform<DecoratorOptions<Options, Transformed>>): ReflectableDecorator<Options, Transformed>;
+    static createDecorator<Options, Transformed = Options>(options: WithTransform<ClassDecoratorOptions<Options, Transformed>>): ReflectableClassDecorator<Options, Transformed>;
+    static createDecorator<Options, Transformed = Options>(options: WithTransform<MethodDecoratorOptions<Options, Transformed>>): ReflectableMethodDecorator<Options, Transformed>;
+    /**
+     * Creates a decorator with additional metadata that can be
+     * used `(for internal use, like @Sse in Http etc.)`
+     * to decorate classes and methods with metadata.
+     * @param options Decorator options.
+     * @returns A decorator function.
+     */
+    static createMetadataDecorator<Options, Transformed extends Record<any, any>>(options: WithTransform<DecoratorOptions<Options, Transformed>>): ReflectableDecorator<Options, Transformed>;
+    static createMetadataDecorator<Options, Transformed extends Record<any, any>>(options: WithTransform<ClassDecoratorOptions<Options, Transformed>>): ReflectableClassDecorator<Options, Transformed>;
+    static createMetadataDecorator<Options, Transformed extends Record<any, any>>(options: WithTransform<MethodDecoratorOptions<Options, Transformed>>): ReflectableMethodDecorator<Options, Transformed>;
+    constructor();
+    /**
+     * Check if metadata exist for a metadata decorator for a specified target.
+     *
+     * @example
+     * `const roles = this.reflector.has(Roles, context.getHandler());`
+     *
+     * @param decorator reflectable decorator created through `Reflector.createDecorator`
+     * @param target context (decorated object) to check metadata from
+     *
+     */
+    has<T extends ReflectableDecorators<any>>(decorator: T, target: Type | Function): boolean;
+    /**
+     * Check if metadata exist for a specified key for a specified target.
+     *
+     * @example
+     * `const roles = this.reflector.has('roles', context.getHandler());`
+     *
+     * @param metadataKey lookup key for metadata to check
+     * @param target context (decorated object) to check metadata from
+     *
+     */
+    has<TKey = any>(metadataKey: TKey, target: Type | Function): boolean;
+    /**
+     * Retrieve metadata for a reflectable decorator for a specified target.
+     *
+     * @example
+     * `const roles = this.reflector.get(Roles, context.getHandler());`
+     *
+     * @param decorator reflectable decorator created through `Reflector.createDecorator`
+     * @param target context (decorated object) to retrieve metadata from
+     *
+     */
+    get<T extends ReflectableDecorators<any>>(decorator: T, target: Type | Function): T extends ReflectableDecorators<any, infer R> ? R : unknown;
+    /**
+     * Retrieve metadata for a specified key for a specified target.
+     *
+     * @example
+     * `const roles = this.reflector.get<string[]>('roles', context.getHandler());`
+     *
+     * @param metadataKey lookup key for metadata to retrieve
+     * @param target context (decorated object) to retrieve metadata from
+     *
+     */
+    get<TResult = any, TKey = any>(metadataKey: TKey, target: Type | Function): TResult;
+    /**
+     * Retrieve metadata for a specified decorator for a specified set of targets.
+     *
+     * @param decorator lookup decorator for metadata to retrieve
+     * @param targets context (decorated objects) to retrieve metadata from
+     *
+     */
+    getAll<T extends ReflectableDecorators<any>>(decorator: T, targets: (Type | Function)[]): T extends ReflectableDecorators<infer R> ? (R extends Array<any> ? R : R[]) : unknown;
+    /**
+     * Retrieve metadata for a specified key for a specified set of targets.
+     *
+     * @param metadataKey lookup key for metadata to retrieve
+     * @param targets context (decorated objects) to retrieve metadata from
+     *
+     */
+    getAll<TResult extends any[] = any[], TKey = any>(metadataKey: TKey, targets: (Type | Function)[]): TResult;
+    /**
+     * Retrieve metadata for a specified decorator for a specified set of targets and merge results.
+     *
+     * @param decorator lookup decorator for metadata to retrieve
+     * @param targets context (decorated objects) to retrieve metadata from
+     *
+     */
+    getAllAndMerge<T extends ReflectableDecorators<any>>(decorator: T, targets: (Type | Function)[]): T extends ReflectableDecorators<infer R> ? R : unknown;
+    /**
+     * Retrieve metadata for a specified key for a specified set of targets and merge results.
+     *
+     * @param metadataKey lookup key for metadata to retrieve
+     * @param targets context (decorated objects) to retrieve metadata from
+     *
+     */
+    getAllAndMerge<TResult extends any[] | object = any[], TKey = any>(metadataKey: TKey, targets: (Type | Function)[]): TResult;
+    /**
+     * Retrieve metadata for a specified decorator for a specified set of targets and return a first not undefined value.
+     *
+     * @param decorator lookup decorator for metadata to retrieve
+     * @param targets context (decorated objects) to retrieve metadata from
+     *
+     */
+    getAllAndOverride<T extends ReflectableDecorators<any>>(decorator: T, targets: (Type | Function)[]): T extends ReflectableDecorators<infer R> ? R : unknown;
+    /**
+     * Retrieve metadata for a specified key for a specified set of targets and return a first not undefined value.
+     *
+     * @param metadataKey lookup key for metadata to retrieve
+     * @param targets context (decorated objects) to retrieve metadata from
+     *
+     */
+    getAllAndOverride<TResult = any, TKey = any>(metadataKey: TKey, targets: (Type | Function)[]): TResult;
+}
+
+declare class VenokContextCreator implements VenokContextCreatorInterface {
+    private readonly guardsContextCreator;
+    private readonly guardsConsumer;
+    private readonly interceptorsContextCreator;
+    private readonly interceptorsConsumer;
+    private readonly modulesContainer;
+    private readonly pipesContextCreator;
+    private readonly pipesConsumer;
+    protected readonly filtersContextCreator: VenokExceptionFilterContext;
+    readonly contextUtils: ContextUtils;
+    readonly venokProxy: VenokProxy;
+    readonly reflector: Reflector;
+    private readonly handlerMetadataStorage;
+    container: VenokContainer;
+    constructor(guardsContextCreator: GuardsContextCreator, guardsConsumer: GuardsConsumer, interceptorsContextCreator: InterceptorsContextCreator, interceptorsConsumer: InterceptorsConsumer, modulesContainer: ModulesContainer, pipesContextCreator: PipesContextCreator, pipesConsumer: PipesConsumer, filtersContextCreator: VenokExceptionFilterContext);
+    static fromContainer(container: VenokContainer, contextClass?: typeof VenokContextCreator, filtersContextClass?: typeof VenokExceptionFilterContext): VenokContextCreator;
+    create<TParamsMetadata extends ParamsMetadata = ParamsMetadata, TContext extends string = ContextType>(instance: object, callback: (...args: unknown[]) => unknown, methodName: string, metadataKey?: string, paramsFactory?: VenokParamsFactoryInterface, contextId?: ContextId, inquirerId?: string, options?: ExternalContextOptions, contextType?: TContext): (...args: any[]) => Promise<any>;
+    getMetadata<TMetadata, TContext extends string = ContextType>(instance: object, methodName: string, metadataKey?: string, paramsFactory?: VenokParamsFactoryInterface, contextType?: TContext): ExternalHandlerMetadata;
+    getContextModuleKey(moduleCtor: Function | undefined): string;
+    exchangeKeysForValues<TMetadata extends Record<string | symbol, any>>(keys: string[], metadata: TMetadata, moduleContext: string, paramsFactory: VenokParamsFactoryInterface, contextId?: ContextId, inquirerId?: string, contextFactory?: (args: unknown[]) => ExecutionContextHost): ParamProperties[];
+    createPipesFn(pipes: PipeTransform[], paramsOptions: (ParamProperties & {
+        metatype?: unknown;
+    })[], contextType: string): ((args: unknown[], ...params: unknown[]) => Promise<void>) | null;
+    getParamValue<T>(value: T, metadata: ArgumentMetadata, pipes: PipeTransform[]): Promise<any>;
+    transformToResult(resultOrDeferred: Observable<any> | any): Promise<any>;
+    createGuardsFn<TContext extends string = ContextType>(guards: any[], instance: object, callback: (...args: any[]) => any, contextType?: TContext): Function | null;
+}
+
+declare class ContextIdFactory {
+    private static strategy?;
+    /**
+     * Generates a context identifier based on the request object.
+     */
+    static create(): ContextId;
+    /**
+     * Generates a random identifier to track asynchronous execution context.
+     * @param request request object
+     * @param propsToInspect
+     */
+    static getByRequest<T extends Record<any, any> = any>(request: T, propsToInspect?: string[]): ContextId;
+    /**
+     * Registers a custom context id strategy that lets you attach
+     * a parent context id to the existing context id object.
+     * @param strategy strategy instance
+     */
+    static apply(strategy: ContextIdStrategy): void;
+    private static isContextIdResolverWithPayload;
+}
+
+/**
+ * Function that returns a new decorator that applies all decorators provided by param
+ *
+ * Useful to build new decorators (or a decorator factory) encapsulating multiple decorators related with the same feature
+ *
+ * @param decorators one or more decorators (e.g., `ApplyGuard(...)`)
+ *
+ * @publicApi
+ */
+declare function applyDecorators(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator>): <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+
+/**
+ * Decorator that binds *parameter decorators* to the method that follows.
+ *
+ * Useful when the language doesn't provide a 'Parameter Decorator' feature
+ * (i.e., vanilla JavaScript).
+ *
+ * @param decorators one or more parameter decorators (e.g., `Req()`)
+ *
+ * @publicApi
+ */
+declare function Bind(...decorators: any[]): MethodDecorator;
+
+/**
+ * Decorator that marks a class as a Venok exception filter. An exception filter
+ * handles exceptions thrown by or not handled by your application code.
+ *
+ * The decorated class must implement the `ExceptionFilter` interface.
+ *
+ * @param exceptions one or more exception *types* specifying
+ * the exceptions to be caught and handled by this filter.
+ *
+ * @usageNotes
+ * Exception filters are applied using the `@UseFilters()` decorator, or (globally)
+ * with `app.useGlobalFilters()`.
+ *
+ * @publicApi
+ */
+declare function Catch(...exceptions: Array<Type | Abstract<any>>): ClassDecorator;
+
+/**
+ * Decorator that sets required dependencies (required with a vanilla JavaScript objects)
+ *
+ * @publicApi
+ */
+declare const Dependencies: (...dependencies: Array<unknown>) => ClassDecorator;
+
+/**
+ * Decorator that binds exception filters to the scope of the controller or
+ * method, depending on its context.
+ *
+ * When `@UseFilters` is used at the provider level, the filter will be
+ * applied to every handler (method) in the provider.
+ *
+ * When `@UseFilters` is used at the individual handler level, the filter
+ * will apply only to that specific method.
+ *
+ * @param filters exception filter instance or class, or a list of exception
+ * filter instances or classes.
+ *
+ * @usageNotes
+ * Exception filters can also be set up globally for all controllers and routes
+ * using `app.useGlobalFilters()`.
+ *
+ * @publicApi
+ */
+declare const UseFilters: (...filters: (ExceptionFilter | Function)[]) => MethodDecorator & ClassDecorator;
+
+/**
+ * Decorator that makes a module global-scoped.
+ *
+ * Once imported into any module, a global-scoped module will be visible
+ * in all modules. Thereafter, modules that wish to inject a service exported
+ * from a global module do not need to import the provider module.
+ *
+ * @publicApi
+ */
+declare function Global(): ClassDecorator;
+
+/**
+ * Decorator that marks a constructor parameter as a target for
+ * Dependency Injection (DI).
+ *
+ * Any injected provider must be visible within the module scope (loosely
+ * speaking, the containing module) of the class it is being injected into. This
+ * can be done by:
+ *
+ * - defining the provider in the same module scope
+ * - exporting the provider from one module scope and importing that module into the
+ *   module scope of the class being injected into
+ * - exporting the provider from a module that is marked as global using the
+ *   `@Global()` decorator
+ *
+ * #### Injection tokens
+ * Can be *types* (class names), *strings* or *symbols*. This depends on how the
+ * provider with which it is associated was defined. Providers defined with the
+ * `@Injectable()` decorator use the class name. Custom Providers may use strings
+ * or symbols as the injection token.
+ *
+ * @param token lookup key for the provider to be injected (assigned to the constructor
+ * parameter).
+ *
+ * @publicApi
+ */
+declare function Inject(token?: InjectionToken | ForwardReference): PropertyDecorator & ParameterDecorator;
+
+/**
+ * Defines the injection scope.
+ *
+ * @publicApi
+ */
+type InjectableOptions = ScopeOptions;
+/**
+ * Decorator that marks a class as a provider(https://venok.com/providers).
+ * Providers can be injected into other classes via constructor parameter injection
+ * using Venok built-in [Dependency Injection (DI)](https://venok.com/providers#dependency-injection)
+ * system.
+ *
+ * When injecting a provider, it must be visible within the module scope (loosely
+ * speaking, the containing module) of the class it is being injected into. This
+ * can be done by:
+ *
+ * - defining the provider in the same module scope
+ * - exporting the provider from one module scope and importing that module into the
+ *   module scope of the class being injected into
+ * - exporting the provider from a module that is marked as global using the
+ *   `@Global()` decorator
+ *
+ * Providers can also be defined in a more explicit and imperative form using
+ * various [custom provider](https://venok.com/fundamentals/custom-providers) techniques that expose
+ * more capabilities of the DI system.
+ *
+ * @param options options specifying scope of injectable
+ *
+ * @see [Providers](https://venok.com/providers)
+ * @see [Custom Providers](https://venok.com/fundamentals/custom-providers)
+ * @see [Injection Scopes](https://venok.com/fundamentals/injection-scopes)
+ *
+ * @publicApi
+ */
+declare function Injectable(options?: InjectableOptions): ClassDecorator;
+/**
+ * @publicApi
+ */
+declare function mixin<T>(mixinClass: Type<T>): Type<T>;
+
+/**
+ * Extended interface for Module decorator that allows custom keys
+ */
+interface ExtendedModuleMetadata {
+    /**
+     * Allows any additional keys (controllers, queues, processors, etc.)
+     * that will be automatically added to the providers array.
+     */
+    [key: string]: Provider[];
+}
+/**
+ * Decorator that marks a class as a module.
+ *
+ * Modules are used by Venok to organize the application structure into scopes.
+ * Providers are scoped by the module they are declared in. Modules and their
+ * classes (Providers) form a graph that determines how Venok
+ *
+ * @param metadata module configuration metadata
+ *
+ * @publicApi
+ */
+declare function Module(metadata: ModuleMetadata & ExtendedModuleMetadata): ClassDecorator;
+
+/**
+ * Parameter decorator for an injected dependency marking the
+ * dependency as optional.
+ *
+ * For example:
+ * ```typescript
+ * constructor(@Optional() @Inject('HTTP_OPTIONS')private readonly httpClient: T) {}
+ * ```
+ *
+ * @see [Optional providers](https://venok.com/providers#optional-providers)
+ *
+ * @publicApi
+ */
+declare function Optional(): PropertyDecorator & ParameterDecorator;
+
+declare const SetMetadata: SetMetadataType;
+
+/**
+ * Decorator that binds guards to the scope of the provider or method,
+ * depending on its context.
+ *
+ * When `@UseGuards` is used at the controller level, the guard will be
+ * applied to every handler (method) in the provider.
+ *
+ * When `@UseGuards` is used at the individual handler level, the guard
+ * will apply only to that specific method.
+ *
+ * @param guards a single guard instance or class, or a list of guard instances
+ * or classes.
+ *
+ * @usageNotes
+ * Guards can also be set up globally for all controllers and routes
+ * using `app.useGlobalGuards()`.
+ *
+ * @publicApi
+ */
+declare function UseGuards(...guards: (CanActivate | Function)[]): MethodDecorator & ClassDecorator;
+
+/**
+ * Decorator that binds pipes to the scope of the provider or method,
+ * depending on its context.
+ *
+ * When `@UsePipes` is used at the controller level, the pipe will be
+ * applied to every handler (method) in the provider.
+ *
+ * When `@UsePipes` is used at the individual handler level, the pipe
+ * will apply only to that specific method.
+ *
+ * @param pipes a single pipe instance or class, or a list of pipe instances or
+ * classes.
+ *
+ * @usageNotes
+ * Pipes can also be set up globally for all controllers and routes
+ * using `app.useGlobalPipes()`.
+ *
+ * @publicApi
+ */
+declare function UsePipes(...pipes: (PipeTransform | Function)[]): ClassDecorator & MethodDecorator;
+
+/**
+ * Decorator that binds interceptors to the scope of the provider or method,
+ * depending on its context.
+ *
+ * When `@UseInterceptors` is used at the controller level, the interceptor will
+ * be applied to every handler (method) in the provider.
+ *
+ * When `@UseInterceptors` is used at the individual handler level, the interceptor
+ * will apply only to that specific method.
+ *
+ * @param interceptors a single interceptor instance or class, or a list of
+ * interceptor instances or classes.
+ *
+ * @usageNotes
+ * Interceptors can also be set up globally for all controllers and routes
+ * using `app.useGlobalInterceptors()`.
+ *
+ * @publicApi
+ */
+declare function UseInterceptors(...interceptors: (VenokInterceptor | Function)[]): MethodDecorator & ClassDecorator;
+
+declare class RuntimeException extends Error {
+    constructor(message?: string);
+    what(): string;
+}
+
+declare class CircularDependencyException extends RuntimeException {
+    constructor(context?: string);
+}
+
+declare class InvalidClassException extends RuntimeException {
+    constructor(value: any);
+}
+
+declare class InvalidClassModuleException extends RuntimeException {
+    constructor(metatypeUsedAsAModule: any, scope: any[]);
+}
+
+declare class InvalidClassScopeException extends RuntimeException {
+    constructor(metatypeOrToken: Type | Abstract<any> | string | symbol);
+}
+
+declare class InvalidExceptionFilterException extends RuntimeException {
+    constructor();
+}
+
+declare class InvalidModuleException extends RuntimeException {
+    constructor(parentModule: any, index: number, scope: any[]);
+}
+
+declare class UndefinedDependencyException extends RuntimeException {
+    constructor(type: string, undefinedDependencyContext: InjectorDependencyContext, module: Module$1);
+}
+
+declare class UndefinedForwardRefException extends RuntimeException {
+    constructor(scope: Type[]);
+}
+
+declare class UndefinedModuleException extends RuntimeException {
+    constructor(parentModule: any, index: number, scope: any[]);
+}
+
+declare class UnknownDependenciesException extends RuntimeException {
+    readonly type: string | symbol;
+    readonly context: InjectorDependencyContext;
+    readonly metadata?: {
+        id: string;
+    } | undefined;
+    readonly moduleRef: {
+        id: string;
+    } | undefined;
+    constructor(type: string | symbol, context: InjectorDependencyContext, moduleRef: Module$1, metadata?: {
+        id: string;
+    } | undefined);
+}
+
+declare class UnknownElementException extends RuntimeException {
+    constructor(name?: string | symbol);
+}
+
+declare class UnknownExportException extends RuntimeException {
+    constructor(token: string | symbol, moduleName: string);
+}
+
+declare class UnknownModuleException extends RuntimeException {
+    constructor(moduleName?: string);
+}
+
+declare const UNKNOWN_DEPENDENCIES_MESSAGE: (type: string | symbol, unknownDependencyContext: InjectorDependencyContext, module: Module$1) => string;
+declare const UNDEFINED_FORWARDREF_MESSAGE: (scope: Type[]) => string;
+declare const INVALID_MODULE_MESSAGE: (parentModule: any, index: number, scope: any[]) => string;
+declare const USING_INVALID_CLASS_AS_A_MODULE_MESSAGE: (metatypeUsedAsAModule: Type | ForwardReference, scope: any[]) => string;
+declare const UNDEFINED_MODULE_MESSAGE: (parentModule: any, index: number, scope: any[]) => string;
+declare const UNKNOWN_EXPORT_MESSAGE: (token: string | symbol | undefined, module: string) => string;
+declare const INVALID_CLASS_MESSAGE: (text: TemplateStringsArray, value: any) => string;
+declare const INVALID_CLASS_SCOPE_MESSAGE: (text: TemplateStringsArray, name: string | undefined) => string;
+declare const UNHANDLED_RUNTIME_EXCEPTION = "Unhandled Runtime Exception.";
+declare const INVALID_EXCEPTION_FILTER = "Invalid exception filters (@UseFilters()).";
+declare const MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = "Unable to load @Venok/microservices package. (Please make sure that it's already installed.)";
+
+declare const isColorAllowed: () => boolean;
+declare const colors: {
+    bold: (text: string) => string;
+    green: (text: string) => string;
+    yellow: (text: string) => string;
+    red: (text: string) => string;
+    magentaBright: (text: string) => string;
+    cyanBright: (text: string) => string;
+};
+declare const yellow: (text: string) => string;
+
+declare function createContextId(): ContextId;
+
+type DefaultParamTypes = {
+    [key: string]: string | number;
+};
+declare const createParamDecoratorWithoutPipes: <FactoryData = any, FactoryContext = any, FactoryOutput = any>(factory: CustomParamFactory<FactoryData, FactoryContext, FactoryOutput>) => (data?: ParamData) => ParameterDecorator;
+/**
+ * Defines custom param decorator
+ *
+ * @param factory
+ * @param enhancers
+ *
+ * @publicApi
+ */
+declare const createParamDecorator: <FactoryData = any, FactoryContext = any, FactoryOutput = any>(factory: CustomParamFactory<FactoryData, FactoryContext, FactoryOutput>, enhancers?: ParamDecoratorEnhancer[]) => (...dataOrPipes: (Type<PipeTransform> | PipeTransform | FactoryData)[]) => ParameterDecorator;
+declare const createNativeParamDecoratorWithoutPipes: <Paramtypes extends DefaultParamTypes>(paramtype: Paramtypes[string]) => (data?: ParamData) => ParameterDecorator;
+declare const createNativeParamDecorator: <Paramtypes extends DefaultParamTypes>(paramtype: Paramtypes[string]) => (data?: any, ...pipes: (Type<PipeTransform> | PipeTransform)[]) => ParameterDecorator;
+
+/**
+ * @publicApi
+ */
+declare function filterLogLevels(parseableString?: string): LogLevel[];
+
+declare function flatten<T extends Array<unknown> = any>(arr: T): T extends Array<infer R> ? R : never;
+
+/**
+ * @publicApi
+ */
+declare function isLogLevel(maybeLogLevel: any): maybeLogLevel is LogLevel;
+
+/**
+ * Checks if target level is enabled.
+ * @param targetLevel target level
+ * @param logLevels array of enabled log levels
+ */
+declare function isLogLevelEnabled(targetLevel: LogLevel, logLevels: LogLevel[] | undefined): boolean;
+
+declare const MODULE_INIT_MESSAGE: (text: TemplateStringsArray, module: string) => string;
+
+declare function extendArrayMetadata<T extends Array<unknown>>(key: string, metadata: T, target: Function): void;
+declare function assignMetadata<TParamtype extends string | number = string>(args: Record<string, ParamMetadata>, paramtype: TParamtype, index: number, data?: ParamData, ...pipes: (Type<PipeTransform> | PipeTransform)[]): {
+    [x: string]: ParamMetadata | {
+        index: number;
+        data: ParamData | undefined;
+        pipes: (PipeTransform<any, any> | Type<PipeTransform<any, any>>)[];
+    };
+};
+declare function assignCustomParameterMetadata(args: Record<string, ParamMetadata>, paramtype: number | string, index: number, factory: CustomParamFactory, data?: ParamData, ...pipes: (Type<PipeTransform> | PipeTransform)[]): {
+    [x: string]: ParamMetadata | {
+        index: number;
+        factory: CustomParamFactory;
+        data: ParamData | undefined;
+        pipes: (PipeTransform<any, any> | Type<PipeTransform<any, any>>)[];
+    };
+};
+
+declare const noop: () => void;
+
+declare const randomStringGenerator: () => string;
+
+declare const rethrow: (err: unknown) => never;
+
+declare const isUndefined: (obj: any) => obj is undefined;
+declare const isNull: (val: any) => val is null | undefined;
+declare const isObject: (fn: any) => fn is object;
+declare const isFunction: (val: any) => val is Function;
+declare const isString: (val: any) => val is string;
+declare const isNumber: (val: any) => val is number;
+declare const isConstructor: (val: any) => boolean;
+declare const isEmpty: (array: any) => boolean;
+declare const isSymbol: (val: any) => val is symbol;
+declare const isPlainObject: (fn: any) => fn is object;
+
+declare class SilentLogger extends Logger {
+    log: () => void;
+    error: () => void;
+    warn: () => void;
+    debug: () => void;
+    verbose: () => void;
+    fatal: () => void;
+    setLogLevels: () => void;
+}
+
+/**
+ * Returns the instances which are transient
+ * @param instances The instances which should be checked whether they are transient
+ */
+declare function getTransientInstances(instances: [InjectionToken, InstanceWrapper][]): InstanceWrapper[];
+/**
+ * Returns the instances which are not transient
+ * @param instances The instances which should be checked whether they are transient
+ */
+declare function getNonTransientInstances(instances: [InjectionToken, InstanceWrapper][]): InstanceWrapper[];
+
+declare enum UuidFactoryMode {
+    Random = "random",
+    Deterministic = "deterministic"
+}
+declare class DeterministicUuidRegistry {
+    private static readonly registry;
+    static get(str: string, inc?: number): string;
+    static clear(): void;
+    private static hashCode;
+}
+declare class UuidFactory {
+    #private;
+    static set mode(value: UuidFactoryMode);
+    static get(key?: string): string;
+}
+
+declare class InvalidDecoratorItemException extends Error {
+    private readonly msg;
+    constructor(decorator: string, item: string, context: string);
+    what(): string;
+}
+declare function validateEach(context: {
+    name: string;
+}, arr: any[], predicate: Function, decorator: string, item: string): boolean;
+
+declare const STATIC_CONTEXT: ContextId;
+declare const PROVIDER_ID_KEY: unique symbol;
+
+declare const ReflectorAliasProvider: Provider;
+declare const requestProvider: Provider;
+declare const inquirerProvider: Provider;
+
+interface ModuleOverride {
+    moduleToReplace: ModuleDefinition;
+    newModule: ModuleDefinition;
+}
+
+declare class GraphInspector {
+    private readonly container;
+    private readonly graph;
+    private readonly enhancersMetadataCache;
+    constructor(container: VenokContainer);
+    inspectModules(modules?: Map<string, Module$1>): void;
+    registerPartial(error: unknown): void;
+    inspectInstanceWrapper<T = any>(source: InstanceWrapper<T>, moduleRef: Module$1): void;
+    insertEnhancerMetadataCache(entry: EnhancerMetadataCacheEntry): void;
+    insertOrphanedEnhancer(entry: OrphanedEnhancerDefinition): void;
+    insertAttachedEnhancer(wrapper: InstanceWrapper): void;
+    insertEntrypointDefinition<T>(definition: Entrypoint<T>, parentId: string): void;
+    insertClassNode(moduleRef: Module$1, wrapper: InstanceWrapper, type: Exclude<Node["metadata"]["type"], "module">): void;
+    private insertModuleNode;
+    private insertModuleToModuleEdges;
+    private insertEnhancerEdge;
+    private insertClassToClassEdge;
+    private insertClassNodes;
+}
+
+declare class MetadataScanner {
+    private readonly cachedScannedPrototypes;
+    getAllMethodNames(prototype: object | null): string[];
+}
+
+interface ModulesScanParameters {
+    moduleDefinition: ModuleDefinition;
+    scope?: Type[];
+    ctxRegistry?: (ForwardReference | DynamicModule | Type)[];
+    overrides?: ModuleOverride[];
+    lazy?: boolean;
+}
+declare class DependenciesScanner {
+    private readonly container;
+    private readonly metadataScanner;
+    private readonly graphInspector;
+    private readonly applicationConfig;
+    private readonly applicationProvidersApplyMap;
+    constructor(container: VenokContainer, metadataScanner: MetadataScanner, graphInspector: GraphInspector, applicationConfig?: ApplicationConfig);
+    scan(module: Type, options?: {
+        overrides?: ModuleOverride[];
+    }): Promise<void>;
+    scanForModules({ moduleDefinition, lazy, scope, ctxRegistry, overrides, }: ModulesScanParameters): Promise<Module$1[]>;
+    insertModule(moduleDefinition: ModuleDefinition, scope: Type[]): Promise<{
+        moduleRef: Module$1;
+        inserted: boolean;
+    } | undefined>;
+    scanModulesForDependencies(modules?: Map<string, Module$1>): Promise<void>;
+    reflectImports(module: Type, token: string, context: string): Promise<void>;
+    reflectProviders(module: Type, token: string): void;
+    reflectDynamicMetadata(cls: Type<InjectableToken>, token: string): void;
+    reflectExports(module: Type, token: string): void;
+    reflectInjectables(component: Type<InjectableToken>, token: string, metadataKey: keyof typeof ENHANCER_KEY_TO_SUBTYPE_MAP): void;
+    reflectParamInjectables(component: Type<InjectableToken>, token: string, metadataKey: string): void;
+    reflectKeyMetadata(component: Type<InjectableToken>, key: string, methodKey: string): {
+        methodKey: string;
+        metadata: any;
+    } | undefined;
+    calculateModulesDistance(): void;
+    insertImport(related: Type | DynamicModule, token: string, context: string): Promise<void>;
+    isCustomProvider(provider: Provider): provider is ClassProvider | ValueProvider | FactoryProvider | ExistingProvider;
+    insertProvider(provider: Provider, token: string): string | symbol | Function | InstanceWrapper<unknown> | undefined;
+    insertInjectable(injectable: Type<InjectableToken> | object, token: string, host: Type<InjectableToken>, subtype: EnhancerSubtype, methodKey?: string): InstanceWrapper<any> | undefined;
+    insertExportedProviderOrModule(toExport: ForwardReference | DynamicModule | Type<unknown>, token: string): void;
+    private insertOrOverrideModule;
+    private getOverrideModuleByModule;
+    private overrideModule;
+    reflectMetadata<T = any>(metadataKey: string, metatype: Type): T[];
+    registerCoreModule(overrides?: ModuleOverride[]): Promise<void>;
+    /**
+     * Add either request or transient globally scoped enhancers
+     * to all controllers metadata storage
+     */
+    addScopedEnhancersMetadata(): void;
+    applyApplicationProviders(): void;
+    getApplyProvidersMap(): {
+        [type: string]: Function;
+    };
+    getApplyRequestProvidersMap(): {
+        [type: string]: Function;
+    };
+    isDynamicModule(module: Type | DynamicModule): module is DynamicModule;
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Injectable()` decorator.
+     */
+    private isInjectable;
+    /**
+     * @param metatype
+     * @returns `true` if `metatype` is annotated with the `@Catch()` decorator.
+     */
+    private isExceptionFilter;
+    private isForwardReference;
+    private isRequestOrTransient;
+}
+
+declare class InstanceLoader<TInjector extends Injector = Injector> {
+    protected readonly container: VenokContainer;
+    protected readonly injector: TInjector;
+    protected readonly graphInspector: GraphInspector;
+    private logger;
+    constructor(container: VenokContainer, injector: TInjector, graphInspector: GraphInspector, logger?: LoggerService);
+    setLogger(logger: Logger): void;
+    createInstancesOfDependencies(modules?: Map<string, Module$1>): Promise<void>;
+    private createPrototypes;
+    private createInstances;
+    private createPrototypesOfProviders;
+    private createInstancesOfProviders;
+    private createPrototypesOfInjectables;
+    private createInstancesOfInjectables;
+    private isModuleWhitelisted;
+}
+
+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 | DynamicModule> | Type | DynamicModule, loadOpts?: LazyModuleLoaderLoadOptions): Promise<ModuleRef>;
+    private registerLoggerConfiguration;
+    private createLazyModulesContainer;
+    private getTargetModuleRef;
+}
+
+declare function getClassScope(provider: Type): Scope;
+
+declare function isClassProvider<T = any>(provider: Provider): provider is ClassProvider<T>;
+declare function isValueProvider<T = any>(provider: Provider): provider is ValueProvider<T>;
+declare function isFactoryProvider<T = any>(provider: Provider): provider is FactoryProvider<T>;
+
+declare function isDurable(provider: Type): boolean | undefined;
+
+declare class InitializeOnPreviewAllowlist {
+    private static readonly allowlist;
+    static add(type: Type): void;
+    static has(type: Type): boolean;
+}
+
+declare class PartialGraphHost {
+    private static partialGraph;
+    static toJSON(): SerializedGraphJson;
+    static toString(): string;
+    static register(partialGraph: SerializedGraph): void;
+}
+
+/**
+ * @publicApi
+ */
+declare class ConsoleLogger implements LoggerService {
+    /**
+     * The options of the logger.
+     */
+    protected options: ConsoleLoggerOptions;
+    /**
+     * The context of the logger (can be set manually or automatically inferred).
+     */
+    protected context?: string;
+    /**
+     * The original context of the logger (set in the constructor).
+     */
+    protected originalContext?: string;
+    /**
+     * The options used for the "inspect" method.
+     */
+    protected inspectOptions: InspectOptions;
+    /**
+     * The last timestamp at which the log message was printed.
+     */
+    protected static lastTimestampAt?: number;
+    constructor();
+    constructor(context: string);
+    constructor(options: ConsoleLoggerOptions);
+    constructor(context: string, options: ConsoleLoggerOptions);
+    /**
+     * Write a 'log' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    log(message: any, context?: string): void;
+    log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write an 'error' level log, if the configured level allows for it.
+     * Prints to `stderr` with newline.
+     */
+    error(message: any, stackOrContext?: string): void;
+    error(message: any, stack?: string, context?: string): void;
+    error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'warn' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    warn(message: any, context?: string): void;
+    warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    debug(message: any, context?: string): void;
+    debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    verbose(message: any, context?: string): void;
+    verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    fatal(message: any, context?: string): void;
+    fatal(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Set log levels
+     * @param levels log levels
+     */
+    setLogLevels(levels: LogLevel[]): void;
+    /**
+     * Set logger context
+     * @param context context
+     */
+    setContext(context: string): void;
+    /**
+     * Resets the logger context to the value that was passed in the constructor.
+     */
+    resetContext(): void;
+    isLevelEnabled(level: LogLevel): boolean;
+    protected getTimestamp(): string;
+    protected printMessages(messages: unknown[], context?: string, logLevel?: LogLevel, writeStreamType?: "stdout" | "stderr", errorStack?: unknown): void;
+    protected printAsJson(message: unknown, options: {
+        context: string;
+        logLevel: LogLevel;
+        writeStreamType?: "stdout" | "stderr";
+        errorStack?: unknown;
+    }): void;
+    protected getJsonLogObject(message: unknown, options: {
+        context: string;
+        logLevel: LogLevel;
+        writeStreamType?: "stdout" | "stderr";
+        errorStack?: unknown;
+    }): {
+        level: LogLevel;
+        pid: number;
+        timestamp: number;
+        message: unknown;
+        context?: string;
+        stack?: unknown;
+    };
+    protected formatPid(pid: number): string;
+    protected formatContext(context: string): string;
+    protected formatMessage(logLevel: LogLevel, message: unknown, pidMessage: string, formattedLogLevel: string, contextMessage: string, timestampDiff: string): string;
+    protected stringifyMessage(message: unknown, logLevel: LogLevel): any;
+    protected colorize(message: string, logLevel: LogLevel): string;
+    protected printStackTrace(stack: string): void;
+    protected updateAndGetTimestampDiff(): string;
+    protected formatTimestampDiff(timestampDiff: number): string;
+    protected getInspectOptions(): InspectOptions;
+    protected stringifyReplacer(key: string, value: unknown): unknown;
+    private getContextAndMessagesToPrint;
+    private getContextAndStackAndMessagesToPrint;
+    private isStackFormat;
+    private getColorByLogLevel;
+}
+
+declare const HANDLER_METADATA_SYMBOL: unique symbol;
+interface HandlerMetadata {
+    argsLength: number;
+    paramtypes: any[];
+    getParamsMetadata: GetParamsMetadata;
+}
+declare class HandlerMetadataStorage<TValue = HandlerMetadata, TKey extends Type<unknown> = any> {
+    private readonly [HANDLER_METADATA_SYMBOL];
+    set(instance: TKey, methodName: string, metadata: TValue): void;
+    get(instance: TKey, methodName: string): TValue | undefined;
+    private getMetadataKey;
+}
+
+declare class MetaHostStorage {
+    /**
+     * A map of class references to metadata keys.
+     */
+    static readonly metaHostLinks: Map<Function | Type<any>, string>;
+    /**
+     * A map of metadata keys to instance wrappers (providers) with the corresponding metadata key.
+     * The map is weakly referenced by the modules container (unique per application).
+     */
+    private static readonly providersByMetaKey;
+    /**
+     * Adds a link between a class reference and a metadata key.
+     * @param target The class reference.
+     * @param metadataKey The metadata key.
+     */
+    static addClassMetaHostLink(target: Type | Function, metadataKey: string): void;
+    /**
+     * Inspects a provider instance wrapper and adds it to the collection of providers
+     * if it has a metadata key.
+     * @param hostContainerRef A reference to the modules' container.
+     * @param instanceWrapper A provider instance wrapper.
+     * @returns void
+     */
+    static inspectProvider(hostContainerRef: ModulesContainer, instanceWrapper: InstanceWrapper): void;
+    static insertByMetaKey(metaKey: string, instanceWrapper: InstanceWrapper, collection: Map<string, Set<InstanceWrapper>>): void;
+    static getProvidersByMetaKey(hostContainerRef: ModulesContainer, metaKey: string): Set<InstanceWrapper>;
+    private static inspectInstanceWrapper;
+    private static getMetaKeyByInstanceWrapper;
+}
+
+export { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_PIPE, type Abstract, ApplicationConfig, ApplicationContext, ApplicationContextOptions, type ArgumentMetadata, type ArgumentsHost, type AttachedEnhancerDefinition, type BeforeApplicationShutdown, Bind, CATCH_WATERMARK, CUSTOM_ROUTE_ARGS_METADATA, type CallHandler, type CanActivate, Catch, CircularDependencyException, type ClassDecoratorOptions, type ClassNode, type ClassProvider, ConsoleLogger, type ConsoleLoggerOptions, ContextCreator, type ContextId, ContextIdFactory, type ContextIdResolver, type ContextIdResolverFn, type ContextIdStrategy, type ContextType, ContextUtils, Module$1 as CoreModule, type CreateDecoratorOptions, type CustomDecorator, type CustomParamFactory, type DecoratorOptions, type DecoratorsType, Dependencies, DependenciesScanner, DeterministicUuidRegistry, type DynamicModule, ENHANCER_KEY_TO_SUBTYPE_MAP, ENHANCER_TOKEN_TO_SUBTYPE_MAP, ENTRY_PROVIDER_WATERMARK, EXCEPTION_FILTERS_METADATA, type Edge, type EnhancerMetadataCacheEntry, type EnhancerSubtype, type Entrypoint, type ExceptionFilter, type ExceptionFilterMetadata, type ExecutionContext, ExecutionContextHost, type ExistingProvider, type ExternalContextOptions, type ExternalHandlerMetadata, type Extras, FILTER_CATCH_EXCEPTIONS, FORBIDDEN_MESSAGE, type FactoryProvider, type ForwardReference, GLOBAL_MODULE_METADATA, GUARDS_METADATA, type GetOrResolveOptions, type GetParamsMetadata, Global, GraphInspector, GuardsConsumer, GuardsContextCreator, HANDLER_METADATA_SYMBOL, HandlerMetadataStorage, type HostComponentInfo, INJECTABLE_WATERMARK, INQUIRER, INSTANCE_ID_SYMBOL, INSTANCE_METADATA_SYMBOL, INTERCEPTORS_METADATA, INVALID_CLASS_MESSAGE, INVALID_CLASS_SCOPE_MESSAGE, INVALID_EXCEPTION_FILTER, INVALID_MODULE_MESSAGE, InitializeOnPreviewAllowlist, Inject, Injectable, type InjectableToken, type InjectionToken, Injector, type InjectorDependency, type InjectorDependencyContext, type InstancePerContext, InstanceWrapper, InterceptorsConsumer, InterceptorsContextCreator, type IntrospectionResult, InvalidClassException, InvalidClassModuleException, InvalidClassScopeException, InvalidDecoratorItemException, InvalidExceptionFilterException, InvalidModuleException, LOG_LEVELS, LazyModuleLoader, type LazyModuleLoaderLoadOptions, type LogLevel, Logger, type LoggerService, MESSAGES, MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION, MODULE_INIT_MESSAGE, MODULE_METADATA, MODULE_PATH, MetaHostStorage, MetadataScanner, type MethodDecoratorOptions, Module, type ModuleDefinition, type ModuleFactory, type ModuleMetadata, type ModuleNode, ModuleRef, type ModuleRefGetOrResolveOpts, ModulesContainer, type Node, OPTIONAL_DEPS_METADATA, OPTIONAL_PROPERTY_DEPS_METADATA, type OnApplicationBootstrap, type OnApplicationShutdown, type OnModuleDestroy, type OnModuleInit, Optional, type OptionalFactoryDependency, type OrphanedEnhancerDefinition, PARAMTYPES_METADATA, PIPES_METADATA, PROPERTY_DEPS_METADATA, PROVIDER_ID_KEY, type ParamData, type ParamDecoratorEnhancer, type ParamMetadata, type ParamProperties, type ParamsMetadata, PartialGraphHost, type PipeTransform, PipesConsumer, PipesContextCreator, type PropertyDependency, type PropertyMetadata, type Provider, REQUEST, REQUEST_CONTEXT_ID, ROUTE_ARGS_METADATA, type ReflectableClassDecorator, type ReflectableDecorator, type ReflectableDecorators, type ReflectableMethodDecorator, Reflector, ReflectorAliasProvider, RuntimeException, SCOPE_OPTIONS_METADATA, SELF_DECLARED_DEPS_METADATA, STATIC_CONTEXT, Scope, type ScopeOptions, type SelectOptions, SerializedGraph, type SerializedGraphJson, type SerializedGraphMetadata, type SerializedGraphStatus, SetMetadata, type SetMetadataType, SilentLogger, type Transform, type Type, UNDEFINED_FORWARDREF_MESSAGE, UNDEFINED_MODULE_MESSAGE, UNHANDLED_RUNTIME_EXCEPTION, UNKNOWN_DEPENDENCIES_MESSAGE, UNKNOWN_EXPORT_MESSAGE, USING_INVALID_CLASS_AS_A_MODULE_MESSAGE, UndefinedDependencyException, UndefinedForwardRefException, UndefinedModuleException, UnknownDependenciesException, UnknownElementException, UnknownExportException, UnknownModuleException, UseFilters, UseGuards, UseInterceptors, UsePipes, UuidFactory, UuidFactoryMode, type ValueProvider, type VenokApplicationContext, VenokContainer, VenokContextCreator, type VenokContextCreatorInterface, VenokExceptionFilterContext, VenokFactory, type VenokInterceptor, type VenokModule, type VenokParamsFactoryInterface, VenokProxy, type WithRequired, type WithTransform, applyDecorators, assignCustomParameterMetadata, assignMetadata, colors, createContextId, createNativeParamDecorator, createNativeParamDecoratorWithoutPipes, createParamDecorator, createParamDecoratorWithoutPipes, extendArrayMetadata, filterLogLevels, flatten, getClassScope, getNonTransientInstances, getTransientInstances, inquirerProvider, isClassProvider, isColorAllowed, isConstructor, isDurable, isEmpty, isFactoryProvider, isFunction, isLogLevel, isLogLevelEnabled, isNull, isNumber, isObject, isPlainObject, isString, isSymbol, isUndefined, isValueProvider, mixin, noop, randomStringGenerator, requestProvider, rethrow, validateEach, yellow };