@nestia/migrate 0.12.0 → 0.13.0-dev.20240411

package/lib/utils/OpenApiConverter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"OpenApiConverter.js","sourceRoot":"","sources":["../../src/utils/OpenApiConverter.ts"],"names":[],"mappings":";;;;;;AAAA,+CAA+C;AAC/C,kDAA0B;AAK1B,gEAA8E;AAE9E,IAAiB,gBAAgB,CAUhC;AAVD,WAAiB,gBAAgB;IAC/B,2EAA2E;IAC3E,gEAAgE;IAChE,mDAAmD;IACnD,KAAK;IAEQ,qBAAI,GAAG,CAAC,OAAoB,EAAY,EAAE;QACrD,MAAM,SAAS,GAAG,IAAI,qBAAa,CAAC,OAAO,CAAC,CAAC;QAC7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAAO,eAAK,CAAC,MAAM;kCAAZ,eAAK,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAAW,SAAS,CAAC,OAAO,EAAc,EAAE;IACjE,CAAC,CAAC;AACJ,CAAC,EAVgB,gBAAgB,gCAAhB,gBAAgB,QAUhC"}

package/lib/utils/SwaggerComponentsExplorer.d.ts

@@ -1,9 +0,0 @@
-import { ISwaggerComponents } from "../module";
-import { ISwaggerRouteParameter } from "../structures/ISwaggerRouteParameter";
-import { ISwaggerRouteRequestBody } from "../structures/ISwaggerRouteRequestBody";
-import { ISwaggerRouteResponse } from "../structures/ISwaggerRouteResponse";
-export declare namespace SwaggerComponentsExplorer {
-    const getParameter: (components: ISwaggerComponents) => (schema: ISwaggerRouteParameter | ISwaggerRouteParameter.IReference) => ISwaggerRouteParameter | null;
-    const getRequestBody: (components: ISwaggerComponents) => (schema: ISwaggerRouteRequestBody | ISwaggerRouteRequestBody.IReference) => ISwaggerRouteRequestBody | null;
-    const getResponse: (components: ISwaggerComponents) => (schema: ISwaggerRouteResponse | ISwaggerRouteResponse.IReference) => ISwaggerRouteResponse | null;
-}

package/lib/utils/SwaggerComponentsExplorer.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwaggerComponentsExplorer = void 0;
-const SwaggerTypeChecker_1 = require("./SwaggerTypeChecker");
-var SwaggerComponentsExplorer;
-(function (SwaggerComponentsExplorer) {
-    SwaggerComponentsExplorer.getParameter = (components) => (schema) => {
-        var _a, _b;
-        return SwaggerTypeChecker_1.SwaggerTypeChecker.isReference(schema) &&
-            schema.$ref.startsWith("#/components/parameters/")
-            ? (_b = (_a = components.parameters) === null || _a === void 0 ? void 0 : _a[schema.$ref.replace("#/components/parameters/", "")]) !== null && _b !== void 0 ? _b : null
-            : schema;
-    };
-    SwaggerComponentsExplorer.getRequestBody = (components) => (schema) => {
-        var _a, _b;
-        return SwaggerTypeChecker_1.SwaggerTypeChecker.isReference(schema) &&
-            schema.$ref.startsWith("#/components/requestBodies/")
-            ? (_b = (_a = components.requestBodies) === null || _a === void 0 ? void 0 : _a[schema.$ref.replace("#/components/requestBodies/", "")]) !== null && _b !== void 0 ? _b : null
-            : schema;
-    };
-    SwaggerComponentsExplorer.getResponse = (components) => (schema) => {
-        var _a, _b;
-        return SwaggerTypeChecker_1.SwaggerTypeChecker.isReference(schema) &&
-            schema.$ref.startsWith("#/components/responses/")
-            ? (_b = (_a = components.responses) === null || _a === void 0 ? void 0 : _a[schema.$ref.replace("#/components/responses/", "")]) !== null && _b !== void 0 ? _b : null
-            : schema;
-    };
-})(SwaggerComponentsExplorer || (exports.SwaggerComponentsExplorer = SwaggerComponentsExplorer = {}));
-//# sourceMappingURL=SwaggerComponentsExplorer.js.map

