@nestjs/swagger

  • Version 7.4.0
  • Published
  • 315 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 ApiAmbiguousResponse

    ApiAmbiguousResponse: (
    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 ApiContinueResponse

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

                      function ApiCookieAuth

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

                        function ApiCreatedResponse

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

                          function ApiDefaultResponse

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

                            function ApiEarlyhintsResponse

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

                              function ApiExcludeController

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

                                function ApiExcludeEndpoint

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

                                  function ApiExpectationFailedResponse

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

                                    function ApiExtension

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

                                      function ApiExtraModels

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

                                        function ApiFailedDependencyResponse

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

                                          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 ApiHttpVersionNotSupportedResponse

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

                                                          function ApiIAmATeapotResponse

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

                                                            function ApiInternalServerErrorResponse

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

                                                              function ApiLengthRequiredResponse

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

                                                                function ApiMethodNotAllowedResponse

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

                                                                  function ApiMisdirectedResponse

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

                                                                    function ApiMovedPermanentlyResponse

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

                                                                      function ApiNoContentResponse

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

                                                                        function ApiNonAuthoritativeInformationResponse

                                                                        ApiNonAuthoritativeInformationResponse: (
                                                                        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 ApiNotModifiedResponse

                                                                                ApiNotModifiedResponse: (
                                                                                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 ApiPartialContentResponse

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

                                                                                            function ApiPayloadTooLargeResponse

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

                                                                                              function ApiPaymentRequiredResponse

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

                                                                                                function ApiPermanentRedirectResponse

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

                                                                                                  function ApiPreconditionFailedResponse

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

                                                                                                    function ApiPreconditionRequiredResponse

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

                                                                                                      function ApiProcessingResponse

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

                                                                                                        function ApiProduces

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

                                                                                                          function ApiProperty

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

                                                                                                            function ApiPropertyOptional

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

                                                                                                              function ApiProxyAuthenticationRequiredResponse

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

                                                                                                                function ApiQuery

                                                                                                                ApiQuery: (options: ApiQueryOptions) => MethodDecorator & ClassDecorator;

                                                                                                                  function ApiRequestedRangeNotSatisfiableResponse

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

                                                                                                                    function ApiRequestTimeoutResponse

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

                                                                                                                      function ApiResetContentResponse

                                                                                                                      ApiResetContentResponse: (
                                                                                                                      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 ApiSeeOtherResponse

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

                                                                                                                                function ApiServiceUnavailableResponse

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

                                                                                                                                  function ApiSwitchingProtocolsResponse

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

                                                                                                                                    function ApiTags

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

                                                                                                                                      function ApiTemporaryRedirectResponse

                                                                                                                                      ApiTemporaryRedirectResponse: (
                                                                                                                                      options?: ApiResponseOptions
                                                                                                                                      ) => 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 ApiUriTooLongResponse

                                                                                                                                                ApiUriTooLongResponse: (
                                                                                                                                                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>,
                                                                                                                                                        options?: { skipNullProperties?: boolean }
                                                                                                                                                        ) => 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> | (() => 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 example

                                                                                                                                                                                                                                example?: any;

                                                                                                                                                                                                                                  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 swaggerUiEnabled

                                                                                                                                                                                                                                                                                          swaggerUiEnabled?: boolean;

                                                                                                                                                                                                                                                                                            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>