nestjs-openapi-next 1.0.0

package/dist/explorers/api-exclude-endpoint.explorer.d.ts

@@ -0,0 +1,2 @@
+import { Type } from '@nestjs/common';
+export declare const exploreApiExcludeEndpointMetadata: (instance: object, prototype: Type<unknown>, method: object) => any;

package/dist/explorers/api-exclude-endpoint.explorer.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiExcludeEndpointMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreApiExcludeEndpointMetadata = (instance, prototype, method) => Reflect.getMetadata(constants_1.DECORATORS.API_EXCLUDE_ENDPOINT, method);
+exports.exploreApiExcludeEndpointMetadata = exploreApiExcludeEndpointMetadata;

package/dist/explorers/api-extra-models.explorer.d.ts

@@ -0,0 +1,3 @@
+import { Type } from '@nestjs/common';
+export declare const exploreGlobalApiExtraModelsMetadata: (metatype: Type<unknown>) => Function[];
+export declare const exploreApiExtraModelsMetadata: (instance: object, prototype: Type<unknown>, method: object) => Function[];

package/dist/explorers/api-extra-models.explorer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiExtraModelsMetadata = exports.exploreGlobalApiExtraModelsMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreGlobalApiExtraModelsMetadata = (metatype) => {
+    const extraModels = Reflect.getMetadata(constants_1.DECORATORS.API_EXTRA_MODELS, metatype);
+    return extraModels || [];
+};
+exports.exploreGlobalApiExtraModelsMetadata = exploreGlobalApiExtraModelsMetadata;
+const exploreApiExtraModelsMetadata = (instance, prototype, method) => Reflect.getMetadata(constants_1.DECORATORS.API_EXTRA_MODELS, method) || [];
+exports.exploreApiExtraModelsMetadata = exploreApiExtraModelsMetadata;

package/dist/explorers/api-headers.explorer.d.ts

@@ -0,0 +1,7 @@
+import { Type } from '@nestjs/common';
+export declare const exploreGlobalApiHeaderMetadata: (metatype: Type<unknown>) => {
+    root: {
+        parameters: any;
+    };
+    depth: number;
+};

package/dist/explorers/api-headers.explorer.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreGlobalApiHeaderMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreGlobalApiHeaderMetadata = (metatype) => {
+    const headers = Reflect.getMetadata(constants_1.DECORATORS.API_HEADERS, metatype);
+    return headers ? { root: { parameters: headers }, depth: 1 } : undefined;
+};
+exports.exploreGlobalApiHeaderMetadata = exploreGlobalApiHeaderMetadata;

package/dist/explorers/api-operation.explorer.d.ts

@@ -0,0 +1,2 @@
+import { Type } from '@nestjs/common';
+export declare const exploreApiOperationMetadata: (instance: object, prototype: Type<unknown>, method: object) => any;

package/dist/explorers/api-operation.explorer.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiOperationMetadata = void 0;
+const constants_1 = require("../constants");
+const api_operation_decorator_1 = require("../decorators/api-operation.decorator");
+const plugin_constants_1 = require("../plugin/plugin-constants");
+const exploreApiOperationMetadata = (instance, prototype, method) => {
+    applyMetadataFactory(prototype, instance);
+    return Reflect.getMetadata(constants_1.DECORATORS.API_OPERATION, method);
+};
+exports.exploreApiOperationMetadata = exploreApiOperationMetadata;
+function applyMetadataFactory(prototype, instance) {
+    const classPrototype = prototype;
+    do {
+        if (!prototype.constructor) {
+            return;
+        }
+        if (!prototype.constructor[plugin_constants_1.METADATA_FACTORY_NAME]) {
+            continue;
+        }
+        const metadata = prototype.constructor[plugin_constants_1.METADATA_FACTORY_NAME]();
+        const methodKeys = Object.keys(metadata).filter((key) => typeof instance[key] === 'function');
+        methodKeys.forEach((key) => {
+            const operationMeta = {};
+            const { summary, deprecated, tags, description } = metadata[key];
+            applyIfNotNil(operationMeta, 'summary', summary);
+            applyIfNotNil(operationMeta, 'deprecated', deprecated);
+            applyIfNotNil(operationMeta, 'tags', tags);
+            applyIfNotNil(operationMeta, 'description', description);
+            if (Object.keys(operationMeta).length === 0) {
+                return;
+            }
+            (0, api_operation_decorator_1.ApiOperation)(operationMeta, { overrideExisting: false })(classPrototype, key, Object.getOwnPropertyDescriptor(classPrototype, key));
+        });
+    } while ((prototype = Reflect.getPrototypeOf(prototype)) &&
+        prototype !== Object.prototype &&
+        prototype);
+}
+function applyIfNotNil(target, key, value) {
+    if (value !== undefined && value !== null) {
+        target[key] = value;
+    }
+}