package/lib/utils/SwaggerComponentsExplorer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SwaggerComponentsExplorer.js","sourceRoot":"","sources":["../../src/utils/SwaggerComponentsExplorer.ts"],"names":[],"mappings":";;;AAIA,6DAA0D;AAE1D,IAAiB,yBAAyB,CAoCzC;AApCD,WAAiB,yBAAyB;IAC3B,sCAAY,GACvB,CAAC,UAA8B,EAAE,EAAE,CACnC,CACE,MAAkE,EACnC,EAAE;;QACjC,OAAA,uCAAkB,CAAC,WAAW,CAAC,MAAM,CAAC;YACtC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,0BAA0B,CAAC;YAChD,CAAC,CAAC,MAAA,MAAA,UAAU,CAAC,UAAU,0CACnB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,0BAA0B,EAAE,EAAE,CAAC,CACpD,mCAAI,IAAI;YACX,CAAC,CAAE,MAAiC,CAAA;KAAA,CAAC;IAE9B,wCAAc,GACzB,CAAC,UAA8B,EAAE,EAAE,CACnC,CACE,MAAsE,EACrC,EAAE;;QACnC,OAAA,uCAAkB,CAAC,WAAW,CAAC,MAAM,CAAC;YACtC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,6BAA6B,CAAC;YACnD,CAAC,CAAC,MAAA,MAAA,UAAU,CAAC,aAAa,0CACtB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,6BAA6B,EAAE,EAAE,CAAC,CACvD,mCAAI,IAAI;YACX,CAAC,CAAE,MAAmC,CAAA;KAAA,CAAC;IAEhC,qCAAW,GACtB,CAAC,UAA8B,EAAE,EAAE,CACnC,CACE,MAAgE,EAClC,EAAE;;QAChC,OAAA,uCAAkB,CAAC,WAAW,CAAC,MAAM,CAAC;YACtC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,yBAAyB,CAAC;YAC/C,CAAC,CAAC,MAAA,MAAA,UAAU,CAAC,SAAS,0CAClB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,yBAAyB,EAAE,EAAE,CAAC,CACnD,mCAAI,IAAI;YACX,CAAC,CAAE,MAAgC,CAAA;KAAA,CAAC;AAC5C,CAAC,EApCgB,yBAAyB,yCAAzB,yBAAyB,QAoCzC"}

package/lib/utils/SwaggerTypeChecker.d.ts

@@ -1,16 +0,0 @@
-import { ISwaggerComponents } from "../structures/ISwaggerComponents";
-import { ISwaggerSchema } from "../structures/ISwaggerSchema";
-export declare namespace SwaggerTypeChecker {
-    const isAnyOf: (schema: ISwaggerSchema) => schema is ISwaggerSchema.IAnyOf;
-    const isOneOf: (schema: ISwaggerSchema) => schema is ISwaggerSchema.IOneOf;
-    const isNullOnly: (schema: ISwaggerSchema) => schema is ISwaggerSchema.INullOnly;
-    const isBoolean: (schema: ISwaggerSchema) => schema is ISwaggerSchema.IBoolean;
-    const isInteger: (schema: ISwaggerSchema) => schema is ISwaggerSchema.IInteger;
-    const isNumber: (schema: ISwaggerSchema) => schema is ISwaggerSchema.INumber;
-    const isString: (schema: ISwaggerSchema) => schema is ISwaggerSchema.IString;
-    const isArray: (schema: ISwaggerSchema) => schema is ISwaggerSchema.IArray;
-    const isObject: (schema: ISwaggerSchema) => schema is ISwaggerSchema.IObject;
-    const isReference: (schema: ISwaggerSchema) => schema is ISwaggerSchema.IReference;
-    const isUnknown: (schema: ISwaggerSchema) => schema is ISwaggerSchema.IUnknown;
-    const isNullable: (components: ISwaggerComponents) => (schema: ISwaggerSchema) => boolean;
-}

