@kubb/agent 4.34.0 → 4.35.0

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

@@ -20,12 +20,13 @@ import { createFabric, createReactFabric, App, File, Function as Function$1, Con
 import { typescriptParser } from '@kubb/react-fabric/parsers';
 import { fsPlugin } from '@kubb/react-fabric/plugins';
 import { performance as performance$1 } from 'node:perf_hooks';
+import { deflateSync } from 'fflate';
+import { x } from 'tinyexec';
 import os$1 from 'node:os';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import * as pkg from 'empathic/package';
 import { coerce, satisfies } from 'semver';
 import { sortBy, isFunction, mergeDeep, isPlainObject as isPlainObject$1, uniqueWith, isDeepEqual, isNumber, difference } from 'remeda';
-import { x } from 'tinyexec';
 import { createJiti } from 'jiti';
 import jsonpointer from 'jsonpointer';
 import BaseOas from 'oas';
@@ -4649,7 +4650,7 @@ async function disconnect({ sessionId, token, studioUrl }) {
   }
 }
 
-var version = "4.34.0";
+var version = "4.35.0";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -4682,6 +4683,103 @@ async function getLatestStudioConfigFromStorage({ sessionId }) {
   return existing[existing.length - 1].config;
 }
 
+const visitorDepths = {
+  deep: "deep"
+};
+function createLimit(concurrency) {
+  let active = 0;
+  const queue = [];
+  function next() {
+    if (active < concurrency && queue.length > 0) {
+      active++;
+      queue.shift()();
+    }
+  }
+  return function limit(fn) {
+    return new Promise((resolve, reject) => {
+      queue.push(() => {
+        Promise.resolve(fn()).then(resolve, reject).finally(() => {
+          active--;
+          next();
+        });
+      });
+      next();
+    });
+  };
+}
+function getChildren(node, recurse) {
+  switch (node.kind) {
+    case "Root":
+      return [...node.schemas, ...node.operations];
+    case "Operation":
+      return [
+        ...node.parameters,
+        ...node.requestBody ? [node.requestBody] : [],
+        ...node.responses
+      ];
+    case "Schema": {
+      const children = [];
+      if (!recurse) return [];
+      if ("properties" in node && node.properties) children.push(...node.properties);
+      if ("items" in node && node.items) children.push(...node.items);
+      if ("members" in node && node.members) children.push(...node.members);
+      return children;
+    }
+    case "Property":
+      return [node.schema];
+    case "Parameter":
+      return [node.schema];
+    case "Response":
+      return node.schema ? [node.schema] : [];
+  }
+}
+async function walk(node, visitor, options = {}) {
+  var _a, _b;
+  return _walk(node, visitor, ((_a = options.depth) != null ? _a : visitorDepths.deep) === visitorDepths.deep, createLimit((_b = options.concurrency) != null ? _b : 30));
+}
+async function _walk(node, visitor, recurse, limit) {
+  switch (node.kind) {
+    case "Root":
+      await limit(() => {
+        var _a;
+        return (_a = visitor.root) == null ? void 0 : _a.call(visitor, node);
+      });
+      break;
+    case "Operation":
+      await limit(() => {
+        var _a;
+        return (_a = visitor.operation) == null ? void 0 : _a.call(visitor, node);
+      });
+      break;
+    case "Schema":
+      await limit(() => {
+        var _a;
+        return (_a = visitor.schema) == null ? void 0 : _a.call(visitor, node);
+      });
+      break;
+    case "Property":
+      await limit(() => {
+        var _a;
+        return (_a = visitor.property) == null ? void 0 : _a.call(visitor, node);
+      });
+      break;
+    case "Parameter":
+      await limit(() => {
+        var _a;
+        return (_a = visitor.parameter) == null ? void 0 : _a.call(visitor, node);
+      });
+      break;
+    case "Response":
+      await limit(() => {
+        var _a;
+        return (_a = visitor.response) == null ? void 0 : _a.call(visitor, node);
+      });
+      break;
+  }
+  const children = getChildren(node, recurse);
+  await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit)));
+}
+
 var __defProp$h = Object.defineProperty;
 var __typeError$c = (msg) => {
   throw TypeError(msg);
@@ -4701,7 +4799,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, _options2$1, _d, _plugins, _usedPluginNames, _promiseManager, _PluginManager_instances, getSortedPlugins_fn, emitProcessingEnd_fn, execute_fn, executeSync_fn, parse_fn, _e, _f, _cache, _cwd, _PackageManager_instances, match_fn, _items, _FunctionParams_static, _g, orderItems_fn, addParams_fn, _cachedLeaves, _h;
+var _emitter, _a$c, _options$c, _URLPath_instances$a, transformParam_fn$a, eachParam_fn$a, _b$2, _head$1, _tail$1, _size$1, _c, _options2$1, _d, _studioIsOpen, _plugins, _usedPluginNames, _promiseManager, _PluginManager_instances, getSortedPlugins_fn, emitProcessingEnd_fn, execute_fn, executeSync_fn, parse_fn, _e, _f, _cache, _cwd, _PackageManager_instances, match_fn, _items, _FunctionParams_static, _g, orderItems_fn, addParams_fn, _cachedLeaves, _h;
 var ValidationPluginError = class extends Error {
 };
 function toError(value) {
@@ -5059,6 +5157,7 @@ eachParam_fn$a = function(fn) {
 function isInputPath(config) {
   return typeof (config == null ? void 0 : config.input) === "object" && config.input !== null && "path" in config.input;
 }
+const DEFAULT_STUDIO_URL = "https://studio.kubb.dev";
 const BARREL_FILENAME = "index.ts";
 const DEFAULT_BANNER = "simple";
 const DEFAULT_EXTENSION = { ".ts": ".ts" };
@@ -5109,6 +5208,30 @@ const formatters = {
     errorMessage: "Oxfmt not found"
   }
 };
+function encodeAst(root) {
+  const compressed = deflateSync(new TextEncoder().encode(JSON.stringify(root)));
+  return Buffer.from(compressed).toString("base64url");
+}
+function getStudioUrl(root, studioUrl, options = {}) {
+  return `${studioUrl.replace(/\/$/, "")}${options.ast ? "/ast" : ""}?root=${encodeAst(root)}`;
+}
+async function openInStudio(root, studioUrl, options = {}) {
+  const url = getStudioUrl(root, studioUrl, options);
+  const cmd = process.platform === "win32" ? "cmd" : process.platform === "darwin" ? "open" : "xdg-open";
+  const args = process.platform === "win32" ? [
+    "/c",
+    "start",
+    "",
+    url
+  ] : [url];
+  try {
+    await x(cmd, args);
+  } catch {
+    console.log(`
+  ${url}
+`);
+  }
+}
 var Node$1 = class Node {
   constructor(value) {
     __publicField$b(this, "value");
@@ -5280,6 +5403,12 @@ var PluginManager = (_e = class {
     __privateAdd$c(this, _PluginManager_instances);
     __publicField$b(this, "config");
     __publicField$b(this, "options");
+    /**
+    * The universal `@kubb/ast` `RootNode` produced by the adapter, set by
+    * the build pipeline after the adapter's `parse()` resolves.
+    */
+    __publicField$b(this, "rootNode");
+    __privateAdd$c(this, _studioIsOpen, false);
     __privateAdd$c(this, _plugins, /* @__PURE__ */ new Set());
     __privateAdd$c(this, _usedPluginNames, {});
     __privateAdd$c(this, _promiseManager);
@@ -5334,6 +5463,7 @@ var PluginManager = (_e = class {
   }
   getContext(plugin) {
     const plugins = [...__privateGet$c(this, _plugins)];
+    const pluginManager = this;
     const baseContext = {
       fabric: this.options.fabric,
       config: this.config,
@@ -5346,6 +5476,18 @@ var PluginManager = (_e = class {
       },
       upsertFile: async (...files) => {
         await this.options.fabric.upsertFile(...files);
+      },
+      get rootNode() {
+        return pluginManager.rootNode;
+      },
+      openInStudio(options) {
+        var _a2, _b2;
+        if (typeof pluginManager.config.devtools !== "object") throw new Error("Devtools must be an object");
+        if (!pluginManager.rootNode) throw new Error("RootNode is not defined, make sure you have set the parser in kubb.config.ts");
+        if (__privateGet$c(pluginManager, _studioIsOpen)) return;
+        __privateSet$c(pluginManager, _studioIsOpen, true);
+        const studioUrl = (_b2 = (_a2 = pluginManager.config.devtools) == null ? void 0 : _a2.studioUrl) != null ? _b2 : "https://studio.kubb.dev";
+        return openInStudio(pluginManager.rootNode, studioUrl, options);
       }
     };
     const mergedExtras = {};
@@ -5553,7 +5695,7 @@ var PluginManager = (_e = class {
     }
     return pluginByPluginName;
   }
-}, _plugins = new WeakMap(), _usedPluginNames = new WeakMap(), _promiseManager = new WeakMap(), _PluginManager_instances = new WeakSet(), getSortedPlugins_fn = function(hookName) {
+}, _studioIsOpen = new WeakMap(), _plugins = new WeakMap(), _usedPluginNames = new WeakMap(), _promiseManager = new WeakMap(), _PluginManager_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) => {
@@ -5663,7 +5805,7 @@ executeSync_fn = function({ strategy, hookName, parameters, plugin }) {
     key: [plugin.name, usedPluginNames[plugin.name]].filter(Boolean)
   };
 }, _e);
-var version$1 = "4.34.0";
+var version$1 = "4.35.0";
 function getDiagnosticInfo() {
   return {
     nodeVersion: version$2,
@@ -5719,6 +5861,10 @@ async function setup(options) {
       defaultBanner: DEFAULT_BANNER,
       ...userConfig.output
     },
+    devtools: userConfig.devtools ? {
+      studioUrl: DEFAULT_STUDIO_URL,
+      ...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
+    } : void 0,
     plugins: userConfig.plugins
   };
   if (definedConfig.output.clean) {
@@ -5765,14 +5911,31 @@ async function setup(options) {
       `  \u2022 Barrel type: ${definedConfig.output.barrelType || "none"}`
     ]
   });
+  const pluginManager = new PluginManager(definedConfig, {
+    fabric,
+    events,
+    concurrency: 15
+  });
+  if (definedConfig.adapter) {
+    const source = inputToAdapterSource(definedConfig);
+    await events.emit("debug", {
+      date: /* @__PURE__ */ new Date(),
+      logs: [`Running adapter: ${definedConfig.adapter.name}`]
+    });
+    pluginManager.rootNode = await definedConfig.adapter.parse(source);
+    await events.emit("debug", {
+      date: /* @__PURE__ */ new Date(),
+      logs: [
+        `\u2713 Adapter '${definedConfig.adapter.name}' resolved RootNode`,
+        `  \u2022 Schemas: ${pluginManager.rootNode.schemas.length}`,
+        `  \u2022 Operations: ${pluginManager.rootNode.operations.length}`
+      ]
+    });
+  }
   return {
     events,
     fabric,
-    pluginManager: new PluginManager(definedConfig, {
-      fabric,
-      events,
-      concurrency: 15
-    }),
+    pluginManager,
     sources
   };
 }
@@ -5913,6 +6076,20 @@ function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, plu
     });
   });
 }
