@kubb/agent 5.0.0-alpha.22 → 5.0.0-alpha.24

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, basename, extname, posix } from 'node:path';
+import path$2, { resolve, dirname, relative, join, basename, posix, extname } from 'node:path';
 import anymatch from 'anymatch';
 import { createHash, randomBytes } from 'node:crypto';
 import process$1, { version as version$2 } from 'node:process';
@@ -4595,65 +4595,7 @@ const visitorDepths = {
 };
 const schemaTypes = {
   enum: "enum"};
-function toCamelOrPascal$f(text, pascal) {
-  return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-    if (word.length > 1 && word === word.toUpperCase()) return word;
-    if (i === 0 && true) return word.charAt(0).toLowerCase() + word.slice(1);
-    return word.charAt(0).toUpperCase() + word.slice(1);
-  }).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-function applyToFileParts$f(text, transformPart) {
-  const parts = text.split(/\.(?=[a-zA-Z])/);
-  return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
-}
-function camelCase$f(text, { isFile, prefix = "", suffix = "" } = {}) {
-  if (isFile) return applyToFileParts$f(text, (part, isLast) => camelCase$f(part, isLast ? {
-    prefix,
-    suffix
-  } : {}));
-  return toCamelOrPascal$f(`${prefix} ${text} ${suffix}`);
-}
-function isValidVarName$c(name) {
-  try {
-    new Function(`var ${name}`);
-  } catch {
-    return false;
-  }
-  return true;
-}
-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");
-const plainStringTypes = /* @__PURE__ */ new Set([
-  "string",
-  "uuid",
-  "email",
-  "url",
-  "datetime"
-]);
-function isStringType(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 caseParams(params, casing) {
-  if (!casing) return params;
-  return params.map((param) => {
-    const transformed = casing === "camelcase" || !isValidVarName$c(param.name) ? camelCase$f(param.name) : param.name;
-    return {
-      ...param,
-      name: transformed
-    };
-  });
-}
-function syncOptionality(required, schema) {
+function syncOptionality(schema, required) {
   var _a;
   const nullable = (_a = schema.nullable) != null ? _a : false;
   return {
@@ -4680,7 +4622,7 @@ function createProperty(props) {
     ...props,
     kind: "Property",
     required,
-    schema: syncOptionality(required, props.schema)
+    schema: syncOptionality(props.schema, required)
   };
 }
 function createParameter(props) {
@@ -4690,9 +4632,43 @@ function createParameter(props) {
     ...props,
     kind: "Parameter",
     required,
-    schema: syncOptionality(required, props.schema)
+    schema: syncOptionality(props.schema, required)
+  };
+}
+function createFunctionParameter(props) {
+  return {
+    optional: false,
+    ...props,
+    kind: "FunctionParameter"
+  };
+}
+function createTypeNode(props) {
+  return {
+    ...props,
+    kind: "Type"
+  };
+}
+function createParameterGroup(props) {
+  return {
+    ...props,
+    kind: "ParameterGroup"
   };
 }
+function createFunctionParameters(props = {}) {
+  return {
+    params: [],
+    ...props,
+    kind: "FunctionParameters"
+  };
+}
+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 createPrinterFactory((node) => node.type)(build);
 }
@@ -4719,6 +4695,32 @@ function createPrinterFactory(getKey) {
     };
   };
 }
+function toCamelOrPascal$f(text, pascal) {
+  return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+    if (word.length > 1 && word === word.toUpperCase()) return word;
+    if (i === 0 && true) return word.charAt(0).toLowerCase() + word.slice(1);
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  }).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+function applyToFileParts$f(text, transformPart) {
+  const parts = text.split(/\.(?=[a-zA-Z])/);
+  return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+function camelCase$f(text, { isFile, prefix = "", suffix = "" } = {}) {
+  if (isFile) return applyToFileParts$f(text, (part, isLast) => camelCase$f(part, isLast ? {
+    prefix,
+    suffix
+  } : {}));
+  return toCamelOrPascal$f(`${prefix} ${text} ${suffix}`);
+}
+function isValidVarName$c(name) {
+  try {
+    new Function(`var ${name}`);
+  } catch {
+    return false;
+  }
+  return true;
+}
 function createLimit(concurrency) {
   let active = 0;
   const queue = [];
@@ -4767,8 +4769,9 @@ function getChildren(node, recurse) {
     case "Response":
       return node.schema ? [node.schema] : [];
     case "FunctionParameter":
-    case "ObjectBindingParameter":
+    case "ParameterGroup":
     case "FunctionParameters":
+    case "Type":
       return [];
   }
 }
@@ -4915,8 +4918,9 @@ function transform(node, options) {
       };
     }
     case "FunctionParameter":
-    case "ObjectBindingParameter":
+    case "ParameterGroup":
     case "FunctionParameters":
+    case "Type":
       return node;
   }
 }
@@ -4993,12 +4997,228 @@ function collect(node, options) {
   })) results.push(item);
   return results;
 }
+const plainStringTypes = /* @__PURE__ */ new Set([
+  "string",
+  "uuid",
+  "email",
+  "url",
+  "datetime"
+]);
+function isStringType(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 caseParams(params, casing) {
+  if (!casing) return params;
+  return params.map((param) => {
+    const transformed = casing === "camelcase" || !isValidVarName$c(param.name) ? camelCase$f(param.name) : param.name;
+    return {
+      ...param,
+      name: transformed
+    };
+  });
+}
+function resolveType({ node, param, resolver }) {
+  var _a;
+  if (!resolver) return createTypeNode({
+    variant: "reference",
+    name: (_a = param.schema.primitive) != null ? _a : "unknown"
+  });
+  const individualName = resolver.resolveParamName(node, param);
+  const groupLocation = param.in === "path" || param.in === "query" || param.in === "header" ? param.in : void 0;
+  const groupResolvers = {
+    path: resolver.resolvePathParamsName,
+    query: resolver.resolveQueryParamsName,
+    header: resolver.resolveHeaderParamsName
+  };
+  const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : void 0;
+  if (groupName && groupName !== individualName) return createTypeNode({
+    variant: "member",
+    base: groupName,
+    key: param.name
+  });
+  return createTypeNode({
+    variant: "reference",
+    name: individualName
+  });
+}
+function createOperationParams(node, options) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
+  const dataName = (_a = paramNames == null ? void 0 : paramNames.data) != null ? _a : "data";
+  const paramsName = (_b = paramNames == null ? void 0 : paramNames.params) != null ? _b : "params";
+  const headersName = (_c = paramNames == null ? void 0 : paramNames.headers) != null ? _c : "headers";
+  const pathName = (_d = paramNames == null ? void 0 : paramNames.path) != null ? _d : "pathParams";
+  const wrapType = (type) => createTypeNode({
+    variant: "reference",
+    name: typeWrapper ? typeWrapper(type) : type
+  });
+  const wrapTypeNode = (type) => type.variant === "reference" ? wrapType(type.name) : type;
+  const casedParams = caseParams(node.parameters, paramsCasing);
+  const pathParams = casedParams.filter((p) => p.in === "path");
+  const queryParams = casedParams.filter((p) => p.in === "query");
+  const headerParams = casedParams.filter((p) => p.in === "header");
+  const bodyType = ((_e = node.requestBody) == null ? void 0 : _e.schema) ? wrapType((_f = resolver == null ? void 0 : resolver.resolveDataName(node)) != null ? _f : "unknown") : void 0;
+  const bodyRequired = (_h = (_g = node.requestBody) == null ? void 0 : _g.required) != null ? _h : false;
+  const queryGroupType = resolver ? resolveGroupType({
+    node,
+    params: queryParams,
+    groupMethod: resolver.resolveQueryParamsName,
+    resolver
+  }) : void 0;
+  const headerGroupType = resolver ? resolveGroupType({
+    node,
+    params: headerParams,
+    groupMethod: resolver.resolveHeaderParamsName,
+    resolver
+  }) : void 0;
+  const params = [];
+  if (paramsType === "object") {
+    const children = [
+      ...pathParams.map((p) => {
+        const type = resolveType({
+          node,
+          param: p,
+          resolver
+        });
+        return createFunctionParameter({
+          name: p.name,
+          type: wrapTypeNode(type),
+          optional: !p.required
+        });
+      }),
+      ...bodyType ? [createFunctionParameter({
+        name: dataName,
+        type: bodyType,
+        optional: !bodyRequired
+      })] : [],
+      ...buildGroupParam({
+        name: paramsName,
+        node,
+        params: queryParams,
+        groupType: queryGroupType,
+        resolver,
+        wrapType
+      }),
+      ...buildGroupParam({
+        name: headersName,
+        node,
+        params: headerParams,
+        groupType: headerGroupType,
+        resolver,
+        wrapType
+      })
+    ];
+    if (children.length) params.push(createParameterGroup({
+      properties: children,
+      default: children.every((c) => c.optional) ? "{}" : void 0
+    }));
+  } else {
+    if (pathParams.length) if (pathParamsType === "inlineSpread") {
+      const spreadType = (_i = resolver == null ? void 0 : resolver.resolvePathParamsName(node, pathParams[0])) != null ? _i : void 0;
+      params.push(createFunctionParameter({
+        name: pathName,
+        type: spreadType ? wrapType(spreadType) : void 0,
+        rest: true
+      }));
+    } else {
+      const pathChildren = pathParams.map((p) => {
+        const type = resolveType({
+          node,
+          param: p,
+          resolver
+        });
+        return createFunctionParameter({
+          name: p.name,
+          type: wrapTypeNode(type),
+          optional: !p.required
+        });
+      });
+      params.push(createParameterGroup({
+        properties: pathChildren,
+        inline: pathParamsType === "inline",
+        default: pathParamsDefault != null ? pathParamsDefault : pathChildren.every((c) => c.optional) ? "{}" : void 0
+      }));
+    }
+    if (bodyType) params.push(createFunctionParameter({
+      name: dataName,
+      type: bodyType,
+      optional: !bodyRequired
+    }));
+    params.push(...buildGroupParam({
+      name: paramsName,
+      node,
+      params: queryParams,
+      groupType: queryGroupType,
+      resolver,
+      wrapType
+    }));
+    params.push(...buildGroupParam({
+      name: headersName,
+      node,
+      params: headerParams,
+      groupType: headerGroupType,
+      resolver,
+      wrapType
+    }));
+  }
+  params.push(...extraParams);
+  return createFunctionParameters({ params });
+}
+function buildGroupParam({ name, node, params, groupType, resolver, wrapType }) {
+  if (groupType) return [createFunctionParameter({
+    name,
+    type: groupType.type.variant === "reference" ? wrapType(groupType.type.name) : groupType.type,
+    optional: groupType.optional
+  })];
+  if (params.length) return [createFunctionParameter({
+    name,
+    type: toStructType({
+      node,
+      params,
+      resolver
+    }),
+    optional: params.every((p) => !p.required)
+  })];
+  return [];
+}
+function resolveGroupType({ node, params, groupMethod, resolver }) {
+  if (!params.length) return;
+  const firstParam = params[0];
+  const groupName = groupMethod.call(resolver, node, firstParam);
+  if (groupName === resolver.resolveParamName(node, firstParam)) return;
+  const allOptional = params.every((p) => !p.required);
+  return {
+    type: createTypeNode({
+      variant: "reference",
+      name: groupName
+    }),
+    optional: allOptional
+  };
+}
+function toStructType({ node, params, resolver }) {
+  return createTypeNode({
+    variant: "struct",
+    properties: params.map((p) => ({
+      name: p.name,
+      optional: !p.required,
+      type: resolveType({
+        node,
+        param: p,
+        resolver
+      })
+    }))
+  });
+}
 
-var __defProp$i = Object.defineProperty;
+var __defProp$h = Object.defineProperty;
 var __typeError$c = (msg) => {
   throw TypeError(msg);
 };
-var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$b = (obj, key, value) => __defNormalProp$b(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __accessCheck$c = (obj, member, msg) => member.has(obj) || __typeError$c("Cannot " + msg);
 var __privateGet$c = (obj, member, getter) => (__accessCheck$c(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
@@ -5013,9 +5233,7 @@ var __privateWrapper$1 = (obj, member, setter, getter) => ({
     return __privateGet$c(obj, member, getter);
   }
 });
-var _emitter, _a$c, _options$c, _URLPath_instances$a, transformParam_fn$a, eachParam_fn$a, _b$2, _head$1, _tail$1, _size$1, _c, _studioIsOpen, _plugins, _usedPluginNames, _PluginDriver_instances, getSortedPlugins_fn, emitProcessingEnd_fn, execute_fn, executeSync_fn, parse_fn, _d, _items, _FunctionParams_static, _e, orderItems_fn, addParams_fn, _cachedLeaves, _f;
-var ValidationPluginError = class extends Error {
-};
+var _emitter, _a$c, _options$c, _URLPath_instances$a, transformParam_fn$a, eachParam_fn$a, _b$2, _head$1, _tail$1, _size$1, _c, _studioIsOpen, _PluginDriver_instances, emitProcessingEnd_fn, execute_fn, executeSync_fn, _d, _items, _FunctionParams_static, _e, orderItems_fn, addParams_fn, _cachedLeaves, _f;
 function toError(value) {
   return value instanceof Error ? value : new Error(String(value));
 }
@@ -5190,15 +5408,6 @@ async function clean(path2) {
     force: true
   });
 }
-function setUniqueName(originalName, data) {
-  let used = data[originalName] || 0;
-  if (used) {
-    data[originalName] = ++used;
-    return originalName;
-  }
-  data[originalName] = 1;
-  return originalName;
-}
 function isPromiseRejectedResult(result) {
   return result.status === "rejected";
 }
@@ -5674,8 +5883,10 @@ var PluginDriver = (_d = class {
     __publicField$b(this, "rootNode");
     __publicField$b(this, "adapter");
     __privateAdd$c(this, _studioIsOpen, false);
-    __privateAdd$c(this, _plugins, /* @__PURE__ */ new Set());
-    __privateAdd$c(this, _usedPluginNames, {});
+    __publicField$b(this, "plugins", /* @__PURE__ */ new Map());
+    /**
+    * @deprecated use resolvers context instead
+    */
     __publicField$b(this, "resolvePath", (params) => {
       var _a2, _b2;
       const defaultPath = resolve(resolve(this.config.root, this.config.output.path), params.baseName);
@@ -5697,42 +5908,46 @@ var PluginDriver = (_d = class {
         ]
       })) == null ? void 0 : _b2.result) || defaultPath;
     });
