@kubb/swagger-ts 1.15.0-canary.20231027T175035 → 1.15.0-canary.20231027T185644

package/dist/index.js

@@ -1,71 +1,43 @@
 import { createRequire } from 'module';
-import path from 'path';
-import { createPlugin, PluginManager, FileManager, SchemaGenerator } from '@kubb/core';
-import { renderTemplate, getRelativePath, transformers, getUniqueName } from '@kubb/core/utils';
-import { pluginName as pluginName$1, OasBuilder, ImportsGenerator, OperationGenerator as OperationGenerator$1, resolve } from '@kubb/swagger';
+import pathParser from 'path';
+import { createPlugin, getDependedPlugins, getPathMode, renderTemplate, getRelativePath, timeout, SchemaGenerator, getUniqueName, nameSorter, combineCodes } from '@kubb/core';
+import { pluginName as pluginName$1, resolve as resolve$1, isReference, OasBuilder, ImportsGenerator, OperationGenerator as OperationGenerator$1, useResolve as useResolve$1 } from '@kubb/swagger';
 import { camelCase, camelCaseTransformMerge, pascalCase, pascalCaseTransformMerge } from 'change-case';
-import { print } from '@kubb/parser';
-import * as factory from '@kubb/parser/factory';
-import { refsSorter, isReference } from '@kubb/swagger/utils';
+import { createTypeAliasDeclaration, modifiers, createOmitDeclaration, appendJSDocToNode, createUnionDeclaration, createPropertySignature, createIndexSignature, createIntersectionDeclaration, createEnumDeclaration, createTupleDeclaration, print, createImportDeclaration } from '@kubb/parser';
+import ts from 'typescript';
 
 createRequire(import.meta.url);
-  
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
+var { factory } = ts;
+var keywordTypeNodes = {
+  any: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+  number: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+  integer: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+  object: factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),
+  string: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+  boolean: factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),
+  undefined: factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
+  null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword))
 };
