@nestjs/swagger

  • Version 7.1.12
  • Published
  • 300 kB
  • 5 dependencies
  • MIT license

Install

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

Overview

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

Index

Functions

Classes

Interfaces

Type Aliases

Functions

function ApiAcceptedResponse

ApiAcceptedResponse: (
options?: ApiResponseOptions
) => MethodDecorator & ClassDecorator;

    function ApiBadGatewayResponse

    ApiBadGatewayResponse: (
    options?: ApiResponseOptions
    ) => MethodDecorator & ClassDecorator;

      function ApiBadRequestResponse

      ApiBadRequestResponse: (
      options?: ApiResponseOptions
      ) => MethodDecorator & ClassDecorator;

        function ApiBasicAuth

        ApiBasicAuth: (name?: string) => ClassDecorator & MethodDecorator;

          function ApiBearerAuth

          ApiBearerAuth: (name?: string) => ClassDecorator & MethodDecorator;

            function ApiBody

            ApiBody: (options: ApiBodyOptions) => MethodDecorator;

              function ApiConflictResponse

              ApiConflictResponse: (
              options?: ApiResponseOptions
              ) => MethodDecorator & ClassDecorator;

                function ApiConsumes

                ApiConsumes: (...mimeTypes: string[]) => MethodDecorator & ClassDecorator;

                  function ApiCookieAuth

                  ApiCookieAuth: (name?: string) => ClassDecorator & MethodDecorator;

                    function ApiCreatedResponse

                    ApiCreatedResponse: (
                    options?: ApiResponseOptions
                    ) => MethodDecorator & ClassDecorator;

                      function ApiDefaultResponse

                      ApiDefaultResponse: (
                      options?: ApiResponseOptions
                      ) => MethodDecorator & ClassDecorator;

                        function ApiExcludeController

                        ApiExcludeController: (disable?: boolean) => ClassDecorator;

                          function ApiExcludeEndpoint

                          ApiExcludeEndpoint: (disable?: boolean) => MethodDecorator;

                            function ApiExtension

                            ApiExtension: (
                            extensionKey: string,
                            extensionProperties: any
                            ) => MethodDecorator & ClassDecorator;

                              function ApiExtraModels

                              ApiExtraModels: (
                              ...models: Function[]
                              ) => (
                              target: object,
                              key?: string | symbol,
                              descriptor?: TypedPropertyDescriptor<any>
                              ) => any;

                                function ApiForbiddenResponse

                                ApiForbiddenResponse: (
                                options?: ApiResponseOptions
                                ) => MethodDecorator & ClassDecorator;

                                  function ApiFoundResponse

                                  ApiFoundResponse: (
                                  options?: ApiResponseOptions
                                  ) => MethodDecorator & ClassDecorator;

                                    function ApiGatewayTimeoutResponse

                                    ApiGatewayTimeoutResponse: (
                                    options?: ApiResponseOptions
                                    ) => MethodDecorator & ClassDecorator;

                                      function ApiGoneResponse

                                      ApiGoneResponse: (
                                      options?: ApiResponseOptions
                                      ) => MethodDecorator & ClassDecorator;

                                        function ApiHeader

                                        ApiHeader: (options: ApiHeaderOptions) => MethodDecorator & ClassDecorator;

                                          function ApiHeaders

                                          ApiHeaders: (headers: ApiHeaderOptions[]) => MethodDecorator & ClassDecorator;

                                            function ApiHideProperty

                                            ApiHideProperty: () => PropertyDecorator;

                                              function ApiInternalServerErrorResponse

                                              ApiInternalServerErrorResponse: (
                                              options?: ApiResponseOptions
                                              ) => MethodDecorator & ClassDecorator;

                                                function ApiMethodNotAllowedResponse

                                                ApiMethodNotAllowedResponse: (
                                                options?: ApiResponseOptions
                                                ) => MethodDecorator & ClassDecorator;

                                                  function ApiMovedPermanentlyResponse

                                                  ApiMovedPermanentlyResponse: (
                                                  options?: ApiResponseOptions
                                                  ) => MethodDecorator & ClassDecorator;

                                                    function ApiNoContentResponse

                                                    ApiNoContentResponse: (
                                                    options?: ApiResponseOptions
                                                    ) => MethodDecorator & ClassDecorator;

                                                      function ApiNotAcceptableResponse

                                                      ApiNotAcceptableResponse: (
                                                      options?: ApiResponseOptions
                                                      ) => MethodDecorator & ClassDecorator;

                                                        function ApiNotFoundResponse

                                                        ApiNotFoundResponse: (
                                                        options?: ApiResponseOptions
                                                        ) => MethodDecorator & ClassDecorator;

                                                          function ApiNotImplementedResponse

                                                          ApiNotImplementedResponse: (
                                                          options?: ApiResponseOptions
                                                          ) => MethodDecorator & ClassDecorator;

                                                            function ApiOAuth2

                                                            ApiOAuth2: (scopes: string[], name?: string) => ClassDecorator & MethodDecorator;

                                                              function ApiOkResponse

                                                              ApiOkResponse: (
                                                              options?: ApiResponseOptions
                                                              ) => MethodDecorator & ClassDecorator;

                                                                function ApiOperation

                                                                ApiOperation: (
                                                                options: ApiOperationOptions,
                                                                { overrideExisting }?: { overrideExisting: boolean }
                                                                ) => MethodDecorator;

                                                                  function ApiParam

                                                                  ApiParam: (options: ApiParamOptions) => MethodDecorator;

                                                                    function ApiPayloadTooLargeResponse

                                                                    ApiPayloadTooLargeResponse: (
                                                                    options?: ApiResponseOptions
                                                                    ) => MethodDecorator & ClassDecorator;

                                                                      function ApiPreconditionFailedResponse

                                                                      ApiPreconditionFailedResponse: (
                                                                      options?: ApiResponseOptions
                                                                      ) => MethodDecorator & ClassDecorator;

                                                                        function ApiProduces

                                                                        ApiProduces: (...mimeTypes: string[]) => MethodDecorator & ClassDecorator;

                                                                          function ApiProperty

                                                                          ApiProperty: (options?: ApiPropertyOptions) => PropertyDecorator;

                                                                            function ApiPropertyOptional

                                                                            ApiPropertyOptional: (options?: ApiPropertyOptions) => PropertyDecorator;

                                                                              function ApiQuery

                                                                              ApiQuery: (options: ApiQueryOptions) => MethodDecorator;

                                                                                function ApiRequestTimeoutResponse

                                                                                ApiRequestTimeoutResponse: (
                                                                                options?: ApiResponseOptions
                                                                                ) => MethodDecorator & ClassDecorator;

                                                                                  function ApiResponse

                                                                                  ApiResponse: (
                                                                                  options: ApiResponseOptions,
                                                                                  { overrideExisting }?: { overrideExisting: boolean }
                                                                                  ) => MethodDecorator & ClassDecorator;

                                                                                    function ApiResponseProperty

                                                                                    ApiResponseProperty: (
                                                                                    options?: Pick<
                                                                                    ApiPropertyOptions,
                                                                                    'type' | 'example' | 'format' | 'enum' | 'deprecated'
                                                                                    >
                                                                                    ) => PropertyDecorator;

                                                                                      function ApiSecurity

                                                                                      ApiSecurity: (
                                                                                      name: string | SecurityRequirementObject,
                                                                                      requirements?: string[]
                                                                                      ) => ClassDecorator & MethodDecorator;

                                                                                        function ApiServiceUnavailableResponse

                                                                                        ApiServiceUnavailableResponse: (
                                                                                        options?: ApiResponseOptions
                                                                                        ) => MethodDecorator & ClassDecorator;

                                                                                          function ApiTags

                                                                                          ApiTags: (...tags: string[]) => MethodDecorator & ClassDecorator;

                                                                                            function ApiTooManyRequestsResponse

                                                                                            ApiTooManyRequestsResponse: (
                                                                                            options?: ApiResponseOptions
                                                                                            ) => MethodDecorator & ClassDecorator;

                                                                                              function ApiUnauthorizedResponse

                                                                                              ApiUnauthorizedResponse: (
                                                                                              options?: ApiResponseOptions
                                                                                              ) => MethodDecorator & ClassDecorator;

                                                                                                function ApiUnprocessableEntityResponse

                                                                                                ApiUnprocessableEntityResponse: (
                                                                                                options?: ApiResponseOptions
                                                                                                ) => MethodDecorator & ClassDecorator;

                                                                                                  function ApiUnsupportedMediaTypeResponse

                                                                                                  ApiUnsupportedMediaTypeResponse: (
                                                                                                  options?: ApiResponseOptions
                                                                                                  ) => MethodDecorator & ClassDecorator;

                                                                                                    function getSchemaPath

                                                                                                    getSchemaPath: (model: string | Function) => string;

                                                                                                      function IntersectionType

                                                                                                      IntersectionType: <T extends Type[]>(
                                                                                                      ...classRefs: T
                                                                                                      ) => Type<UnionToIntersection<ClassRefsToConstructors<T>[number]>>;

                                                                                                        function OmitType

                                                                                                        OmitType: <T, K extends keyof T>(
                                                                                                        classRef: Type<T>,
                                                                                                        keys: readonly K[]
                                                                                                        ) => Type<Omit<T, K>>;

                                                                                                          function PartialType

                                                                                                          PartialType: <T>(classRef: Type<T>) => Type<Partial<T>>;

                                                                                                            function PickType

                                                                                                            PickType: <T, K extends keyof T>(
                                                                                                            classRef: Type<T>,
                                                                                                            keys: readonly K[]
                                                                                                            ) => Type<Pick<T, K>>;

                                                                                                              function refs

                                                                                                              refs: (...models: Function[]) => { $ref: string }[];

                                                                                                                Classes

                                                                                                                class DocumentBuilder

                                                                                                                class DocumentBuilder {}

                                                                                                                  method addApiKey

                                                                                                                  addApiKey: (options?: SecuritySchemeObject, name?: string) => this;

                                                                                                                    method addBasicAuth

                                                                                                                    addBasicAuth: (options?: SecuritySchemeObject, name?: string) => this;

                                                                                                                      method addBearerAuth

                                                                                                                      addBearerAuth: (options?: SecuritySchemeObject, name?: string) => this;

                                                                                                                        method addCookieAuth

                                                                                                                        addCookieAuth: (
                                                                                                                        cookieName?: string,
                                                                                                                        options?: SecuritySchemeObject,
                                                                                                                        securityName?: string
                                                                                                                        ) => this;

                                                                                                                          method addGlobalParameters

                                                                                                                          addGlobalParameters: (...parameters: ParameterObject[]) => this;

                                                                                                                            method addOAuth2

                                                                                                                            addOAuth2: (options?: SecuritySchemeObject, name?: string) => this;

                                                                                                                              method addSecurity

                                                                                                                              addSecurity: (name: string, options: SecuritySchemeObject) => this;

                                                                                                                                method addSecurityRequirements

                                                                                                                                addSecurityRequirements: (
                                                                                                                                name: string | SecurityRequirementObject,
                                                                                                                                requirements?: string[]
                                                                                                                                ) => this;

                                                                                                                                  method addServer

                                                                                                                                  addServer: (
                                                                                                                                  url: string,
                                                                                                                                  description?: string,
                                                                                                                                  variables?: Record<string, ServerVariableObject>
                                                                                                                                  ) => this;

                                                                                                                                    method addTag

                                                                                                                                    addTag: (
                                                                                                                                    name: string,
                                                                                                                                    description?: string,
                                                                                                                                    externalDocs?: ExternalDocumentationObject
                                                                                                                                    ) => this;

                                                                                                                                      method build

                                                                                                                                      build: () => Omit<OpenAPIObject, 'paths'>;

                                                                                                                                        method setBasePath

                                                                                                                                        setBasePath: (path: string) => this;

                                                                                                                                          method setContact

                                                                                                                                          setContact: (name: string, url: string, email: string) => this;

                                                                                                                                            method setDescription

                                                                                                                                            setDescription: (description: string) => this;

                                                                                                                                              method setExternalDoc

                                                                                                                                              setExternalDoc: (description: string, url: string) => this;

                                                                                                                                                method setLicense

                                                                                                                                                setLicense: (name: string, url: string) => this;

                                                                                                                                                  method setTermsOfService

                                                                                                                                                  setTermsOfService: (termsOfService: string) => this;

                                                                                                                                                    method setTitle

                                                                                                                                                    setTitle: (title: string) => this;

                                                                                                                                                      method setVersion

                                                                                                                                                      setVersion: (version: string) => this;

                                                                                                                                                        class SwaggerModule

                                                                                                                                                        class SwaggerModule {}

                                                                                                                                                          method createDocument

                                                                                                                                                          static createDocument: (
                                                                                                                                                          app: INestApplication,
                                                                                                                                                          config: Omit<OpenAPIObject, 'paths'>,
                                                                                                                                                          options?: SwaggerDocumentOptions
                                                                                                                                                          ) => OpenAPIObject;

                                                                                                                                                            method loadPluginMetadata

                                                                                                                                                            static loadPluginMetadata: (
                                                                                                                                                            metadataFn: () => Promise<Record<string, any>>
                                                                                                                                                            ) => Promise<void>;

                                                                                                                                                              method setup

                                                                                                                                                              static setup: (
                                                                                                                                                              path: string,
                                                                                                                                                              app: INestApplication,
                                                                                                                                                              documentOrFactory: OpenAPIObject | (() => OpenAPIObject),
                                                                                                                                                              options?: SwaggerCustomOptions
                                                                                                                                                              ) => void;

                                                                                                                                                                Interfaces

                                                                                                                                                                interface ApiHeaderOptions

                                                                                                                                                                interface ApiHeaderOptions extends Omit<ParameterObject, 'in'> {}

                                                                                                                                                                  property enum

                                                                                                                                                                  enum?: SwaggerEnumType;

                                                                                                                                                                    interface ApiPropertyOptions

                                                                                                                                                                    interface ApiPropertyOptions extends Omit<SchemaObjectMetadata, 'name' | 'enum'> {}

                                                                                                                                                                      property enum

                                                                                                                                                                      enum?: any[] | Record<string, any>;

                                                                                                                                                                        property enumName

                                                                                                                                                                        enumName?: string;

                                                                                                                                                                          property name

                                                                                                                                                                          name?: string;

                                                                                                                                                                            interface ApiResponseMetadata

                                                                                                                                                                            interface ApiResponseMetadata extends Omit<ResponseObject, 'description'> {}

                                                                                                                                                                              property description

                                                                                                                                                                              description?: string;

                                                                                                                                                                                property isArray

                                                                                                                                                                                isArray?: boolean;

                                                                                                                                                                                  property status

                                                                                                                                                                                  status?: number | 'default' | '1XX' | '2XX' | '3XX' | '4XX' | '5XX';

                                                                                                                                                                                    property type

                                                                                                                                                                                    type?: Type<unknown> | Function | [Function] | string;

                                                                                                                                                                                      interface ApiResponseSchemaHost

                                                                                                                                                                                      interface ApiResponseSchemaHost extends Omit<ResponseObject, 'description'> {}

                                                                                                                                                                                        property description

                                                                                                                                                                                        description?: string;

                                                                                                                                                                                          property schema

                                                                                                                                                                                          schema: SchemaObject & Partial<ReferenceObject>;

                                                                                                                                                                                            property status

                                                                                                                                                                                            status?: number | 'default' | '1XX' | '2XX' | '3XX' | '4XX' | '5XX';

                                                                                                                                                                                              interface OpenAPIObject

                                                                                                                                                                                              interface OpenAPIObject {}

                                                                                                                                                                                                property components

                                                                                                                                                                                                components?: ComponentsObject;

                                                                                                                                                                                                  property externalDocs

                                                                                                                                                                                                  externalDocs?: ExternalDocumentationObject;

                                                                                                                                                                                                    property info

                                                                                                                                                                                                    info: InfoObject;

                                                                                                                                                                                                      property openapi

                                                                                                                                                                                                      openapi: string;

                                                                                                                                                                                                        property paths

                                                                                                                                                                                                        paths: PathsObject;

                                                                                                                                                                                                          property security

                                                                                                                                                                                                          security?: SecurityRequirementObject[];

                                                                                                                                                                                                            property servers

                                                                                                                                                                                                            servers?: ServerObject[];

                                                                                                                                                                                                              property tags

                                                                                                                                                                                                              tags?: TagObject[];

                                                                                                                                                                                                                interface SwaggerCustomOptions

                                                                                                                                                                                                                interface SwaggerCustomOptions {}

                                                                                                                                                                                                                  property customCss

                                                                                                                                                                                                                  customCss?: string;

                                                                                                                                                                                                                    property customCssUrl

                                                                                                                                                                                                                    customCssUrl?: string | string[];

                                                                                                                                                                                                                      property customfavIcon

                                                                                                                                                                                                                      customfavIcon?: string;

                                                                                                                                                                                                                        property customJs

                                                                                                                                                                                                                        customJs?: string | string[];

                                                                                                                                                                                                                          property customJsStr

                                                                                                                                                                                                                          customJsStr?: string | string[];

                                                                                                                                                                                                                            property customSiteTitle

                                                                                                                                                                                                                            customSiteTitle?: string;

                                                                                                                                                                                                                              property customSwaggerUiPath

                                                                                                                                                                                                                              customSwaggerUiPath?: string;

                                                                                                                                                                                                                                property explorer

                                                                                                                                                                                                                                explorer?: boolean;

                                                                                                                                                                                                                                  property jsonDocumentUrl

                                                                                                                                                                                                                                  jsonDocumentUrl?: string;

                                                                                                                                                                                                                                    property patchDocumentOnRequest

                                                                                                                                                                                                                                    patchDocumentOnRequest?: <TRequest = any, TResponse = any>(
                                                                                                                                                                                                                                    req: TRequest,
                                                                                                                                                                                                                                    res: TResponse,
                                                                                                                                                                                                                                    document: OpenAPIObject
                                                                                                                                                                                                                                    ) => OpenAPIObject;

                                                                                                                                                                                                                                      property swaggerOptions

                                                                                                                                                                                                                                      swaggerOptions?: SwaggerUiOptions;

                                                                                                                                                                                                                                        property swaggerUrl

                                                                                                                                                                                                                                        swaggerUrl?: string;

                                                                                                                                                                                                                                          property url

                                                                                                                                                                                                                                          url?: string;

                                                                                                                                                                                                                                            property urls

                                                                                                                                                                                                                                            urls?: Record<'url' | 'name', string>[];

                                                                                                                                                                                                                                              property useGlobalPrefix

                                                                                                                                                                                                                                              useGlobalPrefix?: boolean;

                                                                                                                                                                                                                                                property validatorUrl

                                                                                                                                                                                                                                                validatorUrl?: string;

                                                                                                                                                                                                                                                  property yamlDocumentUrl

                                                                                                                                                                                                                                                  yamlDocumentUrl?: string;

                                                                                                                                                                                                                                                    interface SwaggerDocumentOptions

                                                                                                                                                                                                                                                    interface SwaggerDocumentOptions {}

                                                                                                                                                                                                                                                      property deepScanRoutes

                                                                                                                                                                                                                                                      deepScanRoutes?: boolean;

                                                                                                                                                                                                                                                        property extraModels

                                                                                                                                                                                                                                                        extraModels?: Function[];

                                                                                                                                                                                                                                                          property ignoreGlobalPrefix

                                                                                                                                                                                                                                                          ignoreGlobalPrefix?: boolean;

                                                                                                                                                                                                                                                            property include

                                                                                                                                                                                                                                                            include?: Function[];

                                                                                                                                                                                                                                                              property operationIdFactory

                                                                                                                                                                                                                                                              operationIdFactory?: OperationIdFactory;

                                                                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                                                                type ApiBodyOptions

                                                                                                                                                                                                                                                                type ApiBodyOptions = ApiBodyMetadata | ApiBodySchemaHost;

                                                                                                                                                                                                                                                                  type ApiOperationOptions

                                                                                                                                                                                                                                                                  type ApiOperationOptions = Partial<OperationObject>;

                                                                                                                                                                                                                                                                    type ApiParamOptions

                                                                                                                                                                                                                                                                    type ApiParamOptions = ApiParamMetadata | ApiParamSchemaHost;

                                                                                                                                                                                                                                                                      type ApiQueryOptions

                                                                                                                                                                                                                                                                      type ApiQueryOptions = ApiQueryMetadata | ApiQuerySchemaHost;

                                                                                                                                                                                                                                                                        type ApiResponseOptions

                                                                                                                                                                                                                                                                        type ApiResponseOptions = ApiResponseMetadata | ApiResponseSchemaHost;

                                                                                                                                                                                                                                                                          type OperationIdFactory

                                                                                                                                                                                                                                                                          type OperationIdFactory = (
                                                                                                                                                                                                                                                                          controllerKey: string,
                                                                                                                                                                                                                                                                          methodKey: string,
                                                                                                                                                                                                                                                                          version?: string
                                                                                                                                                                                                                                                                          ) => string;

                                                                                                                                                                                                                                                                            Package Files (31)

                                                                                                                                                                                                                                                                            Dependencies (5)

                                                                                                                                                                                                                                                                            Dev Dependencies (30)

                                                                                                                                                                                                                                                                            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/swagger.

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