@nestjs/core

  • Version 9.4.2
  • Published
  • 502 kB
  • 6 dependencies
  • MIT license

Install

npm i @nestjs/core
yarn add @nestjs/core
pnpm add @nestjs/core

Overview

Nest - modern, fast, powerful node.js web framework (@core)

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable APP_FILTER

const APP_FILTER: string;

    variable APP_GUARD

    const APP_GUARD: string;

      variable APP_INTERCEPTOR

      const APP_INTERCEPTOR: string;

        variable APP_PIPE

        const APP_PIPE: string;

          variable INQUIRER

          const INQUIRER: string;

            variable NestFactory

            const NestFactory: NestFactoryStatic;
            • Use NestFactory 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, Nest assembles the dependency graph and begins the process of Dependency Injection and instantiates the classes needed to launch your application.

            variable REQUEST

            const REQUEST: string;

              Functions

              function createContextId

              createContextId: () => ContextId;

                function repl

                repl: (module: Type | DynamicModule) => Promise<import('repl').REPLServer>;

                  Classes

                  class AbstractHttpAdapter

                  abstract class AbstractHttpAdapter<TServer = any, TRequest = any, TResponse = any>
                  implements HttpServer<TRequest, TResponse> {}

                  constructor

                  constructor(instance?: any);

                    property httpServer

                    protected httpServer: {};

                      property instance

                      protected instance?: any;

                        method all

                        all: {
                        (handler: RequestHandler): any;
                        (path: any, handler: RequestHandler): any;
                        };

                          method applyVersionFilter

                          abstract applyVersionFilter: (
                          handler: Function,
                          version: VersionValue,
                          versioningOptions: VersioningOptions
                          ) => (req: TRequest, res: TResponse, next: () => void) => Function;

                            method close

                            abstract close: () => any;

                              method createMiddlewareFactory

                              abstract createMiddlewareFactory: (
                              requestMethod: RequestMethod
                              ) =>
                              | ((path: string, callback: Function) => any)
                              | Promise<(path: string, callback: Function) => any>;

                                method delete

                                delete: {
                                (handler: RequestHandler): any;
                                (path: any, handler: RequestHandler): any;
                                };

                                  method enableCors

                                  abstract enableCors: (
                                  options: CorsOptions | CorsOptionsDelegate<TRequest>,
                                  prefix?: string
                                  ) => any;

                                    method end

                                    abstract end: (response: any, message?: string) => any;

                                      method get

                                      get: {
                                      (handler: RequestHandler): any;
                                      (path: any, handler: RequestHandler): any;
                                      };

                                        method getHttpServer

                                        getHttpServer: () => TServer;

                                          method getInstance

                                          getInstance: <T = any>() => T;

                                            method getRequestHostname

                                            abstract getRequestHostname: (request: any) => any;

                                              method getRequestMethod

                                              abstract getRequestMethod: (request: any) => any;

                                                method getRequestUrl

                                                abstract getRequestUrl: (request: any) => any;

                                                  method getType

                                                  abstract getType: () => string;

                                                    method head

                                                    head: {
                                                    (handler: RequestHandler): any;
                                                    (path: any, handler: RequestHandler): any;
                                                    };

                                                      method init

                                                      init: () => Promise<void>;

                                                        method initHttpServer

                                                        abstract initHttpServer: (options: NestApplicationOptions) => any;

                                                          method isHeadersSent

                                                          abstract isHeadersSent: (response: any) => any;

                                                            method listen

                                                            listen: {
                                                            (port: string | number, callback?: () => void): any;
                                                            (port: string | number, hostname: string, callback?: () => void): any;
                                                            };

                                                              method options

                                                              options: {
                                                              (handler: RequestHandler): any;
                                                              (path: any, handler: RequestHandler): any;
                                                              };

                                                                method patch

                                                                patch: {
                                                                (handler: RequestHandler): any;
                                                                (path: any, handler: RequestHandler): any;
                                                                };

                                                                  method post

                                                                  post: {
                                                                  (handler: RequestHandler): any;
                                                                  (path: any, handler: RequestHandler): any;
                                                                  };

                                                                    method put

                                                                    put: {
                                                                    (handler: RequestHandler): any;
                                                                    (path: any, handler: RequestHandler): any;
                                                                    };

                                                                      method redirect

                                                                      abstract redirect: (response: any, statusCode: number, url: string) => any;

                                                                        method registerParserMiddleware

                                                                        abstract registerParserMiddleware: (prefix?: string, rawBody?: boolean) => any;

                                                                          method render

                                                                          abstract render: (response: any, view: string, options: any) => any;

                                                                            method reply

                                                                            abstract reply: (response: any, body: any, statusCode?: number) => any;

                                                                              method setErrorHandler

                                                                              abstract setErrorHandler: (handler: Function, prefix?: string) => any;

                                                                                method setHeader

                                                                                abstract setHeader: (response: any, name: string, value: string) => any;

                                                                                  method setHttpServer

                                                                                  setHttpServer: (httpServer: TServer) => void;

                                                                                    method setInstance

                                                                                    setInstance: <T = any>(instance: T) => void;

                                                                                      method setNotFoundHandler

                                                                                      abstract setNotFoundHandler: (handler: Function, prefix?: string) => any;

                                                                                        method setViewEngine

                                                                                        abstract setViewEngine: (engine: string) => any;

                                                                                          method status

                                                                                          abstract status: (response: any, statusCode: number) => any;

                                                                                            method use

                                                                                            use: (...args: any[]) => any;

                                                                                              method useStaticAssets

                                                                                              abstract useStaticAssets: (...args: any[]) => any;

                                                                                                class ApplicationConfig

                                                                                                class ApplicationConfig {}

                                                                                                  constructor

                                                                                                  constructor(ioAdapter?: any);

                                                                                                    method addGlobalFilter

                                                                                                    addGlobalFilter: (filter: ExceptionFilter) => void;

                                                                                                      method addGlobalGuard

                                                                                                      addGlobalGuard: (guard: CanActivate) => void;

                                                                                                        method addGlobalInterceptor

                                                                                                        addGlobalInterceptor: (interceptor: NestInterceptor) => void;

                                                                                                          method addGlobalPipe

                                                                                                          addGlobalPipe: (pipe: PipeTransform<any>) => void;

                                                                                                            method addGlobalRequestFilter

                                                                                                            addGlobalRequestFilter: (wrapper: InstanceWrapper<ExceptionFilter>) => void;

                                                                                                              method addGlobalRequestGuard

                                                                                                              addGlobalRequestGuard: (wrapper: InstanceWrapper<CanActivate>) => void;

                                                                                                                method addGlobalRequestInterceptor

                                                                                                                addGlobalRequestInterceptor: (wrapper: InstanceWrapper<NestInterceptor>) => void;

                                                                                                                  method addGlobalRequestPipe

                                                                                                                  addGlobalRequestPipe: (wrapper: InstanceWrapper<PipeTransform>) => void;

                                                                                                                    method enableVersioning

                                                                                                                    enableVersioning: (options: VersioningOptions) => void;

                                                                                                                      method getGlobalFilters

                                                                                                                      getGlobalFilters: () => ExceptionFilter[];

                                                                                                                        method getGlobalGuards

                                                                                                                        getGlobalGuards: () => CanActivate[];

                                                                                                                          method getGlobalInterceptors

                                                                                                                          getGlobalInterceptors: () => NestInterceptor[];

                                                                                                                            method getGlobalPipes

                                                                                                                            getGlobalPipes: () => PipeTransform<any>[];

                                                                                                                              method getGlobalPrefix

                                                                                                                              getGlobalPrefix: () => string;

                                                                                                                                method getGlobalPrefixOptions

                                                                                                                                getGlobalPrefixOptions: () => GlobalPrefixOptions<ExcludeRouteMetadata>;

                                                                                                                                  method getGlobalRequestFilters

                                                                                                                                  getGlobalRequestFilters: () => InstanceWrapper<ExceptionFilter>[];

                                                                                                                                    method getGlobalRequestGuards

                                                                                                                                    getGlobalRequestGuards: () => InstanceWrapper<CanActivate>[];

                                                                                                                                      method getGlobalRequestInterceptors

                                                                                                                                      getGlobalRequestInterceptors: () => InstanceWrapper<NestInterceptor>[];

                                                                                                                                        method getGlobalRequestPipes

                                                                                                                                        getGlobalRequestPipes: () => InstanceWrapper<PipeTransform>[];

                                                                                                                                          method getIoAdapter

                                                                                                                                          getIoAdapter: () => WebSocketAdapter;

                                                                                                                                            method getVersioning

                                                                                                                                            getVersioning: () => VersioningOptions | undefined;

                                                                                                                                              method setGlobalPrefix

                                                                                                                                              setGlobalPrefix: (prefix: string) => void;

                                                                                                                                                method setGlobalPrefixOptions

                                                                                                                                                setGlobalPrefixOptions: (
                                                                                                                                                options: GlobalPrefixOptions<ExcludeRouteMetadata>
                                                                                                                                                ) => void;

                                                                                                                                                  method setIoAdapter

                                                                                                                                                  setIoAdapter: (ioAdapter: WebSocketAdapter) => void;

                                                                                                                                                    method useGlobalFilters

                                                                                                                                                    useGlobalFilters: (...filters: ExceptionFilter[]) => void;

                                                                                                                                                      method useGlobalGuards

                                                                                                                                                      useGlobalGuards: (...guards: CanActivate[]) => void;

                                                                                                                                                        method useGlobalInterceptors

                                                                                                                                                        useGlobalInterceptors: (...interceptors: NestInterceptor[]) => void;

                                                                                                                                                          method useGlobalPipes

                                                                                                                                                          useGlobalPipes: (...pipes: PipeTransform<any>[]) => void;

                                                                                                                                                            class BaseExceptionFilter

                                                                                                                                                            class BaseExceptionFilter<T = any> implements ExceptionFilter<T> {}

                                                                                                                                                              constructor

                                                                                                                                                              constructor(applicationRef?: HttpServer);

                                                                                                                                                                property applicationRef

                                                                                                                                                                protected readonly applicationRef?: HttpServer;

                                                                                                                                                                  property httpAdapterHost

                                                                                                                                                                  protected readonly httpAdapterHost?: HttpAdapterHost<
                                                                                                                                                                  AbstractHttpAdapter<any, any, any>
                                                                                                                                                                  >;

                                                                                                                                                                    method catch

                                                                                                                                                                    catch: (exception: T, host: ArgumentsHost) => void;

                                                                                                                                                                      method handleUnknownError

                                                                                                                                                                      handleUnknownError: (
                                                                                                                                                                      exception: T,
                                                                                                                                                                      host: ArgumentsHost,
                                                                                                                                                                      applicationRef: AbstractHttpAdapter | HttpServer
                                                                                                                                                                      ) => void;

                                                                                                                                                                        method isExceptionObject

                                                                                                                                                                        isExceptionObject: (err: any) => err is Error;

                                                                                                                                                                          method isHttpError

                                                                                                                                                                          isHttpError: (err: any) => err is { statusCode: number; message: string };
                                                                                                                                                                          • Checks if the thrown error comes from the "http-errors" library.

                                                                                                                                                                            Parameter err

                                                                                                                                                                            error object

                                                                                                                                                                          class ContextIdFactory

                                                                                                                                                                          class ContextIdFactory {}

                                                                                                                                                                            method apply

                                                                                                                                                                            static apply: (strategy: ContextIdStrategy) => void;
                                                                                                                                                                            • Registers a custom context id strategy that lets you attach a parent context id to the existing context id object.

                                                                                                                                                                              Parameter strategy

                                                                                                                                                                              strategy instance

                                                                                                                                                                            method create

                                                                                                                                                                            static create: () => ContextId;
                                                                                                                                                                            • Generates a context identifier based on the request object.

                                                                                                                                                                            method getByRequest

                                                                                                                                                                            static getByRequest: <T extends Record<any, any> = any>(
                                                                                                                                                                            request: T,
                                                                                                                                                                            propsToInspect?: string[]
                                                                                                                                                                            ) => ContextId;
                                                                                                                                                                            • Generates a random identifier to track asynchronous execution context.

                                                                                                                                                                              Parameter request

                                                                                                                                                                              request object

                                                                                                                                                                            class DiscoveryModule

                                                                                                                                                                            class DiscoveryModule {}

                                                                                                                                                                            class DiscoveryService

                                                                                                                                                                            class DiscoveryService {}

                                                                                                                                                                            constructor

                                                                                                                                                                            constructor(modulesContainer: ModulesContainer);

                                                                                                                                                                              method getControllers

                                                                                                                                                                              getControllers: (
                                                                                                                                                                              options?: DiscoveryOptions,
                                                                                                                                                                              modules?: Module[]
                                                                                                                                                                              ) => InstanceWrapper[];

                                                                                                                                                                                method getModules

                                                                                                                                                                                protected getModules: (options?: DiscoveryOptions) => Module[];

                                                                                                                                                                                  method getProviders

                                                                                                                                                                                  getProviders: (
                                                                                                                                                                                  options?: DiscoveryOptions,
                                                                                                                                                                                  modules?: Module[]
                                                                                                                                                                                  ) => InstanceWrapper[];

                                                                                                                                                                                    class ExternalContextCreator

                                                                                                                                                                                    class ExternalContextCreator {}

                                                                                                                                                                                      constructor

                                                                                                                                                                                      constructor(
                                                                                                                                                                                      guardsContextCreator: GuardsContextCreator,
                                                                                                                                                                                      guardsConsumer: GuardsConsumer,
                                                                                                                                                                                      interceptorsContextCreator: InterceptorsContextCreator,
                                                                                                                                                                                      interceptorsConsumer: InterceptorsConsumer,
                                                                                                                                                                                      modulesContainer: ModulesContainer,
                                                                                                                                                                                      pipesContextCreator: PipesContextCreator,
                                                                                                                                                                                      pipesConsumer: PipesConsumer,
                                                                                                                                                                                      filtersContextCreator: ExternalExceptionFilterContext
                                                                                                                                                                                      );

                                                                                                                                                                                        method create

                                                                                                                                                                                        create: <
                                                                                                                                                                                        TParamsMetadata extends ParamsMetadata = ParamsMetadata,
                                                                                                                                                                                        TContext extends string = ContextType
                                                                                                                                                                                        >(
                                                                                                                                                                                        instance: Controller,
                                                                                                                                                                                        callback: (...args: unknown[]) => unknown,
                                                                                                                                                                                        methodName: string,
                                                                                                                                                                                        metadataKey?: string,
                                                                                                                                                                                        paramsFactory?: ParamsFactory,
                                                                                                                                                                                        contextId?: ContextId,
                                                                                                                                                                                        inquirerId?: string,
                                                                                                                                                                                        options?: ExternalContextOptions,
                                                                                                                                                                                        contextType?: TContext
                                                                                                                                                                                        ) => (...args: any[]) => Promise<any>;

                                                                                                                                                                                          method createGuardsFn

                                                                                                                                                                                          createGuardsFn: <TContext extends string = ContextType>(
                                                                                                                                                                                          guards: any[],
                                                                                                                                                                                          instance: Controller,
                                                                                                                                                                                          callback: (...args: any[]) => any,
                                                                                                                                                                                          contextType?: TContext
                                                                                                                                                                                          ) => Function | null;

                                                                                                                                                                                            method createPipesFn

                                                                                                                                                                                            createPipesFn: (
                                                                                                                                                                                            pipes: PipeTransform[],
                                                                                                                                                                                            paramsOptions: (ParamProperties & { metatype?: unknown })[]
                                                                                                                                                                                            ) => (args: unknown[], ...params: unknown[]) => Promise<void>;

                                                                                                                                                                                              method exchangeKeysForValues

                                                                                                                                                                                              exchangeKeysForValues: <TMetadata = any>(
                                                                                                                                                                                              keys: string[],
                                                                                                                                                                                              metadata: TMetadata,
                                                                                                                                                                                              moduleContext: string,
                                                                                                                                                                                              paramsFactory: ParamsFactory,
                                                                                                                                                                                              contextId?: ContextId,
                                                                                                                                                                                              inquirerId?: string,
                                                                                                                                                                                              contextFactory?: (
                                                                                                                                                                                              args: unknown[]
                                                                                                                                                                                              ) => import('./execution-context-host').ExecutionContextHost
                                                                                                                                                                                              ) => ParamProperties[];

                                                                                                                                                                                                method fromContainer

                                                                                                                                                                                                static fromContainer: (container: NestContainer) => ExternalContextCreator;

                                                                                                                                                                                                  method getContextModuleKey

                                                                                                                                                                                                  getContextModuleKey: (moduleCtor: Function | undefined) => string;

                                                                                                                                                                                                    method getMetadata

                                                                                                                                                                                                    getMetadata: <TMetadata, TContext extends string = ContextType>(
                                                                                                                                                                                                    instance: Controller,
                                                                                                                                                                                                    methodName: string,
                                                                                                                                                                                                    metadataKey?: string,
                                                                                                                                                                                                    paramsFactory?: ParamsFactory,
                                                                                                                                                                                                    contextType?: TContext
                                                                                                                                                                                                    ) => ExternalHandlerMetadata;

                                                                                                                                                                                                      method getParamValue

                                                                                                                                                                                                      getParamValue: <T>(
                                                                                                                                                                                                      value: T,
                                                                                                                                                                                                      { metatype, type, data }: { metatype: any; type: any; data: any },
                                                                                                                                                                                                      pipes: PipeTransform[]
                                                                                                                                                                                                      ) => Promise<any>;

                                                                                                                                                                                                        method registerRequestProvider

                                                                                                                                                                                                        registerRequestProvider: <T = any>(request: T, contextId: ContextId) => void;

                                                                                                                                                                                                          method transformToResult

                                                                                                                                                                                                          transformToResult: (resultOrDeferred: any) => Promise<any>;

                                                                                                                                                                                                            class GraphInspector

                                                                                                                                                                                                            class GraphInspector {}

                                                                                                                                                                                                              constructor

                                                                                                                                                                                                              constructor(container: NestContainer);

                                                                                                                                                                                                                method insertAttachedEnhancer

                                                                                                                                                                                                                insertAttachedEnhancer: (wrapper: InstanceWrapper) => void;

                                                                                                                                                                                                                  method insertClassNode

                                                                                                                                                                                                                  insertClassNode: (
                                                                                                                                                                                                                  moduleRef: Module,
                                                                                                                                                                                                                  wrapper: InstanceWrapper,
                                                                                                                                                                                                                  type: Exclude<Node['metadata']['type'], 'module'>
                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                    method insertEnhancerMetadataCache

                                                                                                                                                                                                                    insertEnhancerMetadataCache: (entry: EnhancerMetadataCacheEntry) => void;

                                                                                                                                                                                                                      method insertEntrypointDefinition

                                                                                                                                                                                                                      insertEntrypointDefinition: <T>(
                                                                                                                                                                                                                      definition: Entrypoint<T>,
                                                                                                                                                                                                                      parentId: string
                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                        method insertOrphanedEnhancer

                                                                                                                                                                                                                        insertOrphanedEnhancer: (entry: OrphanedEnhancerDefinition) => void;

                                                                                                                                                                                                                          method inspectInstanceWrapper

                                                                                                                                                                                                                          inspectInstanceWrapper: <T = any>(
                                                                                                                                                                                                                          source: InstanceWrapper<T>,
                                                                                                                                                                                                                          moduleRef: Module
                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                            method inspectModules

                                                                                                                                                                                                                            inspectModules: (modules?: Map<string, Module>) => void;

                                                                                                                                                                                                                              method registerPartial

                                                                                                                                                                                                                              registerPartial: (error: unknown) => void;

                                                                                                                                                                                                                                class HttpAdapterHost

                                                                                                                                                                                                                                class HttpAdapterHost<T extends AbstractHttpAdapter = AbstractHttpAdapter> {}
                                                                                                                                                                                                                                • Defines the HttpAdapterHost object.

                                                                                                                                                                                                                                  HttpAdapterHost wraps the underlying platform-specific HttpAdapter. The HttpAdapter is a wrapper around the underlying native HTTP server library (e.g., Express). The HttpAdapterHost object provides methods to get and set the underlying HttpAdapter.

                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                  • [Http adapter](https://docs.nestjs.com/faq/http-adapter)

                                                                                                                                                                                                                                property httpAdapter

                                                                                                                                                                                                                                httpAdapter: AbstractHttpAdapter<any, any, any>;
                                                                                                                                                                                                                                • Accessor for the underlying HttpAdapter

                                                                                                                                                                                                                                  Example 1

                                                                                                                                                                                                                                  const httpAdapter = adapterHost.httpAdapter;

                                                                                                                                                                                                                                class InitializeOnPreviewAllowlist

                                                                                                                                                                                                                                class InitializeOnPreviewAllowlist {}

                                                                                                                                                                                                                                  method add

                                                                                                                                                                                                                                  static add: (type: Type) => void;

                                                                                                                                                                                                                                    method has

                                                                                                                                                                                                                                    static has: (type: Type) => boolean;

                                                                                                                                                                                                                                      class LazyModuleLoader

                                                                                                                                                                                                                                      class LazyModuleLoader {}

                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                        dependenciesScanner: DependenciesScanner,
                                                                                                                                                                                                                                        instanceLoader: InstanceLoader<Injector>,
                                                                                                                                                                                                                                        moduleCompiler: ModuleCompiler,
                                                                                                                                                                                                                                        modulesContainer: ModulesContainer
                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                          method load

                                                                                                                                                                                                                                          load: (
                                                                                                                                                                                                                                          loaderFn: () =>
                                                                                                                                                                                                                                          | Promise<Type<unknown> | DynamicModule>
                                                                                                                                                                                                                                          | Type<unknown>
                                                                                                                                                                                                                                          | DynamicModule,
                                                                                                                                                                                                                                          loadOpts?: LazyModuleLoaderLoadOptions
                                                                                                                                                                                                                                          ) => Promise<ModuleRef>;

                                                                                                                                                                                                                                            class MetadataScanner

                                                                                                                                                                                                                                            class MetadataScanner {}

                                                                                                                                                                                                                                              method getAllFilteredMethodNames

                                                                                                                                                                                                                                              getAllFilteredMethodNames: (prototype: object) => IterableIterator<string>;

                                                                                                                                                                                                                                              method getAllMethodNames

                                                                                                                                                                                                                                              getAllMethodNames: (prototype: object | null) => string[];

                                                                                                                                                                                                                                                method scanFromPrototype

                                                                                                                                                                                                                                                scanFromPrototype: <T extends Injectable, R = any>(
                                                                                                                                                                                                                                                instance: T,
                                                                                                                                                                                                                                                prototype: object,
                                                                                                                                                                                                                                                callback: (name: string) => R
                                                                                                                                                                                                                                                ) => R[];

                                                                                                                                                                                                                                                class MiddlewareBuilder

                                                                                                                                                                                                                                                class MiddlewareBuilder implements MiddlewareConsumer {}

                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                  routesMapper: RoutesMapper,
                                                                                                                                                                                                                                                  httpAdapter: HttpServer,
                                                                                                                                                                                                                                                  routeInfoPathExtractor: RouteInfoPathExtractor
                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                    method apply

                                                                                                                                                                                                                                                    apply: (
                                                                                                                                                                                                                                                    ...middleware: Array<Type<any> | Function | any>
                                                                                                                                                                                                                                                    ) => MiddlewareConfigProxy;

                                                                                                                                                                                                                                                      method build

                                                                                                                                                                                                                                                      build: () => MiddlewareConfiguration[];

                                                                                                                                                                                                                                                        method getHttpAdapter

                                                                                                                                                                                                                                                        getHttpAdapter: () => HttpServer;

                                                                                                                                                                                                                                                          class ModuleRef

                                                                                                                                                                                                                                                          abstract class ModuleRef extends AbstractInstanceResolver {}

                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                            constructor(container: NestContainer);

                                                                                                                                                                                                                                                              property container

                                                                                                                                                                                                                                                              protected readonly container: NestContainer;

                                                                                                                                                                                                                                                                property injector

                                                                                                                                                                                                                                                                protected readonly injector: Injector;

                                                                                                                                                                                                                                                                  property instanceLinksHost

                                                                                                                                                                                                                                                                  readonly instanceLinksHost: InstanceLinksHost;

                                                                                                                                                                                                                                                                    method create

                                                                                                                                                                                                                                                                    abstract create: <T = any>(type: Type<T>) => Promise<T>;

                                                                                                                                                                                                                                                                      method get

                                                                                                                                                                                                                                                                      abstract get: {
                                                                                                                                                                                                                                                                      <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                      typeOrToken: Type<TInput> | Function | string | symbol
                                                                                                                                                                                                                                                                      ): TResult;
                                                                                                                                                                                                                                                                      <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                      typeOrToken: any,
                                                                                                                                                                                                                                                                      options: { strict?: boolean; each?: false }
                                                                                                                                                                                                                                                                      ): TResult;
                                                                                                                                                                                                                                                                      <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                      typeOrToken: any,
                                                                                                                                                                                                                                                                      options: { strict?: boolean; each: true }
                                                                                                                                                                                                                                                                      ): TResult[];
                                                                                                                                                                                                                                                                      <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                      typeOrToken: any,
                                                                                                                                                                                                                                                                      options?: ModuleRefGetOrResolveOpts
                                                                                                                                                                                                                                                                      ): TResult | TResult[];
                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                      • Retrieves an instance of either injectable or controller, otherwise, throws exception.

                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                        {TResult}

                                                                                                                                                                                                                                                                      • Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.

                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                        {Array}

                                                                                                                                                                                                                                                                      • Retrieves an instance (or a list of instances) of either injectable or controller, otherwise, throws exception.

                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                        {TResult | Array}

                                                                                                                                                                                                                                                                      method instantiateClass

                                                                                                                                                                                                                                                                      protected instantiateClass: <T = any>(
                                                                                                                                                                                                                                                                      type: Type<T>,
                                                                                                                                                                                                                                                                      moduleRef: Module
                                                                                                                                                                                                                                                                      ) => Promise<T>;

                                                                                                                                                                                                                                                                        method introspect

                                                                                                                                                                                                                                                                        introspect: <T = any>(token: Type<T> | string | symbol) => IntrospectionResult;

                                                                                                                                                                                                                                                                          method registerRequestByContextId

                                                                                                                                                                                                                                                                          registerRequestByContextId: <T = any>(request: T, contextId: ContextId) => void;

                                                                                                                                                                                                                                                                            method resolve

                                                                                                                                                                                                                                                                            abstract resolve: {
                                                                                                                                                                                                                                                                            <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                            typeOrToken: Type<TInput> | Function | string | symbol
                                                                                                                                                                                                                                                                            ): Promise<TResult>;
                                                                                                                                                                                                                                                                            <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                            typeOrToken: any,
                                                                                                                                                                                                                                                                            contextId?: { id: number }
                                                                                                                                                                                                                                                                            ): Promise<TResult>;
                                                                                                                                                                                                                                                                            <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                            typeOrToken: any,
                                                                                                                                                                                                                                                                            contextId?: { id: number },
                                                                                                                                                                                                                                                                            options?: { strict?: boolean; each?: false }
                                                                                                                                                                                                                                                                            ): Promise<TResult>;
                                                                                                                                                                                                                                                                            <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                            typeOrToken: any,
                                                                                                                                                                                                                                                                            contextId?: { id: number },
                                                                                                                                                                                                                                                                            options?: { strict?: boolean; each: true }
                                                                                                                                                                                                                                                                            ): Promise<TResult[]>;
                                                                                                                                                                                                                                                                            <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                            typeOrToken: any,
                                                                                                                                                                                                                                                                            contextId?: { id: number },
                                                                                                                                                                                                                                                                            options?: ModuleRefGetOrResolveOpts
                                                                                                                                                                                                                                                                            ): Promise<TResult | TResult[]>;
                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                            • Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.

                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                              {Array}

                                                                                                                                                                                                                                                                            • Resolves transient or request-scoped instances of either injectables or controllers, otherwise, throws exception.

                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                              {Array}

                                                                                                                                                                                                                                                                            • Resolves transient or request-scoped instance (or a list of instances) of either injectable or controller, otherwise, throws exception.

                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                              {Promise<TResult | Array>}

                                                                                                                                                                                                                                                                            class ModulesContainer

                                                                                                                                                                                                                                                                            class ModulesContainer extends Map<string, Module> {}

                                                                                                                                                                                                                                                                              property applicationId

                                                                                                                                                                                                                                                                              readonly applicationId: string;

                                                                                                                                                                                                                                                                                method getById

                                                                                                                                                                                                                                                                                getById: (id: string) => Module | undefined;

                                                                                                                                                                                                                                                                                  class NestApplication

                                                                                                                                                                                                                                                                                  class NestApplication
                                                                                                                                                                                                                                                                                  extends NestApplicationContext<NestApplicationOptions>
                                                                                                                                                                                                                                                                                  implements INestApplication {}

                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                  container: NestContainer,
                                                                                                                                                                                                                                                                                  httpAdapter: HttpServer,
                                                                                                                                                                                                                                                                                  config: ApplicationConfig,
                                                                                                                                                                                                                                                                                  graphInspector: GraphInspector,
                                                                                                                                                                                                                                                                                  appOptions?: NestApplicationOptions
                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                    property logger

                                                                                                                                                                                                                                                                                    protected readonly logger: Logger;

                                                                                                                                                                                                                                                                                      method applyOptions

                                                                                                                                                                                                                                                                                      applyOptions: () => void;

                                                                                                                                                                                                                                                                                        method connectMicroservice

                                                                                                                                                                                                                                                                                        connectMicroservice: <T extends object>(
                                                                                                                                                                                                                                                                                        microserviceOptions: T,
                                                                                                                                                                                                                                                                                        hybridAppOptions?: NestHybridApplicationOptions
                                                                                                                                                                                                                                                                                        ) => INestMicroservice;

                                                                                                                                                                                                                                                                                          method createServer

                                                                                                                                                                                                                                                                                          createServer: <T = any>() => T;

                                                                                                                                                                                                                                                                                            method dispose

                                                                                                                                                                                                                                                                                            protected dispose: () => Promise<void>;

                                                                                                                                                                                                                                                                                              method enableCors

                                                                                                                                                                                                                                                                                              enableCors: (options?: CorsOptions | CorsOptionsDelegate<any>) => void;

                                                                                                                                                                                                                                                                                                method enableVersioning

                                                                                                                                                                                                                                                                                                enableVersioning: (options?: VersioningOptions) => this;

                                                                                                                                                                                                                                                                                                  method getHttpAdapter

                                                                                                                                                                                                                                                                                                  getHttpAdapter: () => AbstractHttpAdapter;

                                                                                                                                                                                                                                                                                                    method getHttpServer

                                                                                                                                                                                                                                                                                                    getHttpServer: () => any;

                                                                                                                                                                                                                                                                                                      method getMicroservices

                                                                                                                                                                                                                                                                                                      getMicroservices: () => INestMicroservice[];

                                                                                                                                                                                                                                                                                                        method getUnderlyingHttpServer

                                                                                                                                                                                                                                                                                                        getUnderlyingHttpServer: <T>() => T;

                                                                                                                                                                                                                                                                                                          method getUrl

                                                                                                                                                                                                                                                                                                          getUrl: () => Promise<string>;

                                                                                                                                                                                                                                                                                                            method init

                                                                                                                                                                                                                                                                                                            init: () => Promise<this>;

                                                                                                                                                                                                                                                                                                              method listen

                                                                                                                                                                                                                                                                                                              listen: {
                                                                                                                                                                                                                                                                                                              (port: number | string): Promise<any>;
                                                                                                                                                                                                                                                                                                              (port: string | number, hostname: string): Promise<any>;
                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                method registerHttpServer

                                                                                                                                                                                                                                                                                                                registerHttpServer: () => void;

                                                                                                                                                                                                                                                                                                                  method registerModules

                                                                                                                                                                                                                                                                                                                  registerModules: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                    method registerParserMiddleware

                                                                                                                                                                                                                                                                                                                    registerParserMiddleware: () => void;

                                                                                                                                                                                                                                                                                                                      method registerRouter

                                                                                                                                                                                                                                                                                                                      registerRouter: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                        method registerRouterHooks

                                                                                                                                                                                                                                                                                                                        registerRouterHooks: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                          method registerWsModule

                                                                                                                                                                                                                                                                                                                          registerWsModule: () => void;

                                                                                                                                                                                                                                                                                                                            method setBaseViewsDir

                                                                                                                                                                                                                                                                                                                            setBaseViewsDir: (path: string | string[]) => this;

                                                                                                                                                                                                                                                                                                                              method setGlobalPrefix

                                                                                                                                                                                                                                                                                                                              setGlobalPrefix: (prefix: string, options?: GlobalPrefixOptions) => this;

                                                                                                                                                                                                                                                                                                                                method setViewEngine

                                                                                                                                                                                                                                                                                                                                setViewEngine: (engineOrOptions: any) => this;

                                                                                                                                                                                                                                                                                                                                  method startAllMicroservices

                                                                                                                                                                                                                                                                                                                                  startAllMicroservices: () => Promise<this>;

                                                                                                                                                                                                                                                                                                                                    method use

                                                                                                                                                                                                                                                                                                                                    use: (args_0: any, args_1?: any) => this;

                                                                                                                                                                                                                                                                                                                                      method useBodyParser

                                                                                                                                                                                                                                                                                                                                      useBodyParser: (args_0: any, args_1?: any) => this;

                                                                                                                                                                                                                                                                                                                                        method useGlobalFilters

                                                                                                                                                                                                                                                                                                                                        useGlobalFilters: (...filters: ExceptionFilter[]) => this;

                                                                                                                                                                                                                                                                                                                                          method useGlobalGuards

                                                                                                                                                                                                                                                                                                                                          useGlobalGuards: (...guards: CanActivate[]) => this;

                                                                                                                                                                                                                                                                                                                                            method useGlobalInterceptors

                                                                                                                                                                                                                                                                                                                                            useGlobalInterceptors: (...interceptors: NestInterceptor[]) => this;

                                                                                                                                                                                                                                                                                                                                              method useGlobalPipes

                                                                                                                                                                                                                                                                                                                                              useGlobalPipes: (...pipes: PipeTransform<any>[]) => this;

                                                                                                                                                                                                                                                                                                                                                method useStaticAssets

                                                                                                                                                                                                                                                                                                                                                useStaticAssets: { (options: any): this; (path: string, options?: any): this };

                                                                                                                                                                                                                                                                                                                                                  method useWebSocketAdapter

                                                                                                                                                                                                                                                                                                                                                  useWebSocketAdapter: (adapter: WebSocketAdapter) => this;

                                                                                                                                                                                                                                                                                                                                                    class NestApplicationContext

                                                                                                                                                                                                                                                                                                                                                    class NestApplicationContext<
                                                                                                                                                                                                                                                                                                                                                    TOptions extends NestApplicationContextOptions = NestApplicationContextOptions
                                                                                                                                                                                                                                                                                                                                                    >
                                                                                                                                                                                                                                                                                                                                                    extends AbstractInstanceResolver
                                                                                                                                                                                                                                                                                                                                                    implements INestApplicationContext {}

                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                    container: NestContainer,
                                                                                                                                                                                                                                                                                                                                                    appOptions?: NestApplicationContextOptions,
                                                                                                                                                                                                                                                                                                                                                    contextModule?: Module,
                                                                                                                                                                                                                                                                                                                                                    scope?: Type<any>[]
                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                      property appOptions

                                                                                                                                                                                                                                                                                                                                                      protected readonly appOptions: NestApplicationContextOptions;

                                                                                                                                                                                                                                                                                                                                                        property container

                                                                                                                                                                                                                                                                                                                                                        protected readonly container: NestContainer;

                                                                                                                                                                                                                                                                                                                                                          property injector

                                                                                                                                                                                                                                                                                                                                                          protected injector: Injector;

                                                                                                                                                                                                                                                                                                                                                            property instanceLinksHost

                                                                                                                                                                                                                                                                                                                                                            readonly instanceLinksHost: InstanceLinksHost;

                                                                                                                                                                                                                                                                                                                                                              property isInitialized

                                                                                                                                                                                                                                                                                                                                                              protected isInitialized: boolean;

                                                                                                                                                                                                                                                                                                                                                                property logger

                                                                                                                                                                                                                                                                                                                                                                protected readonly logger: Logger;

                                                                                                                                                                                                                                                                                                                                                                  method assertNotInPreviewMode

                                                                                                                                                                                                                                                                                                                                                                  protected assertNotInPreviewMode: (methodName: string) => void;

                                                                                                                                                                                                                                                                                                                                                                    method callBeforeShutdownHook

                                                                                                                                                                                                                                                                                                                                                                    protected callBeforeShutdownHook: (signal?: string) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                    • Calls the beforeApplicationShutdown function on the registered modules and children.

                                                                                                                                                                                                                                                                                                                                                                    method callBootstrapHook

                                                                                                                                                                                                                                                                                                                                                                    protected callBootstrapHook: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                    • Calls the onApplicationBootstrap function on the registered modules and its children.

                                                                                                                                                                                                                                                                                                                                                                    method callDestroyHook

                                                                                                                                                                                                                                                                                                                                                                    protected callDestroyHook: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                    • Calls the onModuleDestroy function on the registered modules and its children.

                                                                                                                                                                                                                                                                                                                                                                    method callInitHook

                                                                                                                                                                                                                                                                                                                                                                    protected callInitHook: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                    • Calls the onModuleInit function on the registered modules and its children.

                                                                                                                                                                                                                                                                                                                                                                    method callShutdownHook

                                                                                                                                                                                                                                                                                                                                                                    protected callShutdownHook: (signal?: string) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                    • Calls the onApplicationShutdown function on the registered modules and children.

                                                                                                                                                                                                                                                                                                                                                                    method close

                                                                                                                                                                                                                                                                                                                                                                    close: (signal?: string) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                    • Terminates the application

                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                      {Promise}

                                                                                                                                                                                                                                                                                                                                                                    method dispose

                                                                                                                                                                                                                                                                                                                                                                    protected dispose: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                      method enableShutdownHooks

                                                                                                                                                                                                                                                                                                                                                                      enableShutdownHooks: (signals?: (ShutdownSignal | string)[]) => this;
                                                                                                                                                                                                                                                                                                                                                                      • Enables the usage of shutdown hooks. Will call the onApplicationShutdown function of a provider if the process receives a shutdown signal.

                                                                                                                                                                                                                                                                                                                                                                        Parameter signals

                                                                                                                                                                                                                                                                                                                                                                        The system signals it should listen to

                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                        {this} The Nest application context instance

                                                                                                                                                                                                                                                                                                                                                                      method flushLogs

                                                                                                                                                                                                                                                                                                                                                                      flushLogs: () => void;
                                                                                                                                                                                                                                                                                                                                                                      • Prints buffered logs and detaches buffer.

                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                        {void}

                                                                                                                                                                                                                                                                                                                                                                      method flushLogsOnOverride

                                                                                                                                                                                                                                                                                                                                                                      flushLogsOnOverride: () => void;
                                                                                                                                                                                                                                                                                                                                                                      • Define that it must flush logs right after defining a custom logger.

                                                                                                                                                                                                                                                                                                                                                                      method get

                                                                                                                                                                                                                                                                                                                                                                      get: {
                                                                                                                                                                                                                                                                                                                                                                      <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                                                                                                                      typeOrToken: Type<TInput> | Function | string | symbol
                                                                                                                                                                                                                                                                                                                                                                      ): TResult;
                                                                                                                                                                                                                                                                                                                                                                      <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                                                                                                                      typeOrToken: any,
                                                                                                                                                                                                                                                                                                                                                                      options: { strict?: boolean; each?: false }
                                                                                                                                                                                                                                                                                                                                                                      ): TResult;
                                                                                                                                                                                                                                                                                                                                                                      <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                                                                                                                      typeOrToken: any,
                                                                                                                                                                                                                                                                                                                                                                      options: { strict?: boolean; each: true }
                                                                                                                                                                                                                                                                                                                                                                      ): TResult[];
                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                      • Retrieves an instance of either injectable or controller, otherwise, throws exception.

                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                        {TResult}

                                                                                                                                                                                                                                                                                                                                                                      • Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.

                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                        {Array}

                                                                                                                                                                                                                                                                                                                                                                      method init

                                                                                                                                                                                                                                                                                                                                                                      init: () => Promise<this>;
                                                                                                                                                                                                                                                                                                                                                                      • Initializes the Nest application. Calls the Nest lifecycle events.

                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                        {Promise} The NestApplicationContext instance as Promise

                                                                                                                                                                                                                                                                                                                                                                      method listenToShutdownSignals

                                                                                                                                                                                                                                                                                                                                                                      protected listenToShutdownSignals: (signals: string[]) => void;
                                                                                                                                                                                                                                                                                                                                                                      • Listens to shutdown signals by listening to process events

                                                                                                                                                                                                                                                                                                                                                                        Parameter signals

                                                                                                                                                                                                                                                                                                                                                                        The system signals it should listen to

                                                                                                                                                                                                                                                                                                                                                                      method registerRequestByContextId

                                                                                                                                                                                                                                                                                                                                                                      registerRequestByContextId: <T = any>(request: T, contextId: ContextId) => void;
                                                                                                                                                                                                                                                                                                                                                                      • Registers the request/context object for a given context ID (DI container sub-tree).

                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                        {void}

                                                                                                                                                                                                                                                                                                                                                                      method resolve

                                                                                                                                                                                                                                                                                                                                                                      resolve: {
                                                                                                                                                                                                                                                                                                                                                                      <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                                                                                                                      typeOrToken: Type<TInput> | Function | string | symbol
                                                                                                                                                                                                                                                                                                                                                                      ): Promise<TResult>;
                                                                                                                                                                                                                                                                                                                                                                      <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                                                                                                                      typeOrToken: any,
                                                                                                                                                                                                                                                                                                                                                                      contextId?: { id: number }
                                                                                                                                                                                                                                                                                                                                                                      ): Promise<TResult>;
                                                                                                                                                                                                                                                                                                                                                                      <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                                                                                                                      typeOrToken: any,
                                                                                                                                                                                                                                                                                                                                                                      contextId?: { id: number },
                                                                                                                                                                                                                                                                                                                                                                      options?: { strict?: boolean; each?: false }
                                                                                                                                                                                                                                                                                                                                                                      ): Promise<TResult>;
                                                                                                                                                                                                                                                                                                                                                                      <TInput = any, TResult = TInput>(
                                                                                                                                                                                                                                                                                                                                                                      typeOrToken: any,
                                                                                                                                                                                                                                                                                                                                                                      contextId?: { id: number },
                                                                                                                                                                                                                                                                                                                                                                      options?: { strict?: boolean; each: true }
                                                                                                                                                                                                                                                                                                                                                                      ): Promise<TResult[]>;
                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                      • Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.

                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                        {Array}

                                                                                                                                                                                                                                                                                                                                                                      • Resolves transient or request-scoped instances of either injectables or controllers, otherwise, throws exception.

                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                        {Array}

                                                                                                                                                                                                                                                                                                                                                                      method select

                                                                                                                                                                                                                                                                                                                                                                      select: <T>(moduleType: Type<T> | DynamicModule) => INestApplicationContext;
                                                                                                                                                                                                                                                                                                                                                                      • Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.

                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                        {INestApplicationContext}

                                                                                                                                                                                                                                                                                                                                                                      method selectContextModule

                                                                                                                                                                                                                                                                                                                                                                      selectContextModule: () => void;

                                                                                                                                                                                                                                                                                                                                                                        method unsubscribeFromProcessSignals

                                                                                                                                                                                                                                                                                                                                                                        protected unsubscribeFromProcessSignals: () => void;
                                                                                                                                                                                                                                                                                                                                                                        • Unsubscribes from shutdown signals (process events)

                                                                                                                                                                                                                                                                                                                                                                        method useLogger

                                                                                                                                                                                                                                                                                                                                                                        useLogger: (logger: LoggerService | LogLevel[] | false) => void;
                                                                                                                                                                                                                                                                                                                                                                        • Sets custom logger service. Flushes buffered logs if auto flush is on.

                                                                                                                                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                                                                                                                                          {void}

                                                                                                                                                                                                                                                                                                                                                                        class NestContainer

                                                                                                                                                                                                                                                                                                                                                                        class NestContainer {}

                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                          constructor(_applicationConfig?: ApplicationConfig);

                                                                                                                                                                                                                                                                                                                                                                            property applicationConfig

                                                                                                                                                                                                                                                                                                                                                                            readonly applicationConfig: ApplicationConfig;

                                                                                                                                                                                                                                                                                                                                                                              property serializedGraph

                                                                                                                                                                                                                                                                                                                                                                              readonly serializedGraph: SerializedGraph;

                                                                                                                                                                                                                                                                                                                                                                                method addController

                                                                                                                                                                                                                                                                                                                                                                                addController: (controller: Type<any>, token: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                  method addDynamicMetadata

                                                                                                                                                                                                                                                                                                                                                                                  addDynamicMetadata: (
                                                                                                                                                                                                                                                                                                                                                                                  token: string,
                                                                                                                                                                                                                                                                                                                                                                                  dynamicModuleMetadata: DynamicModule,
                                                                                                                                                                                                                                                                                                                                                                                  scope: Type<any>[]
                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                    method addDynamicModules

                                                                                                                                                                                                                                                                                                                                                                                    addDynamicModules: (modules: any[], scope: Type<any>[]) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                      method addExportedProvider

                                                                                                                                                                                                                                                                                                                                                                                      addExportedProvider: (provider: Type<any>, token: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                        method addGlobalModule

                                                                                                                                                                                                                                                                                                                                                                                        addGlobalModule: (module: Module) => void;

                                                                                                                                                                                                                                                                                                                                                                                          method addImport

                                                                                                                                                                                                                                                                                                                                                                                          addImport: (
                                                                                                                                                                                                                                                                                                                                                                                          relatedModule: Type<any> | DynamicModule,
                                                                                                                                                                                                                                                                                                                                                                                          token: string
                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                            method addInjectable

                                                                                                                                                                                                                                                                                                                                                                                            addInjectable: (
                                                                                                                                                                                                                                                                                                                                                                                            injectable: Provider,
                                                                                                                                                                                                                                                                                                                                                                                            token: string,
                                                                                                                                                                                                                                                                                                                                                                                            enhancerSubtype: EnhancerSubtype,
                                                                                                                                                                                                                                                                                                                                                                                            host?: Type<Injectable>
                                                                                                                                                                                                                                                                                                                                                                                            ) =>
                                                                                                                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                                                                                                                            | symbol
                                                                                                                                                                                                                                                                                                                                                                                            | Function
                                                                                                                                                                                                                                                                                                                                                                                            | import('./instance-wrapper').InstanceWrapper<unknown>;

                                                                                                                                                                                                                                                                                                                                                                                              method addModule

                                                                                                                                                                                                                                                                                                                                                                                              addModule: (
                                                                                                                                                                                                                                                                                                                                                                                              metatype: Type<any> | DynamicModule | Promise<DynamicModule>,
                                                                                                                                                                                                                                                                                                                                                                                              scope: Type<any>[]
                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<Module | undefined>;

                                                                                                                                                                                                                                                                                                                                                                                                method addProvider

                                                                                                                                                                                                                                                                                                                                                                                                addProvider: (
                                                                                                                                                                                                                                                                                                                                                                                                provider: Provider,
                                                                                                                                                                                                                                                                                                                                                                                                token: string,
                                                                                                                                                                                                                                                                                                                                                                                                enhancerSubtype?: EnhancerSubtype
                                                                                                                                                                                                                                                                                                                                                                                                ) => string | symbol | Function;

                                                                                                                                                                                                                                                                                                                                                                                                  method bindGlobalModuleToModule

                                                                                                                                                                                                                                                                                                                                                                                                  bindGlobalModuleToModule: (target: Module, globalModule: Module) => void;

                                                                                                                                                                                                                                                                                                                                                                                                    method bindGlobalScope

                                                                                                                                                                                                                                                                                                                                                                                                    bindGlobalScope: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                      method bindGlobalsToImports

                                                                                                                                                                                                                                                                                                                                                                                                      bindGlobalsToImports: (moduleRef: Module) => void;

                                                                                                                                                                                                                                                                                                                                                                                                        method clear

                                                                                                                                                                                                                                                                                                                                                                                                        clear: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                          method getDynamicMetadataByToken

                                                                                                                                                                                                                                                                                                                                                                                                          getDynamicMetadataByToken: {
                                                                                                                                                                                                                                                                                                                                                                                                          (token: string): DynamicModule;
                                                                                                                                                                                                                                                                                                                                                                                                          <K extends string | number | symbol>(
                                                                                                                                                                                                                                                                                                                                                                                                          token: string,
                                                                                                                                                                                                                                                                                                                                                                                                          metadataKey: K
                                                                                                                                                                                                                                                                                                                                                                                                          ): DynamicModule;
                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                            method getHttpAdapterHostRef

                                                                                                                                                                                                                                                                                                                                                                                                            getHttpAdapterHostRef: () => import('..').HttpAdapterHost<
                                                                                                                                                                                                                                                                                                                                                                                                            import('..').AbstractHttpAdapter<any, any, any>
                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                              method getHttpAdapterRef

                                                                                                                                                                                                                                                                                                                                                                                                              getHttpAdapterRef: () => import('..').AbstractHttpAdapter<any, any, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                method getInternalCoreModuleRef

                                                                                                                                                                                                                                                                                                                                                                                                                getInternalCoreModuleRef: () => Module | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                  method getModuleByKey

                                                                                                                                                                                                                                                                                                                                                                                                                  getModuleByKey: (moduleKey: string) => Module;

                                                                                                                                                                                                                                                                                                                                                                                                                    method getModuleCompiler

                                                                                                                                                                                                                                                                                                                                                                                                                    getModuleCompiler: () => ModuleCompiler;

                                                                                                                                                                                                                                                                                                                                                                                                                      method getModules

                                                                                                                                                                                                                                                                                                                                                                                                                      getModules: () => ModulesContainer;

                                                                                                                                                                                                                                                                                                                                                                                                                        method getModuleTokenFactory

                                                                                                                                                                                                                                                                                                                                                                                                                        getModuleTokenFactory: () => ModuleTokenFactory;

                                                                                                                                                                                                                                                                                                                                                                                                                          method isGlobalModule

                                                                                                                                                                                                                                                                                                                                                                                                                          isGlobalModule: (
                                                                                                                                                                                                                                                                                                                                                                                                                          metatype: Type<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                          dynamicMetadata?: DynamicModule
                                                                                                                                                                                                                                                                                                                                                                                                                          ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                            method registerCoreModuleRef

                                                                                                                                                                                                                                                                                                                                                                                                                            registerCoreModuleRef: (moduleRef: Module) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                              method registerRequestProvider

                                                                                                                                                                                                                                                                                                                                                                                                                              registerRequestProvider: <T = any>(request: T, contextId: ContextId) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                method replace

                                                                                                                                                                                                                                                                                                                                                                                                                                replace: (toReplace: any, options: any & { scope: any[] | null }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method setHttpAdapter

                                                                                                                                                                                                                                                                                                                                                                                                                                  setHttpAdapter: (httpAdapter: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                    class PartialGraphHost

                                                                                                                                                                                                                                                                                                                                                                                                                                    class PartialGraphHost {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      method register

                                                                                                                                                                                                                                                                                                                                                                                                                                      static register: (partialGraph: SerializedGraph) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                        static toJSON: () => import('./interfaces/serialized-graph-json.interface').SerializedGraphJson;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                          static toString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                            class Reflector

                                                                                                                                                                                                                                                                                                                                                                                                                                            class Reflector {}
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Helper class providing Nest reflection capabilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                              See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                              • [Reflection](https://docs.nestjs.com/guards#putting-it-all-together)

                                                                                                                                                                                                                                                                                                                                                                                                                                            method get

                                                                                                                                                                                                                                                                                                                                                                                                                                            get: <TResult = any, TKey = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                            metadataKey: TKey,
                                                                                                                                                                                                                                                                                                                                                                                                                                            target: Type<any> | Function
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => TResult;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Retrieve metadata for a specified key for a specified target.

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter metadataKey

                                                                                                                                                                                                                                                                                                                                                                                                                                              lookup key for metadata to retrieve

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter target

                                                                                                                                                                                                                                                                                                                                                                                                                                              context (decorated object) to retrieve metadata from

                                                                                                                                                                                                                                                                                                                                                                                                                                              Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                              const roles = this.reflector.get<string[]>('roles', context.getHandler());

                                                                                                                                                                                                                                                                                                                                                                                                                                            method getAll

                                                                                                                                                                                                                                                                                                                                                                                                                                            getAll: <TResult extends any[] = any[], TKey = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                            metadataKey: TKey,
                                                                                                                                                                                                                                                                                                                                                                                                                                            targets: (Type<any> | Function)[]
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => TResult;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Retrieve metadata for a specified key for a specified set of targets.

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter metadataKey

                                                                                                                                                                                                                                                                                                                                                                                                                                              lookup key for metadata to retrieve

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter targets

                                                                                                                                                                                                                                                                                                                                                                                                                                              context (decorated objects) to retrieve metadata from

                                                                                                                                                                                                                                                                                                                                                                                                                                            method getAllAndMerge

                                                                                                                                                                                                                                                                                                                                                                                                                                            getAllAndMerge: <TResult extends any[] = any[], TKey = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                            metadataKey: TKey,
                                                                                                                                                                                                                                                                                                                                                                                                                                            targets: (Type<any> | Function)[]
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => TResult;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Retrieve metadata for a specified key for a specified set of targets and merge results.

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter metadataKey

                                                                                                                                                                                                                                                                                                                                                                                                                                              lookup key for metadata to retrieve

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter targets

                                                                                                                                                                                                                                                                                                                                                                                                                                              context (decorated objects) to retrieve metadata from

                                                                                                                                                                                                                                                                                                                                                                                                                                            method getAllAndOverride

                                                                                                                                                                                                                                                                                                                                                                                                                                            getAllAndOverride: <TResult = any, TKey = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                            metadataKey: TKey,
                                                                                                                                                                                                                                                                                                                                                                                                                                            targets: (Type<any> | Function)[]
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => TResult;
                                                                                                                                                                                                                                                                                                                                                                                                                                            • Retrieve metadata for a specified key for a specified set of targets and return a first not undefined value.

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter metadataKey

                                                                                                                                                                                                                                                                                                                                                                                                                                              lookup key for metadata to retrieve

                                                                                                                                                                                                                                                                                                                                                                                                                                              Parameter targets

                                                                                                                                                                                                                                                                                                                                                                                                                                              context (decorated objects) to retrieve metadata from

                                                                                                                                                                                                                                                                                                                                                                                                                                            class RouterModule

                                                                                                                                                                                                                                                                                                                                                                                                                                            class RouterModule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(modulesContainer: ModulesContainer, routes: Routes);

                                                                                                                                                                                                                                                                                                                                                                                                                                              method register

                                                                                                                                                                                                                                                                                                                                                                                                                                              static register: (routes: Routes) => DynamicModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                class SerializedGraph

                                                                                                                                                                                                                                                                                                                                                                                                                                                class SerializedGraph {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getNodeById

                                                                                                                                                                                                                                                                                                                                                                                                                                                  getNodeById: (id: string) => Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method insertAttachedEnhancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                    insertAttachedEnhancer: (nodeId: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method insertEdge

                                                                                                                                                                                                                                                                                                                                                                                                                                                      insertEdge: (edgeDefinition: WithOptionalId<Edge>) => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: 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 });
                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      target: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method insertEntrypoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                        insertEntrypoint: <T>(definition: Entrypoint<T>, parentId: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method insertNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                          insertNode: (nodeDefinition: Node) => Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method insertOrphanedEnhancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                            insertOrphanedEnhancer: (entry: OrphanedEnhancerDefinition) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                              toJSON: () => SerializedGraphJson;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                toString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ContextId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ContextId {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly id: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property payload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      payload?: unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getParent: (info: HostComponentInfo) => ContextId;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ContextIdResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ContextIdResolver {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property payload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            payload: unknown;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Payload associated with the custom context id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resolve: ContextIdResolverFn;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A context id resolver function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ContextIdStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ContextIdStrategy<T = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method attach

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              attach: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              contextId: ContextId,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              request: T
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => ContextIdResolverFn | ContextIdResolver | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Allows to attach a parent context id to the existing child context id. This lets you construct durable DI sub-trees that can be shared between contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter contextId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                auto-generated child context id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                request object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DiscoveryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DiscoveryOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property include

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              include?: Function[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ExternalContextOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ExternalContextOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property filters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  filters?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property guards

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    guards?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property interceptors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interceptors?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HostComponentInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HostComponentInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isTreeDurable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTreeDurable: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Flag that indicates whether DI subtree is durable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property token

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          token: InstanceToken;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Injection token (or class reference)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ModuleRefGetOrResolveOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ModuleRefGetOrResolveOpts {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property each

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            each?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • If enabled, instead of returning a first instance registered under a given token, a list of instances will be returned. false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property strict

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            strict?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • If enabled, lookup will only be performed in the host module. true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ParamsFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ParamsFactory {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method exchangeKeyForValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              exchangeKeyForValue: (type: number, data: ParamData, args: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RouteTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RouteTree {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  children?: Routes | Type<any>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property module

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    module?: Type<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ContextIdResolverFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ContextIdResolverFn = (info: HostComponentInfo) => ContextId;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Routes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Routes = RouteTree[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SerializedGraphStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SerializedGraphStatus = 'partial' | 'complete';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (30)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (6)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (6)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@nestjs/core.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@nestjs/core)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/@nestjs/core"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>