package/dist/explorers/api-parameters.explorer.d.ts

@@ -0,0 +1,71 @@
+import { Type } from '@nestjs/common';
+import { SchemaObject } from '../interfaces/open-api-spec.interface';
+import { ParamWithTypeMetadata } from '../services/parameter-metadata-accessor';
+export declare const exploreApiParametersMetadata: (schemas: Record<string, SchemaObject>, instance: object, prototype: Type<unknown>, method: Function) => {
+    parameters: (Partial<import("../interfaces/open-api-spec.interface").BaseParameterObject> | Partial<ParamWithTypeMetadata> | {
+        schema: {
+            type: string;
+            items: any;
+            nullable?: boolean;
+            discriminator?: import("../interfaces/open-api-spec.interface").DiscriminatorObject;
+            readOnly?: boolean;
+            writeOnly?: boolean;
+            xml?: import("../interfaces/open-api-spec.interface").XmlObject;
+            externalDocs?: import("../interfaces/open-api-spec.interface").ExternalDocumentationObject;
+            example?: any;
+            examples?: any[] | Record<string, any>;
+            deprecated?: boolean;
+            allOf?: (SchemaObject | import("../interfaces/open-api-spec.interface").ReferenceObject)[];
+            oneOf?: (SchemaObject | import("../interfaces/open-api-spec.interface").ReferenceObject)[];
+            anyOf?: (SchemaObject | import("../interfaces/open-api-spec.interface").ReferenceObject)[];
+            not?: SchemaObject | import("../interfaces/open-api-spec.interface").ReferenceObject;
+            properties?: Record<string, SchemaObject | import("../interfaces/open-api-spec.interface").ReferenceObject>;
+            additionalProperties?: SchemaObject | import("../interfaces/open-api-spec.interface").ReferenceObject | boolean;
+            patternProperties?: Record<string, SchemaObject | import("../interfaces/open-api-spec.interface").ReferenceObject> | undefined;
+            description?: string;
+            format?: string;
+            default?: any;
+            title?: string;
+            multipleOf?: number;
+            maximum?: number;
+            exclusiveMaximum?: boolean;
+            minimum?: number;
+            exclusiveMinimum?: boolean;
+            maxLength?: number;
+            minLength?: number;
+            pattern?: string;
+            maxItems?: number;
+            minItems?: number;
+            uniqueItems?: boolean;
+            maxProperties?: number;
+            minProperties?: number;
+            required?: string[];
+            enum?: any[];
+            'x-enumNames'?: string[];
+        };
+    } | {
+        schema: import("lodash").Dictionary<any>;
+        description?: string;
+        required?: boolean;
+        deprecated?: boolean;
+        allowEmptyValue?: boolean;
+        style?: import("../interfaces/open-api-spec.interface").ParameterStyle;
+        explode?: boolean;
+        allowReserved?: boolean;
+        examples?: Record<string, import("../interfaces/open-api-spec.interface").ExampleObject | import("../interfaces/open-api-spec.interface").ReferenceObject>;
+        example?: any;
+        content?: import("../interfaces/open-api-spec.interface").ContentObject;
+    } | {
+        schema: import("lodash").Dictionary<any>;
+        name?: string | number | object;
+        type?: Type<unknown>;
+        in?: import("../interfaces/open-api-spec.interface").ParameterLocation | "body" | "placeholder";
+        isArray?: boolean;
+        items?: SchemaObject;
+        required?: boolean;
+        enum?: unknown[];
+        enumName?: string;
+        enumSchema?: import("../interfaces/enum-schema-attributes.interface").EnumSchemaAttributes;
+        selfRequired?: boolean;
+    })[];
+};

