@nestia/migrate 0.12.1 → 0.13.0-dev.20240411

package/src/programmers/MigrateSchemaProgrammer.ts

@@ -1,14 +1,12 @@
+import { OpenApi } from "@samchon/openapi";
 import ts from "typescript";
 import typia from "typia";
-import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
 import { TypeFactory } from "typia/lib/factories/TypeFactory";
 import { FormatCheatSheet } from "typia/lib/tags/internal/FormatCheatSheet";
 import { Escaper } from "typia/lib/utils/Escaper";
 
-import { ISwaggerComponents } from "../structures/ISwaggerComponents";
-import { ISwaggerSchema } from "../structures/ISwaggerSchema";
 import { FilePrinter } from "../utils/FilePrinter";
-import { SwaggerTypeChecker } from "../utils/SwaggerTypeChecker";
+import { OpenApiTypeChecker } from "../utils/OpenApiTypeChecker";
 import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
 
 export namespace MigrateSchemaProgrammer {
@@ -16,42 +14,45 @@ export namespace MigrateSchemaProgrammer {
     FACADE
   ----------------------------------------------------------- */
   export const write =
-    (components: ISwaggerComponents) =>
+    (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
-    (schema: ISwaggerSchema): ts.TypeNode => {
+    (schema: OpenApi.IJsonSchema): ts.TypeNode => {
+      // CONSIDER ANY TYPE CASE
       const union: ts.TypeNode[] = [];
-      if (SwaggerTypeChecker.isUnknown(schema))
+      if (OpenApiTypeChecker.isUnknown(schema))
         return TypeFactory.keyword("any");
-      else if (SwaggerTypeChecker.isNullOnly(schema)) return createNode("null");
-      else if (SwaggerTypeChecker.isNullable(components)(schema))
-        union.push(createNode("null"));
 
+      // ITERATION
       const type: ts.TypeNode = (() => {
         // ATOMIC
-        if (SwaggerTypeChecker.isBoolean(schema))
+        if (OpenApiTypeChecker.isConstant(schema))
+          return writeConstant(importer)(schema);
+        else if (OpenApiTypeChecker.isBoolean(schema))
           return writeBoolean(importer)(schema);
-        else if (SwaggerTypeChecker.isInteger(schema))
+        else if (OpenApiTypeChecker.isInteger(schema))
           return writeInteger(importer)(schema);
-        else if (SwaggerTypeChecker.isNumber(schema))
+        else if (OpenApiTypeChecker.isNumber(schema))
           return writeNumber(importer)(schema);
-        // INSTANCES
-        else if (SwaggerTypeChecker.isString(schema))
+        else if (OpenApiTypeChecker.isString(schema))
           return writeString(importer)(schema);
-        else if (SwaggerTypeChecker.isArray(schema))
+        // INSTANCES
+        else if (OpenApiTypeChecker.isArray(schema))
           return writeArray(components)(importer)(schema);
-        else if (SwaggerTypeChecker.isObject(schema))
+        else if (OpenApiTypeChecker.isTuple(schema))
+          return writeTuple(components)(importer)(schema);
+        else if (OpenApiTypeChecker.isObject(schema))
           return writeObject(components)(importer)(schema);
-        else if (SwaggerTypeChecker.isReference(schema))
+        else if (OpenApiTypeChecker.isReference(schema))
           return writeReference(importer)(schema);
-        // NESTED UNION
-        else if (SwaggerTypeChecker.isAnyOf(schema))
-          return writeUnion(components)(importer)(schema.anyOf);
-        else if (SwaggerTypeChecker.isOneOf(schema))
+        // UNION
+        else if (OpenApiTypeChecker.isOneOf(schema))
           return writeUnion(components)(importer)(schema.oneOf);
+        else if (OpenApiTypeChecker.isNull(schema)) return createNode("null");
         else return TypeFactory.keyword("any");
       })();
       union.push(type);
 
+      // DETERMINE
       if (union.length === 0) return TypeFactory.keyword("any");
       else if (union.length === 1) return union[0];
       return ts.factory.createUnionTypeNode(union);
@@ -60,17 +61,42 @@ export namespace MigrateSchemaProgrammer {
   /* -----------------------------------------------------------
     ATOMICS
   ----------------------------------------------------------- */
+  const writeConstant =
+    (importer: MigrateImportProgrammer) =>
+    (schema: OpenApi.IJsonSchema.IConstant): ts.TypeNode => {
+      const intersection: ts.TypeNode[] = [
+        ts.factory.createLiteralTypeNode(
+          typeof schema.const === "boolean"
+            ? schema.const === true
+              ? ts.factory.createTrue()
+              : ts.factory.createFalse()
+            : typeof schema.const === "number"
+              ? schema.const < 0
+                ? ts.factory.createPrefixUnaryExpression(
+                    ts.SyntaxKind.MinusToken,
+                    ts.factory.createNumericLiteral(-schema.const),
+                  )
+                : ts.factory.createNumericLiteral(schema.const)
+              : ts.factory.createStringLiteral(schema.const),
+        ),
+      ];
+      writePlugin({
+        importer,
+        regular: typia.misc.literals<keyof OpenApi.IJsonSchema.IConstant>(),
+        intersection,
+      })(schema);
+      return intersection.length === 1
+        ? intersection[0]
+        : ts.factory.createIntersectionTypeNode(intersection);
+    };
+
   const writeBoolean =
     (importer: MigrateImportProgrammer) =>
-    (schema: ISwaggerSchema.IBoolean): ts.TypeNode => {
-      if (schema.enum?.length)
-        return ts.factory.createLiteralTypeNode(
-          schema.enum[0] ? ts.factory.createTrue() : ts.factory.createFalse(),
-        );
+    (schema: OpenApi.IJsonSchema.IBoolean): ts.TypeNode => {
       const intersection: ts.TypeNode[] = [TypeFactory.keyword("boolean")];
       writePlugin({
         importer,
-        regular: typia.misc.literals<keyof ISwaggerSchema.IBoolean>(),
+        regular: typia.misc.literals<keyof OpenApi.IJsonSchema.IBoolean>(),
         intersection,
       })(schema);
       return intersection.length === 1
@@ -80,7 +106,7 @@ export namespace MigrateSchemaProgrammer {
 
   const writeInteger =
     (importer: MigrateImportProgrammer) =>
-    (schema: ISwaggerSchema.IInteger): ts.TypeNode =>
+    (schema: OpenApi.IJsonSchema.IInteger): ts.TypeNode =>
       writeNumeric(() => [
         TypeFactory.keyword("number"),
         importer.tag("Type", "int32"),
@@ -88,19 +114,15 @@ export namespace MigrateSchemaProgrammer {
 
   const writeNumber =
     (importer: MigrateImportProgrammer) =>
-    (schema: ISwaggerSchema.INumber): ts.TypeNode =>
+    (schema: OpenApi.IJsonSchema.INumber): ts.TypeNode =>
       writeNumeric(() => [TypeFactory.keyword("number")])(importer)(schema);
 
   const writeNumeric =
     (factory: () => ts.TypeNode[]) =>
     (importer: MigrateImportProgrammer) =>
-    (schema: ISwaggerSchema.IInteger | ISwaggerSchema.INumber): ts.TypeNode => {
-      if (schema.enum?.length)
-        return ts.factory.createUnionTypeNode(
-          schema.enum.map((i) =>
-            ts.factory.createLiteralTypeNode(ExpressionFactory.number(i)),
-          ),
-        );
+    (
+      schema: OpenApi.IJsonSchema.IInteger | OpenApi.IJsonSchema.INumber,
+    ): ts.TypeNode => {
       const intersection: ts.TypeNode[] = factory();
       if (schema.default !== undefined)
         intersection.push(importer.tag("Default", schema.default));
@@ -122,7 +144,7 @@ export namespace MigrateSchemaProgrammer {
         intersection.push(importer.tag("MultipleOf", schema.multipleOf));
       writePlugin({
         importer,
-        regular: typia.misc.literals<keyof ISwaggerSchema.INumber>(),
+        regular: typia.misc.literals<keyof OpenApi.IJsonSchema.INumber>(),
         intersection,
       })(schema);
       return intersection.length === 1
@@ -132,7 +154,7 @@ export namespace MigrateSchemaProgrammer {
 
   const writeString =
     (importer: MigrateImportProgrammer) =>
-    (schema: ISwaggerSchema.IString): ts.TypeNode => {
+    (schema: OpenApi.IJsonSchema.IString): ts.TypeNode => {
       if (schema.format === "binary")
         return ts.factory.createTypeReferenceNode("File");
 
@@ -157,7 +179,7 @@ export namespace MigrateSchemaProgrammer {
         );
       writePlugin({
         importer,
-        regular: typia.misc.literals<keyof ISwaggerSchema.IString>(),
+        regular: typia.misc.literals<keyof OpenApi.IJsonSchema.IString>(),
         intersection,
       })(schema);
       return intersection.length === 1
@@ -169,9 +191,9 @@ export namespace MigrateSchemaProgrammer {
     INSTANCES
   ----------------------------------------------------------- */
   const writeArray =
-    (components: ISwaggerComponents) =>
+    (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
-    (schema: ISwaggerSchema.IArray): ts.TypeNode => {
+    (schema: OpenApi.IJsonSchema.IArray): ts.TypeNode => {
       const intersection: ts.TypeNode[] = [
         ts.factory.createArrayTypeNode(
           write(components)(importer)(schema.items),
@@ -183,7 +205,33 @@ export namespace MigrateSchemaProgrammer {
         intersection.push(importer.tag("MaxItems", schema.maxItems));
       writePlugin({
         importer,
-        regular: typia.misc.literals<keyof ISwaggerSchema.IArray>(),
+        regular: typia.misc.literals<keyof OpenApi.IJsonSchema.IArray>(),
+        intersection,
+      })(schema);
+      return intersection.length === 1
+        ? intersection[0]
+        : ts.factory.createIntersectionTypeNode(intersection);
+    };
+
+  const writeTuple =
+    (components: OpenApi.IComponents) =>
+    (importer: MigrateImportProgrammer) =>
+    (schema: OpenApi.IJsonSchema.ITuple): ts.TypeNode => {
+      const tuple: ts.TypeNode = ts.factory.createTupleTypeNode([
+        ...schema.prefixItems.map(write(components)(importer)),
+        ...(typeof schema.additionalItems === "object" &&
+        schema.additionalItems !== null
+          ? [
+              ts.factory.createRestTypeNode(
+                write(components)(importer)(schema.additionalItems),
+              ),
+            ]
+          : []),
+      ]);
+      const intersection: ts.TypeNode[] = [tuple];
+      writePlugin({
+        importer,
+        regular: typia.misc.literals<keyof OpenApi.IJsonSchema.ITuple>(),
         intersection,
       })(schema);
       return intersection.length === 1
@@ -192,9 +240,9 @@ export namespace MigrateSchemaProgrammer {
     };
 
   const writeObject =
-    (components: ISwaggerComponents) =>
+    (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
-    (schema: ISwaggerSchema.IObject): ts.TypeNode => {
+    (schema: OpenApi.IJsonSchema.IObject): ts.TypeNode => {
       const regular = () =>
         ts.factory.createTypeLiteralNode(
           Object.entries(schema.properties ?? []).map(([key, value]) =>
@@ -207,7 +255,7 @@ export namespace MigrateSchemaProgrammer {
       const dynamic = () =>
         ts.factory.createTypeLiteralNode([
           writeDynamicProperty(components)(importer)(
-            schema.additionalProperties as ISwaggerSchema,
+            schema.additionalProperties as OpenApi.IJsonSchema,
           ),
         ]);
       return !!schema.properties?.length &&
@@ -219,10 +267,10 @@ export namespace MigrateSchemaProgrammer {
     };
 
   const writeRegularProperty =
-    (components: ISwaggerComponents) =>
+    (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
     (required: string[]) =>
-    (key: string, value: ISwaggerSchema) =>
+    (key: string, value: OpenApi.IJsonSchema) =>
       FilePrinter.description(
         ts.factory.createPropertySignature(
           undefined,
@@ -238,9 +286,9 @@ export namespace MigrateSchemaProgrammer {
       );
 
   const writeDynamicProperty =
-    (components: ISwaggerComponents) =>
+    (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
-    (value: ISwaggerSchema) =>
+    (value: OpenApi.IJsonSchema) =>
       FilePrinter.description(
         ts.factory.createIndexSignature(
           undefined,
@@ -261,7 +309,7 @@ export namespace MigrateSchemaProgrammer {
   const writeReference =
     (importer: MigrateImportProgrammer) =>
     (
-      schema: ISwaggerSchema.IReference,
+      schema: OpenApi.IJsonSchema.IReference,
     ): ts.TypeReferenceNode | ts.KeywordTypeNode => {
       if (schema.$ref.startsWith("#/components/schemas") === false)
         return TypeFactory.keyword("any");
@@ -275,13 +323,13 @@ export namespace MigrateSchemaProgrammer {
     UNIONS
   ----------------------------------------------------------- */
   const writeUnion =
-    (components: ISwaggerComponents) =>
+    (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
-    (elements: ISwaggerSchema[]): ts.UnionTypeNode =>
+    (elements: OpenApi.IJsonSchema[]): ts.UnionTypeNode =>
       ts.factory.createUnionTypeNode(elements.map(write(components)(importer)));
 }
 const createNode = (text: string) => ts.factory.createTypeReferenceNode(text);
-const writeComment = (schema: ISwaggerSchema): string =>
+const writeComment = (schema: OpenApi.IJsonSchema): string =>
   [
     ...(schema.description?.length ? [schema.description] : []),
     ...(schema.description?.length &&

package/src/structures/IMigrateDto.ts

@@ -1,8 +1,8 @@
-import { ISwaggerSchema } from "./ISwaggerSchema";
+import { OpenApi } from "@samchon/openapi";
 
 export interface IMigrateDto {
   name: string;
   location: string;
-  schema: ISwaggerSchema | null;
+  schema: OpenApi.IJsonSchema | null;
   children: IMigrateDto[];
 }

package/src/structures/IMigrateProgram.ts

@@ -1,13 +1,13 @@
+import { OpenApi } from "@samchon/openapi";
+
 import { IMigrateController } from "./IMigrateController";
 import { IMigrateRoute } from "./IMigrateRoute";
-import { ISwagger } from "./ISwagger";
-import { ISwaggerRoute } from "./ISwaggerRoute";
 
 export interface IMigrateProgram extends IMigrateProgram.IProps {
   controllers: IMigrateController[];
 }
 export namespace IMigrateProgram {
-  export type Dictionary = Map<ISwaggerRoute, IEntry>;
+  export type Dictionary = Map<OpenApi.IOperation, IEntry>;
   export interface IEntry {
     controller: IMigrateController;
     route: IMigrateRoute;
@@ -16,7 +16,7 @@ export namespace IMigrateProgram {
     mode: "nest" | "sdk";
     simulate: boolean;
     e2e: boolean;
-    swagger: ISwagger;
+    document: OpenApi.IDocument;
     dictionary: Dictionary;
   }
   export interface IConfig {

package/src/structures/IMigrateRoute.ts

@@ -1,4 +1,4 @@
-import { ISwaggerSchema } from "./ISwaggerSchema";
+import { OpenApi } from "@samchon/openapi";
 
 export interface IMigrateRoute {
   name: string;
@@ -20,18 +20,18 @@ export namespace IMigrateRoute {
   export interface IParameter {
     name: string;
     key: string;
-    schema: ISwaggerSchema;
+    schema: OpenApi.IJsonSchema;
     description?: string;
   }
   export interface IHeaders {
     name: string;
     key: string;
-    schema: ISwaggerSchema;
+    schema: OpenApi.IJsonSchema;
   }
   export interface IQuery {
     name: string;
     key: string;
-    schema: ISwaggerSchema;
+    schema: OpenApi.IJsonSchema;
   }
   export interface IBody {
     name: string;
@@ -41,11 +41,11 @@ export namespace IMigrateRoute {
       | "application/json"
       | "application/x-www-form-urlencoded"
       | "multipart/form-data";
-    schema: ISwaggerSchema;
+    schema: OpenApi.IJsonSchema;
     "x-nestia-encrypted"?: boolean;
   }
   export interface IException {
     description?: string;
-    schema: ISwaggerSchema;
+    schema: OpenApi.IJsonSchema;
   }
 }

package/src/utils/OpenApiTypeChecker.ts

@@ -0,0 +1,73 @@
+import { OpenApi } from "@samchon/openapi";
+
+export namespace OpenApiTypeChecker {
+  export const isOneOf = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IOneOf =>
+    (schema as any).oneOf !== undefined;
+
+  export const isNull = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.INull =>
+    (schema as OpenApi.IJsonSchema.INull).type === "null";
+
+  export const isConstant = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IConstant =>
+    (schema as OpenApi.IJsonSchema.IConstant).const !== undefined;
+
+  export const isBoolean = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IBoolean =>
+    (schema as OpenApi.IJsonSchema.IBoolean).type === "boolean";
+
+  export const isInteger = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IInteger =>
+    (schema as OpenApi.IJsonSchema.IInteger).type === "integer";
+
+  export const isNumber = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.INumber =>
+    (schema as OpenApi.IJsonSchema.INumber).type === "number";
+
+  export const isString = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IString =>
+    (schema as OpenApi.IJsonSchema.IString).type === "string";
+
+  export const isArray = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IArray =>
+    (schema as OpenApi.IJsonSchema.IArray).type === "array" &&
+    (schema as OpenApi.IJsonSchema.IArray).items !== undefined;
+
+  export const isTuple = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.ITuple =>
+    (schema as OpenApi.IJsonSchema.ITuple).type === "array" &&
+    (schema as OpenApi.IJsonSchema.ITuple).prefixItems !== undefined;
+
+  export const isObject = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IObject =>
+    (schema as OpenApi.IJsonSchema.IObject).type === "object";
+
+  export const isReference = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IReference =>
+    (schema as OpenApi.IJsonSchema.IReference).$ref !== undefined;
+
+  export const isUnknown = (
+    schema: OpenApi.IJsonSchema,
+  ): schema is OpenApi.IJsonSchema.IUnknown =>
+    (schema as OpenApi.IJsonSchema.__ISignificant<any>).type === undefined &&
+    !isOneOf(schema) &&
+    !isReference(schema) &&
+    !isConstant(schema);
+
+  // export const isNullable = (schema: OpenApi.IJsonSchema): boolean =>
+  //   SwaggerTypeChecker.isOneOf(schema)
+  //     ? schema.oneOf.some(isNullable)
+  //     : (schema as OpenApi.IJsonSchema.INullOnly).type === "null";
+}

package/lib/structures/ISwagger.d.ts

@@ -1,18 +0,0 @@
-import { ISwaggerComponents } from "./ISwaggerComponents";
-import { ISwaggerInfo } from "./ISwaggerInfo";
-import { ISwaggerRoute } from "./ISwaggerRoute";
-export interface ISwagger {
-    openapi: `3.0.${number}`;
-    info: ISwaggerInfo;
-    servers: ISwagger.IServer[];
-    components: ISwaggerComponents;
-    paths: Record<string, ISwagger.IPath>;
-    security?: Record<string, string[]>[];
-}
-export declare namespace ISwagger {
-    interface IServer {
-        url: string;
-        description?: string;
-    }
-    type IPath = Record<"get" | "post" | "patch" | "put" | "delete", ISwaggerRoute | undefined>;
-}

package/lib/structures/ISwagger.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ISwagger.js.map

package/lib/structures/ISwagger.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ISwagger.js","sourceRoot":"","sources":["../../src/structures/ISwagger.ts"],"names":[],"mappings":""}

package/lib/structures/ISwaggerComponents.d.ts

@@ -1,12 +0,0 @@
-import { ISwaggerRouteParameter } from "./ISwaggerRouteParameter";
-import { ISwaggerRouteRequestBody } from "./ISwaggerRouteRequestBody";
-import { ISwaggerRouteResponse } from "./ISwaggerRouteResponse";
-import { ISwaggerSchema } from "./ISwaggerSchema";
-import { ISwaggerSecurityScheme } from "./ISwaggerSecurityScheme";
-export interface ISwaggerComponents {
-    parameters?: Record<string, ISwaggerRouteParameter>;
-    requestBodies?: Record<string, ISwaggerRouteRequestBody>;
-    responses?: Record<string, ISwaggerRouteResponse>;
-    schemas?: Record<string, ISwaggerSchema>;
-    securitySchemes?: Record<string, ISwaggerSecurityScheme>;
-}

package/lib/structures/ISwaggerComponents.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ISwaggerComponents.js.map

package/lib/structures/ISwaggerComponents.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ISwaggerComponents.js","sourceRoot":"","sources":["../../src/structures/ISwaggerComponents.ts"],"names":[],"mappings":""}

package/lib/structures/ISwaggerInfo.d.ts

@@ -1,71 +0,0 @@
-/**
- * Information about the API.
- *
- * @author Samchon
- */
-export interface ISwaggerInfo {
-    /**
-     * The title of the API.
-     */
-    title: string;
-    /**
-     * A short description of the API.
-     */
-    description?: string;
-    /**
-     * A URL to the Terms of Service for the API.
-     *
-     * @format uri
-     */
-    termsOfService?: string;
-    /**
-     * The contact information for the exposed API.
-     */
-    contact?: ISwaggerInfo.IContact;
-    /**
-     * The license information for the exposed API.
-     */
-    license?: ISwaggerInfo.ILicense;
-    /**
-     * Version of the API.
-     */
-    version: string;
-}
-export declare namespace ISwaggerInfo {
-    /**
-     * Contact information for the exposed API.
-     */
-    interface IContact {
-        /**
-         * The identifying name of the contact person/organization.
-         */
-        name?: string;
-        /**
-         * The URL pointing to the contact information.
-         *
-         * @format uri
-         */
-        url?: string;
-        /**
-         * The email address of the contact person/organization.
-         *
-         * @format email
-         */
-        email?: string;
-    }
-    /**
-     * License information for the exposed API.
-     */
-    interface ILicense {
-        /**
-         * The license name used for the API.
-         */
-        name: string;
-        /**
-         * A URL to the license used for the API.
-         *
-         * @format uri
-         */
-        url?: string;
-    }
-}

package/lib/structures/ISwaggerInfo.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ISwaggerInfo.js.map

package/lib/structures/ISwaggerInfo.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ISwaggerInfo.js","sourceRoot":"","sources":["../../src/structures/ISwaggerInfo.ts"],"names":[],"mappings":""}

package/lib/structures/ISwaggerRoute.d.ts

@@ -1,15 +0,0 @@
-import { IJsDocTagInfo } from "typia/lib/schemas/metadata/IJsDocTagInfo";
-import { ISwaggerRouteParameter } from "./ISwaggerRouteParameter";
-import { ISwaggerRouteRequestBody } from "./ISwaggerRouteRequestBody";
-import { ISwaggerRouteResponse } from "./ISwaggerRouteResponse";
-export interface ISwaggerRoute {
-    parameters?: (ISwaggerRouteParameter | ISwaggerRouteParameter.IReference)[];
-    requestBody?: ISwaggerRouteRequestBody;
-    responses?: Record<string, ISwaggerRouteResponse | ISwaggerRouteResponse.IReference>;
-    summary?: string;
-    description?: string;
-    deprecated?: boolean;
-    security?: Record<string, string[]>[];
-    tags?: string[];
-    "x-nestia-jsDocTags"?: IJsDocTagInfo[];
-}

package/lib/structures/ISwaggerRoute.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ISwaggerRoute.js.map

package/lib/structures/ISwaggerRoute.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ISwaggerRoute.js","sourceRoot":"","sources":["../../src/structures/ISwaggerRoute.ts"],"names":[],"mappings":""}

package/lib/structures/ISwaggerRouteBodyContent.d.ts

@@ -1,14 +0,0 @@
-import { ISwaggerSchema } from "./ISwaggerSchema";
-export interface ISwaggerRouteBodyContent {
-    "text/plain"?: ISwaggerRouteBodyContent.IMediaType;
-    "application/json"?: ISwaggerRouteBodyContent.IMediaType;
-    "application/x-www-form-urlencoded"?: ISwaggerRouteBodyContent.IMediaType;
-    "multipart/form-data"?: ISwaggerRouteBodyContent.IMediaType;
-    "*/*"?: ISwaggerRouteBodyContent.IMediaType;
-}
-export declare namespace ISwaggerRouteBodyContent {
-    interface IMediaType {
-        schema?: ISwaggerSchema;
-        "x-nestia-encrypted"?: boolean;
-    }
-}

package/lib/structures/ISwaggerRouteBodyContent.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ISwaggerRouteBodyContent.js.map

package/lib/structures/ISwaggerRouteBodyContent.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ISwaggerRouteBodyContent.js","sourceRoot":"","sources":["../../src/structures/ISwaggerRouteBodyContent.ts"],"names":[],"mappings":""}

package/lib/structures/ISwaggerRouteHeader.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=ISwaggerRouteHeader.js.map

package/lib/structures/ISwaggerRouteHeader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ISwaggerRouteHeader.js","sourceRoot":"","sources":["../../src/structures/ISwaggerRouteHeader.ts"],"names":[],"mappings":""}

package/lib/structures/ISwaggerRouteParameter.d.ts

@@ -1,13 +0,0 @@
-import { ISwaggerSchema } from "./ISwaggerSchema";
-export interface ISwaggerRouteParameter {
-    name?: string;
-    in: "path" | "query" | "header" | "cookie";
-    schema: ISwaggerSchema;
-    required?: boolean;
-    description?: string;
-}
-export declare namespace ISwaggerRouteParameter {
-    interface IReference {
-        $ref: `#/components/parameters/${string}`;
-    }
-}

package/lib/structures/ISwaggerRouteParameter.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ISwaggerRouteParameter.js.map