@kubb/plugin-zod 3.0.0-alpha.15 → 3.0.0-alpha.17

package/dist/{chunk-BDYQNKJC.js → chunk-ORFIAMY6.js}

@@ -1,50 +1,16 @@
+import { __commonJS, init_esm_shims, __toESM, Zod, Operations } from './chunk-35K4FTRK.js';
+import { createReactGenerator, SchemaGenerator, pluginOasName, OperationGenerator, schemaKeywords, isKeyword } from '@kubb/plugin-oas';
 import { Oas } from '@kubb/plugin-oas/components';
-import { useApp, File, Const, Type, useFile, createRoot, App } from '@kubb/react';
+import { useOas, useOperationManager, useSchemaManager } from '@kubb/plugin-oas/hooks';
 import path from 'node:path';
 import { createPlugin, FileManager, PluginManager } from '@kubb/core';
-import transformers4, { camelCase, pascalCase } from '@kubb/core/transformers';
+import transformers2, { camelCase, pascalCase } from '@kubb/core/transformers';
 import { renderTemplate } from '@kubb/core/utils';
-import { pluginOasName, createReactGenerator, SchemaGenerator, OperationGenerator as OperationGenerator$1, isKeyword, schemaKeywords } from '@kubb/plugin-oas';
-import { useSchema, useOperationManager, useOas, useOperation, useOperations } from '@kubb/plugin-oas/hooks';
-import { jsx, jsxs, Fragment } from '@kubb/react/jsx-runtime';
+import { useApp, File, Type } from '@kubb/react';
+import { jsxs, jsx, Fragment } from '@kubb/react/jsx-runtime';
 import { print } from '@kubb/parser-ts';
 import * as factory from '@kubb/parser-ts/factory';
 
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  __defProp(target, "default", { value: mod, enumerable: true }) ,
-  mod
-));
-
-// ../../node_modules/.pnpm/tsup@8.2.4_@microsoft+api-extractor@7.47.7_@types+node@20.16.4__@swc+core@1.7.22_jiti@1.21.6__fpzbqwwca26qndurg5tnw6xyfi/node_modules/tsup/assets/esm_shims.js
-var init_esm_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.2.4_@microsoft+api-extractor@7.47.7_@types+node@20.16.4__@swc+core@1.7.22_jiti@1.21.6__fpzbqwwca26qndurg5tnw6xyfi/node_modules/tsup/assets/esm_shims.js"() {
-  }
-});
-
 // ../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.production.min.js
 var require_react_production_min = __commonJS({
   "../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.production.min.js"(exports) {
@@ -2203,7 +2169,10 @@ var require_react = __commonJS({
   }
 });
 
-// src/components/Schema.tsx
+// src/generators/index.ts
+init_esm_shims();
+
+// src/generators/zodGenerator.tsx
 init_esm_shims();
 
 // ../plugin-ts/src/index.ts
@@ -2212,46 +2181,28 @@ init_esm_shims();
 // ../plugin-ts/src/plugin.ts
 init_esm_shims();
 
-// ../plugin-ts/src/OperationGenerator.tsx
+// ../plugin-ts/src/generators/index.ts
+init_esm_shims();
+
+// ../plugin-ts/src/generators/typeGenerator.tsx
+init_esm_shims();
+
+// ../plugin-ts/src/components/index.ts
 init_esm_shims();
 
 // ../plugin-ts/src/components/OasType.tsx
 init_esm_shims();
-function Template({ name, typeName, api }) {
+function OasType({ name, typeName, api }) {
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsx(File.Source, { name, isExportable: true, isIndexable: true, children: `export const ${name} = ${JSON.stringify(api, void 0, 2)} as const` }),
     /* @__PURE__ */ jsx("br", {}),
     /* @__PURE__ */ jsx(File.Source, { name: typeName, isExportable: true, isIndexable: true, isTypeOnly: true, children: /* @__PURE__ */ jsx(Type, { name: typeName, export: true, children: `Infer<typeof ${name}>` }) })
   ] });
 }
-var defaultTemplates = { default: Template };
-function OasType({ name, typeName, Template: Template3 = defaultTemplates.default }) {
-  const oas = useOas();
-  return /* @__PURE__ */ jsx(Template3, { name, typeName, api: oas.api });
-}
-OasType.File = function({ name, typeName, templates = defaultTemplates }) {
-  const {
-    pluginManager,
-    plugin: { key: pluginKey }
-  } = useApp();
-  const file = pluginManager.getFile({ name, extName: ".ts", pluginKey });
-  const Template3 = templates.default;
-  return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
-    /* @__PURE__ */ jsx(File.Import, { name: ["Infer"], path: "@kubb/oas", isTypeOnly: true }),
-    /* @__PURE__ */ jsx(OasType, { Template: Template3, name, typeName })
-  ] });
-};
-OasType.templates = defaultTemplates;
 
-// ../plugin-ts/src/components/OperationSchema.tsx
+// ../plugin-ts/src/components/Type.tsx
 init_esm_shims();
-
-// ../plugin-ts/src/SchemaGenerator.tsx
-init_esm_shims();
-
-// ../plugin-ts/src/components/Schema.tsx
-init_esm_shims();
-var import_react3 = __toESM(require_react());
+var import_react3 = __toESM(require_react(), 1);
 
 // ../plugin-ts/src/parser/index.ts
 init_esm_shims();