package/dist/explorers/api-parameters.explorer.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiParametersMetadata = void 0;
+const lodash_1 = require("lodash");
+const constants_1 = require("../constants");
+const model_properties_accessor_1 = require("../services/model-properties-accessor");
+const parameter_metadata_accessor_1 = require("../services/parameter-metadata-accessor");
+const parameters_metadata_mapper_1 = require("../services/parameters-metadata-mapper");
+const schema_object_factory_1 = require("../services/schema-object-factory");
+const swagger_types_mapper_1 = require("../services/swagger-types-mapper");
+const global_parameters_storage_1 = require("../storages/global-parameters.storage");
+const parameterMetadataAccessor = new parameter_metadata_accessor_1.ParameterMetadataAccessor();
+const modelPropertiesAccessor = new model_properties_accessor_1.ModelPropertiesAccessor();
+const parametersMetadataMapper = new parameters_metadata_mapper_1.ParametersMetadataMapper(modelPropertiesAccessor);
+const swaggerTypesMapper = new swagger_types_mapper_1.SwaggerTypesMapper();
+const schemaObjectFactory = new schema_object_factory_1.SchemaObjectFactory(modelPropertiesAccessor, swaggerTypesMapper);
+const exploreApiParametersMetadata = (schemas, instance, prototype, method) => {
+    const explicitParameters = Reflect.getMetadata(constants_1.DECORATORS.API_PARAMETERS, method);
+    const globalParameters = global_parameters_storage_1.GlobalParametersStorage.getAll();
+    const parametersMetadata = parameterMetadataAccessor.explore(instance, prototype, method);
+    const noExplicitAndGlobalMetadata = (0, lodash_1.isNil)(explicitParameters) && (0, lodash_1.isNil)(globalParameters);
+    if (noExplicitAndGlobalMetadata && (0, lodash_1.isNil)(parametersMetadata)) {
+        return undefined;
+    }
+    const reflectedParametersAsProperties = parametersMetadataMapper.transformModelToProperties(parametersMetadata || {});
+    let properties = reflectedParametersAsProperties;
+    if (!noExplicitAndGlobalMetadata) {
+        const mergeImplicitAndExplicit = (item) => (0, lodash_1.assign)(item, (0, lodash_1.find)(explicitParameters, ['name', item.name]));
+        properties = removeBodyMetadataIfExplicitExists(properties, explicitParameters);
+        properties = (0, lodash_1.map)(properties, mergeImplicitAndExplicit);
+        properties = (0, lodash_1.unionWith)(properties, explicitParameters, globalParameters, (arrVal, othVal) => {
+            return arrVal.name === othVal.name && arrVal.in === othVal.in;
+        });
+    }
+    const paramsWithDefinitions = schemaObjectFactory.createFromModel(properties, schemas);
+    const parameters = swaggerTypesMapper.mapParamTypes(paramsWithDefinitions);
+    return parameters ? { parameters } : undefined;
+};
+exports.exploreApiParametersMetadata = exploreApiParametersMetadata;
+function removeBodyMetadataIfExplicitExists(properties, explicitParams) {
+    const isBodyReflected = (0, lodash_1.some)(properties, (p) => p.in === 'body');
+    const isBodyDefinedExplicitly = (0, lodash_1.some)(explicitParams, (p) => p.in === 'body');
+    if (isBodyReflected && isBodyDefinedExplicitly) {
+        return (0, lodash_1.omitBy)(properties, (p) => p.in === 'body');
+    }
+    return properties;
+}

package/dist/explorers/api-produces.explorer.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '@nestjs/common';
+export declare const exploreGlobalApiProducesMetadata: (metatype: Type<unknown>) => {
+    produces: any;
+};
+export declare const exploreApiProducesMetadata: (instance: object, prototype: Type<unknown>, method: object) => any;

package/dist/explorers/api-produces.explorer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiProducesMetadata = exports.exploreGlobalApiProducesMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreGlobalApiProducesMetadata = (metatype) => {
+    const produces = Reflect.getMetadata(constants_1.DECORATORS.API_PRODUCES, metatype);
+    return produces ? { produces } : undefined;
+};
+exports.exploreGlobalApiProducesMetadata = exploreGlobalApiProducesMetadata;
+const exploreApiProducesMetadata = (instance, prototype, method) => Reflect.getMetadata(constants_1.DECORATORS.API_PRODUCES, method);
+exports.exploreApiProducesMetadata = exploreApiProducesMetadata;

package/dist/explorers/api-response.explorer.d.ts