package/lib/utils/SwaggerTypeChecker.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwaggerTypeChecker = void 0;
-var SwaggerTypeChecker;
-(function (SwaggerTypeChecker) {
-    SwaggerTypeChecker.isAnyOf = (schema) => schema.anyOf !== undefined;
-    SwaggerTypeChecker.isOneOf = (schema) => schema.oneOf !== undefined;
-    SwaggerTypeChecker.isNullOnly = (schema) => schema.type === "null";
-    SwaggerTypeChecker.isBoolean = (schema) => schema.type === "boolean";
-    SwaggerTypeChecker.isInteger = (schema) => schema.type === "integer";
-    SwaggerTypeChecker.isNumber = (schema) => schema.type === "number";
-    SwaggerTypeChecker.isString = (schema) => schema.type === "string";
-    SwaggerTypeChecker.isArray = (schema) => schema.type === "array";
-    SwaggerTypeChecker.isObject = (schema) => schema.type === "object";
-    SwaggerTypeChecker.isReference = (schema) => schema.$ref !== undefined;
-    SwaggerTypeChecker.isUnknown = (schema) => schema.type === undefined &&
-        !SwaggerTypeChecker.isAnyOf(schema) &&
-        !SwaggerTypeChecker.isOneOf(schema) &&
-        !SwaggerTypeChecker.isReference(schema);
-    SwaggerTypeChecker.isNullable = (components) => (schema) => {
-        var _a;
-        if (SwaggerTypeChecker.isAnyOf(schema))
-            return schema.anyOf.some(SwaggerTypeChecker.isNullable(components));
-        else if (SwaggerTypeChecker.isOneOf(schema))
-            return schema.oneOf.some(SwaggerTypeChecker.isNullable(components));
-        else if (SwaggerTypeChecker.isReference(schema)) {
-            const $id = schema.$ref.replace("#/components/schemas/", "");
-            const target = ((_a = components.schemas) !== null && _a !== void 0 ? _a : {})[$id];
-            return target === undefined ? false : SwaggerTypeChecker.isNullable(components)(target);
-        }
-        return schema.nullable === true;
-    };
-})(SwaggerTypeChecker || (exports.SwaggerTypeChecker = SwaggerTypeChecker = {}));
-//# sourceMappingURL=SwaggerTypeChecker.js.map

package/lib/utils/SwaggerTypeChecker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SwaggerTypeChecker.js","sourceRoot":"","sources":["../../src/utils/SwaggerTypeChecker.ts"],"names":[],"mappings":";;;AAGA,IAAiB,kBAAkB,CA+DlC;AA/DD,WAAiB,kBAAkB;IACpB,0BAAO,GAAG,CACrB,MAAsB,EACW,EAAE,CAAE,MAAc,CAAC,KAAK,KAAK,SAAS,CAAC;IAE7D,0BAAO,GAAG,CACrB,MAAsB,EACW,EAAE,CAAE,MAAc,CAAC,KAAK,KAAK,SAAS,CAAC;IAE7D,6BAAU,GAAG,CACxB,MAAsB,EACc,EAAE,CAAE,MAAc,CAAC,IAAI,KAAK,MAAM,CAAC;IAE5D,4BAAS,GAAG,CACvB,MAAsB,EACa,EAAE,CAAE,MAAc,CAAC,IAAI,KAAK,SAAS,CAAC;IAE9D,4BAAS,GAAG,CACvB,MAAsB,EACa,EAAE,CAAE,MAAc,CAAC,IAAI,KAAK,SAAS,CAAC;IAE9D,2BAAQ,GAAG,CACtB,MAAsB,EACY,EAAE,CAAE,MAAc,CAAC,IAAI,KAAK,QAAQ,CAAC;IAE5D,2BAAQ,GAAG,CACtB,MAAsB,EACY,EAAE,CAAE,MAAc,CAAC,IAAI,KAAK,QAAQ,CAAC;IAE5D,0BAAO,GAAG,CACrB,MAAsB,EACW,EAAE,CAAE,MAAc,CAAC,IAAI,KAAK,OAAO,CAAC;IAE1D,2BAAQ,GAAG,CACtB,MAAsB,EACY,EAAE,CAAE,MAAc,CAAC,IAAI,KAAK,QAAQ,CAAC;IAE5D,8BAAW,GAAG,CACzB,MAAsB,EACe,EAAE,CAAE,MAAc,CAAC,IAAI,KAAK,SAAS,CAAC;IAEhE,4BAAS,GAAG,CACvB,MAAsB,EACa,EAAE,CACpC,MAAc,CAAC,IAAI,KAAK,SAAS;QAClC,CAAC,mBAAA,OAAO,CAAC,MAAM,CAAC;QAChB,CAAC,mBAAA,OAAO,CAAC,MAAM,CAAC;QAChB,CAAC,mBAAA,WAAW,CAAC,MAAM,CAAC,CAAC;IAEV,6BAAU,GACrB,CAAC,UAA8B,EAAE,EAAE,CACnC,CAAC,MAAsB,EAAW,EAAE;;QAClC,IAAI,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC;YACpC,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,mBAAA,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;aAC9C,IAAI,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC;YACzC,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,mBAAA,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;aAC9C,IAAI,kBAAkB,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;YAChD,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,uBAAuB,EAAE,EAAE,CAAC,CAAC;YAC7D,MAAM,MAAM,GAAG,CAAC,MAAA,UAAU,CAAC,OAAO,mCAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;YAC/C,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,mBAAA,UAAU,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;QACvE,CAAC;QACD,OAAQ,MAAiC,CAAC,QAAQ,KAAK,IAAI,CAAC;IAC9D,CAAC,CAAC;AACN,CAAC,EA/DgB,kBAAkB,kCAAlB,kBAAkB,QA+DlC"}