-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 SchemaGenerator {
-  constructor(options = {
-    usedEnumNames: {},
-    withJSDocs: true,
-    resolveName: ({ name }) => name,
-    enumType: "asConst",
-    dateType: "string",
-    optionalType: "questionToken"
-  }) {
+function resolve(props) {
+  return resolve$1({ ...props, pluginName });
+}
+
+// src/generators/TypeGenerator.ts
+var { factory: factory2 } = ts;
+var TypeGenerator = class _TypeGenerator extends 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" }) {
     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({
@@ -75,18 +47,18 @@ var TypeGenerator = class extends SchemaGenerator {
     keysToOmit
   }) {
     const nodes = [];
-    const type = __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, schema, baseName);
+    const type = this.#getTypeFromSchema(schema, baseName);
     if (!type) {
       return this.extraNodes;
     }
-    const node = factory.createTypeAliasDeclaration({
-      modifiers: [factory.modifiers.export],
-      name: this.options.resolveName({ name: baseName }) || baseName,
-      type: keysToOmit?.length ? factory.createOmitDeclaration({ keys: keysToOmit, type, nonNullable: true }) : type
+    const node = createTypeAliasDeclaration({
+      modifiers: [modifiers.export],
+      name: this.options.resolveName({ name: baseName, pluginName }) || baseName,
+      type: keysToOmit?.length ? createOmitDeclaration({ keys: keysToOmit, type, nonNullable: true }) : type
     });
     if (description) {
       nodes.push(
-        factory.appendJSDocToNode({
+        appendJSDocToNode({
           node,
           comments: [`@description ${description}`]
         })
@@ -101,211 +73,232 @@ var TypeGenerator = class extends SchemaGenerator {
     );
     return [...this.extraNodes, ...filterdNodes];
   }
-};
-_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.createUnionDeclaration({ nodes: [type, factory.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}` }));
+  /**
+   * 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);
     if (!type) {
       return null;
     }
-    if (!isRequired && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
-      type = factory.createUnionDeclaration({ nodes: [type, factory.keywordTypeNodes.undefined] });
+    if (schema && !schema.nullable) {
+      return type;
     }
-    const propertySignature = factory.createPropertySignature({
-      questionToken: ["questionToken", "questionTokenAndUndefined"].includes(optionalType) && !isRequired,
-      name,
-      type,
-      readOnly: schema.readOnly
-    });
-    if (this.options.withJSDocs) {
-      return factory.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 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 = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+      }
+      const propertySignature = createPropertySignature({
+        questionToken: ["questionToken", "questionTokenAndUndefined"].includes(optionalType) && !isRequired,
+        name,
+        type,
+        readOnly: schema.readOnly
       });
+      if (this.options.withJSDocs) {
+        return 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;
+    });
+    if (additionalProperties) {
+      const type = additionalProperties === true ? keywordTypeNodes.any : this.#getTypeFromSchema(additionalProperties);
+      if (type) {
+        members.push(createIndexSignature(type));
+      }
     }
-    return propertySignature;
-  });
-  if (additionalProperties) {
-    const type = additionalProperties === true ? factory.keywordTypeNodes.any : __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, additionalProperties);
-    if (type) {
-      members.push(factory.createIndexSignature(type));
-    }
-  }
-  return factory.createTypeLiteralNode(members.filter(Boolean));
-};
-_getRefAlias = new WeakSet();
-getRefAlias_fn = function(obj, _baseName) {
-  const { $ref } = obj;
-  let ref = this.refs[$ref];
-  if (ref) {
-    return factory.createTypeReferenceNode(ref.propertyName, void 0);
-  }
-  const originalName = getUniqueName($ref.replace(/.+\//, ""), __privateGet(this, _usedAliasNames));
-  const propertyName = this.options.resolveName({ name: originalName }) || originalName;
-  ref = this.refs[$ref] = {
-    propertyName,
-    originalName
-  };
-  return factory.createTypeReferenceNode(ref.propertyName, void 0);
-};
-_getBaseTypeFromSchema = new WeakSet();
-getBaseTypeFromSchema_fn = function(schema, baseName) {
-  if (!schema) {
-    return factory.keywordTypeNodes.any;
+    return factory2.createTypeLiteralNode(members.filter(Boolean));
   }
-  if (isReference(schema)) {
-    return __privateMethod(this, _getRefAlias, getRefAlias_fn).call(this, schema, baseName);
+  /**
+   * 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 = 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);
   }
-  if (schema.oneOf) {
-    const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
-    const union = factory.createUnionDeclaration({
-      withParentheses: true,
-      nodes: schema.oneOf.map((item) => {
-        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item);
-      }).filter((item) => {
-        return item && item !== factory.keywordTypeNodes.any;
-      })
-    });
-    if (schemaWithoutOneOf.properties) {
-      return factory.createIntersectionDeclaration({
-        nodes: [__privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schemaWithoutOneOf, baseName), union].filter(Boolean)
+  /**
+   * 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 (isReference(schema)) {
+      return this.#getRefAlias(schema, baseName);
+    }
+    if (schema.oneOf) {
+      const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
+      const union = createUnionDeclaration({
+        withParentheses: true,
+        nodes: schema.oneOf.map((item) => {
+          return this.#getBaseTypeFromSchema(item);
+        }).filter((item) => {
+          return item && item !== keywordTypeNodes.any;
+        })
       });
+      if (schemaWithoutOneOf.properties) {
+        return createIntersectionDeclaration({
+          nodes: [this.#getBaseTypeFromSchema(schemaWithoutOneOf, baseName), union].filter(Boolean)
+        });
+      }
+      return union;
     }
-    return union;
-  }
-  if (schema.anyOf) {
-    const schemaWithoutAnyOf = { ...schema, anyOf: void 0 };
-    const union = factory.createUnionDeclaration({
-      withParentheses: true,
-      nodes: schema.anyOf.map((item) => {
-        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item);
-      }).filter((item) => {
-        return item && item !== factory.keywordTypeNodes.any;
-      })
-    });
-    if (schemaWithoutAnyOf.properties) {
-      return factory.createIntersectionDeclaration({
-        nodes: [__privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schemaWithoutAnyOf, baseName), union].filter(Boolean)
+    if (schema.anyOf) {
+      const schemaWithoutAnyOf = { ...schema, anyOf: void 0 };
+      const union = createUnionDeclaration({
+        withParentheses: true,
+        nodes: schema.anyOf.map((item) => {
+          return this.#getBaseTypeFromSchema(item);
+        }).filter((item) => {
+          return item && item !== keywordTypeNodes.any;
+        })
       });
+      if (schemaWithoutAnyOf.properties) {
+        return createIntersectionDeclaration({
+          nodes: [this.#getBaseTypeFromSchema(schemaWithoutAnyOf, baseName), union].filter(Boolean)
+        });
+      }
+      return union;
     }
-    return union;
-  }
-  if (schema.allOf) {
-    const schemaWithoutAllOf = { ...schema, allOf: void 0 };
-    const and = factory.createIntersectionDeclaration({
-      withParentheses: true,
-      nodes: schema.allOf.map((item) => {
-        return __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, item);
-      }).filter((item) => {
-        return item && item !== factory.keywordTypeNodes.any;
-      })
-    });
-    if (schemaWithoutAllOf.properties) {
-      return factory.createIntersectionDeclaration({
-        nodes: [__privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schemaWithoutAllOf, baseName), and].filter(Boolean)
+    if (schema.allOf) {
+      const schemaWithoutAllOf = { ...schema, allOf: void 0 };
+      const and = createIntersectionDeclaration({
+        withParentheses: true,
+        nodes: schema.allOf.map((item) => {
+          return this.#getBaseTypeFromSchema(item);
+        }).filter((item) => {
+          return item && item !== keywordTypeNodes.any;
+        })
       });
+      if (schemaWithoutAllOf.properties) {
+        return createIntersectionDeclaration({
+          nodes: [this.#getBaseTypeFromSchema(schemaWithoutAllOf, baseName), and].filter(Boolean)
+        });
+      }
+      return and;
     }
-    return and;
-  }
-  if (schema.enum && baseName) {
-    const enumName = 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 (schema.enum && baseName) {
+      const enumName = 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(
+        ...createEnumDeclaration({
+          name: 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 createUnionDeclaration({
+        nodes: schema.enum.map((name) => {
+          return factory2.createLiteralTypeNode(typeof name === "number" ? factory2.createNumericLiteral(name) : factory2.createStringLiteral(`${name}`));
+        })
       });
     }
-    this.extraNodes.push(
-      ...factory.createEnumDeclaration({
-        name: camelCase(enumName, __privateGet(this, _caseOptions)),
-        typeName: this.options.resolveName({ name: enumName }),
-        enums,
-        type: this.options.enumType
-      })
-    );
-    return factory.createTypeReferenceNode(this.options.resolveName({ name: enumName }), void 0);
-  }
-  if (schema.enum) {
-    return factory.createUnionDeclaration({
-      nodes: schema.enum.map((name) => {
-        return factory.createLiteralTypeNode(typeof name === "number" ? factory.createNumericLiteral(name) : factory.createStringLiteral(`${name}`));
-      })
-    });
-  }
-  if ("items" in schema) {
-    const node = __privateMethod(this, _getTypeFromSchema, getTypeFromSchema_fn).call(this, schema.items, baseName);
-    if (node) {
-      return factory.createArrayTypeNode(node);
+    if ("items" in schema) {
+      const node = this.#getTypeFromSchema(schema.items, baseName);
+      if (node) {
+        return factory2.createArrayTypeNode(node);
+      }
     }
-  }
-  if ("prefixItems" in schema) {
-    const prefixItems = schema.prefixItems;
-    return factory.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.createUnionDeclaration({
-        nodes: [
-          __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, {
-            ...schema,
-            type
-          }, baseName),
-          nullable ? factory.createLiteralTypeNode(factory.createNull()) : void 0
-        ].filter(Boolean)
+    if ("prefixItems" in schema) {
+      const prefixItems = schema.prefixItems;
+      return createTupleDeclaration({
+        nodes: prefixItems.map((item) => {
+          return this.#getBaseTypeFromSchema(item, void 0);
+        })
       });
     }
-    if (this.options.dateType === "date" && ["date", "date-time"].some((item) => item === schema.format)) {
-      return factory.createTypeReferenceNode(factory.createIdentifier("Date"));
+    if (schema.properties || schema.additionalProperties) {
+      return this.#getTypeFromProperties(schema, baseName);
     }
-    if (schema.type in factory.keywordTypeNodes) {
-      return factory.keywordTypeNodes[schema.type];
+    if (schema.type) {
+      if (Array.isArray(schema.type)) {
+        const [type, nullable] = schema.type;
+        return 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 ("const" in schema && schema["const"] !== void 0 && typeof schema["const"] === "string") {
+      return factory2.createLiteralTypeNode(factory2.createStringLiteral(schema["const"]));
+    }
+    return keywordTypeNodes.any;
   }
-  if (schema.format === "binary") {
-    return factory.createTypeReferenceNode("Blob", []);
-  }
-  if ("const" in schema && schema["const"] !== void 0 && typeof schema["const"] === "string") {
-    return factory.createLiteralTypeNode(factory.createStringLiteral(schema["const"]));
-  }
-  return factory.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 OasBuilder {
   configure(options) {
     if (options) {
@@ -318,9 +311,8 @@ var TypeBuilder = class extends OasBuilder {
   }
   print(name) {
     const codes = [];
-    const generated = this.items.filter((operationSchema) => name ? operationSchema.name === name : true).sort(transformers.nameSorter).map((operationSchema) => {
+    const generated = this.items.filter((operationSchema) => name ? operationSchema.name === name : true).sort(nameSorter).map((operationSchema) => {
       const generator = new TypeGenerator({
-        usedEnumNames: this.options.usedEnumNames,
         withJSDocs: this.options.withJSDocs,
         resolveName: this.options.resolveName,
         enumType: this.options.enumType,
@@ -349,7 +341,7 @@ var TypeBuilder = class extends OasBuilder {
       const importMeta = importsGenerator.build(generated.map((item) => item.import));
       if (importMeta) {
         const nodes = importMeta.map((item) => {
-          return factory.createImportDeclaration({
+          return createImportDeclaration({
             name: [{ propertyName: item.ref.propertyName }],
             path: item.path,
             isTypeOnly: true
@@ -358,39 +350,38 @@ var TypeBuilder = class extends OasBuilder {
         codes.unshift(print(nodes));
       }
     }
-    return transformers.combineCodes(codes);
+    return combineCodes(codes);
   }
 };
 var OperationGenerator = class extends OperationGenerator$1 {
   resolve(operation) {
-    const { pluginManager, plugin } = this.context;
-    return resolve({
+    const { pluginManager } = this.context;
+    return resolve$1({
       operation,
       resolveName: pluginManager.resolveName,
       resolvePath: pluginManager.resolvePath,
-      pluginKey: plugin?.key
+      pluginName
     });
   }
   async all() {
     return null;
   }
   async get(operation, schemas, options) {
-    const { mode, enumType, dateType, optionalType, usedEnumNames } = options;
-    const { pluginManager, plugin } = this.context;
+    const { mode, enumType, dateType, optionalType } = options;
+    const { pluginManager } = this.context;
     const type = this.resolve(operation);
     const fileResolver = (name) => {
-      const root = pluginManager.resolvePath({ baseName: type.baseName, pluginKey: plugin?.key, options: { tag: operation.getTags()[0]?.name } });
+      const root = pluginManager.resolvePath({ baseName: type.baseName, pluginName, options: { tag: operation.getTags()[0]?.name } });
       const resolvedTypeId = pluginManager.resolvePath({
         baseName: `${name}.ts`,
-        pluginKey: plugin?.key
+        pluginName
       });
       return getRelativePath(root, resolvedTypeId);
     };
     const source = new TypeBuilder({
-      usedEnumNames,
       fileResolver: mode === "file" ? void 0 : fileResolver,
       withJSDocs: true,
-      resolveName: (params) => pluginManager.resolveName({ ...params, pluginKey: plugin?.key }),
+      resolveName: pluginManager.resolveName,
       enumType,
       optionalType,
       dateType
@@ -400,28 +391,27 @@ var OperationGenerator = class extends OperationGenerator$1 {
       baseName: type.baseName,
       source,
       meta: {
-        pluginKey: plugin.key,
+        pluginName,
         tag: operation.getTags()[0]?.name
       }
     };
   }
   async post(operation, schemas, options) {
-    const { mode, enumType, dateType, optionalType, usedEnumNames } = options;
-    const { pluginManager, plugin } = this.context;
+    const { mode, enumType, dateType, optionalType } = options;
+    const { pluginManager } = this.context;
     const type = this.resolve(operation);
     const fileResolver = (name) => {
-      const root = pluginManager.resolvePath({ baseName: type.baseName, pluginKey: plugin?.key, options: { tag: operation.getTags()[0]?.name } });
+      const root = pluginManager.resolvePath({ baseName: type.baseName, pluginName, options: { tag: operation.getTags()[0]?.name } });
       const resolvedTypeId = pluginManager.resolvePath({
         baseName: `${name}.ts`,
-        pluginKey: plugin?.key
+        pluginName
       });
       return getRelativePath(root, resolvedTypeId);
     };
     const source = new TypeBuilder({
-      usedEnumNames,
       fileResolver: mode === "file" ? void 0 : fileResolver,
       withJSDocs: true,
-      resolveName: (params) => pluginManager.resolveName({ ...params, pluginKey: plugin?.key }),
+      resolveName: pluginManager.resolveName,
       enumType,
       optionalType,
       dateType
@@ -431,7 +421,7 @@ var OperationGenerator = class extends OperationGenerator$1 {
       baseName: type.baseName,
       source,
       meta: {
-        pluginKey: plugin.key,
+        pluginName,
         tag: operation.getTags()[0]?.name
       }
     };
@@ -449,7 +439,6 @@ var OperationGenerator = class extends OperationGenerator$1 {
 
 // src/plugin.ts
 var pluginName = "swagger-ts";
-var pluginKey = ["schema", pluginName];
 var definePlugin = createPlugin((options) => {
   const {
     output = "types",
@@ -459,8 +448,7 @@ var definePlugin = createPlugin((options) => {
     enumType = "asConst",
     dateType = "string",
     optionalType = "questionToken",
-    transformers: transformers2 = {},
-    exportAs
+    transformers = {}
   } = options;
   const template = groupBy?.output ? groupBy.output : `${output}/{{tag}}Controller`;
   let pluginsOptions;
@@ -469,48 +457,46 @@ var definePlugin = createPlugin((options) => {
     options,
     kind: "schema",
     validate(plugins) {
-      pluginsOptions = PluginManager.getDependedPlugins(plugins, [pluginName$1]);
+      pluginsOptions = getDependedPlugins(plugins, [pluginName$1]);
       return true;
     },
     resolvePath(baseName, directory, options2) {
-      const root = path.resolve(this.config.root, this.config.output.path);
-      const mode = FileManager.getMode(path.resolve(root, output));
+      const root = pathParser.resolve(this.config.root, this.config.output.path);
+      const mode = getPathMode(pathParser.resolve(root, output));
       if (mode === "file") {
-        return path.resolve(root, output);
+        return pathParser.resolve(root, output);
       }
       if (options2?.tag && groupBy?.type === "tag") {
         const tag = camelCase(options2.tag, { delimiter: "", transform: camelCaseTransformMerge });
-        return path.resolve(root, renderTemplate(template, { tag }), baseName);
+        return pathParser.resolve(root, renderTemplate(template, { tag }), baseName);
       }
-      return path.resolve(root, output, baseName);
+      return pathParser.resolve(root, output, baseName);
     },
     resolveName(name) {
       const resolvedName = pascalCase(name, { delimiter: "", stripRegexp: /[^A-Z0-9$]/gi, transform: pascalCaseTransformMerge });
-      return transformers2?.name?.(resolvedName) || resolvedName;
+      return transformers?.name?.(resolvedName) || resolvedName;
     },
-    async writeFile(source, writePath) {
-      if (!writePath.endsWith(".ts") || !source) {
+    async writeFile(source, path) {
+      if (!path.endsWith(".ts") || !source) {
         return;
       }
-      return this.fileManager.write(source, writePath);
+      await this.fileManager.write(source, path);
     },
     async buildStart() {
       const [swaggerPlugin] = pluginsOptions;
       const oas = await swaggerPlugin.api.getOas();
       const schemas = await swaggerPlugin.api.getSchemas();
-      const root = path.resolve(this.config.root, this.config.output.path);
-      const mode = FileManager.getMode(path.resolve(root, output));
-      const usedEnumNames = {};
+      const root = pathParser.resolve(this.config.root, this.config.output.path);
+      const mode = getPathMode(pathParser.resolve(root, output));
       if (mode === "directory") {
         const builder = await new TypeBuilder({
-          usedEnumNames,
-          resolveName: (params) => this.resolveName({ pluginKey: this.plugin.key, ...params }),
+          resolveName: (params) => this.resolveName({ pluginName, ...params }),
           fileResolver: (name) => {
             const resolvedTypeId = this.resolvePath({
               baseName: `${name}.ts`,
-              pluginKey: this.plugin.key
+              pluginName
             });
-            const root2 = this.resolvePath({ baseName: ``, pluginKey: this.plugin.key });
+            const root2 = this.resolvePath({ baseName: ``, pluginName });
             return getRelativePath(root2, resolvedTypeId);
           },
           withJSDocs: true,
@@ -525,16 +511,16 @@ var definePlugin = createPlugin((options) => {
           });
         });
         const mapFolderSchema = async ([name]) => {
-          const resolvedPath = this.resolvePath({ baseName: `${this.resolveName({ name, pluginKey: this.plugin.key })}.ts`, pluginKey: this.plugin.key });
-          if (!resolvedPath) {
+          const path = this.resolvePath({ baseName: `${this.resolveName({ name, pluginName })}.ts`, pluginName });
+          if (!path) {
             return null;
           }
           return this.addFile({
-            path: resolvedPath,
-            baseName: `${this.resolveName({ name, pluginKey: this.plugin.key })}.ts`,
+            path,
+            baseName: `${this.resolveName({ name, pluginName })}.ts`,
             source: builder.print(name),
             meta: {
-              pluginKey: this.plugin.key
+              pluginName
             }
           });
         };
@@ -543,8 +529,7 @@ var definePlugin = createPlugin((options) => {
       }
       if (mode === "file") {
         const builder = new TypeBuilder({
-          usedEnumNames,
-          resolveName: (params) => this.resolveName({ pluginKey: this.plugin.key, ...params }),
+          resolveName: (params) => this.resolveName({ pluginName, ...params }),
           withJSDocs: true,
           enumType,
           dateType,
@@ -556,18 +541,17 @@ var definePlugin = createPlugin((options) => {
             name
           });
         });
-        const resolvedPath = this.resolvePath({ baseName: "", pluginKey: this.plugin.key });
-        if (!resolvedPath) {
+        const path = this.resolvePath({ baseName: "", pluginName });
+        if (!path) {
           return;
         }
         await this.addFile({
-          path: resolvedPath,
-          baseName: output,
+          path,
+          baseName: `${this.resolveName({ name: output, pluginName })}.ts`,
           source: builder.print(),
           meta: {
-            pluginKey: this.plugin.key
-          },
-          validate: false
+            pluginName
+          }
         });
       }
       const operationGenerator = new OperationGenerator(
@@ -575,13 +559,11 @@ var definePlugin = createPlugin((options) => {
           mode,
           enumType,
           dateType,
-          optionalType,
-          usedEnumNames
+          optionalType
         },
         {
           oas,
           pluginManager: this.pluginManager,
-          plugin: this.plugin,
           contentType: swaggerPlugin.api.contentType,
           skipBy,
           overrideBy
@@ -594,41 +576,21 @@ var definePlugin = createPlugin((options) => {
       if (this.config.output.write === false) {
         return;
       }
-      const root = path.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
-        }
-      });
+      while (this.fileManager.isExecuting) {
+        await timeout(100);
+      }
+      const root = pathParser.resolve(this.config.root, this.config.output.path);
+      await this.fileManager.addIndexes(root, ".ts");
     }
   };
 });
-function resolve2(props) {
-  return resolve({ pluginKey, ...props });
+function useResolve(props = {}) {
+  return useResolve$1({ pluginName, ...props });
 }
 
 // src/index.ts
 var src_default = definePlugin;
 
-export { src_default as default, definePlugin, pluginKey, pluginName, resolve2 as resolve };
+export { OperationGenerator, TypeBuilder, TypeGenerator, src_default as default, definePlugin, keywordTypeNodes, pluginName, resolve, useResolve };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map