@@ -0,0 +1,13 @@
+import { Type } from '@nestjs/common';
+import { SchemaObject } from '../interfaces/open-api-spec.interface';
+import { FactoriesNeededByResponseFactory } from '../services/response-object-factory';
+export declare const exploreGlobalApiResponseMetadata: (schemas: Record<string, SchemaObject>, metatype: Type<unknown>, factories: FactoriesNeededByResponseFactory) => {
+    responses: {
+        [x: string]: boolean;
+    };
+};
+export declare const exploreApiResponseMetadata: (schemas: Record<string, SchemaObject>, factories: FactoriesNeededByResponseFactory, instance: object, prototype: Type<unknown>, method: Function) => import("lodash").Dictionary<boolean> | {
+    [status]: {
+        description: string;
+    };
+};

package/dist/explorers/api-response.explorer.js

@@ -0,0 +1,103 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiResponseMetadata = exports.exploreGlobalApiResponseMetadata = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("@nestjs/common/constants");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const lodash_1 = require("lodash");
+const constants_2 = require("../constants");
+const decorators_1 = require("../decorators");
+const plugin_constants_1 = require("../plugin/plugin-constants");
+const response_object_factory_1 = require("../services/response-object-factory");
+const global_responses_storage_1 = require("../storages/global-responses.storage");
+const merge_and_uniq_util_1 = require("../utils/merge-and-uniq.util");
+const responseObjectFactory = new response_object_factory_1.ResponseObjectFactory();
+const exploreGlobalApiResponseMetadata = (schemas, metatype, factories) => {
+    const responses = Reflect.getMetadata(constants_2.DECORATORS.API_RESPONSE, metatype);
+    const globalResponses = global_responses_storage_1.GlobalResponsesStorage.getAll();
+    const mappedGlobalResponsesOrUndefined = globalResponses
+        ? mapResponsesToSwaggerResponses(globalResponses, schemas, undefined, factories)
+        : undefined;
+    const produces = Reflect.getMetadata(constants_2.DECORATORS.API_PRODUCES, metatype);
+    return responses
+        ? {
+            responses: Object.assign(Object.assign({}, mappedGlobalResponsesOrUndefined), mapResponsesToSwaggerResponses(responses, schemas, produces, factories))
+        }
+        : mappedGlobalResponsesOrUndefined
+            ? {
+                responses: mappedGlobalResponsesOrUndefined
+            }
+            : undefined;
+};
+exports.exploreGlobalApiResponseMetadata = exploreGlobalApiResponseMetadata;
+const exploreApiResponseMetadata = (schemas, factories, instance, prototype, method) => {
+    applyMetadataFactory(prototype, instance);
+    const responses = Reflect.getMetadata(constants_2.DECORATORS.API_RESPONSE, method);
+    if (responses) {
+        const classProduces = Reflect.getMetadata(constants_2.DECORATORS.API_PRODUCES, prototype);
+        const methodProduces = Reflect.getMetadata(constants_2.DECORATORS.API_PRODUCES, method);
+        const produces = (0, merge_and_uniq_util_1.mergeAndUniq)((0, lodash_1.get)(classProduces, 'produces'), methodProduces);
+        return mapResponsesToSwaggerResponses(responses, schemas, produces, factories);
+    }
+    const status = getStatusCode(method);
+    if (status) {
+        return { [status]: { description: '' } };
+    }
+    return undefined;
+};
+exports.exploreApiResponseMetadata = exploreApiResponseMetadata;
+const getStatusCode = (method) => {
+    const status = Reflect.getMetadata(constants_1.HTTP_CODE_METADATA, method);
+    if (status) {
+        return status;
+    }
+    const requestMethod = Reflect.getMetadata(constants_1.METHOD_METADATA, method);
+    switch (requestMethod) {
+        case common_1.RequestMethod.POST:
+            return common_1.HttpStatus.CREATED;
+        default:
+            return common_1.HttpStatus.OK;
+    }
+};
+const omitParamType = (param) => (0, lodash_1.omit)(param, 'type');
+const mapResponsesToSwaggerResponses = (responses, schemas, produces = ['application/json'], factories) => {
+    produces = (0, shared_utils_1.isEmpty)(produces) ? ['application/json'] : produces;
+    const openApiResponses = (0, lodash_1.mapValues)(responses, (response) => responseObjectFactory.create(response, produces, schemas, factories));
+    return (0, lodash_1.mapValues)(openApiResponses, omitParamType);
+};
+function applyMetadataFactory(prototype, instance) {
+    const classPrototype = prototype;
+    do {
+        if (!prototype.constructor) {
+            return;
+        }
+        if (!prototype.constructor[plugin_constants_1.METADATA_FACTORY_NAME]) {
+            continue;
+        }
+        const metadata = prototype.constructor[plugin_constants_1.METADATA_FACTORY_NAME]();
+        const methodKeys = Object.keys(metadata).filter((key) => typeof instance[key] === 'function');
+        methodKeys.forEach((key) => {
+            const _a = metadata[key], { summary, deprecated, tags } = _a, meta = __rest(_a, ["summary", "deprecated", "tags"]);
+            if (Object.keys(meta).length === 0) {
+                return;
+            }
+            if (meta.status === undefined) {
+                meta.status = getStatusCode(instance[key]);
+            }
+            (0, decorators_1.ApiResponse)(meta, { overrideExisting: false })(classPrototype, key, Object.getOwnPropertyDescriptor(classPrototype, key));
+        });
+    } while ((prototype = Reflect.getPrototypeOf(prototype)) &&
+        prototype !== Object.prototype &&
+        prototype);
+}

