@kubb/swagger-ts 1.15.0-canary.20231023T125947 → 1.15.0-canary.20231024T104451

package/dist/index.d.cts

@@ -1,8 +1,7 @@
 import * as _kubb_core from '@kubb/core';
-import { PluginFactoryOptions, PluginContext, KubbFile, SchemaGenerator } from '@kubb/core';
+import { KubbPlugin, PluginFactoryOptions, PluginContext, KubbFile, SchemaGenerator } from '@kubb/core';
 import { SkipBy, OverrideBy, ResolvePathOptions, OasBuilder, FileResolver, OperationGenerator as OperationGenerator$1, Operation, Resolver, OperationSchemas, OpenAPIV3, Refs, UseResolveProps, ResolveProps } from '@kubb/swagger';
 import ts from 'typescript';
-import { Options as Options$4 } from 'change-case';
 
 type Options$3 = {
     /**
@@ -28,6 +27,10 @@ type Options$3 = {
          */
         output?: string;
     };
+    /**
+     * Name to be used for the `export * as {{exportAs}} from './`
+     */
+    exportAs?: string;
     /**
      * Array containing skipBy paramaters to exclude/skip tags/operations/methods/paths.
      */
@@ -62,15 +65,22 @@ type Options$3 = {
     };
 };
 type FileMeta = {
-    pluginName?: string;
+    pluginKey?: KubbPlugin['key'];
     tag?: string;
 };
-type PluginOptions = PluginFactoryOptions<'swagger-ts', Options$3, false, never, ResolvePathOptions>;
+type PluginOptions = PluginFactoryOptions<'swagger-ts', 'schema', Options$3, false, never, ResolvePathOptions>;
+declare module '@kubb/core' {
+    interface _Register {
+        ['@kubb/swagger-ts']: PluginOptions;
+    }
+}
 
