@kubb/swagger-ts 1.15.0-canary.20231112T135108 → 2.0.0-alpha.10

package/dist/index.cjs

@@ -2,50 +2,94 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var pathParser = require('path');
+var path = require('path');
 var core = require('@kubb/core');
+var utils = require('@kubb/core/utils');
 var swagger = require('@kubb/swagger');
 var changeCase = require('change-case');
 var parser = require('@kubb/parser');
-var ts = require('typescript');
+var factory = require('@kubb/parser/factory');
+var utils$1 = require('@kubb/swagger/utils');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var pathParser__default = /*#__PURE__*/_interopDefault(pathParser);
-var ts__default = /*#__PURE__*/_interopDefault(ts);
-
-// src/plugin.ts
-var { factory } = ts__default.default;
-var keywordTypeNodes = {
-  any: factory.createKeywordTypeNode(ts__default.default.SyntaxKind.AnyKeyword),
-  number: factory.createKeywordTypeNode(ts__default.default.SyntaxKind.NumberKeyword),
-  integer: factory.createKeywordTypeNode(ts__default.default.SyntaxKind.NumberKeyword),
-  object: factory.createKeywordTypeNode(ts__default.default.SyntaxKind.ObjectKeyword),
-  string: factory.createKeywordTypeNode(ts__default.default.SyntaxKind.StringKeyword),
-  boolean: factory.createKeywordTypeNode(ts__default.default.SyntaxKind.BooleanKeyword),
-  undefined: factory.createKeywordTypeNode(ts__default.default.SyntaxKind.UndefinedKeyword),
-  null: factory.createLiteralTypeNode(factory.createToken(ts__default.default.SyntaxKind.NullKeyword))
-};
-function resolve(props) {
-  return swagger.resolve({ ...props, pluginName });
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
 }
 