package/src/structures/ISwagger.ts

@@ -1,23 +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 namespace ISwagger {
-  export interface IServer {
-    url: string;
-    description?: string;
-  }
-  export type IPath = Record<
-    "get" | "post" | "patch" | "put" | "delete",
-    ISwaggerRoute | undefined
-  >;
-}

package/src/structures/ISwaggerComponents.ts

@@ -1,13 +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/src/structures/ISwaggerInfo.ts

@@ -1,80 +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 namespace ISwaggerInfo {
-  /**
-   * Contact information for the exposed API.
-   */
-  export 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.
-   */
-  export 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/src/structures/ISwaggerRoute.ts

@@ -1,20 +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/src/structures/ISwaggerRouteBodyContent.ts

@@ -1,15 +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 namespace ISwaggerRouteBodyContent {
-  export interface IMediaType {
-    schema?: ISwaggerSchema;
-    "x-nestia-encrypted"?: boolean;
-  }
-}

package/src/structures/ISwaggerRouteParameter.ts

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

package/src/structures/ISwaggerRouteRequestBody.ts

@@ -1,12 +0,0 @@
-import { ISwaggerRouteBodyContent } from "./ISwaggerRouteBodyContent";
-
-export interface ISwaggerRouteRequestBody {
-  description?: string;
-  required?: boolean;
-  content?: ISwaggerRouteBodyContent;
-}
-export namespace ISwaggerRouteRequestBody {
-  export interface IReference {
-    $ref: `#/components/requestBodies/${string}`;
-  }
-}

package/src/structures/ISwaggerRouteResponse.ts

@@ -1,11 +0,0 @@
-import { ISwaggerRouteBodyContent } from "./ISwaggerRouteBodyContent";
-
-export interface ISwaggerRouteResponse {
-  description?: string;
-  content?: ISwaggerRouteBodyContent;
-}
-export namespace ISwaggerRouteResponse {
-  export interface IReference {
-    $ref: `#/components/responses/${string}`;
-  }
-}

package/src/structures/ISwaggerSchema.ts

@@ -1,90 +0,0 @@
-export type ISwaggerSchema =
-  | ISwaggerSchema.IUnknown
-  | ISwaggerSchema.INullOnly
-  | ISwaggerSchema.IAnyOf
-  | ISwaggerSchema.IOneOf
-  | ISwaggerSchema.IBoolean
-  | ISwaggerSchema.IInteger
-  | ISwaggerSchema.INumber
-  | ISwaggerSchema.IString
-  | ISwaggerSchema.IArray
-  | ISwaggerSchema.IObject
-  | ISwaggerSchema.IReference;
-export namespace ISwaggerSchema {
-  export interface IUnknown extends IAttribute {
-    type?: undefined;
-  }
-  export interface INullOnly extends IAttribute {
-    type: "null";
-  }
-
-  export interface IAnyOf extends IAttribute {
-    anyOf: ISwaggerSchema[];
-  }
-  export interface IOneOf extends IAttribute {
-    oneOf: ISwaggerSchema[];
-  }
-
-  export interface IBoolean extends ISignificant<"boolean"> {
-    default?: boolean;
-    enum?: boolean[];
-  }
-  export interface IInteger extends ISignificant<"integer"> {
-    /** @type int */ default?: number;
-    /** @type int */ enum?: number[];
-    /** @type int */ minimum?: number;
-    /** @type int */ maximum?: number;
-    /** @type int */ exclusiveMinimum?: boolean;
-    /** @type int */ exclusiveMaximum?: boolean;
-    /** @type uint */ multipleOf?: number;
-  }
-  export interface INumber extends ISignificant<"number"> {
-    default?: number;
-    enum?: number[];
-    minimum?: number;
-    maximum?: number;
-    exclusiveMinimum?: boolean;
-    exclusiveMaximum?: boolean;
-    multipleOf?: number;
-  }
-  export interface IString extends ISignificant<"string"> {
-    default?: string;
-    enum?: string[];
-    format?: string;
-    pattern?: string;
-    /** @type uint */ minLength?: number;
-    /** @type uint */ maxLength?: number;
-  }
-
-  export interface IArray extends ISignificant<"array"> {
-    items: ISwaggerSchema;
-    /** @type uint */ minItems?: number;
-    /** @type uint */ maxItems?: number;
-    "x-typia-tuple"?: ITuple;
-  }
-  export interface ITuple extends ISignificant<"array"> {
-    items: ISwaggerSchema[];
-  }
-  export interface IObject extends ISignificant<"object"> {
-    properties?: Record<string, ISwaggerSchema>;
-    required?: string[];
-    additionalProperties?: ISwaggerSchema | boolean;
-    "x-typia-patternProperties"?: Record<string, ISwaggerSchema>;
-  }
-
-  export interface IReference extends IAttribute {
-    $ref: string;
-  }
-
-  interface ISignificant<Type extends string> extends IAttribute {
-    type: Type;
-    nullable?: boolean;
-  }
-  interface IAttribute {
-    title?: string;
-    description?: string;
-    deprecated?: boolean;
-    "x-typia-optional"?: boolean;
-    "x-typia-rest"?: boolean;
-  }
-}

package/src/structures/ISwaggerSecurityScheme.ts

@@ -1,47 +0,0 @@
-export type ISwaggerSecurityScheme =
-  | ISwaggerSecurityScheme.IHttpBasic
-  | ISwaggerSecurityScheme.IHttpBearer
-  | ISwaggerSecurityScheme.IApiKey
-  | ISwaggerSecurityScheme.IOpenId
-  | ISwaggerSecurityScheme.IOAuth2;
-export namespace ISwaggerSecurityScheme {
-  export interface IHttpBasic {
-    type: "http";
-    scheme: "basic";
-  }
-  export interface IHttpBearer {
-    type: "http";
-    scheme: "bearer";
-    bearerFormat?: string;
-  }
-  export interface IApiKey {
-    type: "apiKey";
-    in?: "header" | "query" | "cookie";
-    name?: string;
-  }
-
-  export interface IOpenId {
-    type: "openIdConnect";
-    openIdConnectUrl: string;
-  }
-
-  export interface IOAuth2 {
-    type: "oauth2";
-    flows: IOAuth2.IFlowSet;
-    description?: string;
-  }
-  export namespace IOAuth2 {
-    export interface IFlowSet {
-      authorizationCode?: IFlow;
-      implicit?: Omit<IFlow, "tokenUrl">;
-      password?: Omit<IFlow, "authorizationUrl">;
-      clientCredentials?: Omit<IFlow, "authorizationUrl">;
-    }
-    export interface IFlow {
-      authorizationUrl: string;
-      tokenUrl?: string;
-      refreshUrl?: string;
-      scopes?: Record<string, string>;
-    }
-  }
-}

package/src/structures/ISwaggerV20.ts

@@ -1,10 +0,0 @@
-import { OpenAPIV2 } from "openapi-types";
-
-export interface ISwaggerV20
-  extends Omit<OpenAPIV2.Document, "swagger">,
-    ISwaggerV20.IVersion {}
-export namespace ISwaggerV20 {
-  export interface IVersion {
-    swagger: "2.0";
-  }
-}

package/src/structures/ISwaggerV31.ts

@@ -1,10 +0,0 @@
-import { OpenAPIV3_1 } from "openapi-types";
-
-export interface ISwaggerV31 extends Omit<OpenAPIV3_1.Document, "openapi"> {
-  openapi: `3.1.${number}`;
-}
-export namespace ISwaggerV31 {
-  export interface IVersion {
-    openapi: `3.1.${number}`;
-  }
-}

package/src/utils/OpenApiConverter.ts

@@ -1,19 +0,0 @@
-// import V2_0Converter from "swagger2openapi";
-import typia from "typia";
-
-import { ISwagger } from "../structures/ISwagger";
-// import { ISwaggerV20 } from "../structures/ISwaggerV20";
-import { ISwaggerV31 } from "../structures/ISwaggerV31";
-import { Converter as V3_1Converter } from "./openapi-down-convert/converter";
-
-export namespace OpenApiConverter {
-  // export const v2_0 = async (swagger: ISwaggerV20): Promise<ISwagger> => {
-  //   const output = await V2_0Converter.convertObj(swagger, {});
-  //   return typia.assert<ISwagger>(output.openapi);
-  // };
-
-  export const v3_1 = (swagger: ISwaggerV31): ISwagger => {
-    const converter = new V3_1Converter(swagger);
-    return typia.assert<ISwagger>(converter.convert() as ISwagger);
-  };
-}

package/src/utils/SwaggerComponentsExplorer.ts

@@ -1,43 +0,0 @@
-import { ISwaggerComponents } from "../module";
-import { ISwaggerRouteParameter } from "../structures/ISwaggerRouteParameter";
-import { ISwaggerRouteRequestBody } from "../structures/ISwaggerRouteRequestBody";
-import { ISwaggerRouteResponse } from "../structures/ISwaggerRouteResponse";
-import { SwaggerTypeChecker } from "./SwaggerTypeChecker";
-
-export namespace SwaggerComponentsExplorer {
-  export const getParameter =
-    (components: ISwaggerComponents) =>
-    (
-      schema: ISwaggerRouteParameter | ISwaggerRouteParameter.IReference,
-    ): ISwaggerRouteParameter | null =>
-      SwaggerTypeChecker.isReference(schema) &&
-      schema.$ref.startsWith("#/components/parameters/")
-        ? components.parameters?.[
-            schema.$ref.replace("#/components/parameters/", "")
-          ] ?? null
-        : (schema as ISwaggerRouteParameter);
-
-  export const getRequestBody =
-    (components: ISwaggerComponents) =>
-    (
-      schema: ISwaggerRouteRequestBody | ISwaggerRouteRequestBody.IReference,
-    ): ISwaggerRouteRequestBody | null =>
-      SwaggerTypeChecker.isReference(schema) &&
-      schema.$ref.startsWith("#/components/requestBodies/")
-        ? components.requestBodies?.[
-            schema.$ref.replace("#/components/requestBodies/", "")
-          ] ?? null
-        : (schema as ISwaggerRouteRequestBody);
-
-  export const getResponse =
-    (components: ISwaggerComponents) =>
-    (
-      schema: ISwaggerRouteResponse | ISwaggerRouteResponse.IReference,
-    ): ISwaggerRouteResponse | null =>
-      SwaggerTypeChecker.isReference(schema) &&
-      schema.$ref.startsWith("#/components/responses/")
-        ? components.responses?.[
-            schema.$ref.replace("#/components/responses/", "")
-          ] ?? null
-        : (schema as ISwaggerRouteResponse);
-}

package/src/utils/SwaggerTypeChecker.ts

@@ -1,67 +0,0 @@
-import { ISwaggerComponents } from "../structures/ISwaggerComponents";
-import { ISwaggerSchema } from "../structures/ISwaggerSchema";
-
-export namespace SwaggerTypeChecker {
-  export const isAnyOf = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IAnyOf => (schema as any).anyOf !== undefined;
-
-  export const isOneOf = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IOneOf => (schema as any).oneOf !== undefined;
-
-  export const isNullOnly = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.INullOnly => (schema as any).type === "null";
-
-  export const isBoolean = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IBoolean => (schema as any).type === "boolean";
-
-  export const isInteger = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IInteger => (schema as any).type === "integer";
-
-  export const isNumber = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.INumber => (schema as any).type === "number";
-
-  export const isString = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IString => (schema as any).type === "string";
-
-  export const isArray = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IArray => (schema as any).type === "array";
-
-  export const isObject = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IObject => (schema as any).type === "object";
-
-  export const isReference = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IReference => (schema as any).$ref !== undefined;
-
-  export const isUnknown = (
-    schema: ISwaggerSchema,
-  ): schema is ISwaggerSchema.IUnknown =>
-    (schema as any).type === undefined &&
-    !isAnyOf(schema) &&
-    !isOneOf(schema) &&
-    !isReference(schema);
-
-  export const isNullable =
-    (components: ISwaggerComponents) =>
-    (schema: ISwaggerSchema): boolean => {
-      if (SwaggerTypeChecker.isAnyOf(schema))
-        return schema.anyOf.some(isNullable(components));
-      else if (SwaggerTypeChecker.isOneOf(schema))
-        return schema.oneOf.some(isNullable(components));
-      else if (SwaggerTypeChecker.isReference(schema)) {
-        const $id = schema.$ref.replace("#/components/schemas/", "");
-        const target = (components.schemas ?? {})[$id];
-        return target === undefined ? false : isNullable(components)(target);
-      }
-      return (schema as ISwaggerSchema.IString).nullable === true;
-    };
-}