@nestjs/core

  • Version 9.2.1
  • Published
  • 447 kB
  • 7 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 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 LazyModuleLoader

                                                                                                                                                                                    class LazyModuleLoader {}

                                                                                                                                                                                      constructor

                                                                                                                                                                                      constructor(
                                                                                                                                                                                      dependenciesScanner: DependenciesScanner,
                                                                                                                                                                                      instanceLoader: InstanceLoader,
                                                                                                                                                                                      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 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);

                                                                                                                                                                                                    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?: GetOrResolveOptions
                                                                                                                                                                                                                      ): 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?: GetOrResolveOptions
                                                                                                                                                                                                                            ): 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;

                                                                                                                                                                                                                                class NestApplication

                                                                                                                                                                                                                                class NestApplication extends NestApplicationContext implements INestApplication {}

                                                                                                                                                                                                                                constructor

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

                                                                                                                                                                                                                                  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 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
                                                                                                                                                                                                                                                                                              extends AbstractInstanceResolver
                                                                                                                                                                                                                                                                                              implements INestApplicationContext {}

                                                                                                                                                                                                                                                                                              constructor

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

                                                                                                                                                                                                                                                                                                property container

                                                                                                                                                                                                                                                                                                protected readonly container: NestContainer;

                                                                                                                                                                                                                                                                                                  property injector

                                                                                                                                                                                                                                                                                                  protected readonly injector: Injector;

                                                                                                                                                                                                                                                                                                    property instanceLinksHost

                                                                                                                                                                                                                                                                                                    readonly instanceLinksHost: InstanceLinksHost;

                                                                                                                                                                                                                                                                                                      property isInitialized

                                                                                                                                                                                                                                                                                                      protected isInitialized: boolean;

                                                                                                                                                                                                                                                                                                        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: () => 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;

                                                                                                                                                                                                                                                                                                                  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,
                                                                                                                                                                                                                                                                                                                              host?: Type<Injectable>
                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                method addModule

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

                                                                                                                                                                                                                                                                                                                                  method addProvider

                                                                                                                                                                                                                                                                                                                                  addProvider: (provider: Provider, token: string) => 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,
                                                                                                                                                                                                                                                                                                                                            metadataKey: keyof DynamicModule
                                                                                                                                                                                                                                                                                                                                            ) => any[];

                                                                                                                                                                                                                                                                                                                                              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 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;

                                                                                                                                                                                                                                                                                                                                                                          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 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 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[];

                                                                                                                                                                                                                                                                                                                                                                                                      Package Files (25)

                                                                                                                                                                                                                                                                                                                                                                                                      Dependencies (7)

                                                                                                                                                                                                                                                                                                                                                                                                      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>