@nestjs/swagger

  • Version 7.3.0
  • Published
  • 305 kB
  • 6 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 & ClassDecorator;

                                                                    function ApiPayloadTooLargeResponse

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

                                                                      function ApiPaymentRequiredResponse

                                                                      ApiPaymentRequiredResponse: (
                                                                      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 & ClassDecorator;

                                                                                  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 addExtension

                                                                                                                            addExtension: (extensionKey: string, extensionProperties: any) => 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 (6)

                                                                                                                                                                                                                                                                                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>