-declare const pluginName: PluginOptions['name'];
+declare const pluginName = "swagger-ts";
+declare const pluginKey: PluginOptions['key'];
 declare const definePlugin: (options: Options$3) => _kubb_core.KubbUserPlugin<PluginOptions>;
 
 type Options$2 = {
+    usedEnumNames: Record<string, number>;
     resolveName: PluginContext['resolveName'];
     fileResolver?: FileResolver;
     withJSDocs?: boolean;
@@ -85,6 +95,7 @@ declare class TypeBuilder extends OasBuilder<Options$2, never> {
 }
 
 type Options$1 = {
+    usedEnumNames: Record<string, number>;
     mode: KubbFile.Mode;
     enumType: NonNullable<Options$3['enumType']>;
     dateType: NonNullable<Options$3['dateType']>;
@@ -101,6 +112,7 @@ declare class OperationGenerator extends OperationGenerator$1<Options$1> {
 }
 
 type Options = {
+    usedEnumNames: Record<string, number>;
     withJSDocs?: boolean;
     resolveName: PluginContext['resolveName'];
     enumType: 'enum' | 'asConst' | 'asPascalConst';
@@ -109,12 +121,9 @@ type Options = {
 };
 declare class TypeGenerator extends SchemaGenerator<Options, OpenAPIV3.SchemaObject, ts.Node[]> {
     #private;
-    static usedEnumNames: Record<string, number>;
     refs: Refs;
     extraNodes: ts.Node[];
     aliases: ts.TypeAliasDeclaration[];
-    usedAliasNames: Record<string, number>;
-    caseOptions: Options$4;
     constructor(options?: Options);
     build({ schema, baseName, description, keysToOmit, }: {
         schema: OpenAPIV3.SchemaObject;
@@ -124,10 +133,7 @@ declare class TypeGenerator extends SchemaGenerator<Options, OpenAPIV3.SchemaObj
     }): ts.Node[];
 }
 
-type Props$1 = UseResolveProps & {
-    pluginName?: never;
-};
-declare function useResolve(props?: Props$1): Resolver;
+declare function useResolve(props?: UseResolveProps): Resolver;
 
 declare const keywordTypeNodes: {
     readonly any: ts.KeywordTypeNode<ts.SyntaxKind.AnyKeyword>;
@@ -140,9 +146,6 @@ declare const keywordTypeNodes: {
     readonly null: ts.LiteralTypeNode;
 };
 
-type Props = ResolveProps & {
-    pluginName?: never;
-};
-declare function resolve(props: Props): Resolver;
+declare function resolve(props: ResolveProps): Resolver;
 
-export { FileMeta, OperationGenerator, Options$3 as Options, PluginOptions, TypeBuilder, TypeGenerator, definePlugin as default, definePlugin, keywordTypeNodes, pluginName, resolve, useResolve };
+export { FileMeta, OperationGenerator, Options$3 as Options, PluginOptions, TypeBuilder, TypeGenerator, definePlugin as default, definePlugin, keywordTypeNodes, pluginKey, pluginName, resolve, useResolve };

package/dist/index.d.ts

@@ -1,8 +1,7 @@
 import * as _kubb_core from '@kubb/core';
-import { PluginFactoryOptions, PluginContext, KubbFile, SchemaGenerator } from '@kubb/core';
+import { KubbPlugin, PluginFactoryOptions, PluginContext, KubbFile, SchemaGenerator } from '@kubb/core';
 import { SkipBy, OverrideBy, ResolvePathOptions, OasBuilder, FileResolver, OperationGenerator as OperationGenerator$1, Operation, Resolver, OperationSchemas, OpenAPIV3, Refs, UseResolveProps, ResolveProps } from '@kubb/swagger';
 import ts from 'typescript';
-import { Options as Options$4 } from 'change-case';
 
 type Options$3 = {
     /**
@@ -28,6 +27,10 @@ type Options$3 = {
          */
         output?: string;
     };
+    /**
+     * Name to be used for the `export * as {{exportAs}} from './`
+     */
+    exportAs?: string;
     /**
      * Array containing skipBy paramaters to exclude/skip tags/operations/methods/paths.
      */
@@ -62,15 +65,22 @@ type Options$3 = {
     };
 };
 type FileMeta = {
-    pluginName?: string;
+    pluginKey?: KubbPlugin['key'];
     tag?: string;
 };
-type PluginOptions = PluginFactoryOptions<'swagger-ts', Options$3, false, never, ResolvePathOptions>;
+type PluginOptions = PluginFactoryOptions<'swagger-ts', 'schema', Options$3, false, never, ResolvePathOptions>;
+declare module '@kubb/core' {
+    interface _Register {
+        ['@kubb/swagger-ts']: PluginOptions;
+    }
+}
 
-declare const pluginName: PluginOptions['name'];
+declare const pluginName = "swagger-ts";
+declare const pluginKey: PluginOptions['key'];
 declare const definePlugin: (options: Options$3) => _kubb_core.KubbUserPlugin<PluginOptions>;
 
 type Options$2 = {
+    usedEnumNames: Record<string, number>;
     resolveName: PluginContext['resolveName'];
     fileResolver?: FileResolver;
     withJSDocs?: boolean;
@@ -85,6 +95,7 @@ declare class TypeBuilder extends OasBuilder<Options$2, never> {
 }
 
 type Options$1 = {
+    usedEnumNames: Record<string, number>;
     mode: KubbFile.Mode;
     enumType: NonNullable<Options$3['enumType']>;
     dateType: NonNullable<Options$3['dateType']>;
@@ -101,6 +112,7 @@ declare class OperationGenerator extends OperationGenerator$1<Options$1> {
 }
 
 type Options = {
+    usedEnumNames: Record<string, number>;
     withJSDocs?: boolean;
     resolveName: PluginContext['resolveName'];
     enumType: 'enum' | 'asConst' | 'asPascalConst';
@@ -109,12 +121,9 @@ type Options = {
 };
 declare class TypeGenerator extends SchemaGenerator<Options, OpenAPIV3.SchemaObject, ts.Node[]> {
     #private;
-    static usedEnumNames: Record<string, number>;
     refs: Refs;
     extraNodes: ts.Node[];
     aliases: ts.TypeAliasDeclaration[];
-    usedAliasNames: Record<string, number>;
-    caseOptions: Options$4;
     constructor(options?: Options);
     build({ schema, baseName, description, keysToOmit, }: {
         schema: OpenAPIV3.SchemaObject;
@@ -124,10 +133,7 @@ declare class TypeGenerator extends SchemaGenerator<Options, OpenAPIV3.SchemaObj
     }): ts.Node[];
 }
 
-type Props$1 = UseResolveProps & {
-    pluginName?: never;
-};
-declare function useResolve(props?: Props$1): Resolver;
+declare function useResolve(props?: UseResolveProps): Resolver;
 
 declare const keywordTypeNodes: {
     readonly any: ts.KeywordTypeNode<ts.SyntaxKind.AnyKeyword>;
@@ -140,9 +146,6 @@ declare const keywordTypeNodes: {
     readonly null: ts.LiteralTypeNode;
 };
 
-type Props = ResolveProps & {
-    pluginName?: never;
-};
-declare function resolve(props: Props): Resolver;
+declare function resolve(props: ResolveProps): Resolver;
 
-export { FileMeta, OperationGenerator, Options$3 as Options, PluginOptions, TypeBuilder, TypeGenerator, definePlugin as default, definePlugin, keywordTypeNodes, pluginName, resolve, useResolve };
+export { FileMeta, OperationGenerator, Options$3 as Options, PluginOptions, TypeBuilder, TypeGenerator, definePlugin as default, definePlugin, keywordTypeNodes, pluginKey, pluginName, resolve, useResolve };

package/dist/index.js

@@ -1,7 +1,7 @@
 import { createRequire } from 'module';
-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 path from 'path';
+import { createPlugin, getDependedPlugins, FileManager, renderTemplate, getRelativePath, SchemaGenerator, getUniqueName, nameSorter, transformers } from '@kubb/core';
+import { pluginName as pluginName$1, resolve as resolve$1, isReference, OasBuilder, refsSorter, ImportsGenerator, OperationGenerator as OperationGenerator$1, useResolve as useResolve$1 } from '@kubb/swagger';
 import { camelCase, camelCaseTransformMerge, pascalCase, pascalCaseTransformMerge } from 'change-case';
 import { createTypeAliasDeclaration, modifiers, createOmitDeclaration, appendJSDocToNode, createUnionDeclaration, createPropertySignature, createIndexSignature, createIntersectionDeclaration, createEnumDeclaration, createTupleDeclaration, print, createImportDeclaration } from '@kubb/parser';
 import ts from 'typescript';
@@ -19,24 +19,29 @@ var keywordTypeNodes = {
   null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword))
 };
 function resolve(props) {
-  return resolve$1({ ...props, pluginName });
+  return resolve$1({ pluginKey, ...props });
 }
 
 // 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 = {};
+var TypeGenerator = class extends SchemaGenerator {
   refs = {};
   extraNodes = [];
   aliases = [];
   // Keep track of already used type aliases
-  usedAliasNames = {};
-  caseOptions = {
+  #usedAliasNames = {};
+  #caseOptions = {
     delimiter: "",
     stripRegexp: /[^A-Z0-9$]/gi
   };
-  constructor(options = { withJSDocs: true, resolveName: ({ name }) => name, enumType: "asConst", dateType: "string", optionalType: "questionToken" }) {
+  constructor(options = {
+    usedEnumNames: {},
+    withJSDocs: true,
+    resolveName: ({ name }) => name,
+    enumType: "asConst",
+    dateType: "string",
+    optionalType: "questionToken"
+  }) {
     super(options);
     return this;
   }
@@ -53,7 +58,7 @@ var TypeGenerator = class _TypeGenerator extends SchemaGenerator {
     }
     const node = createTypeAliasDeclaration({
       modifiers: [modifiers.export],
-      name: this.options.resolveName({ name: baseName, pluginName }) || baseName,
+      name: this.options.resolveName({ name: baseName }) || baseName,
       type: keysToOmit?.length ? createOmitDeclaration({ keys: keysToOmit, type, nonNullable: true }) : type
     });
     if (description) {
@@ -99,7 +104,7 @@ var TypeGenerator = class _TypeGenerator extends SchemaGenerator {
     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 }));
+      let type = this.#getTypeFromSchema(schema, this.options.resolveName({ name: `${baseName || ""} ${name}` }));
       if (!type) {
         return null;
       }
@@ -138,14 +143,14 @@ var TypeGenerator = class _TypeGenerator extends SchemaGenerator {
   /**
    * Create a type alias for the schema referenced by the given ReferenceObject
    */
-  #getRefAlias(obj, baseName) {
+  #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;
+    const originalName = getUniqueName($ref.replace(/.+\//, ""), this.#usedAliasNames);
+    const propertyName = this.options.resolveName({ name: originalName }) || originalName;
     ref = this.refs[$ref] = {
       propertyName,
       originalName
@@ -215,7 +220,7 @@ var TypeGenerator = class _TypeGenerator extends SchemaGenerator {
       return and;
     }
     if (schema.enum && baseName) {
-      const enumName = getUniqueName(baseName, _TypeGenerator.usedEnumNames);
+      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) => {
@@ -224,13 +229,13 @@ var TypeGenerator = class _TypeGenerator extends SchemaGenerator {
       }
       this.extraNodes.push(
         ...createEnumDeclaration({
-          name: camelCase(enumName, this.caseOptions),
-          typeName: this.options.resolveName({ name: enumName, pluginName }),
+          name: camelCase(enumName, this.#caseOptions),
+          typeName: this.options.resolveName({ name: enumName }),
           enums,
           type: this.options.enumType
         })
       );
-      return factory2.createTypeReferenceNode(this.options.resolveName({ name: enumName, pluginName }), void 0);
+      return factory2.createTypeReferenceNode(this.options.resolveName({ name: enumName }), void 0);
     }
     if (schema.enum) {
       return createUnionDeclaration({
@@ -287,15 +292,6 @@ var TypeGenerator = class _TypeGenerator extends SchemaGenerator {
 };
 
 // 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) {
@@ -310,6 +306,7 @@ var TypeBuilder = class extends OasBuilder {
     const codes = [];
     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,
@@ -347,38 +344,39 @@ var TypeBuilder = class extends OasBuilder {
         codes.unshift(print(nodes));
       }
     }
-    return combineCodes(codes);
+    return transformers.combineCodes(codes);
   }
 };
 var OperationGenerator = class extends OperationGenerator$1 {
   resolve(operation) {
-    const { pluginManager } = this.context;
+    const { pluginManager, plugin } = this.context;
     return resolve$1({
       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 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
@@ -388,27 +386,28 @@ var OperationGenerator = class extends OperationGenerator$1 {
       baseName: type.baseName,
       source,
       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 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
@@ -418,7 +417,7 @@ var OperationGenerator = class extends OperationGenerator$1 {
       baseName: type.baseName,
       source,
       meta: {
-        pluginName,
+        pluginKey: plugin.key,
         tag: operation.getTags()[0]?.name
       }
     };
@@ -436,6 +435,7 @@ var OperationGenerator = class extends OperationGenerator$1 {
 
 // src/plugin.ts
 var pluginName = "swagger-ts";
+var pluginKey = ["schema", pluginName];
 var definePlugin = createPlugin((options) => {
   const {
     output = "types",
@@ -445,7 +445,8 @@ var definePlugin = createPlugin((options) => {
     enumType = "asConst",
     dateType = "string",
     optionalType = "questionToken",
-    transformers = {}
+    transformers: transformers2 = {},
+    exportAs
   } = options;
   const template = groupBy?.output ? groupBy.output : `${output}/{{tag}}Controller`;
   let pluginsOptions;
@@ -458,42 +459,44 @@ var definePlugin = createPlugin((options) => {
       return true;
     },
     resolvePath(baseName, directory, options2) {
-      const root = pathParser.resolve(this.config.root, this.config.output.path);
-      const mode = getPathMode(pathParser.resolve(root, output));
+      const root = path.resolve(this.config.root, this.config.output.path);
+      const mode = FileManager.getMode(path.resolve(root, output));
       if (mode === "file") {
-        return pathParser.resolve(root, output);
+        return path.resolve(root, output);
       }
       if (options2?.tag && groupBy?.type === "tag") {
         const tag = camelCase(options2.tag, { delimiter: "", transform: camelCaseTransformMerge });
-        return pathParser.resolve(root, renderTemplate(template, { tag }), baseName);
+        return path.resolve(root, renderTemplate(template, { tag }), baseName);
       }
-      return pathParser.resolve(root, output, baseName);
+      return path.resolve(root, output, baseName);
     },
     resolveName(name) {
       const resolvedName = pascalCase(name, { delimiter: "", stripRegexp: /[^A-Z0-9$]/gi, transform: pascalCaseTransformMerge });
-      return transformers?.name?.(resolvedName) || resolvedName;
+      return transformers2?.name?.(resolvedName) || 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.resolve(this.config.root, this.config.output.path);
-      const mode = getPathMode(pathParser.resolve(root, output));
+      const root = path.resolve(this.config.root, this.config.output.path);
+      const mode = FileManager.getMode(path.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 });
+            const root2 = this.resolvePath({ baseName: ``, pluginKey: this.plugin.key });
             return getRelativePath(root2, resolvedTypeId);
           },
           withJSDocs: true,
@@ -508,16 +511,16 @@ var definePlugin = 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
             }
           });
         };
@@ -526,7 +529,8 @@ var definePlugin = 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,
@@ -538,16 +542,16 @@ var definePlugin = 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: `${this.resolveName({ name: output, pluginKey: this.plugin.key })}.ts`,
           source: builder.print(),
           meta: {
-            pluginName
+            pluginKey: this.plugin.key
           }
         });
       }
@@ -556,11 +560,13 @@ var definePlugin = createPlugin((options) => {
           mode,
           enumType,
           dateType,
-          optionalType
+          optionalType,
+          usedEnumNames
         },
         {
           oas,
           pluginManager: this.pluginManager,
+          plugin: this.plugin,
           contentType: swaggerPlugin.api.contentType,
           skipBy,
           overrideBy
@@ -573,21 +579,41 @@ var definePlugin = createPlugin((options) => {
       if (this.config.output.write === false) {
         return;
       }
-      while (this.fileManager.isExecuting) {
-        await timeout(100);
-      }
-      const root = pathParser.resolve(this.config.root, this.config.output.path);
-      await this.fileManager.addIndexes(root, ".ts");
+      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
+        }
+      });
     }
   };
 });
 function useResolve(props = {}) {
-  return useResolve$1({ pluginName, ...props });
+  return useResolve$1({ pluginKey, ...props });
 }
 
 // src/index.ts
 var src_default = definePlugin;
 
-export { OperationGenerator, TypeBuilder, TypeGenerator, src_default as default, definePlugin, keywordTypeNodes, pluginName, resolve, useResolve };
+export { OperationGenerator, TypeBuilder, TypeGenerator, src_default as default, definePlugin, keywordTypeNodes, pluginKey, pluginName, resolve, useResolve };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map