+function inputToAdapterSource(config) {
+  if (Array.isArray(config.input)) return {
+    type: "paths",
+    paths: config.input.map((i) => resolve(config.root, i.path))
+  };
+  if ("data" in config.input) return {
+    type: "data",
+    data: config.input.data
+  };
+  return {
+    type: "path",
+    path: resolve(config.root, config.input.path)
+  };
+}
 function definePlugin(build2) {
   return (options) => build2(options != null ? options : {});
 }
@@ -7498,66 +7675,120 @@ function getSchemaFactory(oas) {
     };
   };
 }
-async function buildOperations(operations, { config, fabric, plugin, generator, Component }) {
-  if (!Component) return;
-  const { pluginManager, oas, mode } = generator.context;
+function isBuildOperationsV1Options(options) {
+  var _a2;
+  return ((_a2 = options.version) != null ? _a2 : "1") === "1";
+}
+async function buildOperations(operationsOrNodes, options) {
+  const { config, fabric, plugin } = options;
+  if (!options.Component) return;
   const fabricChild = createReactFabric();
-  await fabricChild.render(/* @__PURE__ */ jsx(App, {
-    meta: {
-      pluginManager,
-      plugin,
-      mode,
-      oas
-    },
-    children: /* @__PURE__ */ jsx(Component, {
-      config,
-      operations,
-      generator,
-      plugin
-    })
-  }));
+  if (isBuildOperationsV1Options(options)) {
+    const { generator, Component } = options;
+    const { pluginManager, oas, mode } = generator.context;
+    await fabricChild.render(/* @__PURE__ */ jsx(App, {
+      meta: {
+        pluginManager,
+        plugin,
+        mode,
+        oas
+      },
+      children: /* @__PURE__ */ jsx(Component, {
+        config,
+        operations: operationsOrNodes,
+        generator,
+        plugin
+      })
+    }));
+  } else {
+    const { Component } = options;
+    await fabricChild.render(/* @__PURE__ */ jsx(App, {
+      meta: { plugin },
+      children: /* @__PURE__ */ jsx(Component, {
+        config,
+        nodes: operationsOrNodes,
+        plugin
+      })
+    }));
+  }
   await fabric.context.fileManager.upsert(...fabricChild.files);
   fabricChild.unmount();
 }
-async function buildOperation(operation, { config, fabric, plugin, generator, Component }) {
-  if (!Component) return;
-  const { pluginManager, oas, mode } = generator.context;
+function isBuildOperationV1Options(options) {
+  var _a2;
+  return ((_a2 = options.version) != null ? _a2 : "1") === "1";
+}
+async function buildOperation(operationOrNode, options) {
+  const { config, fabric, plugin } = options;
+  if (!options.Component) return;
   const fabricChild = createReactFabric();
-  await fabricChild.render(/* @__PURE__ */ jsx(App, {
-    meta: {
-      pluginManager,
-      plugin,
-      mode,
-      oas
-    },
-    children: /* @__PURE__ */ jsx(Component, {
-      config,
-      operation,
-      plugin,
-      generator
-    })
-  }));
+  if (isBuildOperationV1Options(options)) {
+    const { generator, Component } = options;
+    const { pluginManager, oas, mode } = generator.context;
+    await fabricChild.render(/* @__PURE__ */ jsx(App, {
+      meta: {
+        pluginManager,
+        plugin,
+        mode,
+        oas
+      },
+      children: /* @__PURE__ */ jsx(Component, {
+        config,
+        operation: operationOrNode,
+        plugin,
+        generator
+      })
+    }));
+  } else {
+    const { Component } = options;
+    await fabricChild.render(/* @__PURE__ */ jsx(App, {
+      meta: { plugin },
+      children: /* @__PURE__ */ jsx(Component, {
+        config,
+        node: operationOrNode,
+        plugin
+      })
+    }));
+  }
   await fabric.context.fileManager.upsert(...fabricChild.files);
   fabricChild.unmount();
 }
-async function buildSchema(schema, { config, fabric, plugin, Component, generator }) {
-  if (!Component) return;
-  const { pluginManager, oas, mode } = generator.context;
+function isBuildSchemaV1Options(options) {
+  var _a2;
+  return ((_a2 = options.version) != null ? _a2 : "1") === "1";
+}
+async function buildSchema(schema, options) {
+  const { config, fabric, plugin } = options;
+  if (!options.Component) return;
   const fabricChild = createReactFabric();
-  await fabricChild.render(/* @__PURE__ */ jsx(App, {
-    meta: {
-      pluginManager,
-      plugin,
-      mode,
-      oas
-    },
-    children: /* @__PURE__ */ jsx(Component, {
-      config,
-      schema,
-      plugin,
-      generator
-    })
-  }));
+  if (isBuildSchemaV1Options(options)) {
+    const { generator, Component } = options;
+    const { pluginManager, oas, mode } = generator.context;
+    await fabricChild.render(/* @__PURE__ */ jsx(App, {
+      meta: {
+        pluginManager,
+        plugin,
+        mode,
+        oas
+      },
+      children: /* @__PURE__ */ jsx(Component, {
+        config,
+        schema,
+        plugin,
+        generator
+      })
+    }));
+  } else {
+    const { Component } = options;
+    await fabricChild.render(/* @__PURE__ */ jsx(App, {
+      meta: { plugin },
+      children: /* @__PURE__ */ jsx(Component, {
+        config,
+        node: schema,
+        plugin
+      })
+    }));
+  }
   await fabric.context.fileManager.upsert(...fabricChild.files);
   fabricChild.unmount();
 }
@@ -8484,6 +8715,8 @@ parseSchemaObject_fn = function({ schema: _schemaObject, name, parentName, rootN
   const generatorLimit = pLimit(GENERATOR_CONCURRENCY);
   const schemaLimit = pLimit(SCHEMA_CONCURRENCY);
   const writeTasks = generators.map((generator) => generatorLimit(async () => {
+    if (generator.version === "2") return [];
+    const v1Generator = generator;
     const schemaTasks = schemaEntries.map(([name, schemaObject]) => schemaLimit(async () => {
       var _a2, _b2;
       const options = __privateMethod$a(this, _SchemaGenerator_instances, getOptions_fn).call(this, name);
@@ -8493,7 +8726,7 @@ parseSchemaObject_fn = function({ schema: _schemaObject, name, parentName, rootN
         parentName: null,
         rootName: name
       });
-      if (generator.type === "react") {
+      if (v1Generator.type === "react") {
         await buildSchema({
           name,
           value: schemaObject,
@@ -8501,7 +8734,7 @@ parseSchemaObject_fn = function({ schema: _schemaObject, name, parentName, rootN
         }, {
           config: this.context.pluginManager.config,
           fabric: this.context.fabric,
-          Component: generator.Schema,
+          Component: v1Generator.Schema,
           generator: this,
           plugin: {
             ...this.context.plugin,
@@ -8513,7 +8746,7 @@ parseSchemaObject_fn = function({ schema: _schemaObject, name, parentName, rootN
         });
         return [];
       }
-      return (_b2 = await ((_a2 = generator.schema) == null ? void 0 : _a2.call(generator, {
+      return (_b2 = await ((_a2 = v1Generator.schema) == null ? void 0 : _a2.call(v1Generator, {
         config: this.context.pluginManager.config,
         generator: this,
         schema: {
@@ -9365,8 +9598,10 @@ ${operations.map(({ operation, name: methodName, typeSchemas, zodSchemas }) => g
 StaticClassClient.getParams = Client.getParams;
 
 function createGenerator(generator) {
+  var _a;
   return {
     type: "core",
+    version: (_a = generator.version) != null ? _a : "1",
     async operations() {
       return [];
     },
@@ -9380,8 +9615,10 @@ function createGenerator(generator) {
   };
 }
 function createReactGenerator(generator) {
+  var _a;
   return {
     type: "react",
+    version: (_a = generator.version) != null ? _a : "1",
     Operations() {
       return null;
     },
@@ -9586,14 +9823,16 @@ var OperationGenerator = (_a$7 = class {
     });
     const writeTasks = generators.map((generator) => generatorLimit(async () => {
       var _a3;
+      if (generator.version === "2") return [];
+      const v1Generator = generator;
       const operationTasks = operations.map(({ operation, method }) => operationLimit(async () => {
         var _a4, _b;
         const options = this.getOptions(operation, method);
-        if (generator.type === "react") {
+        if (v1Generator.type === "react") {
           await buildOperation(operation, {
             config: this.context.pluginManager.config,
             fabric: this.context.fabric,
-            Component: generator.Operation,
+            Component: v1Generator.Operation,
             generator: this,
             plugin: {
               ...this.context.plugin,
@@ -9605,7 +9844,7 @@ var OperationGenerator = (_a$7 = class {
           });
           return [];
         }
-        return (_b = await ((_a4 = generator.operation) == null ? void 0 : _a4.call(generator, {
+        return (_b = await ((_a4 = v1Generator.operation) == null ? void 0 : _a4.call(v1Generator, {
           generator: this,
           config: this.context.pluginManager.config,
           operation,
@@ -9619,17 +9858,17 @@ var OperationGenerator = (_a$7 = class {
         }))) != null ? _b : [];
       }));
       const opResultsFlat = (await Promise.all(operationTasks)).flat();
-      if (generator.type === "react") {
+      if (v1Generator.type === "react") {
         await buildOperations(operations.map((op) => op.operation), {
           fabric: this.context.fabric,
           config: this.context.pluginManager.config,
-          Component: generator.Operations,
+          Component: v1Generator.Operations,
           generator: this,
           plugin: this.context.plugin
         });
         return [];
       }
-      const operationsResult = await ((_a3 = generator.operations) == null ? void 0 : _a3.call(generator, {
+      const operationsResult = await ((_a3 = v1Generator.operations) == null ? void 0 : _a3.call(v1Generator, {
         generator: this,
         config: this.context.pluginManager.config,
         operations: operations.map((op) => op.operation),
@@ -209410,6 +209649,7 @@ function printResponseSchema({ baseName, schemas, pluginManager, unknownType })
 }
 const typeGenerator = createReactGenerator({
   name: "typescript",
+  version: "1",
   Operation({ operation, generator, plugin }) {
     const { options, options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
     const mode = useMode();
@@ -209632,8 +209872,24 @@ const pluginTs = definePlugin((options) => {
     },
     async install() {
       var _a;
-      const root = path$2.resolve(this.config.root, this.config.output.path);
+      const { config, fabric, plugin } = this;
+      const root = path$2.resolve(config.root, config.output.path);
       const mode = getMode(path$2.resolve(root, output.path));
+      if (this.rootNode) {
+        await this.openInStudio({ ast: true });
+        await walk(this.rootNode, { async schema(schemaNode) {
+          await generators.map(async (generator) => {
+            if (generator.type === "react" && generator.version === "2") await buildSchema(schemaNode, {
+              config,
+              fabric,
+              Component: generator.Schema,
+              plugin,
+              version: generator.version
+            });
+          });
+        } }, { depth: "shallow" });
+        return;
+      }
       const oas = await this.getOas();
       const schemaFiles = await new SchemaGenerator(this.plugin.options, {
         fabric: this.fabric,
@@ -210082,6 +210338,21 @@ const pluginZod = definePlugin((options) => {
   };
 });
 
+function WrapperClient({ name, classNames, isExportable = true, isIndexable = true }) {
+  const classCode = `export class ${name} {
+${classNames.map((className) => `  readonly ${camelCase$b(className)}: ${className}`).join("\n")}
+
+  constructor(config: Partial<RequestConfig> & { client?: Client } = {}) {
+${classNames.map((className) => `    this.${camelCase$b(className)} = new ${className}(config)`).join("\n")}
+  }
+}`;
+  return /* @__PURE__ */ jsx(File.Source, {
+    name,
+    isExportable,
+    isIndexable,
+    children: classCode
+  });
+}
 const classClientGenerator = createReactGenerator({
   name: "classClient",
   Operations({ operations, generator, plugin, config }) {
@@ -210191,7 +210462,7 @@ const classClientGenerator = createReactGenerator({
         zodFilesByPath
       };
     }
-    return controllers.map(({ name, file, operations: ops }) => {
+    const files = controllers.map(({ name, file, operations: ops }) => {
       const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops);
       const { zodImportsByFile, zodFilesByPath } = options.parser === "zod" ? collectZodImports(ops) : {
         zodImportsByFile: /* @__PURE__ */ new Map(),
@@ -210293,6 +210564,49 @@ const classClientGenerator = createReactGenerator({
         ]
       }, file.path);
     });
+    if (options.wrapper) {
+      const wrapperFile = pluginManager.getFile({
+        name: options.wrapper.className,
+        extname: ".ts",
+        pluginKey
+      });
+      files.push(/* @__PURE__ */ jsxs(File, {
+        baseName: wrapperFile.baseName,
+        path: wrapperFile.path,
+        meta: wrapperFile.meta,
+        banner: getBanner({
+          oas,
+          output: options.output,
+          config: pluginManager.config
+        }),
+        footer: getFooter({
+          oas,
+          output: options.output
+        }),
+        children: [
+          options.importPath ? /* @__PURE__ */ jsx(File.Import, {
+            name: ["Client", "RequestConfig"],
+            path: options.importPath,
+            isTypeOnly: true
+          }) : /* @__PURE__ */ jsx(File.Import, {
+            name: ["Client", "RequestConfig"],
+            root: wrapperFile.path,
+            path: path$2.resolve(config.root, config.output.path, ".kubb/fetch.ts"),
+            isTypeOnly: true
+          }),
+          controllers.map(({ name, file }) => /* @__PURE__ */ jsx(File.Import, {
+            name: [name],
+            root: wrapperFile.path,
+            path: file.path
+          }, name)),
+          /* @__PURE__ */ jsx(WrapperClient, {
+            name: options.wrapper.className,
+            classNames: controllers.map(({ name }) => name)
+          })
+        ]
+      }, wrapperFile.path));
+    }
+    return files;
   }
 });
 const clientGenerator = createReactGenerator({
@@ -210742,7 +211056,7 @@ const pluginClient = definePlugin((options) => {
   const { output = {
     path: "clients",
     barrelType: "named"
-  }, group, urlType = false, exclude = [], include, override = [], transformers = {}, dataReturnType = "data", paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", operations = false, baseURL, paramsCasing, clientType = "function", parser = "client", client = "axios", importPath, contentType, bundle = false } = options;
+  }, group, urlType = false, exclude = [], include, override = [], transformers = {}, dataReturnType = "data", paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", operations = false, baseURL, paramsCasing, clientType = "function", parser = "client", client = "axios", importPath, contentType, bundle = false, wrapper } = options;
   const resolvedImportPath = importPath != null ? importPath : !bundle ? `@kubb/plugin-client/clients/${client}` : void 0;
   const defaultGenerators = [
     clientType === "staticClass" ? staticClassClientGenerator : clientType === "class" ? classClientGenerator : clientGenerator,
@@ -210765,7 +211079,8 @@ const pluginClient = definePlugin((options) => {
       paramsCasing,
       pathParamsType,
       baseURL,
-      urlType
+      urlType,
+      wrapper
     },
     pre: [pluginOasName, parser === "zod" ? pluginZodName : void 0].filter(Boolean),
     resolvePath(baseName, pathMode, options2) {