@kubb/plugin-zod 3.0.0-alpha.10 → 3.0.0-alpha.12

package/dist/{chunk-CUPQVLRZ.js → chunk-BWE5OHCP.js}

@@ -1,3 +1,15 @@
+import { Oas } from '@kubb/plugin-oas/components';
+import { useApp, File, Const, Type, useFile, createRoot, App } from '@kubb/react';
+import path from 'node:path';
+import { createPlugin, FileManager, PluginManager } from '@kubb/core';
+import transformers4, { 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 { 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;
@@ -23,21 +35,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   // 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.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  __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.2__jiti@1.21.6_postcss@8.4.41_typescript@5.5.4_yaml@2.4.5/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.2.4_@microsoft+api-extractor@7.47.7_@types+node@20.16.2__@swc+core@1.7.22_jiti@1.21.6__vls2oipdlkyfowb7gcil3cs6ye/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.2__jiti@1.21.6_postcss@8.4.41_typescript@5.5.4_yaml@2.4.5/node_modules/tsup/assets/esm_shims.js"() {
-    "use strict";
+  "../../node_modules/.pnpm/tsup@8.2.4_@microsoft+api-extractor@7.47.7_@types+node@20.16.2__@swc+core@1.7.22_jiti@1.21.6__vls2oipdlkyfowb7gcil3cs6ye/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) {
-    "use strict";
     init_esm_shims();
     var l = Symbol.for("react.element");
     var n = Symbol.for("react.portal");
@@ -311,11 +321,9 @@ var require_react_production_min = __commonJS({
 // ../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.development.js
 var require_react_development = __commonJS({
   "../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.development.js"(exports, module) {
-    "use strict";
     init_esm_shims();
     if (process.env.NODE_ENV !== "production") {
       (function() {
-        "use strict";
         if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
           __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
         }
@@ -2186,7 +2194,6 @@ var require_react_development = __commonJS({
 // ../../node_modules/.pnpm/react@18.3.1/node_modules/react/index.js
 var require_react = __commonJS({
   "../../node_modules/.pnpm/react@18.3.1/node_modules/react/index.js"(exports, module) {
-    "use strict";
     init_esm_shims();
     if (process.env.NODE_ENV === "production") {
       module.exports = require_react_production_min();
@@ -2198,31 +2205,18 @@ var require_react = __commonJS({
 
 // src/components/Schema.tsx
 init_esm_shims();
-import { Oas as Oas6 } from "@kubb/plugin-oas/components";
-import { Const as Const2, File as File6, Type as Type2, useApp as useApp6, useFile } from "@kubb/react";
 
 // ../plugin-ts/src/index.ts
 init_esm_shims();
 
 // ../plugin-ts/src/plugin.ts
 init_esm_shims();
-import path from "node:path";
-import { FileManager, PluginManager, createPlugin } from "@kubb/core";
-import { camelCase, pascalCase } from "@kubb/core/transformers";
-import { renderTemplate } from "@kubb/core/utils";
-import { pluginOasName } from "@kubb/plugin-oas";
 
 // ../plugin-ts/src/OperationGenerator.tsx
 init_esm_shims();
-import { OperationGenerator as Generator2 } from "@kubb/plugin-oas";
-import { Oas as Oas4 } from "@kubb/plugin-oas/components";
-import { App as App2, createRoot as createRoot2 } from "@kubb/react";
 
 // ../plugin-ts/src/components/OasType.tsx
 init_esm_shims();
-import { useOas } from "@kubb/plugin-oas/hooks";
-import { File, Type, useApp } from "@kubb/react";
-import { Fragment, jsx, jsxs } from "@kubb/react/jsx-runtime";
 function Template({ 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` }),
@@ -2251,35 +2245,16 @@ OasType.templates = defaultTemplates;
 
 // ../plugin-ts/src/components/OperationSchema.tsx
 init_esm_shims();
-import transformers3 from "@kubb/core/transformers";
-import { print as print2 } from "@kubb/parser-ts";
-import * as factory3 from "@kubb/parser-ts/factory";
-import { Oas as Oas3 } from "@kubb/plugin-oas/components";
-import { useOas as useOas2, useOperation, useOperationManager } from "@kubb/plugin-oas/hooks";
-import { File as File3, useApp as useApp3 } from "@kubb/react";
 
 // ../plugin-ts/src/SchemaGenerator.tsx
 init_esm_shims();
-import { SchemaGenerator as Generator } from "@kubb/plugin-oas";
-import { Oas as Oas2 } from "@kubb/plugin-oas/components";
-import { App, createRoot } from "@kubb/react";
 
 // ../plugin-ts/src/components/Schema.tsx
 init_esm_shims();
-var import_react3 = __toESM(require_react(), 1);
-import { Oas } from "@kubb/plugin-oas/components";
-import { File as File2, useApp as useApp2 } from "@kubb/react";
-import transformers2 from "@kubb/core/transformers";
-import { print } from "@kubb/parser-ts";
-import * as factory2 from "@kubb/parser-ts/factory";
-import { SchemaGenerator, schemaKeywords as schemaKeywords2 } from "@kubb/plugin-oas";
-import { useSchema } from "@kubb/plugin-oas/hooks";
+var import_react3 = __toESM(require_react());
 
 // ../plugin-ts/src/parser/index.ts
 init_esm_shims();
-import transformers from "@kubb/core/transformers";
-import * as factory from "@kubb/parser-ts/factory";
-import { isKeyword, schemaKeywords } from "@kubb/plugin-oas";
 var typeKeywordMapper = {
   any: () => factory.keywordTypeNodes.any,
   unknown: () => factory.keywordTypeNodes.unknown,
@@ -2446,7 +2421,7 @@ function parse(parent, current, options) {
       return factory.appendJSDocToNode({
         node: propertySignature,
         comments: [
-          describeSchema ? `@description ${transformers.jsStringEscape(describeSchema.args)}` : void 0,
+          describeSchema ? `@description ${transformers4.jsStringEscape(describeSchema.args)}` : void 0,
           deprecatedSchema ? "@deprecated" : void 0,
           defaultSchema ? `@default ${defaultSchema.args}` : void 0,
           exampleSchema ? `@example ${exampleSchema.args}` : void 0,
@@ -2473,9 +2448,6 @@ function parse(parent, current, options) {
   }
   return void 0;
 }
-
-// ../plugin-ts/src/components/Schema.tsx
-import { jsx as jsx2, jsxs as jsxs2 } from "@kubb/react/jsx-runtime";
 function Schema(props) {
   const { keysToOmit, description } = props;
   const { tree, name } = useSchema();
@@ -2484,7 +2456,7 @@ function Schema(props) {
     plugin: {
       options: { mapper, enumType, optionalType }
     }
-  } = useApp2();
+  } = useApp();
   if (enumType === "asPascalConst") {
     pluginManager.logger.emit("warning", `enumType '${enumType}' is deprecated`);
   }
@@ -2502,9 +2474,9 @@ function Schema(props) {
   if (!tree.length) {
     return "";
   }
-  const isNullish = tree.some((item) => item.keyword === schemaKeywords2.nullish);
-  const isNullable = tree.some((item) => item.keyword === schemaKeywords2.nullable);
-  const isOptional = tree.some((item) => item.keyword === schemaKeywords2.optional);
+  const isNullish = tree.some((item) => item.keyword === schemaKeywords.nullish);
+  const isNullable = tree.some((item) => item.keyword === schemaKeywords.nullable);
+  const isOptional = tree.some((item) => item.keyword === schemaKeywords.optional);
   let type = tree.map(
     (schema) => parse(void 0, schema, {
       name: resolvedName,
@@ -2517,37 +2489,37 @@ function Schema(props) {
     })
   ).filter(Boolean).at(0) || typeKeywordMapper.undefined();
   if (isNullable) {
-    type = factory2.createUnionDeclaration({
-      nodes: [type, factory2.keywordTypeNodes.null]
+    type = factory.createUnionDeclaration({
+      nodes: [type, factory.keywordTypeNodes.null]
     });
   }
   if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
-    type = factory2.createUnionDeclaration({
-      nodes: [type, factory2.keywordTypeNodes.undefined]
+    type = factory.createUnionDeclaration({
+      nodes: [type, factory.keywordTypeNodes.undefined]
     });
   }
   if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
-    type = factory2.createUnionDeclaration({
-      nodes: [type, factory2.keywordTypeNodes.undefined]
+    type = factory.createUnionDeclaration({
+      nodes: [type, factory.keywordTypeNodes.undefined]
     });
   }
-  const node = factory2.createTypeAliasDeclaration({
-    modifiers: [factory2.modifiers.export],
+  const node = factory.createTypeAliasDeclaration({
+    modifiers: [factory.modifiers.export],
     name: resolvedName,
-    type: keysToOmit?.length ? factory2.createOmitDeclaration({
+    type: keysToOmit?.length ? factory.createOmitDeclaration({
       keys: keysToOmit,
       type,
       nonNullable: true
     }) : type
   });
-  const enumSchemas = SchemaGenerator.deepSearch(tree, schemaKeywords2.enum);
+  const enumSchemas = SchemaGenerator.deepSearch(tree, schemaKeywords.enum);
   const enums = enumSchemas.map((enumSchema) => {
-    const name2 = enumType === "asPascalConst" ? transformers2.pascalCase(enumSchema.args.name) : transformers2.camelCase(enumSchema.args.name);
+    const name2 = enumType === "asPascalConst" ? transformers4.pascalCase(enumSchema.args.name) : transformers4.camelCase(enumSchema.args.name);
     const typeName2 = enumSchema.args.typeName;
-    const [nameNode, typeNode] = factory2.createEnumDeclaration({
+    const [nameNode, typeNode] = factory.createEnumDeclaration({
       name: name2,
       typeName: typeName2,
-      enums: enumSchema.args.items.map((item) => item.value === void 0 ? void 0 : [transformers2.trimQuotes(item.name?.toString()), item.value]).filter(Boolean),
+      enums: enumSchema.args.items.map((item) => item.value === void 0 ? void 0 : [transformers4.trimQuotes(item.name?.toString()), item.value]).filter(Boolean),
       type: enumType
     });
     return {
@@ -2558,43 +2530,37 @@ function Schema(props) {
     };
   });
   typeNodes.push(
-    factory2.appendJSDocToNode({
+    factory.appendJSDocToNode({
       node,
-      comments: [description ? `@description ${transformers2.jsStringEscape(description)}` : void 0].filter(Boolean)
+      comments: [description ? `@description ${transformers4.jsStringEscape(description)}` : void 0].filter(Boolean)
     })
   );
-  return /* @__PURE__ */ jsxs2(import_react3.Fragment, { children: [
-    enums.map(({ name: name2, nameNode, typeName: typeName2, typeNode }, index) => /* @__PURE__ */ jsxs2(import_react3.Fragment, { children: [
-      nameNode && /* @__PURE__ */ jsx2(File2.Source, { name: name2, isExportable: true, isIndexable: true, children: print(nameNode) }),
-      /* @__PURE__ */ jsx2(File2.Source, { name: typeName2, isIndexable: true, isExportable: ["enum", "asConst", "constEnum", "literal", void 0].includes(enumType), isTypeOnly: true, children: print(typeNode) })
+  return /* @__PURE__ */ jsxs(import_react3.Fragment, { children: [
+    enums.map(({ name: name2, nameNode, typeName: typeName2, 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) })
     ] }, [name2, nameNode].join("-"))),
-    enums.every((item) => item.typeName !== resolvedName) && /* @__PURE__ */ jsx2(File2.Source, { name: typeName, isTypeOnly: true, isExportable: true, isIndexable: true, children: print(typeNodes) })
+    enums.every((item) => item.typeName !== resolvedName) && /* @__PURE__ */ jsx(File.Source, { name: typeName, isTypeOnly: true, isExportable: true, isIndexable: true, children: print(typeNodes) })
   ] });
 }
 Schema.File = function({}) {
-  const { pluginManager } = useApp2();
+  const { pluginManager } = useApp();
   const { schema } = useSchema();
-  return /* @__PURE__ */ jsx2(Oas.Schema.File, { isTypeOnly: true, output: pluginManager.config.output.path, children: /* @__PURE__ */ jsx2(Schema, { description: schema?.description }) });
+  return /* @__PURE__ */ jsx(Oas.Schema.File, { isTypeOnly: true, output: pluginManager.config.output.path, children: /* @__PURE__ */ jsx(Schema, { description: schema?.description }) });
 };
-
-// ../plugin-ts/src/SchemaGenerator.tsx
-import { jsx as jsx3 } from "@kubb/react/jsx-runtime";
-var SchemaGenerator2 = class extends Generator {
+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 });
-    root.render(
-      /* @__PURE__ */ jsx3(App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ jsx3(Oas2, { oas, children: /* @__PURE__ */ jsx3(Oas2.Schema, { name, value: schema, tree, children: /* @__PURE__ */ jsx3(Schema.File, {}) }) }) })
-    );
+    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;
   }
 };
-
-// ../plugin-ts/src/components/OperationSchema.tsx
-import { jsx as jsx4, jsxs as jsxs3 } from "@kubb/react/jsx-runtime";
 function printCombinedSchema({
   name,
   operation,
@@ -2608,7 +2574,7 @@ function printCombinedSchema({
       pluginKey: [pluginTsName],
       type: "function"
     });
-    properties["response"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
+    properties["response"] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), void 0);
   }
   if (schemas.request) {
     const identifier = pluginManager.resolveName({
@@ -2616,7 +2582,7 @@ function printCombinedSchema({
       pluginKey: [pluginTsName],
       type: "function"
     });
-    properties["request"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
+    properties["request"] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), void 0);
   }
   if (schemas.pathParams) {
     const identifier = pluginManager.resolveName({
@@ -2624,7 +2590,7 @@ function printCombinedSchema({
       pluginKey: [pluginTsName],
       type: "function"
     });
-    properties["pathParams"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
+    properties["pathParams"] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), void 0);
   }
   if (schemas.queryParams) {
     const identifier = pluginManager.resolveName({
@@ -2632,7 +2598,7 @@ function printCombinedSchema({
       pluginKey: [pluginTsName],
       type: "function"
     });
-    properties["queryParams"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
+    properties["queryParams"] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), void 0);
   }
   if (schemas.headerParams) {
     const identifier = pluginManager.resolveName({
@@ -2640,44 +2606,44 @@ function printCombinedSchema({
       pluginKey: [pluginTsName],
       type: "function"
     });
-    properties["headerParams"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
+    properties["headerParams"] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), void 0);
   }
   if (schemas.errors) {
-    properties["errors"] = factory3.createUnionDeclaration({
+    properties["errors"] = factory.createUnionDeclaration({
       nodes: schemas.errors.map((error) => {
         const identifier = pluginManager.resolveName({
           name: error.name,
           pluginKey: [pluginTsName],
           type: "function"
         });
-        return factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
+        return factory.createTypeReferenceNode(factory.createIdentifier(identifier), void 0);
       })
     });
   }
-  const namespaceNode = factory3.createTypeAliasDeclaration({
+  const namespaceNode = factory.createTypeAliasDeclaration({
     name,
-    type: factory3.createTypeLiteralNode(
+    type: factory.createTypeLiteralNode(
       Object.keys(properties).map((key) => {
         const type = properties[key];
         if (!type) {
           return void 0;
         }
-        return factory3.createPropertySignature({
-          name: transformers3.pascalCase(key),
+        return factory.createPropertySignature({
+          name: transformers4.pascalCase(key),
           type
         });
       }).filter(Boolean)
     ),
-    modifiers: [factory3.modifiers.export]
+    modifiers: [factory.modifiers.export]
   });
-  return print2(namespaceNode);
+  return print(namespaceNode);
 }
 function OperationSchema({ keysToOmit, description }) {
-  return /* @__PURE__ */ jsx4(Schema, { keysToOmit, description });
+  return /* @__PURE__ */ jsx(Schema, { keysToOmit, description });
 }
 OperationSchema.File = function({}) {
-  const { pluginManager, plugin, mode } = useApp3();
-  const oas = useOas2();
+  const { pluginManager, plugin, mode } = useApp();
+  const oas = useOas();
   const { getSchemas, getFile, getName } = useOperationManager();
   const operation = useOperation();
   const file = getFile(operation);
@@ -2693,46 +2659,43 @@ OperationSchema.File = function({}) {
   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__ */ jsxs3(Oas3.Schema, { name, value: schema, tree, children: [
-      mode === "split" && /* @__PURE__ */ jsx4(Oas3.Schema.Imports, { isTypeOnly: true }),
-      /* @__PURE__ */ jsx4(OperationSchema, { description, keysToOmit })
+    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__ */ jsxs3(File3, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
+  return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
     items.map(mapItem),
-    /* @__PURE__ */ jsx4(File3.Source, { name: combinedSchemaName, isExportable: true, isIndexable: true, isTypeOnly: true, children: printCombinedSchema({ name: combinedSchemaName, operation, schemas, pluginManager }) })
+    /* @__PURE__ */ jsx(File.Source, { name: combinedSchemaName, isExportable: true, isIndexable: true, isTypeOnly: true, children: printCombinedSchema({ name: combinedSchemaName, operation, schemas, pluginManager }) })
   ] });
 };
-
-// ../plugin-ts/src/OperationGenerator.tsx
-import { jsx as jsx5 } from "@kubb/react/jsx-runtime";
-var OperationGenerator = class extends Generator2 {
+var OperationGenerator = class extends OperationGenerator$1 {
   async all(operations) {
     const { oas, pluginManager, plugin, mode } = this.context;
-    const root = createRoot2({
+    const root = createRoot({
       logger: pluginManager.logger
     });
-    root.render(
-      /* @__PURE__ */ jsx5(App2, { pluginManager, plugin, mode, children: /* @__PURE__ */ jsx5(Oas4, { oas, operations, generator: this, children: plugin.options.oasType && /* @__PURE__ */ jsx5(OasType.File, { name: "oas", typeName: "Oas" }) }) })
-    );
+    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;
   }
   async operation(operation, options) {
     const { oas, pluginManager, plugin, mode } = this.context;
-    const root = createRoot2({
+    const root = createRoot({
       logger: pluginManager.logger
     });
-    root.render(
-      /* @__PURE__ */ jsx5(App2, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ jsx5(Oas4, { oas, operations: [operation], generator: this, children: /* @__PURE__ */ jsx5(Oas4.Operation, { operation, children: /* @__PURE__ */ jsx5(OperationSchema.File, {}) }) }) })
-    );
+    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/plugin.ts
 var pluginTsName = "plugin-ts";
-var pluginTs = createPlugin((options) => {
+createPlugin((options) => {
   const {
     output = { path: "types" },
     group,
@@ -2834,15 +2797,8 @@ var pluginTs = createPlugin((options) => {
   };
 });
 
-// src/components/Schema.tsx
-import transformers6 from "@kubb/core/transformers";
-import { isKeyword as isKeyword3, schemaKeywords as schemaKeywords5 } from "@kubb/plugin-oas";
-import { useSchema as useSchema2 } from "@kubb/plugin-oas/hooks";
-
 // src/parser/index.ts
 init_esm_shims();
-import transformers4 from "@kubb/core/transformers";
-import { isKeyword as isKeyword2, schemaKeywords as schemaKeywords3 } from "@kubb/plugin-oas";
 var zodKeywordMapper = {
   any: () => "z.any()",
   unknown: () => "z.unknown()",
@@ -2938,29 +2894,29 @@ var zodKeywordMapper = {
 };
 function sort(items) {
   const order = [
-    schemaKeywords3.string,
-    schemaKeywords3.datetime,
-    schemaKeywords3.date,
-    schemaKeywords3.time,
-    schemaKeywords3.tuple,
-    schemaKeywords3.number,
-    schemaKeywords3.object,
-    schemaKeywords3.enum,
-    schemaKeywords3.url,
-    schemaKeywords3.email,
-    schemaKeywords3.firstName,
-    schemaKeywords3.lastName,
-    schemaKeywords3.password,
-    schemaKeywords3.matches,
-    schemaKeywords3.uuid,
-    schemaKeywords3.min,
-    schemaKeywords3.max,
-    schemaKeywords3.default,
-    schemaKeywords3.describe,
-    schemaKeywords3.optional,
-    schemaKeywords3.nullable,
-    schemaKeywords3.nullish,
-    schemaKeywords3.null
+    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 [];
@@ -2972,7 +2928,7 @@ function parse2(parent, current, options) {
   if (!value) {
     return void 0;
   }
-  if (isKeyword2(current, schemaKeywords3.union)) {
+  if (isKeyword(current, schemaKeywords.union)) {
     if (Array.isArray(current.args) && current.args.length === 1) {
       return parse2(parent, current.args[0], options);
     }
@@ -2983,27 +2939,27 @@ function parse2(parent, current, options) {
       sort(current.args).map((schema) => parse2(current, schema, options)).filter(Boolean)
     );
   }
-  if (isKeyword2(current, schemaKeywords3.and)) {
+  if (isKeyword(current, schemaKeywords.and)) {
     const items = sort(current.args).filter((schema) => {
-      return ![schemaKeywords3.optional, schemaKeywords3.describe].includes(schema.keyword);
+      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 (isKeyword2(current, schemaKeywords3.array)) {
+  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 (isKeyword2(current, schemaKeywords3.enum)) {
+  if (isKeyword(current, schemaKeywords.enum)) {
     if (current.args.asConst) {
       return zodKeywordMapper.union(
         current.args.items.map((schema) => {
           return parse2(
             current,
             {
-              keyword: schemaKeywords3.const,
+              keyword: schemaKeywords.const,
               args: schema
             },
             options
@@ -3020,15 +2976,15 @@ function parse2(parent, current, options) {
       })
     );
   }
-  if (isKeyword2(current, schemaKeywords3.ref)) {
+  if (isKeyword(current, schemaKeywords.ref)) {
     return zodKeywordMapper.ref(current.args?.name);
   }
-  if (isKeyword2(current, schemaKeywords3.object)) {
+  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 === schemaKeywords3.name);
+      const nameSchema = schemas.find((schema) => schema.keyword === schemaKeywords.name);
       const mappedName = nameSchema?.args || name;
       if (options.mapper?.[mappedName]) {
         return `"${name}": ${options.mapper?.[mappedName]}`;
@@ -3045,54 +3001,54 @@ function parse2(parent, current, options) {
     ].filter(Boolean);
     return text.join("");
   }
-  if (isKeyword2(current, schemaKeywords3.tuple)) {
+  if (isKeyword(current, schemaKeywords.tuple)) {
     return zodKeywordMapper.tuple(
       sort(current.args.items).map((schema) => parse2(current, schema, options)).filter(Boolean)
     );
   }
-  if (isKeyword2(current, schemaKeywords3.const)) {
+  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 (isKeyword2(current, schemaKeywords3.matches)) {
+  if (isKeyword(current, schemaKeywords.matches)) {
     if (current.args) {
       return zodKeywordMapper.matches(transformers4.toRegExpString(current.args));
     }
   }
-  if (isKeyword2(current, schemaKeywords3.default)) {
+  if (isKeyword(current, schemaKeywords.default)) {
     if (current.args) {
       return zodKeywordMapper.default(current.args);
     }
   }
-  if (isKeyword2(current, schemaKeywords3.describe)) {
+  if (isKeyword(current, schemaKeywords.describe)) {
     if (current.args) {
       return zodKeywordMapper.describe(transformers4.stringify(current.args.toString()));
     }
   }
-  if (isKeyword2(current, schemaKeywords3.string)) {
+  if (isKeyword(current, schemaKeywords.string)) {
     return zodKeywordMapper.string(options.coercion);
   }
-  if (isKeyword2(current, schemaKeywords3.number)) {
+  if (isKeyword(current, schemaKeywords.number)) {
     return zodKeywordMapper.number(options.coercion);
   }
-  if (isKeyword2(current, schemaKeywords3.integer)) {
+  if (isKeyword(current, schemaKeywords.integer)) {
     return zodKeywordMapper.integer(options.coercion);
   }
-  if (isKeyword2(current, schemaKeywords3.min)) {
+  if (isKeyword(current, schemaKeywords.min)) {
     return zodKeywordMapper.min(current.args);
   }
-  if (isKeyword2(current, schemaKeywords3.max)) {
+  if (isKeyword(current, schemaKeywords.max)) {
     return zodKeywordMapper.max(current.args);
   }
-  if (isKeyword2(current, schemaKeywords3.datetime)) {
+  if (isKeyword(current, schemaKeywords.datetime)) {
     return zodKeywordMapper.datetime(current.args.offset, current.args.local);
   }
-  if (isKeyword2(current, schemaKeywords3.date)) {
+  if (isKeyword(current, schemaKeywords.date)) {
     return zodKeywordMapper.date(current.args.type, options.coercion);
   }
-  if (isKeyword2(current, schemaKeywords3.time)) {
+  if (isKeyword(current, schemaKeywords.time)) {
     return zodKeywordMapper.time(current.args.type, options.coercion);
   }
   if (current.keyword in zodKeywordMapper && "args" in current) {
@@ -3107,34 +3063,23 @@ function parse2(parent, current, options) {
 
 // src/plugin.ts
 init_esm_shims();
-import path2 from "node:path";
-import { FileManager as FileManager2, PluginManager as PluginManager2, createPlugin as createPlugin2 } from "@kubb/core";
-import { camelCase as camelCase2, pascalCase as pascalCase2 } from "@kubb/core/transformers";
-import { renderTemplate as renderTemplate2 } from "@kubb/core/utils";
-import { OperationGenerator as OperationGenerator2, SchemaGenerator as SchemaGenerator4, pluginOasName as pluginOasName2 } from "@kubb/plugin-oas";
 
 // src/SchemaGenerator.tsx
 init_esm_shims();
-import { createReactGenerator } from "@kubb/plugin-oas";
 
 // src/components/OperationSchema.tsx
 init_esm_shims();
-import { SchemaGenerator as SchemaGenerator3, schemaKeywords as schemaKeywords4 } from "@kubb/plugin-oas";
-import { Oas as Oas5 } from "@kubb/plugin-oas/components";
-import { useOas as useOas3, useOperation as useOperation2, useOperationManager as useOperationManager2 } from "@kubb/plugin-oas/hooks";
-import { File as File4, useApp as useApp4 } from "@kubb/react";
-import { jsx as jsx6, jsxs as jsxs4 } from "@kubb/react/jsx-runtime";
 function OperationSchema2({ description, keysToOmit }) {
-  return /* @__PURE__ */ jsx6(Schema2, { keysToOmit, withTypeAnnotation: false, description });
+  return /* @__PURE__ */ jsx(Schema2, { keysToOmit, withTypeAnnotation: false, description });
 }
 OperationSchema2.File = function({}) {
-  const { pluginManager, plugin, mode } = useApp4();
-  const { getSchemas, getFile } = useOperationManager2();
-  const oas = useOas3();
-  const operation = useOperation2();
+  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 SchemaGenerator3(plugin.options, {
+  const generator = new SchemaGenerator(plugin.options, {
     oas,
     plugin,
     pluginManager,
@@ -3146,25 +3091,21 @@ OperationSchema2.File = function({}) {
     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__ */ jsxs4(Oas5.Schema, { name, value: schema, tree: [...tree, optional ? { keyword: schemaKeywords4.optional } : void 0].filter(Boolean), children: [
-      mode === "split" && /* @__PURE__ */ jsx6(Oas5.Schema.Imports, { isTypeOnly: false }),
-      /* @__PURE__ */ jsx6(OperationSchema2, { description, keysToOmit })
+    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__ */ jsxs4(File4, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
-    /* @__PURE__ */ jsx6(File4.Import, { name: ["z"], path: plugin.options.importPath }),
+  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();
-import { useOperationManager as useOperationManager3, useOperations } from "@kubb/plugin-oas/hooks";
-import { Const, File as File5, useApp as useApp5 } from "@kubb/react";
-import transformers5 from "@kubb/core/transformers";
-import { Fragment as Fragment3, jsx as jsx7, jsxs as jsxs5 } from "@kubb/react/jsx-runtime";
 function Template2({ operationsName, pathsName, operations }) {
-  const { groupSchemasByName } = useOperationManager3();
+  const { groupSchemasByName } = useOperationManager();
   const transformedOperations = operations.map((operation) => ({ operation, data: groupSchemasByName(operation, { type: "function" }) }));
   const operationsJSON = transformedOperations.reduce(
     (prev, acc) => {
@@ -3183,9 +3124,9 @@ function Template2({ operationsName, pathsName, operations }) {
     },
     {}
   );
-  return /* @__PURE__ */ jsxs5(Fragment3, { children: [
-    /* @__PURE__ */ jsx7(File5.Source, { name: operationsName, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsx7(Const, { export: true, name: operationsName, asConst: true, children: `{${transformers5.stringifyObject(operationsJSON)}}` }) }),
-    /* @__PURE__ */ jsx7(File5.Source, { name: pathsName, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsx7(Const, { export: true, name: pathsName, asConst: true, children: `{${transformers5.stringifyObject(pathsJSON)}}` }) })
+  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 }) {
@@ -3196,17 +3137,17 @@ function RootTemplate({ children }) {
       key: pluginKey,
       options: { extName }
     }
-  } = useApp5();
-  const { getFile } = useOperationManager3();
+  } = useApp();
+  const { getFile } = useOperationManager();
   const operations = useOperations();
-  const { groupSchemasByName } = useOperationManager3();
+  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__ */ jsx7(File5.Import, { name: names, root: file.path, path: getFile(operation).path }, key);
+    return /* @__PURE__ */ jsx(File.Import, { name: names, root: file.path, path: getFile(operation).path }, key);
   }).filter(Boolean);
-  return /* @__PURE__ */ jsxs5(File5, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
+  return /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
     mode === "split" && imports,
     children
   ] });
@@ -3214,37 +3155,34 @@ function RootTemplate({ children }) {
 var defaultTemplates2 = { default: Template2, root: RootTemplate };
 function Operations({ Template: Template3 = defaultTemplates2.default }) {
   const operations = useOperations();
-  return /* @__PURE__ */ jsx7(Template3, { operationsName: "operations", pathsName: "paths", operations });
+  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__ */ jsx7(RootTemplate2, { children: /* @__PURE__ */ jsx7(Operations, { Template: Template3 }) });
+  return /* @__PURE__ */ jsx(RootTemplate2, { children: /* @__PURE__ */ jsx(Operations, { Template: Template3 }) });
 };
 Operations.templates = defaultTemplates2;
-
-// src/SchemaGenerator.tsx
-import { jsx as jsx8 } from "@kubb/react/jsx-runtime";
 var zodParser = createReactGenerator({
   name: "plugin-zod",
   Operations({ options }) {
     if (!options.templates.operations) {
       return null;
     }
-    return /* @__PURE__ */ jsx8(Operations.File, { templates: options.templates.operations });
+    return /* @__PURE__ */ jsx(Operations.File, { templates: options.templates.operations });
   },
   Operation() {
-    return /* @__PURE__ */ jsx8(OperationSchema2.File, {});
+    return /* @__PURE__ */ jsx(OperationSchema2.File, {});
   },
   Schema({ schema, name }) {
-    return /* @__PURE__ */ jsx8(Schema2.File, {});
+    return /* @__PURE__ */ jsx(Schema2.File, {});
   }
 });
 
 // src/plugin.ts
 var pluginZodName = "plugin-zod";
-var pluginZod = createPlugin2((options) => {
+var pluginZod = createPlugin((options) => {
   const {
     output = { path: "zod" },
     group,
@@ -3286,26 +3224,26 @@ var pluginZod = createPlugin2((options) => {
         ...templates
       }
     },
-    pre: [pluginOasName2, typed ? pluginTsName : void 0].filter(Boolean),
+    pre: [pluginOasName, typed ? pluginTsName : void 0].filter(Boolean),
     resolvePath(baseName, pathMode, options2) {
-      const root = path2.resolve(this.config.root, this.config.output.path);
-      const mode = pathMode ?? FileManager2.getMode(path2.resolve(root, output.path));
+      const root = path.resolve(this.config.root, this.config.output.path);
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path));
       if (mode === "single") {
-        return path2.resolve(root, output.path);
+        return path.resolve(root, output.path);
       }
       if (options2?.tag && group?.type === "tag") {
-        const tag = camelCase2(options2.tag);
-        return path2.resolve(root, renderTemplate2(template, { tag }), baseName);
+        const tag = camelCase(options2.tag);
+        return path.resolve(root, renderTemplate(template, { tag }), baseName);
       }
-      return path2.resolve(root, output.path, baseName);
+      return path.resolve(root, output.path, baseName);
     },
     resolveName(name, type) {
-      let resolvedName = camelCase2(name, {
+      let resolvedName = camelCase(name, {
         suffix: type ? "schema" : void 0,
         isFile: type === "file"
       });
       if (type === "type") {
-        resolvedName = pascalCase2(resolvedName);
+        resolvedName = pascalCase(resolvedName);
       }
       if (type) {
         return transformers7?.name?.(resolvedName, type) || resolvedName;
@@ -3313,11 +3251,11 @@ var pluginZod = createPlugin2((options) => {
       return resolvedName;
     },
     async buildStart() {
-      const [swaggerPlugin] = PluginManager2.getDependedPlugins(this.plugins, [pluginOasName2]);
+      const [swaggerPlugin] = PluginManager.getDependedPlugins(this.plugins, [pluginOasName]);
       const oas = await swaggerPlugin.context.getOas();
-      const root = path2.resolve(this.config.root, this.config.output.path);
-      const mode = FileManager2.getMode(path2.resolve(root, output.path));
-      const schemaGenerator = new SchemaGenerator4(this.plugin.options, {
+      const root = path.resolve(this.config.root, this.config.output.path);
+      const mode = FileManager.getMode(path.resolve(root, output.path));
+      const schemaGenerator = new SchemaGenerator(this.plugin.options, {
         oas,
         pluginManager: this.pluginManager,
         plugin: this.plugin,
@@ -3329,7 +3267,7 @@ var pluginZod = createPlugin2((options) => {
       });
       const schemaFiles = await schemaGenerator.build(zodParser);
       await this.addFile(...schemaFiles);
-      const operationGenerator = new OperationGenerator2(this.plugin.options, {
+      const operationGenerator = new OperationGenerator$1(this.plugin.options, {
         oas,
         pluginManager: this.pluginManager,
         plugin: this.plugin,
@@ -3356,18 +3294,15 @@ var pluginZod = createPlugin2((options) => {
     }
   };
 });
-
-// src/components/Schema.tsx
-import { Fragment as Fragment4, jsx as jsx9, jsxs as jsxs6 } from "@kubb/react/jsx-runtime";
 function Schema2(props) {
   const { keysToOmit, withTypeAnnotation, description } = props;
-  const { tree, name } = useSchema2();
+  const { tree, name } = useSchema();
   const {
     pluginManager,
     plugin: {
       options: { mapper, typedSchema, coercion }
     }
-  } = useApp6();
+  } = useApp();
   const resolvedName = pluginManager.resolveName({
     name,
     pluginKey: [pluginZodName],
@@ -3384,34 +3319,34 @@ function Schema2(props) {
     type: "type"
   });
   if (!tree.length) {
-    return /* @__PURE__ */ jsx9(File6.Source, { name: resolvedName, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsx9(
-      Const2,
+    return /* @__PURE__ */ jsx(File.Source, { name: resolvedName, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsx(
+      Const,
       {
         name: resolvedName,
         export: true,
         JSDoc: {
-          comments: [description ? `@description ${transformers6.jsStringEscape(description)}` : void 0].filter(Boolean)
+          comments: [description ? `@description ${transformers4.jsStringEscape(description)}` : void 0].filter(Boolean)
         },
         children: "undefined"
       }
     ) });
   }
-  const hasTuple = tree.some((item) => isKeyword3(item, schemaKeywords5.tuple));
+  const hasTuple = tree.some((item) => isKeyword(item, schemaKeywords.tuple));
   const output = sort(tree).filter((item) => {
-    if (hasTuple && (isKeyword3(item, schemaKeywords5.min) || isKeyword3(item, schemaKeywords5.max))) {
+    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__ */ jsxs6(Fragment4, { children: [
-    /* @__PURE__ */ jsx9(File6.Source, { name: resolvedName, isExportable: true, isIndexable: true, children: /* @__PURE__ */ jsx9(
-      Const2,
+  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 ${transformers6.jsStringEscape(description)}` : void 0].filter(Boolean)
+          comments: [description ? `@description ${transformers4.jsStringEscape(description)}` : void 0].filter(Boolean)
         },
         children: [
           output,
@@ -3420,7 +3355,7 @@ function Schema2(props) {
         ].filter(Boolean).join("") || ""
       }
     ) }),
-    typedSchema && /* @__PURE__ */ jsx9(File6.Source, { name: resolvedTypeName, isExportable: true, isIndexable: true, isTypeOnly: true, children: /* @__PURE__ */ jsx9(Type2, { export: true, name: resolvedTypeName, children: `z.infer<typeof ${resolvedName}>` }) })
+    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({}) {
@@ -3429,12 +3364,12 @@ Schema2.File = function({}) {
     plugin: {
       options: { typed }
     }
-  } = useApp6();
-  const { schema } = useSchema2();
+  } = useApp();
+  const { schema } = useSchema();
   const withTypeAnnotation = !!typed;
-  return /* @__PURE__ */ jsxs6(Oas6.Schema.File, { output: pluginManager.config.output.path, children: [
-    /* @__PURE__ */ jsx9(Schema2.Imports, {}),
-    /* @__PURE__ */ jsx9(Schema2, { withTypeAnnotation, description: schema?.description })
+  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 = () => {
@@ -3443,9 +3378,9 @@ Schema2.Imports = () => {
     plugin: {
       options: { typed, importPath }
     }
-  } = useApp6();
+  } = useApp();
   const { path: root } = useFile();
-  const { name, tree, schema } = useSchema2();
+  const { name, tree, schema } = useSchema();
   const typeName = pluginManager.resolveName({
     name,
     pluginKey: [pluginTsName],
@@ -3461,20 +3396,11 @@ Schema2.Imports = () => {
     pluginKey: [pluginTsName]
   });
   const withTypeAnnotation = !!typed;
-  return /* @__PURE__ */ jsxs6(Fragment4, { children: [
-    /* @__PURE__ */ jsx9(File6.Import, { name: ["z"], path: importPath }),
-    withTypeAnnotation && typeName && typePath && /* @__PURE__ */ jsx9(File6.Import, { isTypeOnly: true, root, path: typePath, name: [typeName] })
+  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] })
   ] });
 };
-
-export {
-  init_esm_shims,
-  Schema2 as Schema,
-  OperationSchema2 as OperationSchema,
-  Operations,
-  pluginZodName,
-  pluginZod
-};
 /*! Bundled license information:
 
 react/cjs/react.production.min.js:
@@ -3499,4 +3425,7 @@ react/cjs/react.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=chunk-CUPQVLRZ.js.map
+
+export { OperationSchema2 as OperationSchema, Operations, Schema2 as Schema, init_esm_shims, pluginZod, pluginZodName };
+//# sourceMappingURL=chunk-BWE5OHCP.js.map
+//# sourceMappingURL=chunk-BWE5OHCP.js.map