package/dist/explorers/api-security.explorer.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '@nestjs/common';
+export declare const exploreGlobalApiSecurityMetadata: (metatype: Type<unknown>) => {
+    security: any;
+};
+export declare const exploreApiSecurityMetadata: (instance: object, prototype: Type<unknown>, method: object) => any;

package/dist/explorers/api-security.explorer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiSecurityMetadata = exports.exploreGlobalApiSecurityMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreGlobalApiSecurityMetadata = (metatype) => {
+    const security = Reflect.getMetadata(constants_1.DECORATORS.API_SECURITY, metatype);
+    return security ? { security } : undefined;
+};
+exports.exploreGlobalApiSecurityMetadata = exploreGlobalApiSecurityMetadata;
+const exploreApiSecurityMetadata = (instance, prototype, method) => {
+    return Reflect.getMetadata(constants_1.DECORATORS.API_SECURITY, method);
+};
+exports.exploreApiSecurityMetadata = exploreApiSecurityMetadata;

package/dist/explorers/api-use-tags.explorer.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '@nestjs/common';
+export declare const exploreGlobalApiTagsMetadata: (autoTagControllers?: boolean) => (metatype: Type<unknown>) => {
+    tags: any;
+};
+export declare const exploreApiTagsMetadata: (instance: object, prototype: Type<unknown>, method: object) => any;

package/dist/explorers/api-use-tags.explorer.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exploreApiTagsMetadata = exports.exploreGlobalApiTagsMetadata = void 0;
+const constants_1 = require("../constants");
+const exploreGlobalApiTagsMetadata = (autoTagControllers) => (metatype) => {
+    const decoratorTags = Reflect.getMetadata(constants_1.DECORATORS.API_TAGS, metatype);
+    const isEmpty = !decoratorTags || decoratorTags.length === 0;
+    if (isEmpty && autoTagControllers) {
+        const defaultTag = metatype.name.replace(/Controller$/, '');
+        return {
+            tags: [defaultTag]
+        };
+    }
+    return isEmpty ? undefined : { tags: decoratorTags };
+};
+exports.exploreGlobalApiTagsMetadata = exploreGlobalApiTagsMetadata;
+const exploreApiTagsMetadata = (instance, prototype, method) => Reflect.getMetadata(constants_1.DECORATORS.API_TAGS, method);
+exports.exploreApiTagsMetadata = exploreApiTagsMetadata;

package/dist/extra/swagger-shim.d.ts

