@kubb/agent 5.0.0-alpha.2 → 5.0.0-alpha.4

package/.output/server/chunks/nitro/nitro.mjs

@@ -7,7 +7,7 @@ import https, { Server as Server$1 } from 'node:https';
 import { EventEmitter } from 'node:events';
 import { Buffer as Buffer$1 } from 'node:buffer';
 import fs$1, { promises, existsSync, readFileSync } from 'node:fs';
-import path$2, { resolve, dirname, relative, join, posix } from 'node:path';
+import path$2, { resolve, dirname, relative, join, basename, extname, posix } from 'node:path';
 import anymatch from 'anymatch';
 import { createHash, randomBytes } from 'node:crypto';
 import process$1, { version as version$2 } from 'node:process';
@@ -15,7 +15,7 @@ import { Logtail } from '@logtail/node';
 import { consola } from 'consola';
 import mod from 'node:module';
 import { access, rm, readFile as readFile$1, readdir as readdir$1, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
-import { createFabric, createReactFabric, App, File, Function as Function$1, Const, FunctionParams, Type as Type$1, useApp } from '@kubb/react-fabric';
+import { createFabric, createReactFabric, App, File, Function as Function$1, Const, FunctionParams, Type as Type$2, useApp } from '@kubb/react-fabric';
 import { typescriptParser } from '@kubb/react-fabric/parsers';
 import { fsPlugin } from '@kubb/react-fabric/plugins';
 import { performance as performance$1 } from 'node:perf_hooks';
@@ -2470,7 +2470,7 @@ function isPureObject(value) {
   const proto = Object.getPrototypeOf(value);
   return !proto || proto.isPrototypeOf(Object);
 }
-function stringify$3(value) {
+function stringify$4(value) {
   if (isPrimitive(value)) {
     return String(value);
   }
@@ -2478,7 +2478,7 @@ function stringify$3(value) {
     return JSON.stringify(value);
   }
   if (typeof value.toJSON === "function") {
-    return stringify$3(value.toJSON());
+    return stringify$4(value.toJSON());
   }
   throw new Error("[unstorage] Cannot stringify value!");
 }
@@ -2800,7 +2800,7 @@ function createStorage(options = {}) {
       if (!driver.setItem) {
         return;
       }
-      await asyncCall(driver.setItem, relativeKey, stringify$3(value), opts);
+      await asyncCall(driver.setItem, relativeKey, stringify$4(value), opts);
       if (!driver.watch) {
         onChange("update", key);
       }
@@ -2812,7 +2812,7 @@ function createStorage(options = {}) {
             batch.driver.setItems,
             batch.items.map((item) => ({
               key: item.relativeKey,
-              value: stringify$3(item.value),
+              value: stringify$4(item.value),
               options: item.options
             })),
             commonOptions
@@ -2826,7 +2826,7 @@ function createStorage(options = {}) {
             return asyncCall(
               batch.driver.setItem,
               item.relativeKey,
-              stringify$3(item.value),
+              stringify$4(item.value),
               item.options
             );
           })
@@ -4653,6 +4653,46 @@ async function disconnect({ sessionId, token, studioUrl }) {
 const visitorDepths = {
   deep: "deep"
 };
+function narrowSchema(node, type) {
+  return (node == null ? void 0 : node.type) === type ? node : void 0;
+}
+function isKind(kind) {
+  return (node) => node.kind === kind;
+}
+const isOperationNode = isKind("Operation");
+const isSchemaNode = isKind("Schema");
+function definePrinter(build) {
+  return (options) => {
+    const { name, options: resolvedOptions, nodes } = build(options != null ? options : {});
+    const context = {
+      options: resolvedOptions,
+      print: (node) => {
+        const handler = nodes[node.type];
+        return handler ? handler.call(context, node) : void 0;
+      }
+    };
+    return {
+      name,
+      options: resolvedOptions,
+      print: context.print,
+      for: (nodes2) => nodes2.map(context.print)
+    };
+  };
+}
+const plainStringTypes = /* @__PURE__ */ new Set([
+  "string",
+  "uuid",
+  "email",
+  "url",
+  "datetime"
+]);
+function isPlainStringType(node) {
+  var _a;
+  if (plainStringTypes.has(node.type)) return true;
+  const temporal = (_a = narrowSchema(node, "date")) != null ? _a : narrowSchema(node, "time");
+  if (temporal) return temporal.representation !== "date";
+  return false;
+}
 function createLimit(concurrency) {
   let active = 0;
   const queue = [];
@@ -4746,6 +4786,35 @@ async function _walk(node, visitor, recurse, limit) {
   const children = getChildren(node, recurse);
   await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit)));
 }
+function collect(node, visitor, options = {}) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const recurse = ((_a = options.depth) != null ? _a : visitorDepths.deep) === visitorDepths.deep;
+  const results = [];
+  let v;
+  switch (node.kind) {
+    case "Root":
+      v = (_b = visitor.root) == null ? void 0 : _b.call(visitor, node);
+      break;
+    case "Operation":
+      v = (_c = visitor.operation) == null ? void 0 : _c.call(visitor, node);
+      break;
+    case "Schema":
+      v = (_d = visitor.schema) == null ? void 0 : _d.call(visitor, node);
+      break;
+    case "Property":
+      v = (_e = visitor.property) == null ? void 0 : _e.call(visitor, node);
+      break;
+    case "Parameter":
+      v = (_f = visitor.parameter) == null ? void 0 : _f.call(visitor, node);
+      break;
+    case "Response":
+      v = (_g = visitor.response) == null ? void 0 : _g.call(visitor, node);
+      break;
+  }
+  if (v !== void 0) results.push(v);
+  for (const child of getChildren(node, recurse)) for (const item of collect(child, visitor, options)) results.push(item);
+  return results;
+}
 
 var __defProp$h = Object.defineProperty;
 var __typeError$c = (msg) => {
@@ -5363,7 +5432,7 @@ function isPromiseRejectedResult(result) {
 }
 function getMode(fileOrFolder) {
   if (!fileOrFolder) return "split";
-  return path$2.extname(fileOrFolder) ? "single" : "split";
+  return extname(fileOrFolder) ? "single" : "split";
 }
 var PluginManager = (_e = class {
   constructor(config, options) {
@@ -5375,14 +5444,14 @@ var PluginManager = (_e = class {
     * the build pipeline after the adapter's `parse()` resolves.
     */
     __publicField$b(this, "rootNode");
+    __publicField$b(this, "adapter");
     __privateAdd$c(this, _studioIsOpen, false);
     __privateAdd$c(this, _plugins, /* @__PURE__ */ new Set());
     __privateAdd$c(this, _usedPluginNames, {});
     __privateAdd$c(this, _promiseManager);
     __publicField$b(this, "resolvePath", (params) => {
       var _a2, _b2;
-      const root = path$2.resolve(this.config.root, this.config.output.path);
-      const defaultPath = path$2.resolve(root, params.baseName);
+      const defaultPath = resolve(resolve(this.config.root, this.config.output.path), params.baseName);
       if (params.pluginName) return ((_a2 = this.hookForPluginSync({
         pluginName: params.pluginName,
         hookName: "resolvePath",
@@ -5437,7 +5506,7 @@ var PluginManager = (_e = class {
       plugin,
       events: this.options.events,
       pluginManager: this,
-      mode: getMode(path$2.resolve(this.config.root, this.config.output.path)),
+      mode: getMode(resolve(this.config.root, this.config.output.path)),
       addFile: async (...files) => {
         await this.options.fabric.addFile(...files);
       },
@@ -5447,11 +5516,14 @@ var PluginManager = (_e = class {
       get rootNode() {
         return pluginManager.rootNode;
       },
+      get adapter() {
+        return pluginManager.adapter;
+      },
       openInStudio(options) {
         var _a2, _b2;
+        if (!pluginManager.config.devtools || __privateGet$c(pluginManager, _studioIsOpen)) return;
         if (typeof pluginManager.config.devtools !== "object") throw new Error("Devtools must be an object");
-        if (!pluginManager.rootNode) throw new Error("RootNode is not defined, make sure you have set the parser in kubb.config.ts");
-        if (__privateGet$c(pluginManager, _studioIsOpen)) return;
+        if (!pluginManager.rootNode || !pluginManager.adapter) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
         __privateSet$c(pluginManager, _studioIsOpen, true);
         const studioUrl = (_b2 = (_a2 = pluginManager.config.devtools) == null ? void 0 : _a2.studioUrl) != null ? _b2 : "https://studio.kubb.dev";
         return openInStudio(pluginManager.rootNode, studioUrl, options);
@@ -5470,18 +5542,22 @@ var PluginManager = (_e = class {
   get plugins() {
     return __privateMethod$c(this, _PluginManager_instances, getSortedPlugins_fn).call(this);
   }
-  getFile({ name, mode, extname, pluginName, options }) {
-    const baseName = `${name}${extname}`;
+  getFile({ name, mode, extname: extname2, pluginName, options }) {
+    const resolvedName = mode ? mode === "single" ? "" : this.resolveName({
+      name,
+      pluginName,
+      type: "file"
+    }) : name;
     const path2 = this.resolvePath({
-      baseName,
+      baseName: `${resolvedName}${extname2}`,
       mode,
       pluginName,
       options
     });
-    if (!path2) throw new Error(`Filepath should be defined for resolvedName "${name}" and pluginName "${pluginName}"`);
+    if (!path2) throw new Error(`Filepath should be defined for resolvedName "${resolvedName}" and pluginName "${pluginName}"`);
     return {
       path: path2,
-      baseName,
+      baseName: basename(path2),
       meta: { pluginName },
       sources: [],
       imports: [],
@@ -5655,7 +5731,8 @@ var PluginManager = (_e = class {
   if (hookName) return plugins.filter((plugin) => hookName in plugin);
   return plugins.map((plugin) => {
     if (plugin.pre) {
-      const missingPlugins = plugin.pre.filter((pluginName) => !plugins.find((pluginToFind) => pluginToFind.name === pluginName));
+      let missingPlugins = plugin.pre.filter((pluginName) => !plugins.find((pluginToFind) => pluginToFind.name === pluginName));
+      if (missingPlugins.includes("plugin-oas") && this.adapter) missingPlugins = missingPlugins.filter((pluginName) => pluginName !== "plugin-oas");
       if (missingPlugins.length > 0) throw new ValidationPluginError(`The plugin '${plugin.name}' has a pre set that references missing plugins for '${missingPlugins.join(", ")}'`);
     }
     return plugin;
@@ -5808,7 +5885,7 @@ const fsStorage = defineStorage(() => ({
     await clean(resolve(base));
   }
 }));
-var version$1 = "5.0.0-alpha.2";
+var version$1 = "5.0.0-alpha.4";
 function getDiagnosticInfo() {
   return {
     nodeVersion: version$2,
@@ -5927,6 +6004,7 @@ async function setup(options) {
       date: /* @__PURE__ */ new Date(),
       logs: [`Running adapter: ${definedConfig.adapter.name}`]
     });
+    pluginManager.adapter = definedConfig.adapter;
     pluginManager.rootNode = await definedConfig.adapter.parse(source);
     await events.emit("debug", {
       date: /* @__PURE__ */ new Date(),
@@ -6095,6 +6173,34 @@ function inputToAdapterSource(config) {
     path: resolve(config.root, config.input.path)
   };
 }
+function defineGenerator(generator) {
+  if (generator.type === "react") return {
+    version: "2",
+    Operations() {
+      return null;
+    },
+    Operation() {
+      return null;
+    },
+    Schema() {
+      return null;
+    },
+    ...generator
+  };
+  return {
+    version: "2",
+    async operations() {
+      return [];
+    },
+    async operation() {
+      return [];
+    },
+    async schema() {
+      return [];
+    },
+    ...generator
+  };
+}
 function definePlugin(build2) {
   return (options) => build2(options != null ? options : {});
 }
@@ -6541,8 +6647,55 @@ async function detectLinter() {
     "eslint"
   ]) if (await isLinterAvailable(linter)) return linter;
 }
+function matchesOperationPattern(node, type, pattern) {
+  switch (type) {
+    case "tag":
+      return node.tags.some((tag) => !!tag.match(pattern));
+    case "operationId":
+      return !!node.operationId.match(pattern);
+    case "path":
+      return !!node.path.match(pattern);
+    case "method":
+      return !!node.method.toLowerCase().match(pattern);
+    default:
+      return false;
+  }
+}
+function matchesSchemaPattern(node, type, pattern) {
+  switch (type) {
+    case "schemaName":
+      return node.name ? !!node.name.match(pattern) : false;
+    default:
+      return null;
+  }
+}
+function resolveOptions(node, { options, exclude = [], include, override = [] }) {
+  var _a2, _b2;
+  if (isOperationNode(node)) {
+    if (exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
+    if (include && !include.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
+    const overrideOptions = (_a2 = override.find(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) == null ? void 0 : _a2.options;
+    return {
+      ...options,
+      ...overrideOptions
+    };
+  }
+  if (isSchemaNode(node)) {
+    if (exclude.some(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) return null;
+    if (include) {
+      const applicable = include.map(({ type, pattern }) => matchesSchemaPattern(node, type, pattern)).filter((r) => r !== null);
+      if (applicable.length > 0 && !applicable.includes(true)) return null;
+    }
+    const overrideOptions = (_b2 = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) == null ? void 0 : _b2.options;
+    return {
+      ...options,
+      ...overrideOptions
+    };
+  }
+  return options;
+}
 
-var version = "5.0.0-alpha.2";
+var version = "5.0.0-alpha.4";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -7606,7 +7759,7 @@ function trimQuotes$3(text) {
   }
   return text;
 }
-function stringify$2(value) {
+function stringify$3(value) {
   if (value === void 0 || value === null) return '""';
   return JSON.stringify(trimQuotes$3(value.toString()));
 }
@@ -7769,17 +7922,18 @@ async function buildOperations(operationsOrNodes, options) {
       })
     }));
   } else {
-    const { Component } = options;
+    const { Component, adapter } = options;
     await fabricChild.render(/* @__PURE__ */ jsx(App, {
       meta: { plugin },
       children: /* @__PURE__ */ jsx(Component, {
         config,
+        adapter,
         nodes: operationsOrNodes,
-        plugin
+        options: options.options
       })
     }));
   }
-  await fabric.context.fileManager.upsert(...fabricChild.files);
+  fabric.context.fileManager.upsert(...fabricChild.files);
   fabricChild.unmount();
 }
 function isBuildOperationV1Options(options) {
@@ -7808,17 +7962,22 @@ async function buildOperation(operationOrNode, options) {
       })
     }));
   } else {
-    const { Component } = options;
+    const { Component, adapter, pluginManager, mode } = options;
     await fabricChild.render(/* @__PURE__ */ jsx(App, {
-      meta: { plugin },
+      meta: {
+        plugin,
+        pluginManager,
+        mode
+      },
       children: /* @__PURE__ */ jsx(Component, {
         config,
+        adapter,
         node: operationOrNode,
-        plugin
+        options: options.options
       })
     }));
   }
-  await fabric.context.fileManager.upsert(...fabricChild.files);
+  fabric.context.fileManager.upsert(...fabricChild.files);
   fabricChild.unmount();
 }
 function isBuildSchemaV1Options(options) {
@@ -7847,17 +8006,22 @@ async function buildSchema(schema, options) {
       })
     }));
   } else {
-    const { Component } = options;
+    const { Component, adapter, pluginManager, mode } = options;
     await fabricChild.render(/* @__PURE__ */ jsx(App, {
-      meta: { plugin },
+      meta: {
+        plugin,
+        pluginManager,
+        mode
+      },
       children: /* @__PURE__ */ jsx(Component, {
         config,
+        adapter,
         node: schema,
-        plugin
+        options: options.options
       })
     }));
   }
-  await fabric.context.fileManager.upsert(...fabricChild.files);
+  fabric.context.fileManager.upsert(...fabricChild.files);
   fabricChild.unmount();
 }
 const GENERATOR_CONCURRENCY = 3;
@@ -8275,7 +8439,7 @@ parseSchemaObject_fn = function({ schema: _schemaObject, name, parentName, rootN
   const defaultNullAndNullable = schemaObject.default === null && nullable;
   if (schemaObject.default !== void 0 && !defaultNullAndNullable && !Array.isArray(schemaObject.default)) if (typeof schemaObject.default === "string") baseItems.push({
     keyword: schemaKeywords.default,
-    args: stringify$2(schemaObject.default)
+    args: stringify$3(schemaObject.default)
   });
   else if (typeof schemaObject.default === "boolean") baseItems.push({
     keyword: schemaKeywords.default,
@@ -8503,7 +8667,7 @@ parseSchemaObject_fn = function({ schema: _schemaObject, name, parentName, rootN
           items: [...new Set(schemaObject[extensionKey])].map((name2, index) => {
             var _a3, _b3;
             return {
-              name: stringify$2(name2),
+              name: stringify$3(name2),
               value: (_a3 = schemaObject.enum) == null ? void 0 : _a3[index],
               format: isNumber((_b3 = schemaObject.enum) == null ? void 0 : _b3[index]) ? "number" : "string"
             };
@@ -8563,7 +8727,7 @@ parseSchemaObject_fn = function({ schema: _schemaObject, name, parentName, rootN
         typeName,
         asConst: false,
         items: [...new Set(filteredValues)].map((value) => ({
-          name: stringify$2(value),
+          name: stringify$3(value),
           value,
           format: isNumber(value) ? "number" : "string"
         }))
@@ -9666,10 +9830,9 @@ ${operations.map(({ operation, name: methodName, typeSchemas, zodSchemas }) => g
 StaticClassClient.getParams = Client.getParams;
 
 function createGenerator(generator) {
-  var _a;
   return {
     type: "core",
-    version: (_a = generator.version) != null ? _a : "1",
+    version: "1",
     async operations() {
       return [];
     },
@@ -9683,10 +9846,9 @@ function createGenerator(generator) {
   };
 }
 function createReactGenerator(generator) {
-  var _a;
   return {
     type: "react",
-    version: (_a = generator.version) != null ? _a : "1",
+    version: "1",
     Operations() {
       return null;
     },
@@ -10109,7 +10271,7 @@ function jsStringEscape$2(input) {
     }
   });
 }
-function stringify$1(value) {
+function stringify$2(value) {
   if (value === void 0 || value === null) return '""';
   return JSON.stringify(trimQuotes$2(value.toString()));
 }
@@ -10149,7 +10311,7 @@ function Operations({ name, operations }) {
       name: "OperationSchema",
       isExportable: true,
       isIndexable: true,
-      children: /* @__PURE__ */ jsx(Type$1, {
+      children: /* @__PURE__ */ jsx(Type$2, {
         name: "OperationSchema",
         export: true,
         children: `{
@@ -10173,7 +10335,7 @@ function Operations({ name, operations }) {
       name: "OperationsMap",
       isExportable: true,
       isIndexable: true,
-      children: /* @__PURE__ */ jsx(Type$1, {
+      children: /* @__PURE__ */ jsx(Type$2, {
         name: "OperationsMap",
         export: true,
         children: "Record<string, OperationSchema>"
@@ -10586,9 +10748,9 @@ const parse$2 = createParser({
         }).filter(Boolean));
       }
       return zodKeywordMapper.enum(current.args.items.map((schema2) => {
-        if (schema2.format === "boolean") return stringify$1(schema2.value);
-        if (schema2.format === "number") return stringify$1(schema2.value);
-        return stringify$1(schema2.value);
+        if (schema2.format === "boolean") return stringify$2(schema2.value);
+        if (schema2.format === "number") return stringify$2(schema2.value);
+        return stringify$2(schema2.value);
       }));
     },
     ref(tree, options) {
@@ -10688,7 +10850,7 @@ const parse$2 = createParser({
       const { current } = tree;
       if (current.args.format === "number" && current.args.value !== void 0) return zodKeywordMapper.const(Number(current.args.value));
       if (current.args.format === "boolean" && current.args.value !== void 0) return zodKeywordMapper.const(typeof current.args.value === "boolean" ? current.args.value : void 0);
-      return zodKeywordMapper.const(stringify$1(current.args.value));
+      return zodKeywordMapper.const(stringify$2(current.args.value));
     },
     matches(tree, options) {
       const { current, siblings } = tree;
@@ -10706,7 +10868,7 @@ const parse$2 = createParser({
     },
     describe(tree, options) {
       const { current } = tree;
-      if (current.args) return zodKeywordMapper.describe(stringify$1(current.args.toString()), void 0, options.mini);
+      if (current.args) return zodKeywordMapper.describe(stringify$2(current.args.toString()), void 0, options.mini);
     },
     string(tree, options) {
       const { siblings } = tree;
@@ -10840,11 +11002,11 @@ function Zod({ name, typeName, tree, schema, inferTypeName, mapper, coercion, ke
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: [typeName && /* @__PURE__ */ jsx(Type$1, {
+    children: [typeName && /* @__PURE__ */ jsx(Type$2, {
       export: true,
       name: inferTypeName,
       children: typeName
-    }), !typeName && /* @__PURE__ */ jsx(Type$1, {
+    }), !typeName && /* @__PURE__ */ jsx(Type$2, {
       export: true,
       name: inferTypeName,
       children: `z.infer<typeof ${name}>`
@@ -208805,7 +208967,11 @@ const modifiers = {
   const: factory.createModifier(ts.SyntaxKind.ConstKeyword),
   static: factory.createModifier(ts.SyntaxKind.StaticKeyword)
 };
-const syntaxKind = { union: SyntaxKind.UnionType };
+const syntaxKind = {
+  union: SyntaxKind.UnionType,
+  literalType: SyntaxKind.LiteralType,
+  stringLiteral: SyntaxKind.StringLiteral
+};
 function getUnknownType(unknownType) {
   if (unknownType === "any") return keywordTypeNodes.any;
   if (unknownType === "void") return keywordTypeNodes.void;
@@ -208998,7 +209164,7 @@ const createTrue = factory.createTrue;
 const createFalse = factory.createFalse;
 const createIndexedAccessTypeNode = factory.createIndexedAccessTypeNode;
 const createTypeOperatorNode = factory.createTypeOperatorNode;
-factory.createPrefixUnaryExpression;
+const createPrefixUnaryExpression = factory.createPrefixUnaryExpression;
 const typeKeywordMapper = {
   any: () => keywordTypeNodes.any,
   unknown: () => keywordTypeNodes.unknown,
@@ -209261,7 +209427,7 @@ const parse$1 = createParser({
     }
   }
 });
-function Type({ name, typedName, tree, keysToOmit, schema, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, mapper, description }) {
+function Type$1({ name, typedName, tree, keysToOmit, schema, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, mapper, description }) {
   const typeNodes = [];
   if (!tree.length) return "";
   const schemaFromTree = tree.find((item) => item.keyword === schemaKeywords.schema);
@@ -209371,6 +209537,18 @@ function Type({ name, typedName, tree, keysToOmit, schema, optionalType, arrayTy
   })] });
 }
 
+function useKubb() {
+  const { meta } = useApp();
+  return {
+    plugin: meta.plugin,
+    mode: meta.mode,
+    config: meta.pluginManager.config,
+    getPluginByName: meta.pluginManager.getPluginByName.bind(meta.pluginManager),
+    getFile: meta.pluginManager.getFile.bind(meta.pluginManager),
+    resolveName: meta.pluginManager.resolveName.bind(meta.pluginManager),
+    resolvePath: meta.pluginManager.resolvePath.bind(meta.pluginManager)
+  };
+}
 function useMode() {
   const { meta } = useApp();
   return meta.mode;
@@ -209546,6 +209724,10 @@ function useSchemaManager() {
   };
 }
 
+function stringify$1(value) {
+  if (value === void 0 || value === null) return '""';
+  return JSON.stringify(trimQuotes$1(value.toString()));
+}
 function printCombinedSchema({ name, schemas, pluginManager }) {
   const properties = {};
   if (schemas.response) properties["response"] = createUnionDeclaration({ nodes: schemas.responses.map((res) => {
@@ -209720,9 +209902,8 @@ function printResponseSchema({ baseName, schemas, pluginManager, unknownType })
   }
   return results.join("\n\n");
 }
-const typeGenerator = createReactGenerator({
+const typeGenerator$1 = createReactGenerator({
   name: "typescript",
-  version: "1",
   Operation({ operation, generator, plugin }) {
     const { options, options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
     const mode = useMode();
@@ -209777,7 +209958,7 @@ const typeGenerator = createReactGenerator({
         imp.name,
         imp.path,
         imp.isTypeOnly
-      ].join("-"))), /* @__PURE__ */ jsx(Type, {
+      ].join("-"))), /* @__PURE__ */ jsx(Type$1, {
         name: type.name,
         typedName: type.typedName,
         description,
@@ -209879,7 +210060,7 @@ const typeGenerator = createReactGenerator({
         schema.name,
         imp.path,
         imp.isTypeOnly
-      ].join("-"))), /* @__PURE__ */ jsx(Type, {
+      ].join("-"))), /* @__PURE__ */ jsx(Type$1, {
         name: type.name,
         typedName: type.typedName,
         description: schema.value.description,
@@ -209895,12 +210076,443 @@ const typeGenerator = createReactGenerator({
     });
   }
 });
+function constToTypeNode(value, format) {
+  if (format === "boolean") return createLiteralTypeNode(value === true ? createTrue() : createFalse());
+  if (format === "number" && typeof value === "number") {
+    if (value < 0) return createLiteralTypeNode(createPrefixUnaryExpression(SyntaxKind.MinusToken, createNumericLiteral(Math.abs(value))));
+    return createLiteralTypeNode(createNumericLiteral(value));
+  }
+  return createLiteralTypeNode(createStringLiteral(String(value)));
+}
+function dateOrStringNode(node) {
+  return node.representation === "date" ? createTypeReferenceNode(createIdentifier("Date")) : keywordTypeNodes.string;
+}
+function buildMemberNodes(members, print) {
+  return (members != null ? members : []).map(print).filter(Boolean);
+}
+function buildTupleNode(node, print) {
+  var _a, _b;
+  let items = ((_a = node.items) != null ? _a : []).map(print).filter(Boolean);
+  const restNode = node.rest ? (_b = print(node.rest)) != null ? _b : void 0 : void 0;
+  const { min, max } = node;
+  if (max !== void 0) {
+    items = items.slice(0, max);
+    if (items.length < max && restNode) items = [...items, ...Array(max - items.length).fill(restNode)];
+  }
+  if (min !== void 0) items = items.map((item, i) => i >= min ? createOptionalTypeNode(item) : item);
+  if (max === void 0 && restNode) items.push(createRestTypeNode(createArrayTypeNode(restNode)));
+  return createTupleTypeNode(items);
+}
+function buildPropertyType(schema, baseType, optionalType) {
+  const addsUndefined = ["undefined", "questionTokenAndUndefined"].includes(optionalType);
+  let type = baseType;
+  if (schema.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
+  if ((schema.nullish || schema.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+  return type;
+}
+function buildPropertyJSDocComments(schema) {
+  return [
+    "description" in schema && schema.description ? `@description ${jsStringEscape$1(schema.description)}` : void 0,
+    "deprecated" in schema && schema.deprecated ? "@deprecated" : void 0,
+    "min" in schema && schema.min !== void 0 ? `@minLength ${schema.min}` : void 0,
+    "max" in schema && schema.max !== void 0 ? `@maxLength ${schema.max}` : void 0,
+    "pattern" in schema && schema.pattern ? `@pattern ${schema.pattern}` : void 0,
+    "default" in schema && schema.default !== void 0 ? `@default ${"primitive" in schema && schema.primitive === "string" ? stringify$1(schema.default) : schema.default}` : void 0,
+    "example" in schema && schema.example !== void 0 ? `@example ${schema.example}` : void 0,
+    "primitive" in schema && schema.primitive ? [`@type ${schema.primitive || "unknown"}`, "optional" in schema && schema.optional ? " | undefined" : void 0].filter(Boolean).join("") : void 0
+  ];
+}
+function buildIndexSignatures(node, propertyCount, print) {
+  var _a, _b;
+  const elements = [];
+  if (node.additionalProperties && node.additionalProperties !== true) {
+    const additionalType = (_a = print(node.additionalProperties)) != null ? _a : keywordTypeNodes.unknown;
+    elements.push(createIndexSignature(propertyCount > 0 ? keywordTypeNodes.unknown : additionalType));
+  } else if (node.additionalProperties === true) elements.push(createIndexSignature(keywordTypeNodes.unknown));
+  if (node.patternProperties) {
+    const first = Object.values(node.patternProperties)[0];
+    if (first) {
+      let patternType = (_b = print(first)) != null ? _b : keywordTypeNodes.unknown;
+      if (first.nullable) patternType = createUnionDeclaration({ nodes: [patternType, keywordTypeNodes.null] });
+      elements.push(createIndexSignature(patternType));
+    }
+  }
+  return elements;
+}
+const printerTs = definePrinter((options) => ({
+  name: "typescript",
+  options,
+  nodes: {
+    any: () => keywordTypeNodes.any,
+    unknown: () => keywordTypeNodes.unknown,
+    void: () => keywordTypeNodes.void,
+    boolean: () => keywordTypeNodes.boolean,
+    null: () => keywordTypeNodes.null,
+    blob: () => createTypeReferenceNode("Blob", []),
+    string: () => keywordTypeNodes.string,
+    uuid: () => keywordTypeNodes.string,
+    email: () => keywordTypeNodes.string,
+    url: () => keywordTypeNodes.string,
+    datetime: () => keywordTypeNodes.string,
+    number: () => keywordTypeNodes.number,
+    integer: () => keywordTypeNodes.number,
+    bigint: () => keywordTypeNodes.bigint,
+    date: (node) => dateOrStringNode(node),
+    time: (node) => dateOrStringNode(node),
+    ref(node) {
+      if (!node.name) return;
+      return createTypeReferenceNode(node.name, void 0);
+    },
+    enum(node) {
+      var _a, _b, _c, _d;
+      const values = (_c = (_b = (_a = node.namedEnumValues) == null ? void 0 : _a.map((v) => v.value)) != null ? _b : node.enumValues) != null ? _c : [];
+      if (this.options.enumType === "inlineLiteral" || !node.name) return (_d = createUnionDeclaration({
+        withParentheses: true,
+        nodes: values.filter((v) => v !== null).map((value) => constToTypeNode(value, typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "string")).filter(Boolean)
+      })) != null ? _d : void 0;
+      return createTypeReferenceNode(["asConst", "asPascalConst"].includes(this.options.enumType) ? `${node.name}Key` : node.name, void 0);
+    },
+    union(node) {
+      var _a, _b, _c;
+      const members = (_a = node.members) != null ? _a : [];
+      const hasStringLiteral = members.some((m) => m.type === "enum" && m.enumType === "string");
+      const hasPlainString = members.some((m) => isPlainStringType(m));
+      if (hasStringLiteral && hasPlainString) return (_b = createUnionDeclaration({
+        withParentheses: true,
+        nodes: members.map((m) => {
+          if (isPlainStringType(m)) return createIntersectionDeclaration({
+            nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
+            withParentheses: true
+          });
+          return this.print(m);
+        }).filter(Boolean)
+      })) != null ? _b : void 0;
+      return (_c = createUnionDeclaration({
+        withParentheses: true,
+        nodes: buildMemberNodes(members, this.print)
+      })) != null ? _c : void 0;
+    },
+    intersection(node) {
+      var _a;
+      return (_a = createIntersectionDeclaration({
+        withParentheses: true,
+        nodes: buildMemberNodes(node.members, this.print)
+      })) != null ? _a : void 0;
+    },
+    array(node) {
+      var _a, _b;
+      return (_b = createArrayDeclaration({
+        nodes: ((_a = node.items) != null ? _a : []).map((item) => this.print(item)).filter(Boolean),
+        arrayType: this.options.arrayType
+      })) != null ? _b : void 0;
+    },
+    tuple(node) {
+      return buildTupleNode(node, this.print);
+    },
+    object(node) {
+      const addsQuestionToken = ["questionToken", "questionTokenAndUndefined"].includes(this.options.optionalType);
+      const { print } = this;
+      const propertyNodes = node.properties.map((prop) => {
+        var _a;
+        const baseType = (_a = print(prop.schema)) != null ? _a : keywordTypeNodes.unknown;
+        const type = buildPropertyType(prop.schema, baseType, this.options.optionalType);
+        return appendJSDocToNode({
+          node: createPropertySignature({
+            questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
+            name: prop.name,
+            type,
+            readOnly: prop.schema.readOnly
+          }),
+          comments: buildPropertyJSDocComments(prop.schema)
+        });
+      });
+      const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, print)];
+      if (!allElements.length) return keywordTypeNodes.object;
+      return createTypeLiteralNode(allElements);
+    }
+  }
+}));
+function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, ...rest }) {
+  const typeNodes = [];
+  const description = rest.description || (node == null ? void 0 : node.description);
+  const enumSchemaNodes = collect(node, { schema(n) {
+    if (n.type === "enum" && n.name) return n;
+  } });
+  let type = printerTs({
+    optionalType,
+    arrayType,
+    enumType
+  }).print(node);
+  if (!type) return;
+  if (["asConst", "asPascalConst"].includes(enumType) && enumSchemaNodes.length > 0) {
+    const isDirectEnum = node.type === "array" && node.items !== void 0;
+    const isEnumOnly = "enum" in node && node.enum;
+    if (isDirectEnum || isEnumOnly) {
+      type = createTypeReferenceNode(`${enumSchemaNodes[0].name}Key`);
+      if (isDirectEnum) if (arrayType === "generic") type = createTypeReferenceNode(createIdentifier("Array"), [type]);
+      else type = createArrayTypeNode(type);
+    }
+  }
+  if (node) {
+    if (node.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
+    if (node.nullish && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+    if (node.optional && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+  }
+  const useTypeGeneration = syntaxType === "type" || [syntaxKind.union].includes(type.kind) || !!(keysToOmit == null ? void 0 : keysToOmit.length);
+  typeNodes.push(createTypeDeclaration({
+    name,
+    isExportable: true,
+    type: (keysToOmit == null ? void 0 : keysToOmit.length) ? createOmitDeclaration({
+      keys: keysToOmit,
+      type,
+      nonNullable: true
+    }) : type,
+    syntax: useTypeGeneration ? "type" : "interface",
+    comments: [
+      (node == null ? void 0 : node.title) ? `${jsStringEscape$1(node.title)}` : void 0,
+      description ? `@description ${jsStringEscape$1(description)}` : void 0,
+      (node == null ? void 0 : node.deprecated) ? "@deprecated" : void 0,
+      node && "min" in node && node.min !== void 0 ? `@minLength ${node.min}` : void 0,
+      node && "max" in node && node.max !== void 0 ? `@maxLength ${node.max}` : void 0,
+      node && "pattern" in node && node.pattern ? `@pattern ${node.pattern}` : void 0,
+      (node == null ? void 0 : node.default) ? `@default ${node.default}` : void 0,
+      (node == null ? void 0 : node.example) ? `@example ${node.example}` : void 0
+    ]
+  }));
+  const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((enumSchemaNode) => {
+    var _a, _b, _c, _d;
+    const enumName = enumType === "asPascalConst" ? pascalCase$6(enumSchemaNode.name) : camelCase$a(enumSchemaNode.name);
+    const typeName = ["asConst", "asPascalConst"].includes(enumType) ? `${enumSchemaNode.name}Key` : enumSchemaNode.name;
+    const [nameNode, typeNode] = createEnumDeclaration({
+      name: enumName,
+      typeName,
+      enums: (_d = (_c = (_a = enumSchemaNode.namedEnumValues) == null ? void 0 : _a.map((v) => [trimQuotes$1(v.name.toString()), v.value])) != null ? _c : (_b = enumSchemaNode.enumValues) == null ? void 0 : _b.filter((v) => v !== null && v !== void 0).map((v) => [trimQuotes$1(v.toString()), v])) != null ? _d : [],
+      type: enumType,
+      enumKeyCasing
+    });
+    return {
+      nameNode,
+      typeNode,
+      name: enumName,
+      typeName
+    };
+  });
+  const shouldExportEnums = enumType !== "inlineLiteral";
+  const shouldExportType = enumType === "inlineLiteral" || enums.every((item) => item.typeName !== name);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ name: enumName, nameNode, typeName, typeNode }) => /* @__PURE__ */ jsxs(Fragment, { children: [nameNode && /* @__PURE__ */ jsx(File.Source, {
+    name: enumName,
+    isExportable: true,
+    isIndexable: true,
+    isTypeOnly: false,
+    children: safePrint(nameNode)
+  }), /* @__PURE__ */ jsx(File.Source, {
+    name: typeName,
+    isIndexable: true,
+    isExportable: [
+      "enum",
+      "asConst",
+      "asPascalConst",
+      "constEnum",
+      "literal",
+      void 0
+    ].includes(enumType),
+    isTypeOnly: [
+      "asConst",
+      "asPascalConst",
+      "literal",
+      void 0
+    ].includes(enumType),
+    children: safePrint(typeNode)
+  })] })), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
+    name: typedName,
+    isTypeOnly: true,
+    isExportable: true,
+    isIndexable: true,
+    children: safePrint(...typeNodes)
+  })] });
+}
+const typeGenerator = defineGenerator({
+  name: "typescript",
+  type: "react",
+  Operation({ node, adapter, options }) {
+    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType } = options;
+    const { plugin, mode, getFile, resolveName } = useKubb();
+    const file = getFile({
+      name: node.operationId,
+      pluginName: plugin.name,
+      extname: ".ts",
+      mode
+    });
+    function renderSchemaType({ node: schemaNode, name, typedName, description }) {
+      const imports = adapter.getImports(schemaNode, (schemaName) => ({
+        name: resolveName({
+          name: schemaName,
+          pluginName: plugin.name,
+          type: "type"
+        }),
+        path: getFile({
+          name: schemaName,
+          pluginName: plugin.name,
+          extname: ".ts",
+          mode
+        }).path
+      }));
+      return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+        root: file.path,
+        path: imp.path,
+        name: imp.name,
+        isTypeOnly: true
+      }, [
+        name,
+        imp.path,
+        imp.isTypeOnly
+      ].join("-"))), /* @__PURE__ */ jsx(Type, {
+        name,
+        typedName,
+        node: schemaNode,
+        description,
+        enumType,
+        enumKeyCasing,
+        optionalType,
+        arrayType,
+        syntaxType
+      })] });
+    }
+    const paramTypes = node.parameters.map((param) => {
+      const name = resolveName({
+        name: `${node.operationId} ${param.name}`,
+        pluginName: plugin.name,
+        type: "function"
+      });
+      const typedName = resolveName({
+        name: `${node.operationId} ${param.name}`,
+        pluginName: plugin.name,
+        type: "type"
+      });
+      return renderSchemaType({
+        node: param.schema,
+        name,
+        typedName
+      });
+    });
+    const responseTypes = node.responses.filter((res) => res.schema).map((res) => {
+      const schemaNode = res.schema;
+      const responseName = `${node.operationId} ${res.statusCode}`;
+      return renderSchemaType({
+        node: schemaNode,
+        name: resolveName({
+          name: responseName,
+          pluginName: plugin.name,
+          type: "function"
+        }),
+        typedName: resolveName({
+          name: responseName,
+          pluginName: plugin.name,
+          type: "type"
+        }),
+        description: res.description
+      });
+    });
+    const requestType = node.requestBody ? (() => {
+      const requestName = `${node.operationId} MutationRequest`;
+      const resolvedName = resolveName({
+        name: requestName,
+        pluginName: plugin.name,
+        type: "function"
+      });
+      const typedName = resolveName({
+        name: requestName,
+        pluginName: plugin.name,
+        type: "type"
+      });
+      return renderSchemaType({
+        node: node.requestBody,
+        name: resolvedName,
+        typedName,
+        description: node.requestBody.description
+      });
+    })() : null;
+    return /* @__PURE__ */ jsxs(File, {
+      baseName: file.baseName,
+      path: file.path,
+      meta: file.meta,
+      children: [
+        paramTypes,
+        responseTypes,
+        requestType
+      ]
+    });
+  },
+  Schema({ node, adapter, options }) {
+    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType } = options;
+    const { plugin, mode, resolveName, getFile } = useKubb();
+    if (!node.name) return;
+    const imports = adapter.getImports(node, (schemaName) => ({
+      name: resolveName({
+        name: schemaName,
+        pluginName: plugin.name,
+        type: "type"
+      }),
+      path: getFile({
+        name: schemaName,
+        pluginName: plugin.name,
+        extname: ".ts",
+        mode
+      }).path
+    }));
+    const isEnumSchema = node.type === "enum";
+    let typedName = resolveName({
+      name: node.name,
+      pluginName: plugin.name,
+      type: "type"
+    });
+    if (["asConst", "asPascalConst"].includes(enumType) && isEnumSchema) typedName = typedName += "Key";
+    const type = {
+      name: resolveName({
+        name: node.name,
+        pluginName: plugin.name,
+        type: "function"
+      }),
+      typedName,
+      file: getFile({
+        name: node.name,
+        pluginName: plugin.name,
+        extname: ".ts",
+        mode
+      })
+    };
+    return /* @__PURE__ */ jsxs(File, {
+      baseName: type.file.baseName,
+      path: type.file.path,
+      meta: type.file.meta,
+      children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+        root: type.file.path,
+        path: imp.path,
+        name: imp.name,
+        isTypeOnly: true
+      }, [
+        node.name,
+        imp.path,
+        imp.isTypeOnly
+      ].join("-"))), /* @__PURE__ */ jsx(Type, {
+        name: type.name,
+        typedName: type.typedName,
+        node,
+        enumType,
+        enumKeyCasing,
+        optionalType,
+        arrayType,
+        syntaxType
+      })]
+    });
+  }
+});
 const pluginTsName = "plugin-ts";
 const pluginTs = definePlugin((options) => {
   const { output = {
     path: "types",
     barrelType: "named"
-  }, group, exclude = [], include, override = [], enumType = "asConst", enumKeyCasing = "none", enumSuffix = "enum", dateType = "string", integerType = "number", unknownType = "any", optionalType = "questionToken", arrayType = "array", emptySchemaType = unknownType, syntaxType = "type", transformers = {}, mapper = {}, paramsCasing, generators = [typeGenerator].filter(Boolean), contentType, UNSTABLE_NAMING } = options;
+  }, group, exclude = [], include, override = [], enumType = "asConst", enumKeyCasing = "none", enumSuffix = "enum", dateType = "string", integerType = "number", unknownType = "any", optionalType = "questionToken", arrayType = "array", emptySchemaType = unknownType, syntaxType = "type", transformers = {}, mapper = {}, paramsCasing, generators = [typeGenerator$1, typeGenerator].filter(Boolean), contentType, UNSTABLE_NAMING } = options;
   return {
     name: pluginTsName,
     options: {
@@ -209945,22 +210557,63 @@ const pluginTs = definePlugin((options) => {
     },
     async install() {
       var _a;
-      const { config, fabric, plugin } = this;
+      const { config, fabric, plugin, adapter, rootNode, pluginManager, openInStudio } = this;
       const root = path$2.resolve(config.root, config.output.path);
       const mode = getMode(path$2.resolve(root, output.path));
-      if (this.rootNode) {
-        await this.openInStudio({ ast: true });
-        await walk(this.rootNode, { async schema(schemaNode) {
-          await generators.map(async (generator) => {
-            if (generator.type === "react" && generator.version === "2") await buildSchema(schemaNode, {
-              config,
-              fabric,
-              Component: generator.Schema,
-              plugin,
-              version: generator.version
+      if (adapter) {
+        await openInStudio({ ast: true });
+        await walk(rootNode, {
+          async schema(schemaNode) {
+            const writeTasks = generators.map(async (generator) => {
+              if (generator.type === "react" && generator.version === "2") {
+                const options2 = resolveOptions(schemaNode, {
+                  options: plugin.options,
+                  exclude,
+                  include,
+                  override
+                });
+                if (options2 === null) return;
+                await buildSchema(schemaNode, {
+                  options: options2,
+                  adapter,
+                  config,
+                  fabric,
+                  Component: generator.Schema,
+                  plugin,
+                  pluginManager,
+                  mode,
+                  version: generator.version
+                });
+              }
             });
-          });
-        } }, { depth: "shallow" });
+            await Promise.all(writeTasks);
+          },
+          async operation(operationNode) {
+            const writeTasks = generators.map(async (generator) => {
+              if (generator.type === "react" && generator.version === "2") {
+                const options2 = resolveOptions(operationNode, {
+                  options: plugin.options,
+                  exclude,
+                  include,
+                  override
+                });
+                if (options2 === null) return;
+                await buildOperation(operationNode, {
+                  options: options2,
+                  adapter,
+                  config,
+                  fabric,
+                  Component: generator.Operation,
+                  plugin,
+                  pluginManager,
+                  mode,
+                  version: generator.version
+                });
+              }
+            });
+            await Promise.all(writeTasks);
+          }
+        }, { depth: "shallow" });
         return;
       }
       const oas = await this.getOas();
@@ -213405,7 +214058,7 @@ function MutationKey$4({ name, typeSchemas, pathParamsType, paramsCasing, operat
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$1, {
+    children: /* @__PURE__ */ jsx(Type$2, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -213473,7 +214126,7 @@ function QueryKey$4({ name, typeSchemas, paramsCasing, pathParamsType, operation
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$1, {
+    children: /* @__PURE__ */ jsx(Type$2, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -214966,7 +215619,7 @@ const hookOptionsGenerator = createReactGenerator({
         isExportable: true,
         isIndexable: true,
         isTypeOnly: true,
-        children: /* @__PURE__ */ jsx(Type$1, {
+        children: /* @__PURE__ */ jsx(Type$2, {
           export: true,
           name,
           children: `{ ${Object.keys(hookOptions).map((key) => `${JSON.stringify(key)}: ${hookOptions[key]}`)} }`
@@ -216475,7 +217128,7 @@ function MutationKey$3({ name, typeSchemas, pathParamsType, paramsCasing, operat
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$1, {
+    children: /* @__PURE__ */ jsx(Type$2, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -216543,7 +217196,7 @@ function QueryKey$3({ name, typeSchemas, paramsCasing, pathParamsType, operation
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$1, {
+    children: /* @__PURE__ */ jsx(Type$2, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -217625,7 +218278,7 @@ function MutationKey$2({ name, typeSchemas, pathParamsType, paramsCasing, operat
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$1, {
+    children: /* @__PURE__ */ jsx(Type$2, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -217693,7 +218346,7 @@ function QueryKey$2({ name, typeSchemas, paramsCasing, pathParamsType, operation
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$1, {
+    children: /* @__PURE__ */ jsx(Type$2, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -218775,7 +219428,7 @@ function MutationKey$1({ name, typeSchemas, pathParamsType, paramsCasing, operat
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$1, {
+    children: /* @__PURE__ */ jsx(Type$2, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -218843,7 +219496,7 @@ function QueryKey$1({ name, typeSchemas, paramsCasing, pathParamsType, operation
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$1, {
+    children: /* @__PURE__ */ jsx(Type$2, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -218972,7 +219625,7 @@ function Mutation$1({ name, clientName, mutationKeyName, mutationKeyTypeName, pa
       isExportable: true,
       isIndexable: true,
       isTypeOnly: true,
-      children: /* @__PURE__ */ jsx(Type$1, {
+      children: /* @__PURE__ */ jsx(Type$2, {
         name: mutationArgTypeName,
         export: true,
         children: hasMutationParams ? `{${mutationArg}}` : "never"
@@ -219986,7 +220639,7 @@ function QueryKey({ name, typeSchemas, paramsCasing, pathParamsType, operation,
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$1, {
+    children: /* @__PURE__ */ jsx(Type$2, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -220464,7 +221117,7 @@ function MutationKey({ name, typeSchemas, pathParamsType, paramsCasing, operatio
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$1, {
+    children: /* @__PURE__ */ jsx(Type$2, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`