-// src/generators/TypeGenerator.ts
-var { factory: factory2 } = ts__default.default;
-var TypeGenerator = class _TypeGenerator extends core.SchemaGenerator {
-  // Collect the types of all referenced schemas so we can export them later
-  static usedEnumNames = {};
-  refs = {};
-  extraNodes = [];
-  aliases = [];
-  // Keep track of already used type aliases
-  usedAliasNames = {};
-  caseOptions = {
-    delimiter: "",
-    stripRegexp: /[^A-Z0-9$]/gi
-  };
-  constructor(options = { withJSDocs: true, resolveName: ({ name }) => name, enumType: "asConst", dateType: "string", optionalType: "questionToken" }) {
+var path__default = /*#__PURE__*/_interopDefault(path);
+var factory__namespace = /*#__PURE__*/_interopNamespace(factory);
+
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _usedAliasNames, _caseOptions, _getTypeFromSchema, getTypeFromSchema_fn, _getTypeFromProperties, getTypeFromProperties_fn, _getRefAlias, getRefAlias_fn, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn;
+var TypeGenerator = class extends core.SchemaGenerator {
+  constructor(options = {
+    usedEnumNames: {},
+    withJSDocs: true,
+    resolveName: ({ name }) => name,
+    enumType: "asConst",
+    dateType: "string",
+    optionalType: "questionToken"
+  }) {
     super(options);
+    /**
+     * Creates a type node from a given schema.
+     * Delegates to getBaseTypeFromSchema internally and
+     * optionally adds a union with null.
+     */
+    __privateAdd(this, _getTypeFromSchema);
+    /**
+     * Recursively creates a type literal with the given props.
+     */
+    __privateAdd(this, _getTypeFromProperties);
+    /**
+     * Create a type alias for the schema referenced by the given ReferenceObject
+     */
+    __privateAdd(this, _getRefAlias);
+    /**
+     * This is the very core of the OpenAPI to TS conversion - it takes a
+     * schema and returns the appropriate type.
+     */
+    __privateAdd(this, _getBaseTypeFromSchema);
+    this.refs = {};
+    this.extraNodes = [];
+    this.aliases = [];
+    // Keep track of already used type aliases
+    __privateAdd(this, _usedAliasNames, {});
+    __privateAdd(this, _caseOptions, {
+      delimiter: "",
+      stripRegexp: /[^A-Z0-9$]/gi
+    });
     return this;
   }
   build({
@@ -55,18 +99,18 @@ var TypeGenerator = class _TypeGenerator extends core.SchemaGenerator {
     keysToOmit
   }) {
     const nodes = [];
-    const type = this.#getTypeFromSchema(schema, baseName);
+    const type = __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, schema, baseName);
     if (!type) {
       return this.extraNodes;
     }
-    const node = parser.createTypeAliasDeclaration({
-      modifiers: [parser.modifiers.export],
-      name: this.options.resolveName({ name: baseName, pluginName }) || baseName,
-      type: keysToOmit?.length ? parser.createOmitDeclaration({ keys: keysToOmit, type, nonNullable: true }) : type
+    const node = factory__namespace.createTypeAliasDeclaration({
+      modifiers: [factory__namespace.modifiers.export],
+      name: this.options.resolveName({ name: baseName }) || baseName,
+      type: keysToOmit?.length ? factory__namespace.createOmitDeclaration({ keys: keysToOmit, type, nonNullable: true }) : type
     });
     if (description) {
       nodes.push(
-        parser.appendJSDocToNode({
+        factory__namespace.appendJSDocToNode({
           node,
           comments: [`@description ${description}`]
         })
@@ -81,232 +125,211 @@ var TypeGenerator = class _TypeGenerator extends core.SchemaGenerator {
     );
     return [...this.extraNodes, ...filterdNodes];
   }
-  /**
-   * Creates a type node from a given schema.
-   * Delegates to getBaseTypeFromSchema internally and
-   * optionally adds a union with null.
-   */
-  #getTypeFromSchema(schema, name) {
-    const type = this.#getBaseTypeFromSchema(schema, name);
+};
+_usedAliasNames = new WeakMap();
+_caseOptions = new WeakMap();
+_getTypeFromSchema = new WeakSet();
+getTypeFromSchema_fn = function(schema, name) {
+  const type = __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schema, name);
+  if (!type) {
+    return null;
+  }
+  if (schema && !schema.nullable) {
+    return type;
+  }
+  return factory__namespace.createUnionDeclaration({ nodes: [type, factory__namespace.keywordTypeNodes.null] });
+};
+_getTypeFromProperties = new WeakSet();
+getTypeFromProperties_fn = function(baseSchema, baseName) {
+  const { optionalType } = this.options;
+  const properties = baseSchema?.properties || {};
+  const required = baseSchema?.required;
+  const additionalProperties = baseSchema?.additionalProperties;
+  const members = Object.keys(properties).map((name) => {
+    const schema = properties[name];
+    const isRequired = required && required.includes(name);
+    let type = __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, schema, this.options.resolveName({ name: `${baseName || ""} ${name}` }));
     if (!type) {
       return null;
     }
-    if (schema && !schema.nullable) {
-      return type;
+    if (!isRequired && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
+      type = factory__namespace.createUnionDeclaration({ nodes: [type, factory__namespace.keywordTypeNodes.undefined] });
     }
-    return parser.createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-  }
-  /**
-   * Recursively creates a type literal with the given props.
-   */
-  #getTypeFromProperties(baseSchema, baseName) {
-    const { optionalType } = this.options;
-    const properties = baseSchema?.properties || {};
-    const required = baseSchema?.required;
-    const additionalProperties = baseSchema?.additionalProperties;
-    const members = Object.keys(properties).map((name) => {
-      const schema = properties[name];
-      const isRequired = required && required.includes(name);
-      let type = this.#getTypeFromSchema(schema, this.options.resolveName({ name: `${baseName || ""} ${name}`, pluginName }));
-      if (!type) {
-        return null;
-      }
-      if (!isRequired && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
-        type = parser.createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-      }
-      const propertySignature = parser.createPropertySignature({
-        questionToken: ["questionToken", "questionTokenAndUndefined"].includes(optionalType) && !isRequired,
-        name,
-        type,
-        readOnly: schema.readOnly
-      });
-      if (this.options.withJSDocs) {
-        return parser.appendJSDocToNode({
-          node: propertySignature,
-          comments: [
-            schema.description ? `@description ${schema.description}` : void 0,
-            schema.type ? `@type ${schema.type}${isRequired ? "" : " | undefined"} ${schema.format || ""}` : void 0,
-            schema.example ? `@example ${schema.example}` : void 0,
-            schema.deprecated ? `@deprecated` : void 0,
-            schema.default !== void 0 && typeof schema.default === "string" ? `@default '${schema.default}'` : void 0,
-            schema.default !== void 0 && typeof schema.default !== "string" ? `@default ${schema.default}` : void 0
-          ].filter(Boolean)
-        });
-      }
-      return propertySignature;
+    const propertySignature = factory__namespace.createPropertySignature({
+      questionToken: ["questionToken", "questionTokenAndUndefined"].includes(optionalType) && !isRequired,
+      name,
+      type,
+      readOnly: schema.readOnly
     });
-    if (additionalProperties) {
-      const type = additionalProperties === true ? keywordTypeNodes.any : this.#getTypeFromSchema(additionalProperties);
-      if (type) {
-        members.push(parser.createIndexSignature(type));
-      }
-    }
-    return factory2.createTypeLiteralNode(members.filter(Boolean));
-  }
-  /**
-   * Create a type alias for the schema referenced by the given ReferenceObject
-   */
-  #getRefAlias(obj, baseName) {
-    const { $ref } = obj;
-    let ref = this.refs[$ref];
-    if (ref) {
-      return factory2.createTypeReferenceNode(ref.propertyName, void 0);
-    }
-    const originalName = core.getUniqueName($ref.replace(/.+\//, ""), this.usedAliasNames);
-    const propertyName = this.options.resolveName({ name: originalName, pluginName }) || originalName;
-    ref = this.refs[$ref] = {
-      propertyName,
-      originalName
-    };
-    return factory2.createTypeReferenceNode(ref.propertyName, void 0);
-  }
-  /**
-   * This is the very core of the OpenAPI to TS conversion - it takes a
-   * schema and returns the appropriate type.
-   */
-  #getBaseTypeFromSchema(schema, baseName) {
-    if (!schema) {
-      return keywordTypeNodes.any;
+    if (this.options.withJSDocs) {
+      return factory__namespace.appendJSDocToNode({
+        node: propertySignature,
+        comments: [
+          schema.description ? `@description ${schema.description}` : void 0,
+          schema.type ? `@type ${schema.type}${isRequired ? "" : " | undefined"} ${schema.format || ""}` : void 0,
+          schema.example ? `@example ${schema.example}` : void 0,
+          schema.deprecated ? `@deprecated` : void 0,
+          schema.default !== void 0 && typeof schema.default === "string" ? `@default '${schema.default}'` : void 0,
+          schema.default !== void 0 && typeof schema.default !== "string" ? `@default ${schema.default}` : void 0
+        ].filter(Boolean)
+      });
     }
-    if (swagger.isReference(schema)) {
-      return this.#getRefAlias(schema, baseName);
+    return propertySignature;
+  });
+  if (additionalProperties) {
+    const type = additionalProperties === true ? factory__namespace.keywordTypeNodes.any : __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, additionalProperties);
+    if (type) {
+      members.push(factory__namespace.createIndexSignature(type));
     }
-    if (schema.oneOf) {
-      const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
-      const union = parser.createUnionDeclaration({
-        withParentheses: true,
-        nodes: schema.oneOf.map((item) => {
-          return this.#getBaseTypeFromSchema(item);
-        }).filter((item) => {
-          return item && item !== keywordTypeNodes.any;
-        })
+  }
+  return factory__namespace.createTypeLiteralNode(members.filter(Boolean));
+};
+_getRefAlias = new WeakSet();
+getRefAlias_fn = function(obj, _baseName) {
+  const { $ref } = obj;
+  let ref = this.refs[$ref];
+  if (ref) {
+    return factory__namespace.createTypeReferenceNode(ref.propertyName, void 0);
+  }
+  const originalName = utils.getUniqueName($ref.replace(/.+\//, ""), __privateGet(this, _usedAliasNames));
+  const propertyName = this.options.resolveName({ name: originalName }) || originalName;
+  ref = this.refs[$ref] = {
+    propertyName,
+    originalName
+  };
+  return factory__namespace.createTypeReferenceNode(ref.propertyName, void 0);
+};
+_getBaseTypeFromSchema = new WeakSet();
+getBaseTypeFromSchema_fn = function(schema, baseName) {
+  if (!schema) {
+    return factory__namespace.keywordTypeNodes.any;
+  }
+  if (utils$1.isReference(schema)) {
+    return __privateMethod(this, _getRefAlias, getRefAlias_fn).call(this, schema, baseName);
+  }
+  if (schema.oneOf) {
+    const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
+    const union = factory__namespace.createUnionDeclaration({
+      withParentheses: true,
+      nodes: schema.oneOf.map((item) => {
+        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item);
+      }).filter((item) => {
+        return item && item !== factory__namespace.keywordTypeNodes.any;
+      })
+    });
+    if (schemaWithoutOneOf.properties) {
+      return factory__namespace.createIntersectionDeclaration({
+        nodes: [__privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schemaWithoutOneOf, baseName), union].filter(Boolean)
       });
-      if (schemaWithoutOneOf.properties) {
-        return parser.createIntersectionDeclaration({
-          nodes: [this.#getBaseTypeFromSchema(schemaWithoutOneOf, baseName), union].filter(Boolean)
-        });
-      }
-      return union;
     }
-    if (schema.anyOf) {
-      const schemaWithoutAnyOf = { ...schema, anyOf: void 0 };
-      const union = parser.createUnionDeclaration({
-        withParentheses: true,
-        nodes: schema.anyOf.map((item) => {
-          return this.#getBaseTypeFromSchema(item);
-        }).filter((item) => {
-          return item && item !== keywordTypeNodes.any;
-        })
+    return union;
+  }
+  if (schema.anyOf) {
+    const schemaWithoutAnyOf = { ...schema, anyOf: void 0 };
+    const union = factory__namespace.createUnionDeclaration({
+      withParentheses: true,
+      nodes: schema.anyOf.map((item) => {
+        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item);
+      }).filter((item) => {
+        return item && item !== factory__namespace.keywordTypeNodes.any;
+      })
+    });
+    if (schemaWithoutAnyOf.properties) {
+      return factory__namespace.createIntersectionDeclaration({
+        nodes: [__privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schemaWithoutAnyOf, baseName), union].filter(Boolean)
       });
-      if (schemaWithoutAnyOf.properties) {
-        return parser.createIntersectionDeclaration({
-          nodes: [this.#getBaseTypeFromSchema(schemaWithoutAnyOf, baseName), union].filter(Boolean)
-        });
-      }
-      return union;
     }
-    if (schema.allOf) {
-      const schemaWithoutAllOf = { ...schema, allOf: void 0 };
-      const and = parser.createIntersectionDeclaration({
-        withParentheses: true,
-        nodes: schema.allOf.map((item) => {
-          return this.#getBaseTypeFromSchema(item);
-        }).filter((item) => {
-          return item && item !== keywordTypeNodes.any;
-        })
+    return union;
+  }
+  if (schema.allOf) {
+    const schemaWithoutAllOf = { ...schema, allOf: void 0 };
+    const and = factory__namespace.createIntersectionDeclaration({
+      withParentheses: true,
+      nodes: schema.allOf.map((item) => {
+        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item);
+      }).filter((item) => {
+        return item && item !== factory__namespace.keywordTypeNodes.any;
+      })
+    });
+    if (schemaWithoutAllOf.properties) {
+      return factory__namespace.createIntersectionDeclaration({
+        nodes: [__privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schemaWithoutAllOf, baseName), and].filter(Boolean)
       });
-      if (schemaWithoutAllOf.properties) {
-        return parser.createIntersectionDeclaration({
-          nodes: [this.#getBaseTypeFromSchema(schemaWithoutAllOf, baseName), and].filter(Boolean)
-        });
-      }
-      return and;
     }
-    if (schema.enum && baseName) {
-      const enumName = core.getUniqueName(baseName, _TypeGenerator.usedEnumNames);
-      let enums = [...new Set(schema.enum)].map((key) => [key, key]);
-      if ("x-enumNames" in schema) {
-        enums = [...new Set(schema["x-enumNames"])].map((key, index) => {
-          return [key, schema.enum?.[index]];
-        });
-      }
-      this.extraNodes.push(
-        ...parser.createEnumDeclaration({
-          name: changeCase.camelCase(enumName, this.caseOptions),
-          typeName: this.options.resolveName({ name: enumName, pluginName }),
-          enums,
-          type: this.options.enumType
-        })
-      );
-      return factory2.createTypeReferenceNode(this.options.resolveName({ name: enumName, pluginName }), void 0);
-    }
-    if (schema.enum) {
-      return parser.createUnionDeclaration({
-        nodes: schema.enum.map((name) => {
-          return factory2.createLiteralTypeNode(typeof name === "number" ? factory2.createNumericLiteral(name) : factory2.createStringLiteral(`${name}`));
-        })
+    return and;
+  }
+  if (schema.enum && baseName) {
+    const enumName = utils.getUniqueName(baseName, this.options.usedEnumNames);
+    let enums = [...new Set(schema.enum)].map((key) => [key, key]);
+    if ("x-enumNames" in schema) {
+      enums = [...new Set(schema["x-enumNames"])].map((key, index) => {
+        return [key, schema.enum?.[index]];
       });
     }
-    if ("items" in schema) {
-      const node = this.#getTypeFromSchema(schema.items, baseName);
-      if (node) {
-        return factory2.createArrayTypeNode(node);
-      }
+    this.extraNodes.push(
+      ...factory__namespace.createEnumDeclaration({
+        name: changeCase.camelCase(enumName, __privateGet(this, _caseOptions)),
+        typeName: this.options.resolveName({ name: enumName }),
+        enums,
+        type: this.options.enumType
+      })
+    );
+    return factory__namespace.createTypeReferenceNode(this.options.resolveName({ name: enumName }), void 0);
+  }
+  if (schema.enum) {
+    return factory__namespace.createUnionDeclaration({
+      nodes: schema.enum.map((name) => {
+        return factory__namespace.createLiteralTypeNode(typeof name === "number" ? factory__namespace.createNumericLiteral(name) : factory__namespace.createStringLiteral(`${name}`));
+      })
+    });
+  }
+  if ("items" in schema) {
+    const node = __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, schema.items, baseName);
+    if (node) {
+      return factory__namespace.createArrayTypeNode(node);
     }
-    if ("prefixItems" in schema) {
-      const prefixItems = schema.prefixItems;
-      return parser.createTupleDeclaration({
-        nodes: prefixItems.map((item) => {
-          return this.#getBaseTypeFromSchema(item, void 0);
-        })
+  }
+  if ("prefixItems" in schema) {
+    const prefixItems = schema.prefixItems;
+    return factory__namespace.createTupleDeclaration({
+      nodes: prefixItems.map((item) => {
+        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item, void 0);
+      })
+    });
+  }
+  if (schema.properties || schema.additionalProperties) {
+    return __privateMethod(this, _getTypeFromProperties, getTypeFromProperties_fn).call(this, schema, baseName);
+  }
+  if (schema.type) {
+    if (Array.isArray(schema.type)) {
+      const [type, nullable] = schema.type;
+      return factory__namespace.createUnionDeclaration({
+        nodes: [
+          __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, {
+            ...schema,
+            type
+          }, baseName),
+          nullable ? factory__namespace.createLiteralTypeNode(factory__namespace.createNull()) : void 0
+        ].filter(Boolean)
       });
     }
-    if (schema.properties || schema.additionalProperties) {
-      return this.#getTypeFromProperties(schema, baseName);
-    }
-    if (schema.type) {
-      if (Array.isArray(schema.type)) {
-        const [type, nullable] = schema.type;
-        return parser.createUnionDeclaration({
-          nodes: [
-            this.#getBaseTypeFromSchema(
-              {
-                ...schema,
-                type
-              },
-              baseName
-            ),
-            nullable ? factory2.createLiteralTypeNode(factory2.createNull()) : void 0
-          ].filter(Boolean)
-        });
-      }
-      if (this.options.dateType === "date" && ["date", "date-time"].some((item) => item === schema.format)) {
-        return factory2.createTypeReferenceNode(factory2.createIdentifier("Date"));
-      }
-      if (schema.type in keywordTypeNodes) {
-        return keywordTypeNodes[schema.type];
-      }
-    }
-    if (schema.format === "binary") {
-      return factory2.createTypeReferenceNode("Blob", []);
+    if (this.options.dateType === "date" && ["date", "date-time"].some((item) => item === schema.format)) {
+      return factory__namespace.createTypeReferenceNode(factory__namespace.createIdentifier("Date"));
     }
-    if ("const" in schema && schema["const"] !== void 0 && typeof schema["const"] === "string") {
-      return factory2.createLiteralTypeNode(factory2.createStringLiteral(schema["const"]));
+    if (schema.type in factory__namespace.keywordTypeNodes) {
+      return factory__namespace.keywordTypeNodes[schema.type];
     }
-    return keywordTypeNodes.any;
   }
+  if (schema.format === "binary") {
+    return factory__namespace.createTypeReferenceNode("Blob", []);
+  }
+  if ("const" in schema && schema["const"] !== void 0 && typeof schema["const"] === "string") {
+    return factory__namespace.createLiteralTypeNode(factory__namespace.createStringLiteral(schema["const"]));
+  }
+  return factory__namespace.keywordTypeNodes.any;
 };
 
 // src/builders/TypeBuilder.ts
-function refsSorter(a, b) {
-  if (Object.keys(a.import.refs)?.length < Object.keys(b.import.refs)?.length) {
-    return -1;
-  }
-  if (Object.keys(a.import.refs)?.length > Object.keys(b.import.refs)?.length) {
-    return 1;
-  }
-  return 0;
-}
 var TypeBuilder = class extends swagger.OasBuilder {
   configure(options) {
     if (options) {
@@ -319,8 +342,9 @@ var TypeBuilder = class extends swagger.OasBuilder {
   }
   print(name) {
     const codes = [];
-    const generated = this.items.filter((operationSchema) => name ? operationSchema.name === name : true).sort(core.nameSorter).map((operationSchema) => {
+    const generated = this.items.filter((operationSchema) => name ? operationSchema.name === name : true).sort(utils.transformers.nameSorter).map((operationSchema) => {
       const generator = new TypeGenerator({
+        usedEnumNames: this.options.usedEnumNames,
         withJSDocs: this.options.withJSDocs,
         resolveName: this.options.resolveName,
         enumType: this.options.enumType,
@@ -340,7 +364,7 @@ var TypeBuilder = class extends swagger.OasBuilder {
         },
         sources
       };
-    }).sort(refsSorter);
+    }).sort(utils$1.refsSorter);
     generated.forEach((item) => {
       codes.push(parser.print(item.sources));
     });
@@ -349,7 +373,7 @@ var TypeBuilder = class extends swagger.OasBuilder {
       const importMeta = importsGenerator.build(generated.map((item) => item.import));
       if (importMeta) {
         const nodes = importMeta.map((item) => {
-          return parser.createImportDeclaration({
+          return factory__namespace.createImportDeclaration({
             name: [{ propertyName: item.ref.propertyName }],
             path: item.path,
             isTypeOnly: true
@@ -358,78 +382,87 @@ var TypeBuilder = class extends swagger.OasBuilder {
         codes.unshift(parser.print(nodes));
       }
     }
-    return core.combineCodes(codes);
+    return utils.transformers.combineCodes(codes);
   }
 };
+var _printCombinedSchema, printCombinedSchema_fn;
 var OperationGenerator = class extends swagger.OperationGenerator {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _printCombinedSchema);
+  }
   resolve(operation) {
-    const { pluginManager } = this.context;
+    const { pluginManager, plugin } = this.context;
     return swagger.resolve({
       operation,
       resolveName: pluginManager.resolveName,
       resolvePath: pluginManager.resolvePath,
-      pluginName
+      pluginKey: plugin?.key
     });
   }
   async all() {
     return null;
   }
   async get(operation, schemas, options) {
-    const { mode, enumType, dateType, optionalType } = options;
-    const { pluginManager } = this.context;
+    const { mode, enumType, dateType, optionalType, usedEnumNames } = options;
+    const { pluginManager, plugin } = this.context;
     const type = this.resolve(operation);
     const fileResolver = (name) => {
-      const root = pluginManager.resolvePath({ baseName: type.baseName, pluginName, options: { tag: operation.getTags()[0]?.name } });
+      const root = pluginManager.resolvePath({ baseName: type.baseName, pluginKey: plugin?.key, options: { tag: operation.getTags()[0]?.name } });
       const resolvedTypeId = pluginManager.resolvePath({
         baseName: `${name}.ts`,
-        pluginName
+        pluginKey: plugin?.key
       });
-      return core.getRelativePath(root, resolvedTypeId);
+      return utils.getRelativePath(root, resolvedTypeId);
     };
     const source = new TypeBuilder({
+      usedEnumNames,
       fileResolver: mode === "file" ? void 0 : fileResolver,
       withJSDocs: true,
-      resolveName: pluginManager.resolveName,
+      resolveName: (params) => pluginManager.resolveName({ ...params, pluginKey: plugin?.key }),
       enumType,
       optionalType,
       dateType
     }).add(schemas.pathParams).add(schemas.queryParams).add(schemas.headerParams).add(schemas.response).add(schemas.errors).configure().print();
+    const combinedSchemaSource = __privateMethod(this, _printCombinedSchema, printCombinedSchema_fn).call(this, type.name, operation, schemas);
     return {
       path: type.path,
       baseName: type.baseName,
-      source,
+      source: [source, combinedSchemaSource].join("\n"),
       meta: {
-        pluginName,
+        pluginKey: plugin.key,
         tag: operation.getTags()[0]?.name
       }
     };
   }
   async post(operation, schemas, options) {
-    const { mode, enumType, dateType, optionalType } = options;
-    const { pluginManager } = this.context;
+    const { mode, enumType, dateType, optionalType, usedEnumNames } = options;
+    const { pluginManager, plugin } = this.context;
     const type = this.resolve(operation);
     const fileResolver = (name) => {
-      const root = pluginManager.resolvePath({ baseName: type.baseName, pluginName, options: { tag: operation.getTags()[0]?.name } });
+      const root = pluginManager.resolvePath({ baseName: type.baseName, pluginKey: plugin?.key, options: { tag: operation.getTags()[0]?.name } });
       const resolvedTypeId = pluginManager.resolvePath({
         baseName: `${name}.ts`,
-        pluginName
+        pluginKey: plugin?.key
       });
-      return core.getRelativePath(root, resolvedTypeId);
+      return utils.getRelativePath(root, resolvedTypeId);
     };
     const source = new TypeBuilder({
+      usedEnumNames,
       fileResolver: mode === "file" ? void 0 : fileResolver,
       withJSDocs: true,
-      resolveName: pluginManager.resolveName,
+      resolveName: (params) => pluginManager.resolveName({ ...params, pluginKey: plugin?.key }),
       enumType,
       optionalType,
       dateType
     }).add(schemas.pathParams).add(schemas.queryParams).add(schemas.headerParams).add(schemas.request).add(schemas.response).add(schemas.errors).configure().print();
+    const combinedSchemaSource = __privateMethod(this, _printCombinedSchema, printCombinedSchema_fn).call(this, type.name, operation, schemas);
     return {
       path: type.path,
       baseName: type.baseName,
-      source,
+      source: [source, combinedSchemaSource].join("\n"),
       meta: {
-        pluginName,
+        pluginKey: plugin.key,
         tag: operation.getTags()[0]?.name
       }
     };
@@ -444,68 +477,134 @@ var OperationGenerator = class extends swagger.OperationGenerator {
     return this.post(operation, schemas, options);
   }
 };
+_printCombinedSchema = new WeakSet();
+printCombinedSchema_fn = function(name, operation, schemas) {
+  const properties = {
+    "response": factory__namespace.createTypeReferenceNode(
+      factory__namespace.createIdentifier(schemas.response.name),
+      void 0
+    )
+  };
+  if (schemas.request) {
+    properties["request"] = factory__namespace.createTypeReferenceNode(
+      factory__namespace.createIdentifier(schemas.request.name),
+      void 0
+    );
+  }
+  if (schemas.pathParams) {
+    properties["pathParams"] = factory__namespace.createTypeReferenceNode(
+      factory__namespace.createIdentifier(schemas.pathParams.name),
+      void 0
+    );
+  }
+  if (schemas.queryParams) {
+    properties["queryParams"] = factory__namespace.createTypeReferenceNode(
+      factory__namespace.createIdentifier(schemas.queryParams.name),
+      void 0
+    );
+  }
+  if (schemas.headerParams) {
+    properties["headerParams"] = factory__namespace.createTypeReferenceNode(
+      factory__namespace.createIdentifier(schemas.headerParams.name),
+      void 0
+    );
+  }
+  if (schemas.errors) {
+    properties["errors"] = factory__namespace.createUnionDeclaration({
+      nodes: schemas.errors.map((error) => {
+        return factory__namespace.createTypeReferenceNode(
+          factory__namespace.createIdentifier(error.name),
+          void 0
+        );
+      })
+    });
+  }
+  const namespaceNode = factory__namespace.createNamespaceDeclaration({
+    name: operation.method === "get" ? `${name}Query` : `${name}Mutation`,
+    statements: Object.keys(properties).map((key) => {
+      const type = properties[key];
+      if (!type) {
+        return void 0;
+      }
+      return factory__namespace.createTypeAliasDeclaration({
+        modifiers: [factory__namespace.modifiers.export],
+        name: changeCase.pascalCase(key),
+        type
+      });
+    }).filter(Boolean)
+  });
+  return parser.print(namespaceNode);
+};
 
 // src/plugin.ts
 var pluginName = "swagger-ts";
+var pluginKey = ["schema", pluginName];
 var definePlugin = core.createPlugin((options) => {
   const {
     output = "types",
-    groupBy,
-    skipBy = [],
-    overrideBy = [],
+    group,
+    exclude = [],
+    include,
+    override = [],
     enumType = "asConst",
     dateType = "string",
     optionalType = "questionToken",
-    transformers = {}
+    transformers: transformers2 = {},
+    exportAs
   } = options;
-  const template = groupBy?.output ? groupBy.output : `${output}/{{tag}}Controller`;
+  const template = group?.output ? group.output : `${output}/{{tag}}Controller`;
   let pluginsOptions;
   return {
     name: pluginName,
     options,
     kind: "schema",
     validate(plugins) {
-      pluginsOptions = core.getDependedPlugins(plugins, [swagger.pluginName]);
+      pluginsOptions = core.PluginManager.getDependedPlugins(plugins, [swagger.pluginName]);
       return true;
     },
     resolvePath(baseName, directory, options2) {
-      const root = pathParser__default.default.resolve(this.config.root, this.config.output.path);
-      const mode = core.getPathMode(pathParser__default.default.resolve(root, output));
+      const root = path__default.default.resolve(this.config.root, this.config.output.path);
+      const mode = core.FileManager.getMode(path__default.default.resolve(root, output));
       if (mode === "file") {
-        return pathParser__default.default.resolve(root, output);
+        return path__default.default.resolve(root, output);
       }
-      if (options2?.tag && groupBy?.type === "tag") {
+      if (options2?.tag && group?.type === "tag") {
         const tag = changeCase.camelCase(options2.tag, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
-        return pathParser__default.default.resolve(root, core.renderTemplate(template, { tag }), baseName);
+        return path__default.default.resolve(root, utils.renderTemplate(template, { tag }), baseName);
       }
-      return pathParser__default.default.resolve(root, output, baseName);
+      return path__default.default.resolve(root, output, baseName);
     },
-    resolveName(name) {
+    resolveName(name, type) {
       const resolvedName = changeCase.pascalCase(name, { delimiter: "", stripRegexp: /[^A-Z0-9$]/gi, transform: changeCase.pascalCaseTransformMerge });
-      return transformers?.name?.(resolvedName) || resolvedName;
+      if (type) {
+        return transformers2?.name?.(resolvedName, type) || resolvedName;
+      }
+      return resolvedName;
     },
-    async writeFile(source, path) {
-      if (!path.endsWith(".ts") || !source) {
+    async writeFile(source, writePath) {
+      if (!writePath.endsWith(".ts") || !source) {
         return;
       }
-      await this.fileManager.write(source, path);
+      return this.fileManager.write(source, writePath);
     },
     async buildStart() {
       const [swaggerPlugin] = pluginsOptions;
       const oas = await swaggerPlugin.api.getOas();
       const schemas = await swaggerPlugin.api.getSchemas();
-      const root = pathParser__default.default.resolve(this.config.root, this.config.output.path);
-      const mode = core.getPathMode(pathParser__default.default.resolve(root, output));
+      const root = path__default.default.resolve(this.config.root, this.config.output.path);
+      const mode = core.FileManager.getMode(path__default.default.resolve(root, output));
+      const usedEnumNames = {};
       if (mode === "directory") {
         const builder = await new TypeBuilder({
-          resolveName: (params) => this.resolveName({ pluginName, ...params }),
+          usedEnumNames,
+          resolveName: (params) => this.resolveName({ pluginKey: this.plugin.key, ...params }),
           fileResolver: (name) => {
             const resolvedTypeId = this.resolvePath({
               baseName: `${name}.ts`,
-              pluginName
+              pluginKey: this.plugin.key
             });
-            const root2 = this.resolvePath({ baseName: ``, pluginName });
-            return core.getRelativePath(root2, resolvedTypeId);
+            const root2 = this.resolvePath({ baseName: ``, pluginKey: this.plugin.key });
+            return utils.getRelativePath(root2, resolvedTypeId);
           },
           withJSDocs: true,
           enumType,
@@ -519,16 +618,16 @@ var definePlugin = core.createPlugin((options) => {
           });
         });
         const mapFolderSchema = async ([name]) => {
-          const path = this.resolvePath({ baseName: `${this.resolveName({ name, pluginName })}.ts`, pluginName });
-          if (!path) {
+          const resolvedPath = this.resolvePath({ baseName: `${this.resolveName({ name, pluginKey: this.plugin.key })}.ts`, pluginKey: this.plugin.key });
+          if (!resolvedPath) {
             return null;
           }
           return this.addFile({
-            path,
-            baseName: `${this.resolveName({ name, pluginName })}.ts`,
+            path: resolvedPath,
+            baseName: `${this.resolveName({ name, pluginKey: this.plugin.key })}.ts`,
             source: builder.print(name),
             meta: {
-              pluginName
+              pluginKey: this.plugin.key
             }
           });
         };
@@ -537,7 +636,8 @@ var definePlugin = core.createPlugin((options) => {
       }
       if (mode === "file") {
         const builder = new TypeBuilder({
-          resolveName: (params) => this.resolveName({ pluginName, ...params }),
+          usedEnumNames,
+          resolveName: (params) => this.resolveName({ pluginKey: this.plugin.key, ...params }),
           withJSDocs: true,
           enumType,
           dateType,
@@ -549,17 +649,18 @@ var definePlugin = core.createPlugin((options) => {
             name
           });
         });
-        const path = this.resolvePath({ baseName: "", pluginName });
-        if (!path) {
+        const resolvedPath = this.resolvePath({ baseName: "", pluginKey: this.plugin.key });
+        if (!resolvedPath) {
           return;
         }
         await this.addFile({
-          path,
-          baseName: `${this.resolveName({ name: output, pluginName })}.ts`,
+          path: resolvedPath,
+          baseName: output,
           source: builder.print(),
           meta: {
-            pluginName
-          }
+            pluginKey: this.plugin.key
+          },
+          validate: false
         });
       }
       const operationGenerator = new OperationGenerator(
@@ -567,14 +668,17 @@ var definePlugin = core.createPlugin((options) => {
           mode,
           enumType,
           dateType,
-          optionalType
+          optionalType,
+          usedEnumNames
         },
         {
           oas,
           pluginManager: this.pluginManager,
+          plugin: this.plugin,
           contentType: swaggerPlugin.api.contentType,
-          skipBy,
-          overrideBy
+          exclude,
+          include,
+          override
         }
       );
       const files = await operationGenerator.build();
@@ -584,29 +688,41 @@ var definePlugin = core.createPlugin((options) => {
       if (this.config.output.write === false) {
         return;
       }
-      while (this.fileManager.isExecuting) {
-        await core.timeout(100);
-      }
-      const root = pathParser__default.default.resolve(this.config.root, this.config.output.path);
-      await this.fileManager.addIndexes(root, ".ts");
+      const root = path__default.default.resolve(this.config.root, this.config.output.path);
+      await this.fileManager.addIndexes({
+        root,
+        extName: ".ts",
+        meta: { pluginKey: this.plugin.key },
+        options: {
+          map: (file) => {
+            return {
+              ...file,
+              exports: file.exports?.map((item) => {
+                if (exportAs) {
+                  return {
+                    ...item,
+                    name: exportAs,
+                    asAlias: !!exportAs
+                  };
+                }
+                return item;
+              })
+            };
+          },
+          output,
+          isTypeOnly: true
+        }
+      });
     }
   };
 });
-function useResolve(props = {}) {
-  return swagger.useResolve({ pluginName, ...props });
-}
 
 // src/index.ts
 var src_default = definePlugin;
 
-exports.OperationGenerator = OperationGenerator;
-exports.TypeBuilder = TypeBuilder;
-exports.TypeGenerator = TypeGenerator;
 exports.default = src_default;
 exports.definePlugin = definePlugin;
-exports.keywordTypeNodes = keywordTypeNodes;
+exports.pluginKey = pluginKey;
 exports.pluginName = pluginName;
-exports.resolve = resolve;
-exports.useResolve = useResolve;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map