@@ -0,0 +1,100 @@
+export declare function ApiProperty(): () => void;
+export declare function ApiPropertyOptional(): () => void;
+export declare function ApiResponseProperty(): () => void;
+export declare function ApiBasicAuth(): () => void;
+export declare function ApiBearerAuth(): () => void;
+export declare function ApiBody(): () => void;
+export declare function ApiConsumes(): () => void;
+export declare function ApiCookieAuth(): () => void;
+export declare function ApiExcludeEndpoint(): () => void;
+export declare function ApiExcludeController(): () => void;
+export declare function ApiExtraModels(): () => void;
+export declare function ApiHeader(): () => void;
+export declare function ApiHeaders(): () => void;
+export declare function ApiHideProperty(): () => void;
+export declare function ApiOAuth2(): () => void;
+export declare function ApiOperation(): () => void;
+export declare function ApiParam(): () => void;
+export declare function ApiProduces(): () => void;
+export declare function ApiQuery(): () => void;
+export declare function ApiResponse(): () => void;
+export declare function ApiContinueResponse(): () => void;
+export declare function ApiSwitchingProtocolsResponse(): () => void;
+export declare function ApiProcessingResponse(): () => void;
+export declare function ApiEarlyhintsResponse(): () => void;
+export declare function ApiOkResponse(): () => void;
+export declare function ApiCreatedResponse(): () => void;
+export declare function ApiAcceptedResponse(): () => void;
+export declare function ApiNonAuthoritativeInformationResponse(): () => void;
+export declare function ApiNoContentResponse(): () => void;
+export declare function ApiResetContentResponse(): () => void;
+export declare function ApiPartialContentResponse(): () => void;
+export declare function ApiAmbiguousResponse(): () => void;
+export declare function ApiMovedPermanentlyResponse(): () => void;
+export declare function ApiFoundResponse(): () => void;
+export declare function ApiSeeOtherResponse(): () => void;
+export declare function ApiNotModifiedResponse(): () => void;
+export declare function ApiTemporaryRedirectResponse(): () => void;
+export declare function ApiPermanentRedirectResponse(): () => void;
+export declare function ApiBadRequestResponse(): () => void;
+export declare function ApiUnauthorizedResponse(): () => void;
+export declare function ApiPaymentRequiredResponse(): () => void;
+export declare function ApiForbiddenResponse(): () => void;
+export declare function ApiNotFoundResponse(): () => void;
+export declare function ApiMethodNotAllowedResponse(): () => void;
+export declare function ApiNotAcceptableResponse(): () => void;
+export declare function ApiProxyAuthenticationRequiredResponse(): () => void;
+export declare function ApiRequestTimeoutResponse(): () => void;
+export declare function ApiConflictResponse(): () => void;
+export declare function ApiGoneResponse(): () => void;
+export declare function ApiLengthRequiredResponse(): () => void;
+export declare function ApiPreconditionFailedResponse(): () => void;
+export declare function ApiPayloadTooLargeResponse(): () => void;
+export declare function ApiUriTooLongResponse(): () => void;
+export declare function ApiUnsupportedMediaTypeResponse(): () => void;
+export declare function ApiRequestedRangeNotSatisfiableResponse(): () => void;
+export declare function ApiExpectationFailedResponse(): () => void;
+export declare function ApiIAmATeapotResponse(): () => void;
+export declare function ApiMisdirectedResponse(): () => void;
+export declare function ApiUnprocessableEntityResponse(): () => void;
+export declare function ApiFailedDependencyResponse(): () => void;
+export declare function ApiPreconditionRequiredResponse(): () => void;
+export declare function ApiTooManyRequestsResponse(): () => void;
+export declare function ApiInternalServerErrorResponse(): () => void;
+export declare function ApiNotImplementedResponse(): () => void;
+export declare function ApiBadGatewayResponse(): () => void;
+export declare function ApiServiceUnavailableResponse(): () => void;
+export declare function ApiGatewayTimeoutResponse(): () => void;
+export declare function ApiHttpVersionNotSupportedResponse(): () => void;
+export declare function ApiDefaultResponse(): () => void;
+export declare function ApiSchema(): () => void;
+export declare function ApiSecurity(): () => void;
+export declare function ApiSecurityDeviceFlow(): () => void;
+export declare function ApiTags(): () => void;
+export declare function ApiTagGroup(): () => void;
+export declare function ApiCallbacks(): () => void;
+export declare function ApiQueryMethod(): () => void;
+export declare function ApiStreamingResponse(): () => void;
+export declare function ApiLink(): () => void;
+export declare function ApiDefaultGetter(): () => void;
+export declare function ApiExtension(): () => void;
+export declare function DocumentBuilder(): () => void;
+export declare function SwaggerModule(): () => void;
+export declare function IntersectionType(): {
+    new (): {};
+};
+export declare function OmitType(): {
+    new (): {};
+};
+export declare function PartialType(): {
+    new (): {};
+};
+export declare function PickType(): {
+    new (): {};
+};
+export declare function getSchemaPath(): () => string;
+export declare function refs(): any[];
+export declare function before(): () => string;
+export declare function ReadonlyVisitor(): {
+    new (): {};
+};