@@ -2421,7 +2372,7 @@ function parse(parent, current, options) {
       return factory.appendJSDocToNode({
         node: propertySignature,
         comments: [
-          describeSchema ? `@description ${transformers4.jsStringEscape(describeSchema.args)}` : void 0,
+          describeSchema ? `@description ${transformers2.jsStringEscape(describeSchema.args)}` : void 0,
           deprecatedSchema ? "@deprecated" : void 0,
           defaultSchema ? `@default ${defaultSchema.args}` : void 0,
           exampleSchema ? `@example ${exampleSchema.args}` : void 0,
@@ -2448,28 +2399,7 @@ function parse(parent, current, options) {
   }
   return void 0;
 }
-function Schema(props) {
-  const { keysToOmit, description } = props;
-  const { tree, name } = useSchema();
-  const {
-    pluginManager,
-    plugin: {
-      options: { mapper, enumType, optionalType }
-    }
-  } = useApp();
-  if (enumType === "asPascalConst") {
-    pluginManager.logger.emit("warning", `enumType '${enumType}' is deprecated`);
-  }
-  const resolvedName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: "function"
-  });
-  const typeName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: "type"
-  });
+function Type2({ name, typedName, tree, keysToOmit, optionalType, enumType, mapper, description }) {
   const typeNodes = [];
   if (!tree.length) {
     return "";
@@ -2479,8 +2409,8 @@ function Schema(props) {
   const isOptional = tree.some((item) => item.keyword === schemaKeywords.optional);
   let type = tree.map(
     (schema) => parse(void 0, schema, {
-      name: resolvedName,
-      typeName,
+      name,
+      typeName: typedName,
       description,
       keysToOmit,
       optionalType,
@@ -2505,7 +2435,7 @@ function Schema(props) {
   }
   const node = factory.createTypeAliasDeclaration({
     modifiers: [factory.modifiers.export],
-    name: resolvedName,
+    name,
     type: keysToOmit?.length ? factory.createOmitDeclaration({
       keys: keysToOmit,
       type,
@@ -2514,59 +2444,36 @@ function Schema(props) {
   });
   const enumSchemas = SchemaGenerator.deepSearch(tree, schemaKeywords.enum);
   const enums = enumSchemas.map((enumSchema) => {
-    const name2 = enumType === "asPascalConst" ? transformers4.pascalCase(enumSchema.args.name) : transformers4.camelCase(enumSchema.args.name);
-    const typeName2 = enumSchema.args.typeName;
+    const name2 = enumType === "asPascalConst" ? transformers2.pascalCase(enumSchema.args.name) : transformers2.camelCase(enumSchema.args.name);
+    const typeName = enumSchema.args.typeName;
     const [nameNode, typeNode] = factory.createEnumDeclaration({
       name: name2,
-      typeName: typeName2,
-      enums: enumSchema.args.items.map((item) => item.value === void 0 ? void 0 : [transformers4.trimQuotes(item.name?.toString()), item.value]).filter(Boolean),
+      typeName,
+      enums: enumSchema.args.items.map((item) => item.value === void 0 ? void 0 : [transformers2.trimQuotes(item.name?.toString()), item.value]).filter(Boolean),
       type: enumType
     });
     return {
       nameNode,
       typeNode,
       name: name2,
-      typeName: typeName2
+      typeName
     };
   });
   typeNodes.push(
     factory.appendJSDocToNode({
       node,
-      comments: [description ? `@description ${transformers4.jsStringEscape(description)}` : void 0].filter(Boolean)
+      comments: [description ? `@description ${transformers2.jsStringEscape(description)}` : void 0].filter(Boolean)
     })
   );
   return /* @__PURE__ */ jsxs(import_react3.Fragment, { children: [
-    enums.map(({ name: name2, nameNode, typeName: typeName2, typeNode }, index) => /* @__PURE__ */ jsxs(import_react3.Fragment, { children: [
+    enums.map(({ name: name2, nameNode, typeName, typeNode }, index) => /* @__PURE__ */ jsxs(import_react3.Fragment, { children: [
       nameNode && /* @__PURE__ */ jsx(File.Source, { name: name2, isExportable: true, isIndexable: true, children: print([nameNode]) }),
-      /* @__PURE__ */ jsx(File.Source, { name: typeName2, isIndexable: true, isExportable: ["enum", "asConst", "constEnum", "literal", void 0].includes(enumType), isTypeOnly: true, children: print([typeNode]) })
+      /* @__PURE__ */ jsx(File.Source, { name: typeName, isIndexable: true, isExportable: ["enum", "asConst", "constEnum", "literal", void 0].includes(enumType), isTypeOnly: true, children: print([typeNode]) })
     ] }, [name2, nameNode].join("-"))),
-    enums.every((item) => item.typeName !== resolvedName) && /* @__PURE__ */ jsx(File.Source, { name: typeName, isTypeOnly: true, isExportable: true, isIndexable: true, children: print(typeNodes) })
+    enums.every((item) => item.typeName !== name) && /* @__PURE__ */ jsx(File.Source, { name: typedName, isTypeOnly: true, isExportable: true, isIndexable: true, children: print(typeNodes) })
   ] });
 }
-Schema.File = function({}) {
-  const { pluginManager } = useApp();
-  const { schema } = useSchema();
-  return /* @__PURE__ */ jsx(Oas.Schema.File, { isTypeOnly: true, output: pluginManager.config.output.path, children: /* @__PURE__ */ jsx(Schema, { description: schema?.description }) });
-};
-var SchemaGenerator2 = class extends SchemaGenerator {
-  async schema(name, schema, options) {
-    const { oas, pluginManager, plugin, mode, output } = this.context;
-    const root = createRoot({
-      logger: pluginManager.logger
-    });
-    const tree = this.parse({ schema, name });
-    const Component = () => /* @__PURE__ */ jsx(App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ jsx(Oas, { oas, children: /* @__PURE__ */ jsx(Oas.Schema, { name, value: schema, tree, children: /* @__PURE__ */ jsx(Schema.File, {}) }) }) });
-    Component.displayName = pascalCase(name);
-    root.render(/* @__PURE__ */ jsx(Component, {}));
-    return root.files;
-  }
-};
-function printCombinedSchema({
-  name,
-  operation,
-  schemas,
-  pluginManager
-}) {
+function printCombinedSchema({ name, schemas, pluginManager }) {
   const properties = {};
   if (schemas.response) {
     const identifier = pluginManager.resolveName({
@@ -2629,7 +2536,7 @@ function printCombinedSchema({
           return void 0;
         }
         return factory.createPropertySignature({
-          name: transformers4.pascalCase(key),
+          name: transformers2.pascalCase(key),
           type
         });
       }).filter(Boolean)
@@ -2638,60 +2545,101 @@ function printCombinedSchema({
   });
   return print([namespaceNode]);
 }
-function OperationSchema({ keysToOmit, description }) {
-  return /* @__PURE__ */ jsx(Schema, { keysToOmit, description });
-}
-OperationSchema.File = function({}) {
-  const { pluginManager, plugin, mode } = useApp();
-  const oas = useOas();
-  const { getSchemas, getFile, getName } = useOperationManager();
-  const operation = useOperation();
-  const file = getFile(operation);
-  const schemas = getSchemas(operation);
-  const factoryName = getName(operation, { type: "type" });
-  const generator = new SchemaGenerator2(plugin.options, {
-    oas,
-    plugin,
-    pluginManager,
-    mode,
-    override: plugin.options.override
-  });
-  const items = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response].flat().filter(Boolean);
-  const mapItem = ({ name, schema, description, keysToOmit, ...options }, i) => {
-    const tree = generator.parse({ schema, name });
-    return /* @__PURE__ */ jsxs(Oas.Schema, { name, value: schema, tree, children: [
-      mode === "split" && /* @__PURE__ */ jsx(Oas.Schema.Imports, { isTypeOnly: true }),
-      /* @__PURE__ */ jsx(OperationSchema, { description, keysToOmit })
-    ] }, i);
-  };
-  const combinedSchemaName = operation.method === "get" ? `${factoryName}Query` : `${factoryName}Mutation`;
-  return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
-    items.map(mapItem),
-    /* @__PURE__ */ jsx(File.Source, { name: combinedSchemaName, isExportable: true, isIndexable: true, isTypeOnly: true, children: printCombinedSchema({ name: combinedSchemaName, operation, schemas, pluginManager }) })
-  ] });
-};
-var OperationGenerator = class extends OperationGenerator$1 {
-  async all(operations) {
-    const { oas, pluginManager, plugin, mode } = this.context;
-    const root = createRoot({
-      logger: pluginManager.logger
+var typeGenerator = createReactGenerator({
+  name: "typescript",
+  Operation({ operation, options }) {
+    const { mapper, enumType, optionalType } = options;
+    const { plugin, pluginManager, mode } = useApp();
+    const oas = useOas();
+    const { getSchemas, getFile, getName } = useOperationManager();
+    const schemaManager = useSchemaManager();
+    const file = getFile(operation);
+    const schemas = getSchemas(operation);
+    const type = getName(operation, { type: "function", pluginKey: [pluginTsName] });
+    const combinedSchemaName = operation.method === "get" ? `${type}Query` : `${type}Mutation`;
+    const schemaGenerator = new SchemaGenerator(options, {
+      oas,
+      plugin,
+      pluginManager,
+      mode,
+      override: options.override
     });
-    const Component = () => /* @__PURE__ */ jsx(App, { pluginManager, plugin, mode, children: /* @__PURE__ */ jsx(Oas, { oas, operations, generator: this, children: plugin.options.oasType && /* @__PURE__ */ jsx(OasType.File, { name: "oas", typeName: "Oas" }) }) });
-    Component.displayName = pascalCase("operations");
-    root.render(/* @__PURE__ */ jsx(Component, {}));
-    return root.files;
+    const operationSchemas = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response].flat().filter(Boolean);
+    const mapOperationSchema = ({ name, schema, description, keysToOmit, ...options2 }, i) => {
+      const tree = schemaGenerator.parse({ schema, name });
+      const imports = schemaManager.getImports(tree);
+      const type2 = {
+        name: schemaManager.getName(name, { type: "type" }),
+        typedName: schemaManager.getName(name, { type: "type" }),
+        file: schemaManager.getFile(options2.operationName || name, { tag: options2.operation?.getTags()[0]?.name })
+      };
+      return /* @__PURE__ */ jsxs(Oas.Schema, { name, value: schema, tree, children: [
+        mode === "split" && imports.map((imp, index) => /* @__PURE__ */ jsx(File.Import, { root: file.path, path: imp.path, name: imp.name, isTypeOnly: true }, index)),
+        /* @__PURE__ */ jsx(
+          Type2,
+          {
+            name: type2.name,
+            typedName: type2.typedName,
+            description,
+            tree,
+            mapper,
+            enumType,
+            optionalType,
+            keysToOmit
+          }
+        )
+      ] }, i);
+    };
+    return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
+      operationSchemas.map(mapOperationSchema),
+      /* @__PURE__ */ jsx(File.Source, { name: combinedSchemaName, isExportable: true, isIndexable: true, isTypeOnly: true, children: printCombinedSchema({ name: combinedSchemaName, schemas, pluginManager }) })
+    ] });
+  },
+  Schema({ schema, options }) {
+    const { mapper, enumType, optionalType } = options;
+    const { mode } = useApp();
+    const { getName, getImports, getFile } = useSchemaManager();
+    const imports = getImports(schema.tree);
+    if (enumType === "asPascalConst") {
+      console.warn(`enumType '${enumType}' is deprecated`);
+    }
+    const type = {
+      name: getName(schema.name, { type: "function" }),
+      typedName: getName(schema.name, { type: "type" }),
+      file: getFile(schema.name)
+    };
+    return /* @__PURE__ */ jsxs(File, { baseName: type.file.baseName, path: type.file.path, meta: type.file.meta, children: [
+      mode === "split" && imports.map((imp, index) => /* @__PURE__ */ jsx(File.Import, { root: type.file.path, path: imp.path, name: imp.name, isTypeOnly: true }, index)),
+      /* @__PURE__ */ jsx(
+        Type2,
+        {
+          name: type.name,
+          typedName: type.typedName,
+          description: schema.value.description,
+          tree: schema.tree,
+          mapper,
+          enumType,
+          optionalType
+        }
+      )
+    ] });
   }
-  async operation(operation, options) {
-    const { oas, pluginManager, plugin, mode } = this.context;
-    const root = createRoot({
-      logger: pluginManager.logger
-    });
-    const Component = () => /* @__PURE__ */ jsx(App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ jsx(Oas, { oas, operations: [operation], generator: this, children: /* @__PURE__ */ jsx(Oas.Operation, { operation, children: /* @__PURE__ */ jsx(OperationSchema.File, {}) }) }) });
-    Component.displayName = pascalCase(operation.getOperationId());
-    root.render(/* @__PURE__ */ jsx(Component, {}));
-    return root.files;
+});
+
+// ../plugin-ts/src/generators/oasGenerator.tsx
+init_esm_shims();
+var oasGenerator = createReactGenerator({
+  name: "oas",
+  Operations() {
+    const { pluginManager, plugin } = useApp();
+    const oas = useOas();
+    const file = pluginManager.getFile({ name: "oas", extName: ".ts", pluginKey: plugin.key });
+    return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
+      /* @__PURE__ */ jsx(File.Import, { name: ["Infer"], path: "@kubb/oas", isTypeOnly: true }),
+      /* @__PURE__ */ jsx(OasType, { name: "oas", typeName: "Oas", api: oas.api })
+    ] });
   }
-};
+});
 
 // ../plugin-ts/src/plugin.ts
 var pluginTsName = "plugin-ts";
@@ -2707,7 +2655,7 @@ createPlugin((options) => {
     dateType = "string",
     unknownType = "any",
     optionalType = "questionToken",
-    transformers: transformers7 = {},
+    transformers: transformers4 = {},
     oasType = false,
     mapper = {}
   } = options;
@@ -2719,8 +2667,7 @@ createPlugin((options) => {
       ...output
     },
     options: {
-      extName: output.extName,
-      transformers: transformers7,
+      transformers: transformers4,
       dateType,
       optionalType,
       oasType,
@@ -2748,7 +2695,7 @@ createPlugin((options) => {
     resolveName(name, type) {
       const resolvedName = pascalCase(name, { isFile: type === "file" });
       if (type) {
-        return transformers7?.name?.(resolvedName, type) || resolvedName;
+        return transformers4?.name?.(resolvedName, type) || resolvedName;
       }
       return resolvedName;
     },
@@ -2757,7 +2704,7 @@ createPlugin((options) => {
       const oas = await swaggerPlugin.context.getOas();
       const root = path.resolve(this.config.root, this.config.output.path);
       const mode = FileManager.getMode(path.resolve(root, output.path));
-      const schemaGenerator = new SchemaGenerator2(this.plugin.options, {
+      const schemaGenerator = new SchemaGenerator(this.plugin.options, {
         oas,
         pluginManager: this.pluginManager,
         plugin: this.plugin,
@@ -2767,7 +2714,7 @@ createPlugin((options) => {
         mode,
         output: output.path
       });
-      const schemaFiles = await schemaGenerator.build();
+      const schemaFiles = await schemaGenerator.build(...[typeGenerator, oasType === "infer" ? oasGenerator : void 0].filter(Boolean));
       await this.addFile(...schemaFiles);
       const operationGenerator = new OperationGenerator(this.plugin.options, {
         oas,
@@ -2779,7 +2726,7 @@ createPlugin((options) => {
         override,
         mode
       });
-      const operationFiles = await operationGenerator.build();
+      const operationFiles = await operationGenerator.build(...[typeGenerator, oasType === "infer" ? oasGenerator : void 0].filter(Boolean));
       await this.addFile(...operationFiles);
       if (this.config.output.exportType) {
         const barrelFiles = await this.fileManager.getBarrelFiles({
@@ -2796,391 +2743,99 @@ createPlugin((options) => {
     }
   };
 });
-
-// src/parser/index.ts
-init_esm_shims();
-var zodKeywordMapper = {
-  any: () => "z.any()",
-  unknown: () => "z.unknown()",
-  number: (coercion, min, max) => {
-    return [coercion ? "z.coerce.number()" : "z.number()", min !== void 0 ? `.min(${min})` : void 0, max !== void 0 ? `.max(${max})` : void 0].filter(Boolean).join("");
-  },
-  integer: (coercion, min, max) => {
-    return [
-      coercion ? "z.coerce.number().int()" : "z.number().int()",
-      min !== void 0 ? `.min(${min})` : void 0,
-      max !== void 0 ? `.max(${max})` : void 0
-    ].filter(Boolean).join("");
-  },
-  object: (value) => `z.object({${value}})`,
-  string: (coercion, min, max) => {
-    return [coercion ? "z.coerce.string()" : "z.string()", min !== void 0 ? `.min(${min})` : void 0, max !== void 0 ? `.max(${max})` : void 0].filter(Boolean).join("");
-  },
-  boolean: () => "z.boolean()",
-  undefined: () => "z.undefined()",
-  nullable: () => ".nullable()",
-  null: () => "z.null()",
-  nullish: () => ".nullish()",
-  array: (items = [], min, max) => {
-    return [`z.array(${items?.join("")})`, min !== void 0 ? `.min(${min})` : void 0, max !== void 0 ? `.max(${max})` : void 0].filter(Boolean).join("");
-  },
-  tuple: (items = []) => `z.tuple([${items?.join(", ")}])`,
-  enum: (items = []) => `z.enum([${items?.join(", ")}])`,
-  union: (items = []) => `z.union([${items?.join(", ")}])`,
-  const: (value) => `z.literal(${value ?? ""})`,
-  /**
-   * ISO 8601
-   */
-  datetime: (offset = false, local = false) => {
-    if (offset) {
-      return `z.string().datetime({ offset: ${offset} })`;
-    }
-    if (local) {
-      return `z.string().datetime({ local: ${local} })`;
-    }
-    return "z.string().datetime()";
-  },
-  /**
-   * Type `'date'` Date
-   * Type `'string'` ISO date format (YYYY-MM-DD)
-   * @default ISO date format (YYYY-MM-DD)
-   */
-  date: (type = "string", coercion) => {
-    if (type === "string") {
-      return "z.string().date()";
-    }
-    if (coercion) {
-      return "z.coerce.date()";
-    }
-    return "z.date()";
-  },
-  /**
-   * Type `'date'` Date
-   * Type `'string'` ISO time format (HH:mm:ss[.SSSSSS])
-   * @default ISO time format (HH:mm:ss[.SSSSSS])
-   */
-  time: (type = "string", coercion) => {
-    if (type === "string") {
-      return "z.string().time()";
-    }
-    if (coercion) {
-      return "z.coerce.date()";
-    }
-    return "z.date()";
-  },
-  uuid: () => ".uuid()",
-  url: () => ".url()",
-  strict: () => ".strict()",
-  default: (value) => `.default(${value ?? ""})`,
-  and: (items = []) => items?.map((item) => `.and(${item})`).join(""),
-  describe: (value = "") => `.describe(${value})`,
-  min: (value) => `.min(${value ?? ""})`,
-  max: (value) => `.max(${value ?? ""})`,
-  optional: () => ".optional()",
-  matches: (value = "") => `.regex(${value})`,
-  email: () => ".email()",
-  firstName: void 0,
-  lastName: void 0,
-  password: void 0,
-  phone: void 0,
-  readOnly: void 0,
-  ref: (value) => value ? `z.lazy(() => ${value})` : void 0,
-  blob: () => "z.string()",
-  deprecated: void 0,
-  example: void 0,
-  schema: void 0,
-  catchall: (value) => value ? `.catchall(${value})` : void 0,
-  name: void 0
-};
-function sort(items) {
-  const order = [
-    schemaKeywords.string,
-    schemaKeywords.datetime,
-    schemaKeywords.date,
-    schemaKeywords.time,
-    schemaKeywords.tuple,
-    schemaKeywords.number,
-    schemaKeywords.object,
-    schemaKeywords.enum,
-    schemaKeywords.url,
-    schemaKeywords.email,
-    schemaKeywords.firstName,
-    schemaKeywords.lastName,
-    schemaKeywords.password,
-    schemaKeywords.matches,
-    schemaKeywords.uuid,
-    schemaKeywords.min,
-    schemaKeywords.max,
-    schemaKeywords.default,
-    schemaKeywords.describe,
-    schemaKeywords.optional,
-    schemaKeywords.nullable,
-    schemaKeywords.nullish,
-    schemaKeywords.null
-  ];
-  if (!items) {
-    return [];
-  }
-  return transformers4.orderBy(items, [(v) => order.indexOf(v.keyword)], ["asc"]);
-}
-function parse2(parent, current, options) {
-  const value = zodKeywordMapper[current.keyword];
-  if (!value) {
-    return void 0;
-  }
-  if (isKeyword(current, schemaKeywords.union)) {
-    if (Array.isArray(current.args) && current.args.length === 1) {
-      return parse2(parent, current.args[0], options);
-    }
-    if (Array.isArray(current.args) && !current.args.length) {
-      return "";
-    }
-    return zodKeywordMapper.union(
-      sort(current.args).map((schema) => parse2(current, schema, options)).filter(Boolean)
-    );
-  }
-  if (isKeyword(current, schemaKeywords.and)) {
-    const items = sort(current.args).filter((schema) => {
-      return ![schemaKeywords.optional, schemaKeywords.describe].includes(schema.keyword);
-    }).map((schema) => parse2(current, schema, options)).filter(Boolean);
-    return `${items.slice(0, 1)}${zodKeywordMapper.and(items.slice(1))}`;
-  }
-  if (isKeyword(current, schemaKeywords.array)) {
-    return zodKeywordMapper.array(
-      sort(current.args.items).map((schemas) => parse2(current, schemas, options)).filter(Boolean),
-      current.args.min,
-      current.args.max
-    );
-  }
-  if (isKeyword(current, schemaKeywords.enum)) {
-    if (current.args.asConst) {
-      return zodKeywordMapper.union(
-        current.args.items.map((schema) => {
-          return parse2(
-            current,
-            {
-              keyword: schemaKeywords.const,
-              args: schema
-            },
-            options
-          );
-        }).filter(Boolean)
-      );
-    }
-    return zodKeywordMapper.enum(
-      current.args.items.map((schema) => {
-        if (schema.format === "number") {
-          return transformers4.stringify(schema.value);
-        }
-        return transformers4.stringify(schema.value);
-      })
-    );
-  }
-  if (isKeyword(current, schemaKeywords.ref)) {
-    return zodKeywordMapper.ref(current.args?.name);
-  }
-  if (isKeyword(current, schemaKeywords.object)) {
-    const properties = Object.entries(current.args?.properties || {}).filter((item) => {
-      const schema = item[1];
-      return schema && typeof schema.map === "function";
-    }).map(([name, schemas]) => {
-      const nameSchema = schemas.find((schema) => schema.keyword === schemaKeywords.name);
-      const mappedName = nameSchema?.args || name;
-      if (options.mapper?.[mappedName]) {
-        return `"${name}": ${options.mapper?.[mappedName]}`;
-      }
-      return `"${name}": ${sort(schemas).map((schema, array) => {
-        return parse2(current, schema, options);
-      }).filter(Boolean).join("")}`;
-    }).join(",");
-    const additionalProperties = current.args?.additionalProperties?.length ? current.args.additionalProperties.map((schema) => parse2(current, schema, options)).filter(Boolean).at(0) : void 0;
-    const text = [
-      zodKeywordMapper.object(properties),
-      current.args?.strict ? zodKeywordMapper.strict() : void 0,
-      additionalProperties ? zodKeywordMapper.catchall(additionalProperties) : void 0
-    ].filter(Boolean);
-    return text.join("");
-  }
-  if (isKeyword(current, schemaKeywords.tuple)) {
-    return zodKeywordMapper.tuple(
-      sort(current.args.items).map((schema) => parse2(current, schema, options)).filter(Boolean)
-    );
-  }
-  if (isKeyword(current, schemaKeywords.const)) {
-    if (current.args.format === "number" && current.args.value !== void 0) {
-      return zodKeywordMapper.const(Number.parseInt(current.args.value?.toString()));
-    }
-    return zodKeywordMapper.const(transformers4.stringify(current.args.value));
-  }
-  if (isKeyword(current, schemaKeywords.matches)) {
-    if (current.args) {
-      return zodKeywordMapper.matches(transformers4.toRegExpString(current.args));
-    }
-  }
-  if (isKeyword(current, schemaKeywords.default)) {
-    if (current.args) {
-      return zodKeywordMapper.default(current.args);
-    }
-  }
-  if (isKeyword(current, schemaKeywords.describe)) {
-    if (current.args) {
-      return zodKeywordMapper.describe(transformers4.stringify(current.args.toString()));
-    }
-  }
-  if (isKeyword(current, schemaKeywords.string)) {
-    return zodKeywordMapper.string(options.coercion);
-  }
-  if (isKeyword(current, schemaKeywords.number)) {
-    return zodKeywordMapper.number(options.coercion);
-  }
-  if (isKeyword(current, schemaKeywords.integer)) {
-    return zodKeywordMapper.integer(options.coercion);
-  }
-  if (isKeyword(current, schemaKeywords.min)) {
-    return zodKeywordMapper.min(current.args);
-  }
-  if (isKeyword(current, schemaKeywords.max)) {
-    return zodKeywordMapper.max(current.args);
-  }
-  if (isKeyword(current, schemaKeywords.datetime)) {
-    return zodKeywordMapper.datetime(current.args.offset, current.args.local);
-  }
-  if (isKeyword(current, schemaKeywords.date)) {
-    return zodKeywordMapper.date(current.args.type, options.coercion);
-  }
-  if (isKeyword(current, schemaKeywords.time)) {
-    return zodKeywordMapper.time(current.args.type, options.coercion);
-  }
-  if (current.keyword in zodKeywordMapper && "args" in current) {
-    const value2 = zodKeywordMapper[current.keyword];
-    return value2(current.args);
-  }
-  if (current.keyword in zodKeywordMapper) {
-    return value();
-  }
-  return void 0;
-}
-
-// src/plugin.ts
-init_esm_shims();
-
-// src/SchemaGenerator.tsx
-init_esm_shims();
-
-// src/components/OperationSchema.tsx
-init_esm_shims();
-function OperationSchema2({ description, keysToOmit }) {
-  return /* @__PURE__ */ jsx(Schema2, { keysToOmit, withTypeAnnotation: false, description });
-}
-OperationSchema2.File = function({}) {
-  const { pluginManager, plugin, mode } = useApp();
-  const { getSchemas, getFile } = useOperationManager();
-  const oas = useOas();
-  const operation = useOperation();
-  const file = getFile(operation);
-  const schemas = getSchemas(operation);
-  const generator = new SchemaGenerator(plugin.options, {
-    oas,
-    plugin,
-    pluginManager,
-    mode,
-    override: plugin.options.override
-  });
-  const items = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response].flat().filter(Boolean);
-  const mapItem = ({ name, schema, description, keysToOmit, ...options }, i) => {
-    const required = Array.isArray(schema?.required) ? !!schema.required.length : !!schema?.required;
-    const optional = !required && !!name.includes("Params");
-    const tree = generator.parse({ schema, name });
-    return /* @__PURE__ */ jsxs(Oas.Schema, { name, value: schema, tree: [...tree, optional ? { keyword: schemaKeywords.optional } : void 0].filter(Boolean), children: [
-      mode === "split" && /* @__PURE__ */ jsx(Oas.Schema.Imports, { isTypeOnly: false }),
-      /* @__PURE__ */ jsx(OperationSchema2, { description, keysToOmit })
-    ] }, i);
-  };
-  return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
-    /* @__PURE__ */ jsx(File.Import, { name: ["z"], path: plugin.options.importPath }),
-    items.map(mapItem)
-  ] });
-};
-
-// src/components/Operations.tsx
-init_esm_shims();
-function Template2({ operationsName, pathsName, operations }) {
-  const { groupSchemasByName } = useOperationManager();
-  const transformedOperations = operations.map((operation) => ({ operation, data: groupSchemasByName(operation, { type: "function" }) }));
-  const operationsJSON = transformedOperations.reduce(
-    (prev, acc) => {
-      prev[`"${acc.operation.getOperationId()}"`] = acc.data;
-      return prev;
-    },
-    {}
-  );
-  const pathsJSON = transformedOperations.reduce(
-    (prev, acc) => {
-      prev[`"${acc.operation.path}"`] = {
-        ...prev[`"${acc.operation.path}"`] || {},
-        [acc.operation.method]: `operations["${acc.operation.getOperationId()}"]`
+var zodGenerator = createReactGenerator({
+  name: "zod",
+  Operation({ operation, options }) {
+    const { coercion, inferred, typed, mapper } = options;
+    const { plugin, pluginManager, mode } = useApp();
+    const oas = useOas();
+    const { getSchemas, getFile } = useOperationManager();
+    const schemaManager = useSchemaManager();
+    const file = getFile(operation);
+    const schemas = getSchemas(operation);
+    const schemaGenerator = new SchemaGenerator(options, {
+      oas,
+      plugin,
+      pluginManager,
+      mode,
+      override: options.override
+    });
+    const operationSchemas = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response].flat().filter(Boolean);
+    const mapOperationSchema = ({ name, schema, description, keysToOmit, ...options2 }, i) => {
+      const required = Array.isArray(schema?.required) ? !!schema.required.length : !!schema?.required;
+      const optional = !required && !!name.includes("Params");
+      const tree = [...schemaGenerator.parse({ schema, name }), optional ? { keyword: schemaKeywords.optional } : void 0].filter(Boolean);
+      const imports = schemaManager.getImports(tree);
+      const zod = {
+        name: schemaManager.getName(name, { type: "function" }),
+        inferTypeName: schemaManager.getName(name, { type: "type" }),
+        file: schemaManager.getFile(name)
       };
-      return prev;
-    },
-    {}
-  );
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(File.Source, { name: operationsName, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsx(Const, { export: true, name: operationsName, asConst: true, children: `{${transformers4.stringifyObject(operationsJSON)}}` }) }),
-    /* @__PURE__ */ jsx(File.Source, { name: pathsName, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsx(Const, { export: true, name: pathsName, asConst: true, children: `{${transformers4.stringifyObject(pathsJSON)}}` }) })
-  ] });
-}
-function RootTemplate({ children }) {
-  const {
-    mode,
-    pluginManager,
-    plugin: {
-      key: pluginKey,
-      options: { extName }
-    }
-  } = useApp();
-  const { getFile } = useOperationManager();
-  const operations = useOperations();
-  const { groupSchemasByName } = useOperationManager();
-  const transformedOperations = operations.map((operation) => ({ operation, data: groupSchemasByName(operation, { type: "function" }) }));
-  const file = pluginManager.getFile({ name: "operations", extName: ".ts", pluginKey });
-  const imports = Object.entries(transformedOperations).map(([key, { data, operation }]) => {
-    const names = [data.request, ...Object.values(data.responses), ...Object.values(data.parameters)].filter(Boolean);
-    return /* @__PURE__ */ jsx(File.Import, { name: names, root: file.path, path: getFile(operation).path }, key);
-  }).filter(Boolean);
-  return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
-    mode === "split" && imports,
-    children
-  ] });
-}
-var defaultTemplates2 = { default: Template2, root: RootTemplate };
-function Operations({ Template: Template3 = defaultTemplates2.default }) {
-  const operations = useOperations();
-  return /* @__PURE__ */ jsx(Template3, { operationsName: "operations", pathsName: "paths", operations });
-}
-Operations.File = function(props) {
-  const templates = { ...defaultTemplates2, ...props.templates };
-  const Template3 = templates.default;
-  const RootTemplate2 = templates.root;
-  return /* @__PURE__ */ jsx(RootTemplate2, { children: /* @__PURE__ */ jsx(Operations, { Template: Template3 }) });
-};
-Operations.templates = defaultTemplates2;
-var zodParser = createReactGenerator({
-  name: "plugin-zod",
-  Operations({ options }) {
-    if (!options.templates.operations) {
-      return null;
-    }
-    return /* @__PURE__ */ jsx(Operations.File, { templates: options.templates.operations });
-  },
-  Operation() {
-    return /* @__PURE__ */ jsx(OperationSchema2.File, {});
+      const type = {
+        name: schemaManager.getName(name, { type: "type", pluginKey: [pluginTsName] }),
+        file: schemaManager.getFile(options2.operationName || name, { pluginKey: [pluginTsName], tag: options2.operation?.getTags()[0]?.name })
+      };
+      return /* @__PURE__ */ jsxs(Oas.Schema, { name, value: schema, tree, children: [
+        typed && /* @__PURE__ */ jsx(File.Import, { isTypeOnly: true, root: file.path, path: type.file.path, name: [type.name] }),
+        imports.map((imp, index) => /* @__PURE__ */ jsx(File.Import, { root: file.path, path: imp.path, name: imp.name }, index)),
+        /* @__PURE__ */ jsx(
+          Zod,
+          {
+            name: zod.name,
+            typeName: typed ? type.name : void 0,
+            inferTypeName: inferred ? zod.inferTypeName : void 0,
+            description,
+            tree,
+            mapper,
+            coercion,
+            keysToOmit
+          }
+        )
+      ] }, i);
+    };
+    return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
+      /* @__PURE__ */ jsx(File.Import, { name: ["z"], path: plugin.options.importPath }),
+      operationSchemas.map(mapOperationSchema)
+    ] });
   },
-  Schema({ schema, name }) {
-    return /* @__PURE__ */ jsx(Schema2.File, {});
+  Schema({ schema, options }) {
+    const { coercion, inferred, typed, mapper, importPath } = options;
+    const { getName, getFile, getImports } = useSchemaManager();
+    const imports = getImports(schema.tree);
+    const zod = {
+      name: getName(schema.name, { type: "function" }),
+      inferTypeName: getName(schema.name, { type: "type" }),
+      file: getFile(schema.name)
+    };
+    const type = {
+      name: getName(schema.name, { type: "type", pluginKey: [pluginTsName] }),
+      file: getFile(schema.name, { pluginKey: [pluginTsName] })
+    };
+    return /* @__PURE__ */ jsxs(File, { baseName: zod.file.baseName, path: zod.file.path, meta: zod.file.meta, children: [
+      /* @__PURE__ */ jsx(File.Import, { name: ["z"], path: importPath }),
+      typed && /* @__PURE__ */ jsx(File.Import, { isTypeOnly: true, root: zod.file.path, path: type.file.path, name: [type.name] }),
+      imports.map((imp, index) => /* @__PURE__ */ jsx(File.Import, { root: zod.file.path, path: imp.path, name: imp.name }, index)),
+      /* @__PURE__ */ jsx(
+        Zod,
+        {
+          name: zod.name,
+          typeName: typed ? type.name : void 0,
+          inferTypeName: inferred ? zod.inferTypeName : void 0,
+          description: schema.value.description,
+          tree: schema.tree,
+          mapper,
+          coercion
+        }
+      )
+    ] });
   }
 });
 
+// src/generators/operationsGenerator.tsx
+init_esm_shims();
+
 // src/plugin.ts
+init_esm_shims();
 var pluginZodName = "plugin-zod";
 var pluginZod = createPlugin((options) => {
   const {
@@ -3189,15 +2844,15 @@ var pluginZod = createPlugin((options) => {
     exclude = [],
     include,
     override = [],
-    transformers: transformers7 = {},
+    transformers: transformers4 = {},
     dateType = "string",
     unknownType = "any",
     typed = false,
-    typedSchema = false,
     mapper = {},
-    templates,
+    operations = false,
     importPath = "zod",
-    coercion = false
+    coercion = false,
+    inferred = false
   } = options;
   const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`;
   return {
@@ -3208,21 +2863,18 @@ var pluginZod = createPlugin((options) => {
     },
     options: {
       extName: output.extName,
-      transformers: transformers7,
+      transformers: transformers4,
       include,
       exclude,
       override,
       typed,
-      typedSchema,
       dateType,
       unknownType,
       mapper,
       importPath,
       coercion,
-      templates: {
-        operations: Operations.templates,
-        ...templates
-      }
+      operations,
+      inferred
     },
     pre: [pluginOasName, typed ? pluginTsName : void 0].filter(Boolean),
     resolvePath(baseName, pathMode, options2) {
@@ -3246,7 +2898,7 @@ var pluginZod = createPlugin((options) => {
         resolvedName = pascalCase(resolvedName);
       }
       if (type) {
-        return transformers7?.name?.(resolvedName, type) || resolvedName;
+        return transformers4?.name?.(resolvedName, type) || resolvedName;
       }
       return resolvedName;
     },
@@ -3265,9 +2917,9 @@ var pluginZod = createPlugin((options) => {
         mode,
         output: output.path
       });
-      const schemaFiles = await schemaGenerator.build(zodParser);
+      const schemaFiles = await schemaGenerator.build(...[zodGenerator, operations ? operationsGenerator : void 0].filter(Boolean));
       await this.addFile(...schemaFiles);
-      const operationGenerator = new OperationGenerator$1(this.plugin.options, {
+      const operationGenerator = new OperationGenerator(this.plugin.options, {
         oas,
         pluginManager: this.pluginManager,
         plugin: this.plugin,
@@ -3277,7 +2929,7 @@ var pluginZod = createPlugin((options) => {
         override,
         mode
       });
-      const operationFiles = await operationGenerator.build(zodParser);
+      const operationFiles = await operationGenerator.build(...[zodGenerator, operations ? operationsGenerator : void 0].filter(Boolean));
       await this.addFile(...operationFiles);
       if (this.config.output.exportType) {
         const barrelFiles = await this.fileManager.getBarrelFiles({
@@ -3294,113 +2946,24 @@ var pluginZod = createPlugin((options) => {
     }
   };
 });
-function Schema2(props) {
-  const { keysToOmit, withTypeAnnotation, description } = props;
-  const { tree, name } = useSchema();
-  const {
-    pluginManager,
-    plugin: {
-      options: { mapper, typedSchema, coercion }
-    }
-  } = useApp();
-  const resolvedName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginZodName],
-    type: "function"
-  });
-  const resolvedTypeName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginZodName],
-    type: "type"
-  });
-  const typeName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: "type"
-  });
-  if (!tree.length) {
-    return /* @__PURE__ */ jsx(File.Source, { name: resolvedName, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsx(
-      Const,
-      {
-        name: resolvedName,
-        export: true,
-        JSDoc: {
-          comments: [description ? `@description ${transformers4.jsStringEscape(description)}` : void 0].filter(Boolean)
-        },
-        children: "undefined"
-      }
-    ) });
+var operationsGenerator = createReactGenerator({
+  name: "operations",
+  Operations({ operations, options }) {
+    const { pluginManager } = useApp();
+    const { getFile, groupSchemasByName } = useOperationManager();
+    const name = "operations";
+    const file = pluginManager.getFile({ name, extName: ".ts", pluginKey: [pluginZodName] });
+    const transformedOperations = operations.map((operation) => ({ operation, data: groupSchemasByName(operation, { type: "function" }) }));
+    const imports = Object.entries(transformedOperations).map(([key, { data, operation }]) => {
+      const names = [data.request, ...Object.values(data.responses), ...Object.values(data.parameters)].filter(Boolean);
+      return /* @__PURE__ */ jsx(File.Import, { name: names, root: file.path, path: getFile(operation).path }, key);
+    }).filter(Boolean);
+    return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
+      imports,
+      /* @__PURE__ */ jsx(Operations, { name, operations: transformedOperations })
+    ] });
   }
-  const hasTuple = tree.some((item) => isKeyword(item, schemaKeywords.tuple));
-  const output = sort(tree).filter((item) => {
-    if (hasTuple && (isKeyword(item, schemaKeywords.min) || isKeyword(item, schemaKeywords.max))) {
-      return false;
-    }
-    return true;
-  }).map((item) => parse2(void 0, item, { name, typeName, description, mapper, coercion, keysToOmit })).filter(Boolean).join("");
-  const suffix = output.endsWith(".nullable()") ? ".unwrap().and" : ".and";
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(File.Source, { name: resolvedName, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsx(
-      Const,
-      {
-        export: true,
-        name: resolvedName,
-        JSDoc: {
-          comments: [description ? `@description ${transformers4.jsStringEscape(description)}` : void 0].filter(Boolean)
-        },
-        children: [
-          output,
-          keysToOmit?.length ? `${suffix}(z.object({ ${keysToOmit.map((key) => `${key}: z.never()`).join(",")} }))` : void 0,
-          withTypeAnnotation && typeName ? ` as z.ZodType<${typeName}>` : ""
-        ].filter(Boolean).join("") || ""
-      }
-    ) }),
-    typedSchema && /* @__PURE__ */ jsx(File.Source, { name: resolvedTypeName, isExportable: true, isIndexable: true, isTypeOnly: true, children: /* @__PURE__ */ jsx(Type, { export: true, name: resolvedTypeName, children: `z.infer<typeof ${resolvedName}>` }) })
-  ] });
-}
-Schema2.File = function({}) {
-  const {
-    pluginManager,
-    plugin: {
-      options: { typed }
-    }
-  } = useApp();
-  const { schema } = useSchema();
-  const withTypeAnnotation = !!typed;
-  return /* @__PURE__ */ jsxs(Oas.Schema.File, { output: pluginManager.config.output.path, children: [
-    /* @__PURE__ */ jsx(Schema2.Imports, {}),
-    /* @__PURE__ */ jsx(Schema2, { withTypeAnnotation, description: schema?.description })
-  ] });
-};
-Schema2.Imports = () => {
-  const {
-    pluginManager,
-    plugin: {
-      options: { typed, importPath }
-    }
-  } = useApp();
-  const { path: root } = useFile();
-  const { name, tree, schema } = useSchema();
-  const typeName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: "type"
-  });
-  const typeFileName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: "file"
-  });
-  const typePath = pluginManager.resolvePath({
-    baseName: typeFileName,
-    pluginKey: [pluginTsName]
-  });
-  const withTypeAnnotation = !!typed;
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(File.Import, { name: ["z"], path: importPath }),
-    withTypeAnnotation && typeName && typePath && /* @__PURE__ */ jsx(File.Import, { isTypeOnly: true, root, path: typePath, name: [typeName] })
-  ] });
-};
+});
 /*! Bundled license information:
 
 react/cjs/react.production.min.js:
@@ -3426,6 +2989,6 @@ react/cjs/react.development.js:
    *)
 */
 
-export { OperationSchema2 as OperationSchema, Operations, Schema2 as Schema, init_esm_shims, pluginZod, pluginZodName };
-//# sourceMappingURL=chunk-BDYQNKJC.js.map
-//# sourceMappingURL=chunk-BDYQNKJC.js.map
+export { operationsGenerator, pluginZod, pluginZodName, zodGenerator };
+//# sourceMappingURL=chunk-ORFIAMY6.js.map
+//# sourceMappingURL=chunk-ORFIAMY6.js.map