+    /**
+    * @deprecated use resolvers context instead
+    */
     __publicField$b(this, "resolveName", (params) => {
-      var _a2;
-      if (params.pluginName) {
-        const names = this.hookForPluginSync({
-          pluginName: params.pluginName,
-          hookName: "resolveName",
-          parameters: [params.name.trim(), params.type]
-        });
-        return transformReservedWord([...new Set(names)].at(0) || params.name);
-      }
-      const name = (_a2 = this.hookFirstSync({
+      var _a2, _b2, _c2;
+      if (params.pluginName) return transformReservedWord((_b2 = (_a2 = this.hookForPluginSync({
+        pluginName: params.pluginName,
+        hookName: "resolveName",
+        parameters: [params.name.trim(), params.type]
+      })) == null ? void 0 : _a2.at(0)) != null ? _b2 : params.name);
+      const name = (_c2 = this.hookFirstSync({
         hookName: "resolveName",
         parameters: [params.name.trim(), params.type]
-      })) == null ? void 0 : _a2.result;
+      })) == null ? void 0 : _c2.result;
       return transformReservedWord(name != null ? name : params.name);
     });
     this.config = config;
     this.options = options;
-    [...config.plugins || []].forEach((plugin) => {
-      const parsedPlugin = __privateMethod$c(this, _PluginDriver_instances, parse_fn).call(this, plugin);
-      __privateGet$c(this, _plugins).add(parsedPlugin);
+    config.plugins.map((plugin) => Object.assign({ install() {
+    } }, plugin)).sort((a, b) => {
+      var _a2, _b2;
+      if ((_a2 = b.pre) == null ? void 0 : _a2.includes(a.name)) return 1;
+      if ((_b2 = b.post) == null ? void 0 : _b2.includes(a.name)) return -1;
+      return 0;
+    }).forEach((plugin) => {
+      this.plugins.set(plugin.name, plugin);
     });
   }
   get events() {
     return this.options.events;
   }
   getContext(plugin) {
-    const plugins = [...__privateGet$c(this, _plugins)];
     const driver = this;
     const baseContext = {
-      fabric: this.options.fabric,
-      config: this.config,
+      fabric: driver.options.fabric,
+      config: driver.config,
       plugin,
-      events: this.options.events,
-      driver: this,
-      mode: getMode(resolve(this.config.root, this.config.output.path)),
+      getPlugin: driver.getPlugin.bind(driver),
+      events: driver.options.events,
+      driver,
       addFile: async (...files) => {
         await this.options.fabric.addFile(...files);
       },
@@ -5745,6 +5960,9 @@ var PluginDriver = (_d = class {
       get adapter() {
         return driver.adapter;
       },
+      get resolver() {
+        return plugin.resolver;
+      },
       openInStudio(options) {
         var _a2, _b2;
         if (!driver.config.devtools || __privateGet$c(driver, _studioIsOpen)) return;
@@ -5756,8 +5974,8 @@ var PluginDriver = (_d = class {
       }
     };
     const mergedExtras = {};
-    for (const p of plugins) if (typeof p.inject === "function") {
-      const result = p.inject.call(baseContext, baseContext);
+    for (const plugin2 of this.plugins.values()) if (typeof plugin2.inject === "function") {
+      const result = plugin2.inject.call(baseContext, baseContext);
       if (result !== null && typeof result === "object") Object.assign(mergedExtras, result);
     }
     return {
@@ -5765,9 +5983,9 @@ var PluginDriver = (_d = class {
       ...mergedExtras
     };
   }
-  get plugins() {
-    return __privateMethod$c(this, _PluginDriver_instances, getSortedPlugins_fn).call(this);
-  }
+  /**
+  * @deprecated use resolvers context instead
+  */
   getFile({ name, mode, extname: extname2, pluginName, options }) {
     const resolvedName = mode ? mode === "single" ? "" : this.resolveName({
       name,
@@ -5794,44 +6012,41 @@ var PluginDriver = (_d = class {
   * Run a specific hookName for plugin x.
   */
   async hookForPlugin({ pluginName, hookName, parameters }) {
-    const plugins = this.getPluginsByName(hookName, pluginName);
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) return [null];
     this.events.emit("plugins:hook:progress:start", {
       hookName,
-      plugins
+      plugins: [plugin]
+    });
+    const result = await __privateMethod$c(this, _PluginDriver_instances, execute_fn).call(this, {
+      strategy: "hookFirst",
+      hookName,
+      parameters,
+      plugin
     });
-    const items = [];
-    for (const plugin of plugins) {
-      const result = await __privateMethod$c(this, _PluginDriver_instances, execute_fn).call(this, {
-        strategy: "hookFirst",
-        hookName,
-        parameters,
-        plugin
-      });
-      if (result !== void 0 && result !== null) items.push(result);
-    }
     this.events.emit("plugins:hook:progress:end", { hookName });
-    return items;
+    return [result];
   }
   /**
   * Run a specific hookName for plugin x.
   */
   hookForPluginSync({ pluginName, hookName, parameters }) {
-    return this.getPluginsByName(hookName, pluginName).map((plugin) => {
-      return __privateMethod$c(this, _PluginDriver_instances, executeSync_fn).call(this, {
-        strategy: "hookFirst",
-        hookName,
-        parameters,
-        plugin
-      });
-    }).filter((x2) => x2 !== null);
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) return null;
+    const result = __privateMethod$c(this, _PluginDriver_instances, executeSync_fn).call(this, {
+      strategy: "hookFirst",
+      hookName,
+      parameters,
+      plugin
+    });
+    return result !== null ? [result] : [];
   }
   /**
   * Returns the first non-null result.
   */
   async hookFirst({ hookName, parameters, skipped }) {
-    const plugins = __privateMethod$c(this, _PluginDriver_instances, getSortedPlugins_fn).call(this, hookName).filter((plugin) => {
-      return skipped ? !skipped.has(plugin) : true;
-    });
+    const plugins = [];
+    for (const plugin of this.plugins.values()) if (hookName in plugin && (skipped ? !skipped.has(plugin) : true)) plugins.push(plugin);
     this.events.emit("plugins:hook:progress:start", {
       hookName,
       plugins
@@ -5858,10 +6073,9 @@ var PluginDriver = (_d = class {
   */
   hookFirstSync({ hookName, parameters, skipped }) {
     let parseResult = null;
-    const plugins = __privateMethod$c(this, _PluginDriver_instances, getSortedPlugins_fn).call(this, hookName).filter((plugin) => {
-      return skipped ? !skipped.has(plugin) : true;
-    });
-    for (const plugin of plugins) {
+    for (const plugin of this.plugins.values()) {
+      if (!(hookName in plugin)) continue;
+      if (skipped == null ? void 0 : skipped.has(plugin)) continue;
       parseResult = {
         result: __privateMethod$c(this, _PluginDriver_instances, executeSync_fn).call(this, {
           strategy: "hookFirst",
@@ -5871,7 +6085,7 @@ var PluginDriver = (_d = class {
         }),
         plugin
       };
-      if ((parseResult == null ? void 0 : parseResult.result) != null) break;
+      if (parseResult.result != null) break;
     }
     return parseResult;
   }
@@ -5879,7 +6093,8 @@ var PluginDriver = (_d = class {
   * Runs all plugins in parallel based on `this.plugin` order and `pre`/`post` settings.
   */
   async hookParallel({ hookName, parameters }) {
-    const plugins = __privateMethod$c(this, _PluginDriver_instances, getSortedPlugins_fn).call(this, hookName);
+    const plugins = [];
+    for (const plugin of this.plugins.values()) if (hookName in plugin) plugins.push(plugin);
     this.events.emit("plugins:hook:progress:start", {
       hookName,
       plugins
@@ -5899,7 +6114,7 @@ var PluginDriver = (_d = class {
     results.forEach((result, index) => {
       var _a2;
       if (isPromiseRejectedResult(result)) {
-        const plugin = __privateMethod$c(this, _PluginDriver_instances, getSortedPlugins_fn).call(this, hookName)[index];
+        const plugin = plugins[index];
         if (plugin) {
           const startTime = (_a2 = pluginStartTimes.get(plugin)) != null ? _a2 : performance$1.now();
           this.events.emit("error", result.reason, {
@@ -5922,7 +6137,8 @@ var PluginDriver = (_d = class {
   * Chains plugins
   */
   async hookSeq({ hookName, parameters }) {
-    const plugins = __privateMethod$c(this, _PluginDriver_instances, getSortedPlugins_fn).call(this, hookName);
+    const plugins = [];
+    for (const plugin of this.plugins.values()) if (hookName in plugin) plugins.push(plugin);
     this.events.emit("plugins:hook:progress:start", {
       hookName,
       plugins
@@ -5937,35 +6153,10 @@ var PluginDriver = (_d = class {
     }));
     this.events.emit("plugins:hook:progress:end", { hookName });
   }
-  getPluginByName(pluginName) {
-    return [...__privateGet$c(this, _plugins)].find((item) => item.name === pluginName);
+  getPlugin(pluginName) {
+    return this.plugins.get(pluginName);
   }
-  getPluginsByName(hookName, pluginName) {
-    const plugins = [...this.plugins];
-    const pluginByPluginName = plugins.filter((plugin) => hookName in plugin).filter((item) => item.name === pluginName);
-    if (!(pluginByPluginName == null ? void 0 : pluginByPluginName.length)) {
-      const corePlugin = plugins.find((plugin) => plugin.name === "core" && hookName in plugin);
-      return corePlugin ? [corePlugin] : [];
-    }
-    return pluginByPluginName;
-  }
-}, _studioIsOpen = new WeakMap(), _plugins = new WeakMap(), _usedPluginNames = new WeakMap(), _PluginDriver_instances = new WeakSet(), getSortedPlugins_fn = function(hookName) {
-  const plugins = [...__privateGet$c(this, _plugins)];
-  if (hookName) return plugins.filter((plugin) => hookName in plugin);
-  return plugins.map((plugin) => {
-    if (plugin.pre) {
-      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;
-  }).sort((a, b) => {
-    var _a2, _b2;
-    if ((_a2 = b.pre) == null ? void 0 : _a2.includes(a.name)) return 1;
-    if ((_b2 = b.post) == null ? void 0 : _b2.includes(a.name)) return -1;
-    return 0;
-  });
-}, /**
+}, _studioIsOpen = new WeakMap(), _PluginDriver_instances = new WeakSet(), /**
 * Run an async plugin hook and return the result.
 * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
 * @param args Arguments passed to the plugin hook.
@@ -6048,16 +6239,6 @@ executeSync_fn = function({ strategy, hookName, parameters, plugin }) {
     });
     return null;
   }
-}, parse_fn = function(plugin) {
-  const usedPluginNames = __privateGet$c(this, _usedPluginNames);
-  setUniqueName(plugin.name, usedPluginNames);
-  const usageCount = usedPluginNames[plugin.name];
-  if (usageCount && usageCount > 1) throw new ValidationPluginError(`Duplicate plugin "${plugin.name}" detected. Each plugin can only be used once. Use a different configuration instead of adding multiple instances of the same plugin.`);
-  return {
-    install() {
-    },
-    ...plugin
-  };
 }, _d);
 function createStorage(build2) {
   return (options) => build2(options != null ? options : {});
@@ -6108,7 +6289,7 @@ const fsStorage = createStorage(() => ({
     await clean(resolve(base));
   }
 }));
-var version$1 = "5.0.0-alpha.22";
+var version$1 = "5.0.0-alpha.24";
 function getDiagnosticInfo() {
   return {
     nodeVersion: version$2,
@@ -6252,7 +6433,7 @@ async function safeBuild(options, overrides) {
   const pluginTimings = /* @__PURE__ */ new Map();
   const config = driver.config;
   try {
-    for (const plugin of driver.plugins) {
+    for (const plugin of driver.plugins.values()) {
       const context = driver.getContext(plugin);
       const hrStart = process.hrtime();
       const installer = plugin.install.bind(context);
@@ -6362,7 +6543,7 @@ async function safeBuild(options, overrides) {
 }
 function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }) {
   const pluginNameMap = /* @__PURE__ */ new Map();
-  for (const plugin of driver.plugins) pluginNameMap.set(plugin.name, plugin);
+  for (const plugin of driver.plugins.values()) pluginNameMap.set(plugin.name, plugin);
   return barrelFiles.flatMap((file) => {
     var _a2, _b2;
     const containsOnlyTypes = (_a2 = file.sources) == null ? void 0 : _a2.every((source) => source.isTypeOnly);
@@ -6403,9 +6584,6 @@ function inputToAdapterSource(config) {
 function createPlugin(build2) {
   return (options) => build2(options != null ? options : {});
 }
-function defineBuilder(build2) {
-  return build2();
-}
 function defineGenerator(generator) {
   if (generator.type === "react") return {
     version: "2",
@@ -6434,14 +6612,6 @@ function defineGenerator(generator) {
     ...generator
   };
 }
-function definePreset(name, { resolvers, transformers, generators }) {
-  return {
-    name,
-    resolvers,
-    transformers,
-    generators
-  };
-}
 function definePresets(presets) {
   return presets;
 }
@@ -6500,13 +6670,7 @@ function defaultResolveOptions(node, { options, exclude = [], include, override
 }
 function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root, output, group }) {
   if ((pathMode != null ? pathMode : getMode(path$2.resolve(root, output.path))) === "single") return path$2.resolve(root, output.path);
-  if (group && (groupPath || tag)) {
-    const groupName = group.name ? group.name : (ctx) => {
-      if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-      return `${camelCase$e(ctx.group)}Controller`;
-    };
-    return path$2.resolve(root, output.path, groupName({ group: group.type === "path" ? groupPath : tag }), baseName);
-  }
+  if (group && (groupPath || tag)) return path$2.resolve(root, output.path, group.name({ group: group.type === "path" ? groupPath : tag }), baseName);
   return path$2.resolve(root, output.path, baseName);
 }
 function defaultResolveFile({ name, extname: extname2, tag, path: groupPath }, context) {
@@ -6582,19 +6746,15 @@ async function renderOperation$1(node, options) {
   const { config, fabric, plugin, Component, adapter, driver } = options;
   if (!Component) return;
   const fabricChild = createReactFabric();
-  await fabricChild.render(/* @__PURE__ */ jsx(Fabric, {
-    meta: {
-      plugin,
-      driver
-    },
-    children: /* @__PURE__ */ jsx(Component, {
-      config,
-      plugin,
-      adapter,
-      node,
-      options: options.options
-    })
-  }));
+  await fabricChild.render(/* @__PURE__ */ jsx(Fabric, { children: /* @__PURE__ */ jsx(Component, {
+    config,
+    plugin,
+    driver,
+    adapter,
+    node,
+    options: options.options,
+    resolver: options.resolver
+  }) }));
   fabric.context.fileManager.upsert(...fabricChild.files);
   fabricChild.unmount();
 }
@@ -6602,19 +6762,15 @@ async function renderSchema$1(node, options) {
   const { config, fabric, plugin, Component, adapter, driver } = options;
   if (!Component) return;
   const fabricChild = createReactFabric();
-  await fabricChild.render(/* @__PURE__ */ jsx(Fabric, {
-    meta: {
-      plugin,
-      driver
-    },
-    children: /* @__PURE__ */ jsx(Component, {
-      config,
-      plugin,
-      adapter,
-      node,
-      options: options.options
-    })
-  }));
+  await fabricChild.render(/* @__PURE__ */ jsx(Fabric, { children: /* @__PURE__ */ jsx(Component, {
+    config,
+    plugin,
+    driver,
+    adapter,
+    node,
+    options: options.options,
+    resolver: options.resolver
+  }) }));
   fabric.context.fileManager.upsert(...fabricChild.files);
   fabricChild.unmount();
 }
@@ -6967,7 +7123,10 @@ async function getBarrelFiles(files, { type, meta = {}, root, output }) {
 }
 async function getConfigs(config, args) {
   const resolved = await (typeof config === "function" ? config(args) : config);
-  return (Array.isArray(resolved) ? resolved : [resolved]).map((item) => ({ ...item }));
+  return (Array.isArray(resolved) ? resolved : [resolved]).map((item) => ({
+    plugins: [],
+    ...item
+  }));
 }
 function mergeResolvers(...resolvers) {
   return resolvers.reduce((acc, curr) => ({
@@ -6977,7 +7136,7 @@ function mergeResolvers(...resolvers) {
 }
 function getPreset(params) {
   var _a2, _b2, _c2, _d2, _e2;
-  const { preset: presetName, presets, resolvers, transformers: userTransformers, generators: userGenerators } = params;
+  const { preset: presetName, presets, resolvers = [], transformers: userTransformers = [], generators: userGenerators = [] } = params;
   const [defaultResolver2, ...userResolvers] = resolvers;
   const preset = presets[presetName];
   const resolver = mergeResolvers(mergeResolvers(defaultResolver2, ...(_a2 = preset == null ? void 0 : preset.resolvers) != null ? _a2 : []), ...userResolvers != null ? userResolvers : []);
@@ -7036,7 +7195,7 @@ function satisfiesDependency(dependency, version2, cwd) {
   return satisfies(semVer, version2);
 }
 
-var version = "5.0.0-alpha.22";
+var version = "5.0.0-alpha.24";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -7227,8 +7386,8 @@ async function loadConfig(resolvedConfigPath) {
   return configs[0];
 }
 
-var __defProp$h = Object.defineProperty;
-var __name$6 = (target, value) => __defProp$h(target, "name", {
+var __defProp$g = Object.defineProperty;
+var __name$5 = (target, value) => __defProp$g(target, "name", {
   value,
   configurable: true
 });
@@ -7362,11 +7521,11 @@ function isKeyword(meta, keyword) {
   return meta.keyword === keyword;
 }
 
-var __defProp$g = Object.defineProperty;
+var __defProp$f = Object.defineProperty;
 var __typeError$b = (msg) => {
   throw TypeError(msg);
 };
-var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$a = (obj, key, value) => __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __accessCheck$b = (obj, member, msg) => member.has(obj) || __typeError$b("Cannot " + msg);
 var __privateGet$b = (obj, member, getter) => (__accessCheck$b(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
@@ -8106,11 +8265,11 @@ function resolveServerUrl(server, overrides) {
   return url;
 }
 
-var __defProp$f = Object.defineProperty;
+var __defProp$e = Object.defineProperty;
 var __typeError$a = (msg) => {
   throw TypeError(msg);
 };
-var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$9 = (obj, key, value) => __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __accessCheck$a = (obj, member, msg) => member.has(obj) || __typeError$a("Cannot " + msg);
 var __privateGet$a = (obj, member, getter) => (__accessCheck$a(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
@@ -9344,11 +9503,11 @@ function withRequiredRequestBodySchema(operationSchema) {
   };
 }
 
-var __defProp$e = Object.defineProperty;
+var __defProp$d = Object.defineProperty;
 var __typeError$9 = (msg) => {
   throw TypeError(msg);
 };
-var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$8 = (obj, key, value) => __defNormalProp$8(obj, key + "" , value);
 var __accessCheck$9 = (obj, member, msg) => member.has(obj) || __typeError$9("Cannot " + msg);
 var __privateGet$9 = (obj, member, getter) => (__accessCheck$9(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
@@ -9594,11 +9753,11 @@ function isParameterSchema(schemaName) {
   return lowerName.includes("pathparams") || lowerName.includes("queryparams") || lowerName.includes("headerparams");
 }
 
-var __defProp$d = Object.defineProperty;
+var __defProp$c = Object.defineProperty;
 var __typeError$8 = (msg) => {
   throw TypeError(msg);
 };
-var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$7 = (obj, key, value) => __defNormalProp$7(obj, key + "" , value);
 var __accessCheck$8 = (obj, member, msg) => member.has(obj) || __typeError$8("Cannot " + msg);
 var __privateGet$8 = (obj, member, getter) => (__accessCheck$8(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
@@ -9802,7 +9961,7 @@ function getParams$1$5({ paramsType, paramsCasing, pathParamsType, typeSchemas }
     default: getDefaultValue((_b = typeSchemas.pathParams) == null ? void 0 : _b.schema)
   } : void 0 });
 }
-__name$6(getParams$1$5, "getParams");
+__name$5(getParams$1$5, "getParams");
 function Url({ name, isExportable = true, isIndexable = true, typeSchemas, baseURL, paramsType, paramsCasing, pathParamsType, operation }) {
   const path = new URLPath$7(operation.path);
   const params = getParams$1$5({
@@ -9983,7 +10142,7 @@ Client.getParams = getParams$d;
 function buildHeaders$1(contentType, hasHeaderParams) {
   return [contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : void 0, hasHeaderParams ? "...headers" : void 0].filter(Boolean);
 }
-__name$6(buildHeaders$1, "buildHeaders");
+__name$5(buildHeaders$1, "buildHeaders");
 function buildGenerics$1(typeSchemas) {
   var _a2, _b;
   const TError = `ResponseErrorConfig<${((_a2 = typeSchemas.errors) == null ? void 0 : _a2.map((item) => item.name).join(" | ")) || "Error"}>`;
@@ -9993,7 +10152,7 @@ function buildGenerics$1(typeSchemas) {
     ((_b = typeSchemas.request) == null ? void 0 : _b.name) || "unknown"
   ].filter(Boolean);
 }
-__name$6(buildGenerics$1, "buildGenerics");
+__name$5(buildGenerics$1, "buildGenerics");
 function buildClientParams$1({ operation, path, baseURL, typeSchemas, isFormData, headers }) {
   var _a2, _b;
   return FunctionParams.factory({ config: {
@@ -10009,25 +10168,25 @@ function buildClientParams$1({ operation, path, baseURL, typeSchemas, isFormData
     }
   } });
 }
-__name$6(buildClientParams$1, "buildClientParams");
+__name$5(buildClientParams$1, "buildClientParams");
 function buildRequestDataLine$1({ parser, zodSchemas, typeSchemas }) {
   var _a2, _b;
   if (parser === "zod" && ((_a2 = zodSchemas == null ? void 0 : zodSchemas.request) == null ? void 0 : _a2.name)) return `const requestData = ${zodSchemas.request.name}.parse(data)`;
   if ((_b = typeSchemas == null ? void 0 : typeSchemas.request) == null ? void 0 : _b.name) return "const requestData = data";
   return "";
 }
-__name$6(buildRequestDataLine$1, "buildRequestDataLine");
+__name$5(buildRequestDataLine$1, "buildRequestDataLine");
 function buildFormDataLine$1(isFormData, hasRequest) {
   return isFormData && hasRequest ? "const formData = buildFormData(requestData)" : "";
 }
-__name$6(buildFormDataLine$1, "buildFormDataLine");
+__name$5(buildFormDataLine$1, "buildFormDataLine");
 function buildReturnStatement$1({ dataReturnType, parser, zodSchemas }) {
   if (dataReturnType === "full" && parser === "zod" && zodSchemas) return `return {...res, data: ${zodSchemas.response.name}.parse(res.data)}`;
   if (dataReturnType === "data" && parser === "zod" && zodSchemas) return `return ${zodSchemas.response.name}.parse(res.data)`;
   if (dataReturnType === "full" && parser === "client") return "return res";
   return "return res.data";
 }
-__name$6(buildReturnStatement$1, "buildReturnStatement");
+__name$5(buildReturnStatement$1, "buildReturnStatement");
 function generateMethod$1({ operation, name, typeSchemas, zodSchemas, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType }) {
   var _a2, _b;
   const path = new URLPath$7(operation.path, { casing: paramsCasing });
@@ -10074,7 +10233,7 @@ function generateMethod$1({ operation, name, typeSchemas, zodSchemas, baseURL, d
 ${methodBody}
   }`;
 }
-__name$6(generateMethod$1, "generateMethod");
+__name$5(generateMethod$1, "generateMethod");
 function ClassClient({ name, isExportable = true, isIndexable = true, operations, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType, children }) {
   const classCode = `export class ${name} {
   #config: Partial<RequestConfig> & { client?: Client }
@@ -11451,157 +11610,6 @@ function Zod({ name, typeName, tree, schema, inferTypeName, mapper, coercion, ke
   })] });
 }
 
-var __defProp$c = Object.defineProperty;
-var __name$5 = (target, value) => __defProp$c(target, "name", {
-  value,
-  configurable: true
-});
-
-const builderTs = defineBuilder(() => ({
-  name: "default",
-  buildParams({ params, node, resolver }) {
-    return createSchema({
-      type: "object",
-      properties: params.map((param) => createProperty({
-        name: param.name,
-        required: param.required,
-        schema: createSchema({
-          type: "ref",
-          name: resolver.resolveParamName(node, param)
-        })
-      }))
-    });
-  },
-  buildData({ node, resolver }) {
-    var _a;
-    const pathParams = node.parameters.filter((p) => p.in === "path");
-    const queryParams = node.parameters.filter((p) => p.in === "query");
-    const headerParams = node.parameters.filter((p) => p.in === "header");
-    return createSchema({
-      type: "object",
-      deprecated: node.deprecated,
-      properties: [
-        createProperty({
-          name: "data",
-          schema: ((_a = node.requestBody) == null ? void 0 : _a.schema) ? createSchema({
-            type: "ref",
-            name: resolver.resolveDataTypedName(node),
-            optional: true
-          }) : createSchema({
-            type: "never",
-            optional: true
-          })
-        }),
-        createProperty({
-          name: "pathParams",
-          required: pathParams.length > 0,
-          schema: pathParams.length > 0 ? this.buildParams({
-            params: pathParams,
-            node,
-            resolver
-          }) : createSchema({ type: "never" })
-        }),
-        createProperty({
-          name: "queryParams",
-          schema: queryParams.length > 0 ? createSchema({
-            ...this.buildParams({
-              params: queryParams,
-              node,
-              resolver
-            }),
-            optional: true
-          }) : createSchema({
-            type: "never",
-            optional: true
-          })
-        }),
-        createProperty({
-          name: "headerParams",
-          schema: headerParams.length > 0 ? createSchema({
-            ...this.buildParams({
-              params: headerParams,
-              node,
-              resolver
-            }),
-            optional: true
-          }) : createSchema({
-            type: "never",
-            optional: true
-          })
-        }),
-        createProperty({
-          name: "url",
-          required: true,
-          schema: createSchema({
-            type: "url",
-            path: node.path
-          })
-        })
-      ]
-    });
-  },
-  buildResponses({ node, resolver }) {
-    if (node.responses.length === 0) return null;
-    return createSchema({
-      type: "object",
-      properties: node.responses.map((res) => createProperty({
-        name: String(res.statusCode),
-        required: true,
-        schema: createSchema({
-          type: "ref",
-          name: resolver.resolveResponseStatusTypedName(node, res.statusCode)
-        })
-      }))
-    });
-  },
-  buildResponseUnion({ node, resolver }) {
-    const responsesWithSchema = node.responses.filter((res) => res.schema);
-    if (responsesWithSchema.length === 0) return null;
-    return createSchema({
-      type: "union",
-      members: responsesWithSchema.map((res) => createSchema({
-        type: "ref",
-        name: resolver.resolveResponseStatusTypedName(node, res.statusCode)
-      }))
-    });
-  }
-}));
-
-function toCamelOrPascal$a(text, pascal) {
-  return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-    if (word.length > 1 && word === word.toUpperCase()) return word;
-    if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-    return word.charAt(0).toUpperCase() + word.slice(1);
-  }).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-function applyToFileParts$a(text, transformPart) {
-  const parts = text.split(/\.(?=[a-zA-Z])/);
-  return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
-}
-function camelCase$a(text, { isFile, prefix = "", suffix = "" } = {}) {
-  if (isFile) return applyToFileParts$a(text, (part, isLast) => camelCase$a(part, isLast ? {
-    prefix,
-    suffix
-  } : {}));
-  return toCamelOrPascal$a(`${prefix} ${text} ${suffix}`, false);
-}
-function pascalCase$6(text, { isFile, prefix = "", suffix = "" } = {}) {
-  if (isFile) return applyToFileParts$a(text, (part, isLast) => isLast ? pascalCase$6(part, {
-    prefix,
-    suffix
-  }) : camelCase$a(part));
-  return toCamelOrPascal$a(`${prefix} ${text} ${suffix}`, true);
-}
-function snakeCase(text, { prefix = "", suffix = "" } = {}) {
-  return `${prefix} ${text} ${suffix}`.trim().replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s\-.]+/g, "_").replace(/[^a-zA-Z0-9_]/g, "").toLowerCase().split("_").filter(Boolean).join("_");
-}
-function screamingSnakeCase(text, { prefix = "", suffix = "" } = {}) {
-  return snakeCase(text, {
-    prefix,
-    suffix
-  }).toUpperCase();
-}
-
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : "undefined" !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function getDefaultExportFromCjs (x) {
@@ -209486,6 +209494,40 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
 var typescriptExports = typescript.exports;
 const ts = /*@__PURE__*/getDefaultExportFromCjs(typescriptExports);
 
+function toCamelOrPascal$a(text, pascal) {
+  return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+    if (word.length > 1 && word === word.toUpperCase()) return word;
+    if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  }).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+function applyToFileParts$a(text, transformPart) {
+  const parts = text.split(/\.(?=[a-zA-Z])/);
+  return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+function camelCase$a(text, { isFile, prefix = "", suffix = "" } = {}) {
+  if (isFile) return applyToFileParts$a(text, (part, isLast) => camelCase$a(part, isLast ? {
+    prefix,
+    suffix
+  } : {}));
+  return toCamelOrPascal$a(`${prefix} ${text} ${suffix}`, false);
+}
+function pascalCase$6(text, { isFile, prefix = "", suffix = "" } = {}) {
+  if (isFile) return applyToFileParts$a(text, (part, isLast) => isLast ? pascalCase$6(part, {
+    prefix,
+    suffix
+  }) : camelCase$a(part));
+  return toCamelOrPascal$a(`${prefix} ${text} ${suffix}`, true);
+}
+function snakeCase(text, { prefix = "", suffix = "" } = {}) {
+  return `${prefix} ${text} ${suffix}`.trim().replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s\-.]+/g, "_").replace(/[^a-zA-Z0-9_]/g, "").toLowerCase().split("_").filter(Boolean).join("_");
+}
+function screamingSnakeCase(text, { prefix = "", suffix = "" } = {}) {
+  return snakeCase(text, {
+    prefix,
+    suffix
+  }).toUpperCase();
+}
 function trimQuotes$1(text) {
   if (text.length >= 2) {
     const first = text[0];
@@ -209697,8 +209739,8 @@ const keywordTypeNodes = {
   null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword)),
   never: factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
 };
-function createUrlTemplateType(path) {
-  const normalized = path.replace(/:([^/]+)/g, "{$1}");
+function createUrlTemplateType(path2) {
+  const normalized = path2.replace(/:([^/]+)/g, "{$1}");
   if (!normalized.includes("{")) return factory.createLiteralTypeNode(factory.createStringLiteral(normalized));
   const segments = normalized.split(/(\{[^}]+\})/);
   const parts = [];
@@ -209736,211 +209778,11 @@ const createFalse = factory.createFalse;
 factory.createIndexedAccessTypeNode;
 factory.createTypeOperatorNode;
 const createPrefixUnaryExpression = factory.createPrefixUnaryExpression;
-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 = OPTIONAL_ADDS_UNDEFINED.has(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) {
-  const isArray = schema.type === "array";
-  return [
-    "description" in schema && schema.description ? `@description ${jsStringEscape$1(schema.description)}` : void 0,
-    "deprecated" in schema && schema.deprecated ? "@deprecated" : void 0,
-    !isArray && "min" in schema && schema.min !== void 0 ? `@minLength ${schema.min}` : void 0,
-    !isArray && "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) => {
-  const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType);
-  return {
-    name: "typescript",
-    options,
-    nodes: {
-      any: () => keywordTypeNodes.any,
-      unknown: () => keywordTypeNodes.unknown,
-      void: () => keywordTypeNodes.void,
-      never: () => keywordTypeNodes.never,
-      boolean: () => keywordTypeNodes.boolean,
-      null: () => keywordTypeNodes.null,
-      blob: () => createTypeReferenceNode("Blob", []),
-      string: () => keywordTypeNodes.string,
-      uuid: () => keywordTypeNodes.string,
-      email: () => keywordTypeNodes.string,
-      url: (node) => {
-        if (node.path) return createUrlTemplateType(node.path);
-        return keywordTypeNodes.string;
-      },
-      datetime: () => keywordTypeNodes.string,
-      number: () => keywordTypeNodes.number,
-      integer: () => keywordTypeNodes.number,
-      bigint: () => keywordTypeNodes.bigint,
-      date: dateOrStringNode,
-      time: dateOrStringNode,
-      ref(node) {
-        var _a;
-        if (!node.name) return;
-        const refName = node.ref ? (_a = node.ref.split("/").at(-1)) != null ? _a : node.name : node.name;
-        return createTypeReferenceNode(node.ref ? this.options.resolver.default(refName, "type") : refName, 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)).filter(Boolean)
-        })) != null ? _d : void 0;
-        return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix ? this.options.resolver.resolveEnumKeyTypedName(node, this.options.enumTypeSuffix) : this.options.resolver.default(node.name, "type"), void 0);
-      },
-      union(node) {
-        var _a, _b, _c;
-        const members = (_a = node.members) != null ? _a : [];
-        const hasStringLiteral = members.some((m) => {
-          var _a2;
-          return ((_a2 = narrowSchema(m, schemaTypes.enum)) == null ? void 0 : _a2.primitive) === "string";
-        });
-        const hasPlainString = members.some((m) => isStringType(m));
-        if (hasStringLiteral && hasPlainString) return (_b = createUnionDeclaration({
-          withParentheses: true,
-          nodes: members.map((m) => {
-            if (isStringType(m)) return createIntersectionDeclaration({
-              nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
-              withParentheses: true
-            });
-            return this.transform(m);
-          }).filter(Boolean)
-        })) != null ? _b : void 0;
-        return (_c = createUnionDeclaration({
-          withParentheses: true,
-          nodes: buildMemberNodes(members, this.transform)
-        })) != null ? _c : void 0;
-      },
-      intersection(node) {
-        var _a;
-        return (_a = createIntersectionDeclaration({
-          withParentheses: true,
-          nodes: buildMemberNodes(node.members, this.transform)
-        })) != null ? _a : void 0;
-      },
-      array(node) {
-        var _a, _b;
-        return (_b = createArrayDeclaration({
-          nodes: ((_a = node.items) != null ? _a : []).map((item) => this.transform(item)).filter(Boolean),
-          arrayType: this.options.arrayType
-        })) != null ? _b : void 0;
-      },
-      tuple(node) {
-        return buildTupleNode(node, this.transform);
-      },
-      object(node) {
-        const { transform, options: options2 } = this;
-        const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options2.optionalType);
-        const propertyNodes = node.properties.map((prop) => {
-          var _a;
-          const baseType = (_a = transform(prop.schema)) != null ? _a : keywordTypeNodes.unknown;
-          const type = buildPropertyType(prop.schema, baseType, options2.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, transform)];
-        if (!allElements.length) return keywordTypeNodes.object;
-        return createTypeLiteralNode(allElements);
-      }
-    },
-    print(node) {
-      let type = this.transform(node);
-      if (!type) return null;
-      if (node.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-      if ((node.nullish || node.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-      const { typeName, syntaxType = "type", description, keysToOmit } = this.options;
-      if (!typeName) return safePrint(type);
-      const useTypeGeneration = syntaxType === "type" || type.kind === syntaxKind.union || !!(keysToOmit == null ? void 0 : keysToOmit.length);
-      return safePrint(createTypeDeclaration({
-        name: typeName,
-        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
-        ]
-      }));
-    }
-  };
-});
-
 function getEnumNames({ node, enumType, enumTypeSuffix, resolver }) {
   const resolved = resolver.default(node.name, "type");
   return {
     enumName: enumType === "asPascalConst" ? resolved : camelCase$a(node.name),
-    typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? resolver.resolveEnumKeyTypedName(node, enumTypeSuffix) : resolved,
-    refName: resolved
+    typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolved
   };
 }
 function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
@@ -209972,7 +209814,205 @@ function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
     children: safePrint(typeNode)
   })] });
 }
-function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumTypeSuffix, enumKeyCasing, description, resolver }) {
+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 = OPTIONAL_ADDS_UNDEFINED.has(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) {
+  const isArray = schema.type === "array";
+  return [
+    "description" in schema && schema.description ? `@description ${jsStringEscape$1(schema.description)}` : void 0,
+    "deprecated" in schema && schema.deprecated ? "@deprecated" : void 0,
+    !isArray && "min" in schema && schema.min !== void 0 ? `@minLength ${schema.min}` : void 0,
+    !isArray && "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) => {
+  const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType);
+  return {
+    name: "typescript",
+    options,
+    nodes: {
+      any: () => keywordTypeNodes.any,
+      unknown: () => keywordTypeNodes.unknown,
+      void: () => keywordTypeNodes.void,
+      never: () => keywordTypeNodes.never,
+      boolean: () => keywordTypeNodes.boolean,
+      null: () => keywordTypeNodes.null,
+      blob: () => createTypeReferenceNode("Blob", []),
+      string: () => keywordTypeNodes.string,
+      uuid: () => keywordTypeNodes.string,
+      email: () => keywordTypeNodes.string,
+      url: (node) => {
+        if (node.path) return createUrlTemplateType(node.path);
+        return keywordTypeNodes.string;
+      },
+      datetime: () => keywordTypeNodes.string,
+      number: () => keywordTypeNodes.number,
+      integer: () => keywordTypeNodes.number,
+      bigint: () => keywordTypeNodes.bigint,
+      date: dateOrStringNode,
+      time: dateOrStringNode,
+      ref(node) {
+        var _a, _b;
+        if (!node.name) return;
+        const refName = node.ref ? (_a = node.ref.split("/").at(-1)) != null ? _a : node.name : node.name;
+        return createTypeReferenceNode(node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix && ((_b = this.options.enumSchemaNames) == null ? void 0 : _b.has(refName)) ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enumTypeSuffix) : node.ref ? this.options.resolver.default(refName, "type") : refName, 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)).filter(Boolean)
+        })) != null ? _d : void 0;
+        return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix ? this.options.resolver.resolveEnumKeyName(node, this.options.enumTypeSuffix) : this.options.resolver.default(node.name, "type"), void 0);
+      },
+      union(node) {
+        var _a, _b, _c;
+        const members = (_a = node.members) != null ? _a : [];
+        const hasStringLiteral = members.some((m) => {
+          var _a2;
+          return ((_a2 = narrowSchema(m, schemaTypes.enum)) == null ? void 0 : _a2.primitive) === "string";
+        });
+        const hasPlainString = members.some((m) => isStringType(m));
+        if (hasStringLiteral && hasPlainString) return (_b = createUnionDeclaration({
+          withParentheses: true,
+          nodes: members.map((m) => {
+            if (isStringType(m)) return createIntersectionDeclaration({
+              nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
+              withParentheses: true
+            });
+            return this.transform(m);
+          }).filter(Boolean)
+        })) != null ? _b : void 0;
+        return (_c = createUnionDeclaration({
+          withParentheses: true,
+          nodes: buildMemberNodes(members, this.transform)
+        })) != null ? _c : void 0;
+      },
+      intersection(node) {
+        var _a;
+        return (_a = createIntersectionDeclaration({
+          withParentheses: true,
+          nodes: buildMemberNodes(node.members, this.transform)
+        })) != null ? _a : void 0;
+      },
+      array(node) {
+        var _a, _b;
+        return (_b = createArrayDeclaration({
+          nodes: ((_a = node.items) != null ? _a : []).map((item) => this.transform(item)).filter(Boolean),
+          arrayType: this.options.arrayType
+        })) != null ? _b : void 0;
+      },
+      tuple(node) {
+        return buildTupleNode(node, this.transform);
+      },
+      object(node) {
+        const { transform: transform2, options: options2 } = this;
+        const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options2.optionalType);
+        const propertyNodes = node.properties.map((prop) => {
+          var _a;
+          const baseType = (_a = transform2(prop.schema)) != null ? _a : keywordTypeNodes.unknown;
+          const type = buildPropertyType(prop.schema, baseType, options2.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, transform2)];
+        if (!allElements.length) return keywordTypeNodes.object;
+        return createTypeLiteralNode(allElements);
+      }
+    },
+    print(node) {
+      let type = this.transform(node);
+      if (!type) return null;
+      if (node.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
+      if ((node.nullish || node.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+      const { name, syntaxType = "type", description, keysToOmit } = this.options;
+      if (!name) return safePrint(type);
+      const useTypeGeneration = syntaxType === "type" || type.kind === syntaxKind.union || !!(keysToOmit == null ? void 0 : keysToOmit.length);
+      return safePrint(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
+        ]
+      }));
+    }
+  };
+});
+function Type({ name, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumTypeSuffix, enumKeyCasing, description, resolver, enumSchemaNames }) {
   const resolvedDescription = description || (node == null ? void 0 : node.description);
   const enumSchemaNodes = collect(node, { schema(n) {
     const enumNode = narrowSchema(n, schemaTypes.enum);
@@ -209983,11 +210023,12 @@ function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, synt
     arrayType,
     enumType,
     enumTypeSuffix,
-    typeName: name,
+    name,
     syntaxType,
     description: resolvedDescription,
     keysToOmit,
-    resolver
+    resolver,
+    enumSchemaNames
   }).print(node);
   if (!output) return;
   const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node2) => {
@@ -210010,156 +210051,125 @@ function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, synt
     enumKeyCasing,
     resolver
   })), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
-    name: typedName,
+    name,
     isTypeOnly: true,
     isExportable: true,
     isIndexable: true,
     children: output
   })] });
 }
-
-function resolveName(name, type) {
-  return pascalCase$6(name, { isFile: type === "file" });
+function buildParams({ params, node, resolver }) {
+  return createSchema({
+    type: "object",
+    properties: params.map((param) => createProperty({
+      name: param.name,
+      required: param.required,
+      schema: createSchema({
+        type: "ref",
+        name: resolver.resolveParamName(node, param)
+      })
+    }))
+  });
+}
+function buildData({ node, resolver }) {
+  var _a;
+  const pathParams = node.parameters.filter((p) => p.in === "path");
+  const queryParams = node.parameters.filter((p) => p.in === "query");
+  const headerParams = node.parameters.filter((p) => p.in === "header");
+  return createSchema({
+    type: "object",
+    deprecated: node.deprecated,
+    properties: [
+      createProperty({
+        name: "data",
+        schema: ((_a = node.requestBody) == null ? void 0 : _a.schema) ? createSchema({
+          type: "ref",
+          name: resolver.resolveDataName(node),
+          optional: true
+        }) : createSchema({
+          type: "never",
+          optional: true
+        })
+      }),
+      createProperty({
+        name: "pathParams",
+        required: pathParams.length > 0,
+        schema: pathParams.length > 0 ? buildParams({
+          params: pathParams,
+          node,
+          resolver
+        }) : createSchema({ type: "never" })
+      }),
+      createProperty({
+        name: "queryParams",
+        schema: queryParams.length > 0 ? createSchema({
+          ...buildParams({
+            params: queryParams,
+            node,
+            resolver
+          }),
+          optional: true
+        }) : createSchema({
+          type: "never",
+          optional: true
+        })
+      }),
+      createProperty({
+        name: "headerParams",
+        schema: headerParams.length > 0 ? createSchema({
+          ...buildParams({
+            params: headerParams,
+            node,
+            resolver
+          }),
+          optional: true
+        }) : createSchema({
+          type: "never",
+          optional: true
+        })
+      }),
+      createProperty({
+        name: "url",
+        required: true,
+        schema: createSchema({
+          type: "url",
+          path: node.path
+        })
+      })
+    ]
+  });
+}
+function buildResponses({ node, resolver }) {
+  if (node.responses.length === 0) return null;
+  return createSchema({
+    type: "object",
+    properties: node.responses.map((res) => createProperty({
+      name: String(res.statusCode),
+      required: true,
+      schema: createSchema({
+        type: "ref",
+        name: resolver.resolveResponseStatusName(node, res.statusCode)
+      })
+    }))
+  });
+}
+function buildResponseUnion({ node, resolver }) {
+  const responsesWithSchema = node.responses.filter((res) => res.schema);
+  if (responsesWithSchema.length === 0) return null;
+  return createSchema({
+    type: "union",
+    members: responsesWithSchema.map((res) => createSchema({
+      type: "ref",
+      name: resolver.resolveResponseStatusName(node, res.statusCode)
+    }))
+  });
 }
-const resolverTs = defineResolver(() => {
-  return {
-    name: "default",
-    pluginName: "plugin-ts",
-    default(name, type) {
-      return resolveName(name, type);
-    },
-    resolveName(name) {
-      return this.default(name, "function");
-    },
-    resolveTypedName(name) {
-      return this.default(name, "type");
-    },
-    resolvePathName(name, type) {
-      return this.default(name, type);
-    },
-    resolveParamName(node, param) {
-      return this.resolveName(`${node.operationId} ${this.default(param.in)} ${param.name}`);
-    },
-    resolveParamTypedName(node, param) {
-      return this.resolveTypedName(`${node.operationId} ${this.default(param.in)} ${param.name}`);
-    },
-    resolveResponseStatusName(node, statusCode) {
-      return this.resolveName(`${node.operationId} Status ${statusCode}`);
-    },
-    resolveResponseStatusTypedName(node, statusCode) {
-      return this.resolveTypedName(`${node.operationId} Status ${statusCode}`);
-    },
-    resolveDataName(node) {
-      return this.resolveName(`${node.operationId} Data`);
-    },
-    resolveDataTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} Data`);
-    },
-    resolveRequestConfigName(node) {
-      return this.resolveName(`${node.operationId} RequestConfig`);
-    },
-    resolveRequestConfigTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} RequestConfig`);
-    },
-    resolveResponsesName(node) {
-      return this.resolveName(`${node.operationId} Responses`);
-    },
-    resolveResponsesTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} Responses`);
-    },
-    resolveResponseName(node) {
-      return this.resolveName(`${node.operationId} Response`);
-    },
-    resolveResponseTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} Response`);
-    },
-    resolveEnumKeyTypedName(node, enumTypeSuffix = "key") {
-      var _a;
-      return `${this.resolveTypedName((_a = node.name) != null ? _a : "")}${enumTypeSuffix}`;
-    },
-    resolvePathParamsName(_node) {
-      throw new Error("resolvePathParamsName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamName per individual parameter instead.");
-    },
-    resolvePathParamsTypedName(_node) {
-      throw new Error("resolvePathParamsTypedName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamTypedName per individual parameter instead.");
-    },
-    resolveQueryParamsName(_node) {
-      throw new Error("resolveQueryParamsName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamName per individual parameter instead.");
-    },
-    resolveQueryParamsTypedName(_node) {
-      throw new Error("resolveQueryParamsTypedName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamTypedName per individual parameter instead.");
-    },
-    resolveHeaderParamsName(_node) {
-      throw new Error("resolveHeaderParamsName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamName per individual parameter instead.");
-    },
-    resolveHeaderParamsTypedName(_node) {
-      throw new Error("resolveHeaderParamsTypedName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamTypedName per individual parameter instead.");
-    }
-  };
-});
-const resolverTsLegacy = defineResolver(() => {
-  return {
-    ...resolverTs,
-    pluginName: "plugin-ts",
-    resolveResponseStatusName(node, statusCode) {
-      if (statusCode === "default") return this.resolveName(`${node.operationId} Error`);
-      return this.resolveName(`${node.operationId} ${statusCode}`);
-    },
-    resolveResponseStatusTypedName(node, statusCode) {
-      if (statusCode === "default") return this.resolveTypedName(`${node.operationId} Error`);
-      return this.resolveTypedName(`${node.operationId} ${statusCode}`);
-    },
-    resolveDataName(node) {
-      const suffix = node.method === "GET" ? "QueryRequest" : "MutationRequest";
-      return this.resolveName(`${node.operationId} ${suffix}`);
-    },
-    resolveDataTypedName(node) {
-      const suffix = node.method === "GET" ? "QueryRequest" : "MutationRequest";
-      return this.resolveTypedName(`${node.operationId} ${suffix}`);
-    },
-    resolveResponsesName(node) {
-      const suffix = node.method === "GET" ? "Query" : "Mutation";
-      return `${this.default(node.operationId, "function")}${suffix}`;
-    },
-    resolveResponsesTypedName(node) {
-      const suffix = node.method === "GET" ? "Query" : "Mutation";
-      return `${this.default(node.operationId, "type")}${suffix}`;
-    },
-    resolveResponseName(node) {
-      const suffix = node.method === "GET" ? "QueryResponse" : "MutationResponse";
-      return this.resolveName(`${node.operationId} ${suffix}`);
-    },
-    resolveResponseTypedName(node) {
-      const suffix = node.method === "GET" ? "QueryResponse" : "MutationResponse";
-      return this.resolveTypedName(`${node.operationId} ${suffix}`);
-    },
-    resolvePathParamsName(node) {
-      return this.resolveName(`${node.operationId} PathParams`);
-    },
-    resolvePathParamsTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} PathParams`);
-    },
-    resolveQueryParamsName(node) {
-      return this.resolveName(`${node.operationId} QueryParams`);
-    },
-    resolveQueryParamsTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} QueryParams`);
-    },
-    resolveHeaderParamsName(node) {
-      return this.resolveName(`${node.operationId} HeaderParams`);
-    },
-    resolveHeaderParamsTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} HeaderParams`);
-    }
-  };
-});
-
 const typeGenerator = defineGenerator({
   name: "typescript",
   type: "react",
-  Operation({ node, adapter, options, config }) {
-    var _a, _b, _c;
-    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, resolver, transformers = [] } = options;
+  Operation({ node, adapter, options, config, resolver }) {
+    var _a, _b, _c, _d, _e;
+    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options;
     const root = path$2.resolve(config.root, config.output.path);
     const mode = getMode(path$2.resolve(root, output.path));
     const file = resolver.resolveFile({
@@ -210173,11 +210183,16 @@ const typeGenerator = defineGenerator({
       group
     });
     const params = caseParams(node.parameters, paramsCasing);
-    function renderSchemaType({ node: schemaNode, name, typedName, description, keysToOmit }) {
+    const enumSchemaNames = new Set(((_c = (_b = adapter.rootNode) == null ? void 0 : _b.schemas) != null ? _c : []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name));
+    function resolveImportName(schemaName) {
+      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
+      return resolver.default(schemaName, "type");
+    }
+    function renderSchemaType({ node: schemaNode, name, description, keysToOmit }) {
       if (!schemaNode) return null;
       const transformedNode = transform(schemaNode, composeTransformers(...transformers));
       const imports = adapter.getImports(transformedNode, (schemaName) => ({
-        name: resolver.default(schemaName, "type"),
+        name: resolveImportName(schemaName),
         path: resolver.resolveFile({
           name: schemaName,
           extname: ".ts"
@@ -210198,7 +210213,6 @@ const typeGenerator = defineGenerator({
         imp.isTypeOnly
       ].join("-"))), /* @__PURE__ */ jsx(Type, {
         name,
-        typedName,
         node: transformedNode,
         description,
         enumType,
@@ -210208,54 +210222,49 @@ const typeGenerator = defineGenerator({
         arrayType,
         syntaxType,
         resolver,
-        keysToOmit
+        keysToOmit,
+        enumSchemaNames
       })] });
     }
     const paramTypes = params.map((param) => renderSchemaType({
       node: param.schema,
-      name: resolver.resolveParamName(node, param),
-      typedName: resolver.resolveParamTypedName(node, param)
+      name: resolver.resolveParamName(node, param)
     }));
-    const requestType = ((_b = node.requestBody) == null ? void 0 : _b.schema) ? renderSchemaType({
+    const requestType = ((_d = node.requestBody) == null ? void 0 : _d.schema) ? renderSchemaType({
       node: node.requestBody.schema,
       name: resolver.resolveDataName(node),
-      typedName: resolver.resolveDataTypedName(node),
-      description: (_c = node.requestBody.description) != null ? _c : node.requestBody.schema.description,
+      description: (_e = node.requestBody.description) != null ? _e : node.requestBody.schema.description,
       keysToOmit: node.requestBody.keysToOmit
     }) : null;
     const responseTypes = node.responses.map((res) => renderSchemaType({
       node: res.schema,
       name: resolver.resolveResponseStatusName(node, res.statusCode),
-      typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
       description: res.description,
       keysToOmit: res.keysToOmit
     }));
     const dataType = renderSchemaType({
-      node: builderTs.buildData({
+      node: buildData({
         node: {
           ...node,
           parameters: params
         },
         resolver
       }),
-      name: resolver.resolveRequestConfigName(node),
-      typedName: resolver.resolveRequestConfigTypedName(node)
+      name: resolver.resolveRequestConfigName(node)
     });
     const responsesType = renderSchemaType({
-      node: builderTs.buildResponses({
+      node: buildResponses({
         node,
         resolver
       }),
-      name: resolver.resolveResponsesName(node),
-      typedName: resolver.resolveResponsesTypedName(node)
+      name: resolver.resolveResponsesName(node)
     });
     const responseType = renderSchemaType({
-      node: builderTs.buildResponseUnion({
+      node: buildResponseUnion({
         node,
         resolver
       }),
       name: resolver.resolveResponseName(node),
-      typedName: resolver.resolveResponseTypedName(node),
       description: "Union of all possible responses"
     });
     return /* @__PURE__ */ jsxs(File, {
@@ -210280,14 +210289,20 @@ const typeGenerator = defineGenerator({
       ]
     });
   },
-  Schema({ node, adapter, options, config }) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, resolver, transformers = [] } = options;
+  Schema({ node, adapter, options, config, resolver }) {
+    var _a, _b;
+    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options;
     const root = path$2.resolve(config.root, config.output.path);
     const mode = getMode(path$2.resolve(root, output.path));
     if (!node.name) return;
     const transformedNode = transform(node, composeTransformers(...transformers));
+    const enumSchemaNames = new Set(((_b = (_a = adapter.rootNode) == null ? void 0 : _a.schemas) != null ? _b : []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name));
+    function resolveImportName(schemaName) {
+      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
+      return resolver.default(schemaName, "type");
+    }
     const imports = adapter.getImports(transformedNode, (schemaName) => ({
-      name: resolver.default(schemaName, "type"),
+      name: resolveImportName(schemaName),
       path: resolver.resolveFile({
         name: schemaName,
         extname: ".ts"
@@ -210298,10 +210313,8 @@ const typeGenerator = defineGenerator({
       }).path
     }));
     const isEnumSchema = !!narrowSchema(node, schemaTypes.enum);
-    const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyTypedName(node, enumTypeSuffix) : resolver.resolveTypedName(node.name);
     const type = {
-      name: resolver.resolveName(node.name),
-      typedName,
+      name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveName(node.name),
       file: resolver.resolveFile({
         name: node.name,
         extname: ".ts"
@@ -210334,7 +210347,6 @@ const typeGenerator = defineGenerator({
         imp.isTypeOnly
       ].join("-"))), /* @__PURE__ */ jsx(Type, {
         name: type.name,
-        typedName: type.typedName,
         node: transformedNode,
         enumType,
         enumTypeSuffix,
@@ -210342,11 +210354,92 @@ const typeGenerator = defineGenerator({
         optionalType,
         arrayType,
         syntaxType,
-        resolver
+        resolver,
+        enumSchemaNames
       })]
     });
   }
 });
+function resolveName(name, type) {
+  return pascalCase$6(name, { isFile: type === "file" });
+}
+const resolverTs = defineResolver(() => {
+  return {
+    name: "default",
+    pluginName: "plugin-ts",
+    default(name, type) {
+      return resolveName(name, type);
+    },
+    resolveName(name) {
+      return this.default(name, "function");
+    },
+    resolvePathName(name, type) {
+      return this.default(name, type);
+    },
+    resolveParamName(node, param) {
+      return this.resolveName(`${node.operationId} ${param.in} ${param.name}`);
+    },
+    resolveResponseStatusName(node, statusCode) {
+      return this.resolveName(`${node.operationId} Status ${statusCode}`);
+    },
+    resolveDataName(node) {
+      return this.resolveName(`${node.operationId} Data`);
+    },
+    resolveRequestConfigName(node) {
+      return this.resolveName(`${node.operationId} RequestConfig`);
+    },
+    resolveResponsesName(node) {
+      return this.resolveName(`${node.operationId} Responses`);
+    },
+    resolveResponseName(node) {
+      return this.resolveName(`${node.operationId} Response`);
+    },
+    resolveEnumKeyName(node, enumTypeSuffix = "key") {
+      var _a;
+      return `${this.resolveName((_a = node.name) != null ? _a : "")}${enumTypeSuffix}`;
+    },
+    resolvePathParamsName(node, param) {
+      return this.resolveParamName(node, param);
+    },
+    resolveQueryParamsName(node, param) {
+      return this.resolveParamName(node, param);
+    },
+    resolveHeaderParamsName(node, param) {
+      return this.resolveParamName(node, param);
+    }
+  };
+});
+const resolverTsLegacy = defineResolver(() => {
+  return {
+    ...resolverTs,
+    pluginName: "plugin-ts",
+    resolveResponseStatusName(node, statusCode) {
+      if (statusCode === "default") return this.resolveName(`${node.operationId} Error`);
+      return this.resolveName(`${node.operationId} ${statusCode}`);
+    },
+    resolveDataName(node) {
+      const suffix = node.method === "GET" ? "QueryRequest" : "MutationRequest";
+      return this.resolveName(`${node.operationId} ${suffix}`);
+    },
+    resolveResponsesName(node) {
+      const suffix = node.method === "GET" ? "Query" : "Mutation";
+      return this.resolveName(`${node.operationId} ${suffix}`);
+    },
+    resolveResponseName(node) {
+      const suffix = node.method === "GET" ? "QueryResponse" : "MutationResponse";
+      return this.resolveName(`${node.operationId} ${suffix}`);
+    },
+    resolvePathParamsName(node, _param) {
+      return this.resolveName(`${node.operationId} PathParams`);
+    },
+    resolveQueryParamsName(node, _param) {
+      return this.resolveName(`${node.operationId} QueryParams`);
+    },
+    resolveHeaderParamsName(node, _param) {
+      return this.resolveName(`${node.operationId} HeaderParams`);
+    }
+  };
+});
 function buildGroupedParamsSchema({ params, parentName }) {
   return createSchema({
     type: "object",
@@ -210378,22 +210471,22 @@ function buildLegacyResponsesSchemaNode({ node, resolver }) {
   const errorResponses = node.responses.filter((res) => res.statusCode === "default" || Number(res.statusCode) >= 400);
   const responseSchema = successResponses.length > 0 ? successResponses.length === 1 ? createSchema({
     type: "ref",
-    name: resolver.resolveResponseStatusTypedName(node, successResponses[0].statusCode)
+    name: resolver.resolveResponseStatusName(node, successResponses[0].statusCode)
   }) : createSchema({
     type: "union",
     members: successResponses.map((res) => createSchema({
       type: "ref",
-      name: resolver.resolveResponseStatusTypedName(node, res.statusCode)
+      name: resolver.resolveResponseStatusName(node, res.statusCode)
     }))
   }) : createSchema({ type: "any" });
   const errorsSchema = errorResponses.length > 0 ? errorResponses.length === 1 ? createSchema({
     type: "ref",
-    name: resolver.resolveResponseStatusTypedName(node, errorResponses[0].statusCode)
+    name: resolver.resolveResponseStatusName(node, errorResponses[0].statusCode)
   }) : createSchema({
     type: "union",
     members: errorResponses.map((res) => createSchema({
       type: "ref",
-      name: resolver.resolveResponseStatusTypedName(node, res.statusCode)
+      name: resolver.resolveResponseStatusName(node, res.statusCode)
     }))
   }) : createSchema({ type: "any" });
   const properties = [createProperty({
@@ -210406,31 +210499,34 @@ function buildLegacyResponsesSchemaNode({ node, resolver }) {
     required: true,
     schema: createSchema({
       type: "ref",
-      name: resolver.resolveDataTypedName(node)
+      name: resolver.resolveDataName(node)
     })
   }));
-  if (node.parameters.some((p) => p.in === "query") && resolver.resolveQueryParamsTypedName) properties.push(createProperty({
+  const queryParam = node.parameters.find((p) => p.in === "query");
+  if (queryParam) properties.push(createProperty({
     name: "QueryParams",
     required: true,
     schema: createSchema({
       type: "ref",
-      name: resolver.resolveQueryParamsTypedName(node)
+      name: resolver.resolveQueryParamsName(node, queryParam)
     })
   }));
-  if (node.parameters.some((p) => p.in === "path") && resolver.resolvePathParamsTypedName) properties.push(createProperty({
+  const pathParam = node.parameters.find((p) => p.in === "path");
+  if (pathParam) properties.push(createProperty({
     name: "PathParams",
     required: true,
     schema: createSchema({
       type: "ref",
-      name: resolver.resolvePathParamsTypedName(node)
+      name: resolver.resolvePathParamsName(node, pathParam)
     })
   }));
-  if (node.parameters.some((p) => p.in === "header") && resolver.resolveHeaderParamsTypedName) properties.push(createProperty({
+  const headerParam = node.parameters.find((p) => p.in === "header");
+  if (headerParam) properties.push(createProperty({
     name: "HeaderParams",
     required: true,
     schema: createSchema({
       type: "ref",
-      name: resolver.resolveHeaderParamsTypedName(node)
+      name: resolver.resolveHeaderParamsName(node, headerParam)
     })
   }));
   properties.push(createProperty({
@@ -210451,13 +210547,13 @@ function buildLegacyResponseUnionSchemaNode({ node, resolver }) {
   if (successResponses.length === 0) return createSchema({ type: "any" });
   if (successResponses.length === 1) return createSchema({
     type: "ref",
-    name: resolver.resolveResponseStatusTypedName(node, successResponses[0].statusCode)
+    name: resolver.resolveResponseStatusName(node, successResponses[0].statusCode)
   });
   return createSchema({
     type: "union",
     members: successResponses.map((res) => createSchema({
       type: "ref",
-      name: resolver.resolveResponseStatusTypedName(node, res.statusCode)
+      name: resolver.resolveResponseStatusName(node, res.statusCode)
     }))
   });
 }
@@ -210489,9 +210585,9 @@ function nameUnnamedEnums(node, parentName) {
 const typeGeneratorLegacy = defineGenerator({
   name: "typescript-legacy",
   type: "react",
-  Operation({ node, adapter, options, config }) {
+  Operation({ node, adapter, options, config, resolver }) {
     var _a, _b, _c;
-    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, resolver, transformers = [] } = options;
+    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options;
     const root = path$2.resolve(config.root, config.output.path);
     const mode = getMode(path$2.resolve(root, output.path));
     const file = resolver.resolveFile({
@@ -210505,7 +210601,7 @@ const typeGeneratorLegacy = defineGenerator({
       group
     });
     const params = caseParams(node.parameters, paramsCasing);
-    function renderSchemaType({ node: schemaNode, name, typedName, description, keysToOmit }) {
+    function renderSchemaType({ node: schemaNode, name, description, keysToOmit }) {
       if (!schemaNode) return null;
       const transformedNode = transform(schemaNode, composeTransformers(...transformers));
       const imports = adapter.getImports(transformedNode, (schemaName) => ({
@@ -210530,7 +210626,6 @@ const typeGeneratorLegacy = defineGenerator({
         imp.isTypeOnly
       ].join("-"))), /* @__PURE__ */ jsx(Type, {
         name,
-        typedName,
         node: transformedNode,
         description,
         enumType,
@@ -210552,7 +210647,6 @@ const typeGeneratorLegacy = defineGenerator({
       return renderSchemaType({
         node: res.schema ? nameUnnamedEnums(res.schema, baseResponseName) : res.schema,
         name: responseName,
-        typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
         description: res.description,
         keysToOmit: res.keysToOmit
       });
@@ -210560,7 +210654,6 @@ const typeGeneratorLegacy = defineGenerator({
     const requestType = ((_b = node.requestBody) == null ? void 0 : _b.schema) ? renderSchemaType({
       node: nameUnnamedEnums(node.requestBody.schema, resolverTsLegacy.resolveDataName(node)),
       name: resolver.resolveDataName(node),
-      typedName: resolver.resolveDataTypedName(node),
       description: (_c = node.requestBody.description) != null ? _c : node.requestBody.schema.description,
       keysToOmit: node.requestBody.keysToOmit
     }) : null;
@@ -210568,26 +210661,23 @@ const typeGeneratorLegacy = defineGenerator({
       pathParams.length > 0 ? renderSchemaType({
         node: buildGroupedParamsSchema({
           params: pathParams,
-          parentName: resolverTsLegacy.resolvePathParamsName(node)
+          parentName: resolverTsLegacy.resolvePathParamsName(node, pathParams[0])
         }),
-        name: resolver.resolvePathParamsName(node),
-        typedName: resolver.resolvePathParamsTypedName(node)
+        name: resolver.resolvePathParamsName(node, pathParams[0])
       }) : null,
       queryParams.length > 0 ? renderSchemaType({
         node: buildGroupedParamsSchema({
           params: queryParams,
-          parentName: resolverTsLegacy.resolveQueryParamsName(node)
+          parentName: resolverTsLegacy.resolveQueryParamsName(node, queryParams[0])
         }),
-        name: resolver.resolveQueryParamsName(node),
-        typedName: resolver.resolveQueryParamsTypedName(node)
+        name: resolver.resolveQueryParamsName(node, queryParams[0])
       }) : null,
       headerParams.length > 0 ? renderSchemaType({
         node: buildGroupedParamsSchema({
           params: headerParams,
-          parentName: resolverTsLegacy.resolveHeaderParamsName(node)
+          parentName: resolverTsLegacy.resolveHeaderParamsName(node, headerParams[0])
         }),
-        name: resolver.resolveHeaderParamsName(node),
-        typedName: resolver.resolveHeaderParamsTypedName(node)
+        name: resolver.resolveHeaderParamsName(node, headerParams[0])
       }) : null
     ];
     const legacyResponsesType = renderSchemaType({
@@ -210595,16 +210685,14 @@ const typeGeneratorLegacy = defineGenerator({
         node,
         resolver
       }),
-      name: resolver.resolveResponsesName(node),
-      typedName: resolver.resolveResponsesTypedName(node)
+      name: resolver.resolveResponsesName(node)
     });
     const legacyResponseType = renderSchemaType({
       node: buildLegacyResponseUnionSchemaNode({
         node,
         resolver
       }),
-      name: resolver.resolveResponseName(node),
-      typedName: resolver.resolveResponseTypedName(node)
+      name: resolver.resolveResponseName(node)
     });
     return /* @__PURE__ */ jsxs(File, {
       baseName: file.baseName,
@@ -210627,8 +210715,8 @@ const typeGeneratorLegacy = defineGenerator({
       ]
     });
   },
-  Schema({ node, adapter, options, config }) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, resolver, transformers = [] } = options;
+  Schema({ node, adapter, options, config, resolver }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options;
     const root = path$2.resolve(config.root, config.output.path);
     const mode = getMode(path$2.resolve(root, output.path));
     if (!node.name) return;
@@ -210645,10 +210733,8 @@ const typeGeneratorLegacy = defineGenerator({
       }).path
     }));
     const isEnumSchema = !!narrowSchema(node, schemaTypes.enum);
-    const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyTypedName(node, enumTypeSuffix) : resolver.resolveTypedName(node.name);
     const type = {
-      name: resolver.resolveName(node.name),
-      typedName,
+      name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveName(node.name),
       file: resolver.resolveFile({
         name: node.name,
         extname: ".ts"
@@ -210681,7 +210767,6 @@ const typeGeneratorLegacy = defineGenerator({
         imp.isTypeOnly
       ].join("-"))), /* @__PURE__ */ jsx(Type, {
         name: type.name,
-        typedName: type.typedName,
         node: transformedNode,
         enumType,
         enumTypeSuffix,
@@ -210694,34 +210779,27 @@ const typeGeneratorLegacy = defineGenerator({
     });
   }
 });
-
-const presets = definePresets({
-  default: definePreset("default", {
+const presets$1 = definePresets({
+  default: {
+    name: "default",
     resolvers: [resolverTs],
     generators: [typeGenerator]
-  }),
-  kubbV4: definePreset("kubbV4", {
+  },
+  kubbV4: {
+    name: "kubbV4",
     resolvers: [resolverTsLegacy],
     generators: [typeGeneratorLegacy]
-  })
+  }
 });
-function getPreset$1(preset, { resolvers, transformers, generators }) {
-  return getPreset({
-    preset,
-    presets,
-    resolvers: [resolverTs, ...resolvers != null ? resolvers : []],
-    transformers,
-    generators
-  });
-}
-__name$5(getPreset$1, "getPreset");
 const pluginTsName = "plugin-ts";
 const pluginTs = createPlugin((options) => {
   const { output = {
     path: "types",
     barrelType: "named"
   }, group, exclude = [], include, override = [], enumType = "asConst", enumTypeSuffix = "Key", enumKeyCasing = "none", optionalType = "questionToken", arrayType = "array", syntaxType = "type", paramsCasing, compatibilityPreset = "default", resolvers: userResolvers = [], transformers: userTransformers = [], generators: userGenerators = [] } = options;
-  const { resolver, transformers, generators } = getPreset$1(compatibilityPreset, {
+  const preset = getPreset({
+    preset: compatibilityPreset,
+    presets: presets$1,
     resolvers: userResolvers,
     transformers: userTransformers,
     generators: userGenerators
@@ -210730,26 +210808,37 @@ const pluginTs = createPlugin((options) => {
   let resolvePathWarning = false;
   return {
     name: pluginTsName,
-    options: {
-      output,
-      optionalType,
-      group,
-      arrayType,
-      enumType,
-      enumTypeSuffix,
-      enumKeyCasing,
-      syntaxType,
-      paramsCasing,
-      resolver,
-      transformers
+    get resolver() {
+      return preset.resolver;
+    },
+    get options() {
+      return {
+        output,
+        optionalType,
+        group: group ? {
+          ...options.group,
+          name: (ctx) => {
+            var _a;
+            if (((_a = options.group) == null ? void 0 : _a.type) === "path") return `${ctx.group.split("/")[1]}`;
+            return `${camelCase$a(ctx.group)}Controller`;
+          }
+        } : void 0,
+        arrayType,
+        enumType,
+        enumTypeSuffix,
+        enumKeyCasing,
+        syntaxType,
+        paramsCasing,
+        transformers: preset.transformers
+      };
     },
     resolvePath(baseName, pathMode, options2) {
       var _a, _b;
       if (!resolvePathWarning) {
-        this.driver.events.emit("warn", "Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead");
+        this.events.emit("warn", "Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead");
         resolvePathWarning = true;
       }
-      return resolver.resolvePath({
+      return this.plugin.resolver.resolvePath({
         baseName,
         pathMode,
         tag: (_a = options2 == null ? void 0 : options2.group) == null ? void 0 : _a.tag,
@@ -210757,26 +210846,26 @@ const pluginTs = createPlugin((options) => {
       }, {
         root: path$2.resolve(this.config.root, this.config.output.path),
         output,
-        group
+        group: this.plugin.options.group
       });
     },
     resolveName(name, type) {
       if (!resolveNameWarning) {
-        this.driver.events.emit("warn", "Do not use resolveName for pluginTs, use resolverTs.default instead");
+        this.events.emit("warn", "Do not use resolveName for pluginTs, use resolverTs.default instead");
         resolveNameWarning = true;
       }
-      return resolver.default(name, type);
+      return this.plugin.resolver.default(name, type);
     },
     async install() {
       var _a;
-      const { config, fabric, plugin, adapter, rootNode, driver, openInStudio } = this;
+      const { config, fabric, plugin, adapter, rootNode, driver, openInStudio, resolver } = this;
       const root = path$2.resolve(config.root, config.output.path);
       if (!adapter) throw new Error("Plugin cannot work without adapter being set");
       await openInStudio({ ast: true });
       await walk(rootNode, {
         depth: "shallow",
         async schema(schemaNode) {
-          const writeTasks = generators.map(async (generator) => {
+          const writeTasks = preset.generators.map(async (generator) => {
             if (generator.type === "react" && generator.version === "2") {
               const options2 = resolver.resolveOptions(schemaNode, {
                 options: plugin.options,
@@ -210787,6 +210876,7 @@ const pluginTs = createPlugin((options) => {
               if (options2 === null) return;
               await renderSchema$1(schemaNode, {
                 options: options2,
+                resolver,
                 adapter,
                 config,
                 fabric,
@@ -210799,7 +210889,7 @@ const pluginTs = createPlugin((options) => {
           await Promise.all(writeTasks);
         },
         async operation(operationNode) {
-          const writeTasks = generators.map(async (generator) => {
+          const writeTasks = preset.generators.map(async (generator) => {
             if (generator.type === "react" && generator.version === "2") {
               const options2 = resolver.resolveOptions(operationNode, {
                 options: plugin.options,
@@ -210810,6 +210900,7 @@ const pluginTs = createPlugin((options) => {
               if (options2 === null) return;
               await renderOperation$1(operationNode, {
                 options: options2,
+                resolver,
                 adapter,
                 config,
                 fabric,
@@ -210832,6 +210923,89 @@ const pluginTs = createPlugin((options) => {
     }
   };
 });
+const kindToHandlerKey = {
+  FunctionParameter: "functionParameter",
+  ParameterGroup: "parameterGroup",
+  FunctionParameters: "functionParameters",
+  Type: "type"
+};
+const defineFunctionPrinter = createPrinterFactory((node) => kindToHandlerKey[node.kind]);
+function rank(param) {
+  var _a;
+  if (param.kind === "ParameterGroup") {
+    if (param.default) return 2;
+    return ((_a = param.optional) != null ? _a : param.properties.every((p) => p.optional || p.default !== void 0)) ? 1 : 0;
+  }
+  if (param.rest) return 3;
+  if (param.default) return 2;
+  return param.optional ? 1 : 0;
+}
+function sortParams(params) {
+  return [...params].sort((a, b) => rank(a) - rank(b));
+}
+function sortChildParams(params) {
+  return [...params].sort((a, b) => rank(a) - rank(b));
+}
+const functionPrinter = defineFunctionPrinter((options) => ({
+  name: "functionParameters",
+  options,
+  nodes: {
+    type(node) {
+      if (node.variant === "member") return `${node.base}['${node.key}']`;
+      if (node.variant === "struct") return `{ ${node.properties.map((p) => {
+        const typeStr = this.transform(p.type);
+        return p.optional ? `${p.name}?: ${typeStr}` : `${p.name}: ${typeStr}`;
+      }).join("; ")} }`;
+      if (node.variant === "reference") return node.name;
+      return null;
+    },
+    functionParameter(node) {
+      const { mode, transformName, transformType } = this.options;
+      const name = transformName ? transformName(node.name) : node.name;
+      const rawType = node.type ? this.transform(node.type) : void 0;
+      const type = rawType != null && transformType ? transformType(rawType) : rawType;
+      if (mode === "keys" || mode === "values") return node.rest ? `...${name}` : name;
+      if (mode === "call") return node.rest ? `...${name}` : name;
+      if (node.rest) return type ? `...${name}: ${type}` : `...${name}`;
+      if (type) {
+        if (node.optional) return `${name}?: ${type}`;
+        return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`;
+      }
+      return node.default ? `${name} = ${node.default}` : name;
+    },
+    parameterGroup(node) {
+      var _a, _b, _c;
+      const { mode, transformName, transformType } = this.options;
+      const sorted = sortChildParams(node.properties);
+      const isOptional = (_a = node.optional) != null ? _a : sorted.every((p) => p.optional || p.default !== void 0);
+      if (node.inline) return sorted.map((p) => this.transform(p)).filter(Boolean).join(", ");
+      if (mode === "keys" || mode === "values") return `{ ${sorted.map((p) => p.name).join(", ")} }`;
+      if (mode === "call") return `{ ${sorted.map((p) => p.name).join(", ")} }`;
+      const names = sorted.map((p) => {
+        return transformName ? transformName(p.name) : p.name;
+      });
+      const nameStr = names.length ? `{ ${names.join(", ")} }` : void 0;
+      if (!nameStr) return null;
+      let typeAnnotation = node.type ? (_b = this.transform(node.type)) != null ? _b : void 0 : void 0;
+      if (!typeAnnotation) {
+        const typeParts = sorted.filter((p) => p.type).map((p) => {
+          const rawT = p.type ? this.transform(p.type) : void 0;
+          const t = rawT != null && transformType ? transformType(rawT) : rawT;
+          return p.optional || p.default !== void 0 ? `${p.name}?: ${t}` : `${p.name}: ${t}`;
+        });
+        typeAnnotation = typeParts.length ? `{ ${typeParts.join("; ")} }` : void 0;
+      }
+      if (typeAnnotation) {
+        if (isOptional) return `${nameStr}: ${typeAnnotation} = ${(_c = node.default) != null ? _c : "{}"}`;
+        return node.default ? `${nameStr}: ${typeAnnotation} = ${node.default}` : `${nameStr}: ${typeAnnotation}`;
+      }
+      return node.default ? `${nameStr} = ${node.default}` : nameStr;
+    },
+    functionParameters(node) {
+      return sortParams(node.params).map((p) => this.transform(p)).filter(Boolean).join(", ");
+    }
+  }
+}));
 
 function useDriver() {
   const { meta } = useFabric();
@@ -212282,14 +212456,14 @@ function isValidVarName$7(name) {
   return true;
 }
 var URLPath$6 = (_a$6 = class {
-  constructor(path, options = {}) {
+  constructor(path2, options = {}) {
     __privateAdd$6(this, _URLPath_instances$6);
     /**
     * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
     */
     __publicField$6(this, "path");
     __privateAdd$6(this, _options$6);
-    this.path = path;
+    this.path = path2;
     __privateSet$6(this, _options$6, options);
   }
   /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
@@ -212416,80 +212590,63 @@ eachParam_fn$6 = function(fn) {
     fn(raw, __privateMethod$6(this, _URLPath_instances$6, transformParam_fn$6).call(this, raw));
   }
 }, _a$6);
-function getParams$c({ paramsType, paramsCasing, pathParamsType, typeSchemas }) {
-  var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
-  if (paramsType === "object") {
-    const pathParams = getPathParams(typeSchemas.pathParams, {
-      typed: true,
-      casing: paramsCasing
-    });
-    return FunctionParams.factory({
-      data: {
-        mode: "object",
-        children: {
-          ...pathParams,
-          data: ((_a2 = typeSchemas.request) == null ? void 0 : _a2.name) ? {
-            type: (_b = typeSchemas.request) == null ? void 0 : _b.name,
-            optional: isOptional((_c = typeSchemas.request) == null ? void 0 : _c.schema)
-          } : void 0,
-          params: ((_d = typeSchemas.queryParams) == null ? void 0 : _d.name) ? {
-            type: (_e = typeSchemas.queryParams) == null ? void 0 : _e.name,
-            optional: isOptional((_f = typeSchemas.queryParams) == null ? void 0 : _f.schema)
-          } : void 0,
-          headers: ((_g = typeSchemas.headerParams) == null ? void 0 : _g.name) ? {
-            type: (_h = typeSchemas.headerParams) == null ? void 0 : _h.name,
-            optional: isOptional((_i = typeSchemas.headerParams) == null ? void 0 : _i.schema)
-          } : void 0
-        }
-      },
-      options: {
-        type: "Partial<Cypress.RequestOptions>",
-        default: "{}"
-      }
-    });
-  }
-  return FunctionParams.factory({
-    pathParams: ((_j = typeSchemas.pathParams) == null ? void 0 : _j.name) ? {
-      mode: pathParamsType === "object" ? "object" : "inlineSpread",
-      children: getPathParams(typeSchemas.pathParams, {
-        typed: true,
-        casing: paramsCasing
+const declarationPrinter = functionPrinter({ mode: "declaration" });
+function getParams$c({ paramsType, pathParamsType, paramsCasing, resolver, node }) {
+  var _a2;
+  const paramsNode = createOperationParams(node, {
+    paramsType,
+    pathParamsType,
+    paramsCasing,
+    resolver,
+    extraParams: [createFunctionParameter({
+      name: "options",
+      type: createTypeNode({
+        variant: "reference",
+        name: "Partial<Cypress.RequestOptions>"
       }),
-      default: isAllOptional((_k = typeSchemas.pathParams) == null ? void 0 : _k.schema) ? "{}" : void 0
-    } : void 0,
-    data: ((_l = typeSchemas.request) == null ? void 0 : _l.name) ? {
-      type: (_m = typeSchemas.request) == null ? void 0 : _m.name,
-      optional: isOptional((_n = typeSchemas.request) == null ? void 0 : _n.schema)
-    } : void 0,
-    params: ((_o = typeSchemas.queryParams) == null ? void 0 : _o.name) ? {
-      type: (_p = typeSchemas.queryParams) == null ? void 0 : _p.name,
-      optional: isOptional((_q = typeSchemas.queryParams) == null ? void 0 : _q.schema)
-    } : void 0,
-    headers: ((_r = typeSchemas.headerParams) == null ? void 0 : _r.name) ? {
-      type: (_s = typeSchemas.headerParams) == null ? void 0 : _s.name,
-      optional: isOptional((_t = typeSchemas.headerParams) == null ? void 0 : _t.schema)
-    } : void 0,
-    options: {
-      type: "Partial<Cypress.RequestOptions>",
       default: "{}"
-    }
+    })]
   });
+  return (_a2 = declarationPrinter.print(paramsNode)) != null ? _a2 : "";
 }
-function Request({ baseURL = "", name, dataReturnType, typeSchemas, url, method, paramsType, paramsCasing, pathParamsType }) {
-  var _a2, _b, _c;
-  const path = new URLPath$6(url, { casing: paramsCasing });
-  const params = getParams$c({
+function Request({ baseURL = "", name, dataReturnType, resolver, node, paramsType, pathParamsType, paramsCasing }) {
+  var _a2;
+  const paramsSignature = getParams$c({
     paramsType,
-    paramsCasing,
     pathParamsType,
-    typeSchemas
+    paramsCasing,
+    resolver,
+    node
   });
-  const returnType = dataReturnType === "data" ? `Cypress.Chainable<${typeSchemas.response.name}>` : `Cypress.Chainable<Cypress.Response<${typeSchemas.response.name}>>`;
-  const urlTemplate = path.toTemplateString({ prefix: baseURL });
-  const requestOptions = [`method: '${method}'`, `url: ${urlTemplate}`];
-  if ((_a2 = typeSchemas.queryParams) == null ? void 0 : _a2.name) requestOptions.push("qs: params");
-  if ((_b = typeSchemas.headerParams) == null ? void 0 : _b.name) requestOptions.push("headers");
-  if ((_c = typeSchemas.request) == null ? void 0 : _c.name) requestOptions.push("body: data");
+  const responseType = resolver.resolveResponseName(node);
+  const returnType = dataReturnType === "data" ? `Cypress.Chainable<${responseType}>` : `Cypress.Chainable<Cypress.Response<${responseType}>>`;
+  const casedPathParams = caseParams(node.parameters.filter((p) => p.in === "path"), paramsCasing);
+  const pathParamNameMap = new Map(casedPathParams.map((p) => [camelCase$8(p.name), p.name]));
+  const urlTemplate = new URLPath$6(node.path, { casing: paramsCasing }).toTemplateString({
+    prefix: baseURL,
+    replacer: (param) => {
+      var _a3;
+      return (_a3 = pathParamNameMap.get(camelCase$8(param))) != null ? _a3 : param;
+    }
+  });
+  const requestOptions = [`method: '${node.method}'`, `url: ${urlTemplate}`];
+  const queryParams = node.parameters.filter((p) => p.in === "query");
+  if (queryParams.length > 0) {
+    const casedQueryParams = caseParams(queryParams, paramsCasing);
+    if (casedQueryParams.some((p, i) => p.name !== queryParams[i].name)) {
+      const pairs = queryParams.map((orig, i) => `${orig.name}: params.${casedQueryParams[i].name}`).join(", ");
+      requestOptions.push(`qs: params ? { ${pairs} } : undefined`);
+    } else requestOptions.push("qs: params");
+  }
+  const headerParams = node.parameters.filter((p) => p.in === "header");
+  if (headerParams.length > 0) {
+    const casedHeaderParams = caseParams(headerParams, paramsCasing);
+    if (casedHeaderParams.some((p, i) => p.name !== headerParams[i].name)) {
+      const pairs = headerParams.map((orig, i) => `'${orig.name}': headers.${casedHeaderParams[i].name}`).join(", ");
+      requestOptions.push(`headers: headers ? { ${pairs} } : undefined`);
+    } else requestOptions.push("headers");
+  }
+  if ((_a2 = node.requestBody) == null ? void 0 : _a2.schema) requestOptions.push("body: data");
   requestOptions.push("...options");
   return /* @__PURE__ */ jsx(File.Source, {
     name,
@@ -212498,135 +212655,185 @@ function Request({ baseURL = "", name, dataReturnType, typeSchemas, url, method,
     children: /* @__PURE__ */ jsx(Function$1, {
       name,
       export: true,
-      params: params.toConstructor(),
+      params: paramsSignature,
       returnType,
-      children: dataReturnType === "data" ? `return cy.request<${typeSchemas.response.name}>({
+      children: dataReturnType === "data" ? `return cy.request<${responseType}>({
   ${requestOptions.join(",\n  ")}
-}).then((res) => res.body)` : `return cy.request<${typeSchemas.response.name}>({
+}).then((res) => res.body)` : `return cy.request<${responseType}>({
   ${requestOptions.join(",\n  ")}
 })`
     })
   });
 }
 Request.getParams = getParams$c;
-
-const cypressGenerator = createReactGenerator({
+const cypressGenerator = defineGenerator({
   name: "cypress",
-  Operation({ operation, generator, plugin }) {
-    var _a, _b, _c, _d, _e;
-    const { options: { output, baseURL, dataReturnType, paramsCasing, paramsType, pathParamsType } } = plugin;
-    const driver = useDriver();
-    const oas = useOas();
-    const { getSchemas, getName, getFile } = useOperationManager(generator);
-    const request = {
-      name: getName(operation, { type: "function" }),
-      file: getFile(operation)
-    };
-    const type = {
-      file: getFile(operation, { pluginName: pluginTsName }),
-      schemas: getSchemas(operation, {
-        pluginName: pluginTsName,
-        type: "type"
-      })
-    };
+  type: "react",
+  Operation({ node, adapter, options, config, driver, resolver }) {
+    var _a2, _b, _c, _d, _e, _f;
+    const { output, baseURL, dataReturnType, paramsCasing, paramsType, pathParamsType, group } = options;
+    const root = path$2.resolve(config.root, config.output.path);
+    const pluginTs = driver.getPlugin(pluginTsName);
+    if (!pluginTs) return null;
+    const file = resolver.resolveFile({
+      name: node.operationId,
+      extname: ".ts",
+      tag: (_a2 = node.tags[0]) != null ? _a2 : "default",
+      path: node.path
+    }, {
+      root,
+      output,
+      group
+    });
+    const tsFile = pluginTs.resolver.resolveFile({
+      name: node.operationId,
+      extname: ".ts",
+      tag: (_b = node.tags[0]) != null ? _b : "default",
+      path: node.path
+    }, {
+      root,
+      output: (_d = (_c = pluginTs.options) == null ? void 0 : _c.output) != null ? _d : output,
+      group: (_e = pluginTs.options) == null ? void 0 : _e.group
+    });
+    const name = resolver.resolveName(node.operationId);
+    const casedParams = caseParams(node.parameters, paramsCasing);
+    const tsResolver = pluginTs.resolver;
+    const pathParams = casedParams.filter((p) => p.in === "path");
+    const queryParams = casedParams.filter((p) => p.in === "query");
+    const headerParams = casedParams.filter((p) => p.in === "header");
+    const importedTypeNames = [
+      ...pathParams.length && tsResolver.resolvePathParamsName ? pathParams.map((p) => tsResolver.resolvePathParamsName(node, p)) : pathParams.map((p) => tsResolver.resolveParamName(node, p)),
+      ...queryParams.length && tsResolver.resolveQueryParamsName ? queryParams.map((p) => tsResolver.resolveQueryParamsName(node, p)) : queryParams.map((p) => tsResolver.resolveParamName(node, p)),
+      ...headerParams.length && tsResolver.resolveHeaderParamsName ? headerParams.map((p) => tsResolver.resolveHeaderParamsName(node, p)) : headerParams.map((p) => tsResolver.resolveParamName(node, p)),
+      ((_f = node.requestBody) == null ? void 0 : _f.schema) ? tsResolver.resolveDataName(node) : void 0,
+      tsResolver.resolveResponseName(node)
+    ].filter(Boolean);
     return /* @__PURE__ */ jsxs(File, {
-      baseName: request.file.baseName,
-      path: request.file.path,
-      meta: request.file.meta,
-      banner: getBanner({
-        oas,
+      baseName: file.baseName,
+      path: file.path,
+      meta: file.meta,
+      banner: resolver.resolveBanner(adapter.rootNode, {
         output,
-        config: driver.config
+        config
       }),
-      footer: getFooter({
-        oas,
-        output
+      footer: resolver.resolveFooter(adapter.rootNode, {
+        output,
+        config
       }),
-      children: [/* @__PURE__ */ jsx(File.Import, {
-        name: [
-          (_a = type.schemas.request) == null ? void 0 : _a.name,
-          type.schemas.response.name,
-          (_b = type.schemas.pathParams) == null ? void 0 : _b.name,
-          (_c = type.schemas.queryParams) == null ? void 0 : _c.name,
-          (_d = type.schemas.headerParams) == null ? void 0 : _d.name,
-          ...((_e = type.schemas.statusCodes) == null ? void 0 : _e.map((item) => item.name)) || []
-        ].filter(Boolean),
-        root: request.file.path,
-        path: type.file.path,
+      children: [tsFile && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+        name: Array.from(new Set(importedTypeNames)),
+        root: file.path,
+        path: tsFile.path,
         isTypeOnly: true
       }), /* @__PURE__ */ jsx(Request, {
-        name: request.name,
+        name,
+        node,
+        resolver: tsResolver,
         dataReturnType,
         paramsCasing,
         paramsType,
         pathParamsType,
-        typeSchemas: type.schemas,
-        method: operation.method,
-        baseURL,
-        url: operation.path
+        baseURL
       })]
     });
   }
 });
-
+const resolverCypress = defineResolver(() => ({
+  name: "default",
+  pluginName: "plugin-cypress",
+  default(name, type) {
+    return camelCase$8(name, { isFile: type === "file" });
+  },
+  resolveName(name) {
+    return this.default(name, "function");
+  }
+}));
+const presets = definePresets({
+  default: {
+    name: "default",
+    resolvers: [resolverCypress],
+    generators: [cypressGenerator]
+  },
+  kubbV4: {
+    name: "kubbV4",
+    resolvers: [resolverCypress],
+    generators: [cypressGenerator]
+  }
+});
 const pluginCypressName = "plugin-cypress";
 const pluginCypress = createPlugin((options) => {
   const { output = {
     path: "cypress",
     barrelType: "named"
-  }, group, dataReturnType = "data", exclude = [], include, override = [], transformers = {}, generators = [cypressGenerator].filter(Boolean), contentType, baseURL, paramsCasing, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline" } = options;
+  }, group, dataReturnType = "data", exclude = [], include, override = [], baseURL, paramsCasing, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", compatibilityPreset = "default", resolvers: userResolvers = [], transformers: userTransformers = [], generators: userGenerators = [] } = options;
+  const preset = getPreset({
+    preset: compatibilityPreset,
+    presets,
+    resolvers: [resolverCypress, ...userResolvers],
+    transformers: userTransformers,
+    generators: userGenerators
+  });
   return {
     name: pluginCypressName,
-    options: {
-      output,
-      dataReturnType,
-      group,
-      baseURL,
-      paramsCasing,
-      paramsType,
-      pathParamsType
-    },
-    pre: [pluginOasName, pluginTsName].filter(Boolean),
-    resolvePath(baseName, pathMode, options2) {
-      var _a, _b;
-      const root = path$2.resolve(this.config.root, this.config.output.path);
-      if ((pathMode != null ? pathMode : getMode(path$2.resolve(root, output.path))) === "single")
-        return path$2.resolve(root, output.path);
-      if (group && (((_a = options2 == null ? void 0 : options2.group) == null ? void 0 : _a.path) || ((_b = options2 == null ? void 0 : options2.group) == null ? void 0 : _b.tag))) {
-        const groupName = (group == null ? void 0 : group.name) ? group.name : (ctx) => {
-          if ((group == null ? void 0 : group.type) === "path") return `${ctx.group.split("/")[1]}`;
-          return `${camelCase$8(ctx.group)}Requests`;
-        };
-        return path$2.resolve(root, output.path, groupName({ group: group.type === "path" ? options2.group.path : options2.group.tag }), baseName);
-      }
-      return path$2.resolve(root, output.path, baseName);
+    get resolver() {
+      return preset.resolver;
     },
-    resolveName(name, type) {
-      var _a;
-      const resolvedName = camelCase$8(name, { isFile: type === "file" });
-      if (type) return ((_a = transformers == null ? void 0 : transformers.name) == null ? void 0 : _a.call(transformers, resolvedName, type)) || resolvedName;
-      return resolvedName;
+    get options() {
+      var _a2;
+      return {
+        output,
+        dataReturnType,
+        group: group ? {
+          ...options.group,
+          name: ((_a2 = options.group) == null ? void 0 : _a2.name) ? options.group.name : (ctx) => {
+            if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+            return `${camelCase$8(ctx.group)}Requests`;
+          }
+        } : void 0,
+        baseURL,
+        paramsCasing,
+        paramsType,
+        pathParamsType,
+        resolver: preset.resolver,
+        transformers: preset.transformers
+      };
     },
+    pre: [pluginTsName].filter(Boolean),
     async install() {
-      var _a;
-      const root = path$2.resolve(this.config.root, this.config.output.path);
-      const mode = getMode(path$2.resolve(root, output.path));
-      const oas = await this.getOas();
-      const files = await new OperationGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        exclude,
-        include,
-        override,
-        mode
-      }).build(...generators);
-      await this.upsertFile(...files);
+      var _a2;
+      const { config, fabric, plugin, adapter, rootNode, driver } = this;
+      const root = path$2.resolve(config.root, config.output.path);
+      const resolver = preset.resolver;
+      if (!adapter) throw new Error("Plugin cannot work without adapter being set");
+      await walk(rootNode, {
+        depth: "shallow",
+        async operation(operationNode) {
+          const writeTasks = preset.generators.map(async (generator) => {
+            if (generator.type === "react" && generator.version === "2") {
+              const resolvedOptions = resolver.resolveOptions(operationNode, {
+                options: plugin.options,
+                exclude,
+                include,
+                override
+              });
+              if (resolvedOptions === null) return;
+              await renderOperation$1(operationNode, {
+                options: resolvedOptions,
+                adapter,
+                config,
+                fabric,
+                Component: generator.Operation,
+                plugin,
+                driver,
+                resolver
+              });
+            }
+          });
+          await Promise.all(writeTasks);
+        }
+      });
       const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: (_a = output.barrelType) != null ? _a : "named",
+        type: (_a2 = output.barrelType) != null ? _a2 : "named",
         root,
         output,
         meta: { pluginName: this.plugin.name }
@@ -213705,7 +213912,7 @@ const serverGenerator = createReactGenerator({
               "${((_b = oas.api.info) == null ? void 0 : _b.title) || "server"}": {
                 "type": "stdio",
                 "command": "npx",
-                "args": ["tsx", "${file.path}"]
+                "args": ["tsx", "${path$2.relative(path$2.dirname(jsonFile.path), file.path)}"]
               }
             }
           }
@@ -213772,7 +213979,7 @@ const pluginMcp = createPlugin((options) => {
       const oas = await this.getOas();
       const baseURL = await this.getBaseURL();
       if (baseURL) this.plugin.options.client.baseURL = baseURL;
-      const hasClientPlugin = !!this.driver.getPluginByName(pluginClientName);
+      const hasClientPlugin = !!this.getPlugin(pluginClientName);
       if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) await this.addFile({
         baseName: "fetch.ts",
         path: path$2.resolve(root, ".kubb/fetch.ts"),
@@ -216138,7 +216345,7 @@ const infiniteQueryGenerator$1 = createReactGenerator({
         suffix: "infinite"
       })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -216392,7 +216599,7 @@ const mutationGenerator$4 = createReactGenerator({
         type: "function"
       })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -216588,7 +216795,7 @@ const queryGenerator$4 = createReactGenerator({
       typeName: getName(operation, { type: "type" }),
       file: getFile(operation, { prefix: "use" })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -216807,7 +217014,7 @@ const suspenseInfiniteQueryGenerator = createReactGenerator({
         suffix: "suspenseInfinite"
       })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -217041,7 +217248,7 @@ const suspenseQueryGenerator = createReactGenerator({
         suffix: "suspense"
       })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -217339,7 +217546,7 @@ const pluginReactQuery = createPlugin((options) => {
       const oas = await this.getOas();
       const baseURL = await this.getBaseURL();
       if (baseURL) this.plugin.options.client.baseURL = baseURL;
-      const hasClientPlugin = !!this.driver.getPluginByName(pluginClientName);
+      const hasClientPlugin = !!this.getPlugin(pluginClientName);
       if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) await this.upsertFile({
         baseName: "fetch.ts",
         path: path$2.resolve(root, ".kubb/fetch.ts"),
@@ -218143,7 +218350,7 @@ const mutationGenerator$3 = createReactGenerator({
         type: "function"
       })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -218318,7 +218525,7 @@ const queryGenerator$3 = createReactGenerator({
       typeName: getName(operation, { type: "type" }),
       file: getFile(operation, { prefix: "create" })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -218587,7 +218794,7 @@ const pluginSolidQuery = createPlugin((options) => {
       const oas = await this.getOas();
       const baseURL = await this.getBaseURL();
       if (baseURL) this.plugin.options.client.baseURL = baseURL;
-      const hasClientPlugin = !!this.driver.getPluginByName(pluginClientName);
+      const hasClientPlugin = !!this.getPlugin(pluginClientName);
       if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) await this.upsertFile({
         baseName: "fetch.ts",
         path: path$2.resolve(root, ".kubb/fetch.ts"),
@@ -219337,7 +219544,7 @@ const mutationGenerator$2 = createReactGenerator({
         type: "function"
       })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -219511,7 +219718,7 @@ const queryGenerator$2 = createReactGenerator({
       typeName: getName(operation, { type: "type" }),
       file: getFile(operation, { prefix: "create" })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -219780,7 +219987,7 @@ const pluginSvelteQuery = createPlugin((options) => {
       const oas = await this.getOas();
       const baseURL = await this.getBaseURL();
       if (baseURL) this.plugin.options.client.baseURL = baseURL;
-      const hasClientPlugin = !!this.driver.getPluginByName(pluginClientName);
+      const hasClientPlugin = !!this.getPlugin(pluginClientName);
       if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) await this.upsertFile({
         baseName: "fetch.ts",
         path: path$2.resolve(root, ".kubb/fetch.ts"),
@@ -220568,7 +220775,7 @@ const mutationGenerator$1 = createReactGenerator({
         type: "function"
       })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -220738,7 +220945,7 @@ const queryGenerator$1 = createReactGenerator({
       typeName: getName(operation, { type: "type" }),
       file: getFile(operation, { prefix: "use" })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -220995,7 +221202,7 @@ const pluginSwr = createPlugin((options) => {
       const oas = await this.getOas();
       const baseURL = await this.getBaseURL();
       if (baseURL) this.plugin.options.client.baseURL = baseURL;
-      const hasClientPlugin = !!this.driver.getPluginByName(pluginClientName);
+      const hasClientPlugin = !!this.getPlugin(pluginClientName);
       if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) await this.upsertFile({
         baseName: "fetch.ts",
         path: path$2.resolve(root, ".kubb/fetch.ts"),
@@ -222090,7 +222297,7 @@ const infiniteQueryGenerator = createReactGenerator({
         suffix: "infinite"
       })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -222335,7 +222542,7 @@ const mutationGenerator = createReactGenerator({
         type: "function"
       })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -222510,7 +222717,7 @@ const queryGenerator = createReactGenerator({
       typeName: getName(operation, { type: "type" }),
       file: getFile(operation, { prefix: "use" })
     };
-    const shouldUseClientPlugin = !!driver.getPluginByName(pluginClientName) && options.client.clientType !== "class";
+    const shouldUseClientPlugin = !!driver.getPlugin(pluginClientName) && options.client.clientType !== "class";
     const client = {
       name: shouldUseClientPlugin ? getName(operation, {
         type: "function",
@@ -222800,7 +223007,7 @@ const pluginVueQuery = createPlugin((options) => {
       const oas = await this.getOas();
       const baseURL = await this.getBaseURL();
       if (baseURL) this.plugin.options.client.baseURL = baseURL;
-      const hasClientPlugin = !!this.driver.getPluginByName(pluginClientName);
+      const hasClientPlugin = !!this.getPlugin(pluginClientName);
       if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) await this.upsertFile({
         baseName: "fetch.ts",
         path: path$2.resolve(root, ".kubb/fetch.ts"),
@@ -223050,13 +223257,12 @@ function setupEventsStream(ws, events, getSource) {
     });
   });
   events.on("generation:start", (config) => {
-    var _a;
     sendDataMessage({
       type: "generation:start",
       data: [
         {
           name: config.name,
-          plugins: ((_a = config.plugins) == null ? void 0 : _a.length) || 0
+          plugins: config.plugins.length
         }
       ],
       timestamp: Date.now()
@@ -223163,7 +223369,7 @@ async function connectToStudio(options) {
     heartbeatTimer = setInterval(() => sendAgentMessage(ws, { type: "ping" }), heartbeatInterval);
     setupEventsStream(ws, events, () => currentSource);
     ws.addEventListener("message", async (message) => {
-      var _a2, _b, _c, _d, _e, _f, _g;
+      var _a2, _b, _c, _d, _e, _f;
       try {
         const data = JSON.parse(message.data);
         logger.info(`[${maskedSessionId}] Received "${data.type}" from Studio`);
@@ -223225,7 +223431,7 @@ async function connectToStudio(options) {
                 configPath,
                 permissions: { allowAll: effectiveAllowAll, allowWrite: effectiveWrite, allowPublish: effectivePublish },
                 config: {
-                  plugins: (_d = config.plugins) == null ? void 0 : _d.map((plugin) => ({
+                  plugins: config.plugins.map((plugin) => ({
                     name: `@kubb/${plugin.name}`,
                     options: serializePluginOptions(plugin.options)
                   }))
@@ -223242,7 +223448,7 @@ async function connectToStudio(options) {
             }
             currentSource = "publish";
             const config = await loadConfig(resolvedConfigPath);
-            const resolvedCommand = (_f = (_e = data.payload.command) != null ? _e : process.env.KUBB_AGENT_PUBLISH_COMMAND) != null ? _f : "npm publish";
+            const resolvedCommand = (_e = (_d = data.payload.command) != null ? _d : process.env.KUBB_AGENT_PUBLISH_COMMAND) != null ? _e : "npm publish";
             await publish({
               command: resolvedCommand,
               outputPath: config.output.path,
@@ -223256,7 +223462,7 @@ async function connectToStudio(options) {
         }
         logger.warn(`[${maskedSessionId}] Unknown message type from Kubb Studio: ${message.data}`);
       } catch (error) {
-        logger.error(`[${maskedSessionId}] [unhandledRejection] ${(_g = error == null ? void 0 : error.message) != null ? _g : error}`);
+        logger.error(`[${maskedSessionId}] [unhandledRejection] ${(_f = error == null ? void 0 : error.message) != null ? _f : error}`);
       }
     });
   } catch (error) {