@kubb/agent 5.0.0-alpha.3 → 5.0.0-alpha.5

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

@@ -15,7 +15,7 @@ import { Logtail } from '@logtail/node';
 import { consola } from 'consola';
 import mod from 'node:module';
 import { access, rm, readFile as readFile$1, readdir as readdir$1, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
-import { createFabric, createReactFabric, App, File, Function as Function$1, Const, FunctionParams, Type as Type$2, useApp } from '@kubb/react-fabric';
+import { createFabric, createReactFabric, Fabric, File, Function as Function$1, Const, FunctionParams, Type as Type$2, useFabric } from '@kubb/react-fabric';
 import { typescriptParser } from '@kubb/react-fabric/parsers';
 import { fsPlugin } from '@kubb/react-fabric/plugins';
 import { performance as performance$1 } from 'node:perf_hooks';
@@ -4521,7 +4521,7 @@ function formatMs$1(ms) {
   if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
   return `${Math.round(ms)}ms`;
 }
-function parseHex$1(color) {
+function parseHex$2(color) {
   const int = Number.parseInt(color.replace("#", ""), 16);
   return Number.isNaN(int) ? {
     r: 255,
@@ -4533,18 +4533,18 @@ function parseHex$1(color) {
     b: int & 255
   };
 }
-function hex$1(color) {
-  const { r, g, b } = parseHex$1(color);
+function hex$2(color) {
+  const { r, g, b } = parseHex$2(color);
   return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[0m`;
 }
 ({
-  lid: hex$1("#F55A17"),
-  woodTop: hex$1("#F5A217"),
-  woodMid: hex$1("#F58517"),
-  woodBase: hex$1("#B45309"),
-  eye: hex$1("#FFFFFF"),
-  highlight: hex$1("#adadc6"),
-  blush: hex$1("#FDA4AF")
+  lid: hex$2("#F55A17"),
+  woodTop: hex$2("#F5A217"),
+  woodMid: hex$2("#F58517"),
+  woodBase: hex$2("#B45309"),
+  eye: hex$2("#FFFFFF"),
+  highlight: hex$2("#adadc6"),
+  blush: hex$2("#FDA4AF")
 });
 function maskString(value, start = 8, end = 4) {
   if (value.length <= start + end) return value;
@@ -4653,9 +4653,32 @@ async function disconnect({ sessionId, token, studioUrl }) {
 const visitorDepths = {
   deep: "deep"
 };
+function createSchema(props) {
+  if (props["type"] === "object") return {
+    properties: [],
+    ...props,
+    kind: "Schema"
+  };
+  return {
+    ...props,
+    kind: "Schema"
+  };
+}
+function createProperty(props) {
+  return {
+    required: false,
+    ...props,
+    kind: "Property"
+  };
+}
 function narrowSchema(node, type) {
   return (node == null ? void 0 : node.type) === type ? node : void 0;
 }
+function isKind(kind) {
+  return (node) => node.kind === kind;
+}
+const isOperationNode = isKind("Operation");
+const isSchemaNode = isKind("Schema");
 function definePrinter(build) {
   return (options) => {
     const { name, options: resolvedOptions, nodes } = build(options != null ? options : {});
@@ -4674,6 +4697,49 @@ function definePrinter(build) {
     };
   };
 }
+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(".");
+  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 parseHex$1(color) {
+  const int = Number.parseInt(color.replace("#", ""), 16);
+  return Number.isNaN(int) ? {
+    r: 255,
+    g: 255,
+    b: 255
+  } : {
+    r: int >> 16 & 255,
+    g: int >> 8 & 255,
+    b: int & 255
+  };
+}
+function hex$1(color) {
+  const { r, g, b } = parseHex$1(color);
+  return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[0m`;
+}
+hex$1("#F55A17"), hex$1("#F5A217"), hex$1("#F58517"), hex$1("#B45309"), hex$1("#FFFFFF"), hex$1("#adadc6"), hex$1("#FDA4AF");
+function isValidVarName$c(name) {
+  try {
+    new Function(`var ${name}`);
+  } catch {
+    return false;
+  }
+  return true;
+}
 const plainStringTypes = /* @__PURE__ */ new Set([
   "string",
   "uuid",
@@ -4688,6 +4754,16 @@ function isPlainStringType(node) {
   if (temporal) return temporal.representation !== "date";
   return false;
 }
+function applyParamsCasing$1(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 createLimit(concurrency) {
   let active = 0;
   const queue = [];
@@ -5880,7 +5956,7 @@ const fsStorage = defineStorage(() => ({
     await clean(resolve(base));
   }
 }));
-var version$1 = "5.0.0-alpha.3";
+var version$1 = "5.0.0-alpha.5";
 function getDiagnosticInfo() {
   return {
     nodeVersion: version$2,
@@ -6168,6 +6244,34 @@ function inputToAdapterSource(config) {
     path: resolve(config.root, config.input.path)
   };
 }
+function defineGenerator(generator) {
+  if (generator.type === "react") return {
+    version: "2",
+    Operations() {
+      return null;
+    },
+    Operation() {
+      return null;
+    },
+    Schema() {
+      return null;
+    },
+    ...generator
+  };
+  return {
+    version: "2",
+    async operations() {
+      return [];
+    },
+    async operation() {
+      return [];
+    },
+    async schema() {
+      return [];
+    },
+    ...generator
+  };
+}
 function definePlugin(build2) {
   return (options) => build2(options != null ? options : {});
 }
@@ -6614,8 +6718,55 @@ async function detectLinter() {
     "eslint"
   ]) if (await isLinterAvailable(linter)) return linter;
 }
+function matchesOperationPattern(node, type, pattern) {
+  switch (type) {
+    case "tag":
+      return node.tags.some((tag) => !!tag.match(pattern));
+    case "operationId":
+      return !!node.operationId.match(pattern);
+    case "path":
+      return !!node.path.match(pattern);
+    case "method":
+      return !!node.method.toLowerCase().match(pattern);
+    default:
+      return false;
+  }
+}
+function matchesSchemaPattern(node, type, pattern) {
+  switch (type) {
+    case "schemaName":
+      return node.name ? !!node.name.match(pattern) : false;
+    default:
+      return null;
+  }
+}
+function resolveOptions(node, { options, exclude = [], include, override = [] }) {
+  var _a2, _b2;
+  if (isOperationNode(node)) {
+    if (exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
+    if (include && !include.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
+    const overrideOptions = (_a2 = override.find(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) == null ? void 0 : _a2.options;
+    return {
+      ...options,
+      ...overrideOptions
+    };
+  }
+  if (isSchemaNode(node)) {
+    if (exclude.some(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) return null;
+    if (include) {
+      const applicable = include.map(({ type, pattern }) => matchesSchemaPattern(node, type, pattern)).filter((r) => r !== null);
+      if (applicable.length > 0 && !applicable.includes(true)) return null;
+    }
+    const overrideOptions = (_b2 = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) == null ? void 0 : _b2.options;
+    return {
+      ...options,
+      ...overrideOptions
+    };
+  }
+  return options;
+}
 
-var version = "5.0.0-alpha.3";
+var version = "5.0.0-alpha.5";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -7827,7 +7978,7 @@ async function buildOperations(operationsOrNodes, options) {
   if (isBuildOperationsV1Options(options)) {
     const { generator, Component } = options;
     const { pluginManager, oas, mode } = generator.context;
-    await fabricChild.render(/* @__PURE__ */ jsx(App, {
+    await fabricChild.render(/* @__PURE__ */ jsx(Fabric, {
       meta: {
         pluginManager,
         plugin,
@@ -7843,17 +7994,17 @@ async function buildOperations(operationsOrNodes, options) {
     }));
   } else {
     const { Component, adapter } = options;
-    await fabricChild.render(/* @__PURE__ */ jsx(App, {
+    await fabricChild.render(/* @__PURE__ */ jsx(Fabric, {
       meta: { plugin },
       children: /* @__PURE__ */ jsx(Component, {
         config,
         adapter,
         nodes: operationsOrNodes,
-        options: plugin.options
+        options: options.options
       })
     }));
   }
-  await fabric.context.fileManager.upsert(...fabricChild.files);
+  fabric.context.fileManager.upsert(...fabricChild.files);
   fabricChild.unmount();
 }
 function isBuildOperationV1Options(options) {
@@ -7867,7 +8018,7 @@ async function buildOperation(operationOrNode, options) {
   if (isBuildOperationV1Options(options)) {
     const { generator, Component } = options;
     const { pluginManager, oas, mode } = generator.context;
-    await fabricChild.render(/* @__PURE__ */ jsx(App, {
+    await fabricChild.render(/* @__PURE__ */ jsx(Fabric, {
       meta: {
         pluginManager,
         plugin,
@@ -7883,7 +8034,7 @@ async function buildOperation(operationOrNode, options) {
     }));
   } else {
     const { Component, adapter, pluginManager, mode } = options;
-    await fabricChild.render(/* @__PURE__ */ jsx(App, {
+    await fabricChild.render(/* @__PURE__ */ jsx(Fabric, {
       meta: {
         plugin,
         pluginManager,
@@ -7893,11 +8044,11 @@ async function buildOperation(operationOrNode, options) {
         config,
         adapter,
         node: operationOrNode,
-        options: plugin.options
+        options: options.options
       })
     }));
   }
-  await fabric.context.fileManager.upsert(...fabricChild.files);
+  fabric.context.fileManager.upsert(...fabricChild.files);
   fabricChild.unmount();
 }
 function isBuildSchemaV1Options(options) {
@@ -7911,7 +8062,7 @@ async function buildSchema(schema, options) {
   if (isBuildSchemaV1Options(options)) {
     const { generator, Component } = options;
     const { pluginManager, oas, mode } = generator.context;
-    await fabricChild.render(/* @__PURE__ */ jsx(App, {
+    await fabricChild.render(/* @__PURE__ */ jsx(Fabric, {
       meta: {
         pluginManager,
         plugin,
@@ -7927,7 +8078,7 @@ async function buildSchema(schema, options) {
     }));
   } else {
     const { Component, adapter, pluginManager, mode } = options;
-    await fabricChild.render(/* @__PURE__ */ jsx(App, {
+    await fabricChild.render(/* @__PURE__ */ jsx(Fabric, {
       meta: {
         plugin,
         pluginManager,
@@ -7937,11 +8088,11 @@ async function buildSchema(schema, options) {
         config,
         adapter,
         node: schema,
-        options: plugin.options
+        options: options.options
       })
     }));
   }
-  await fabric.context.fileManager.upsert(...fabricChild.files);
+  fabric.context.fileManager.upsert(...fabricChild.files);
   fabricChild.unmount();
 }
 const GENERATOR_CONCURRENCY = 3;
@@ -9750,10 +9901,9 @@ ${operations.map(({ operation, name: methodName, typeSchemas, zodSchemas }) => g
 StaticClassClient.getParams = Client.getParams;
 
 function createGenerator(generator) {
-  var _a;
   return {
     type: "core",
-    version: (_a = generator.version) != null ? _a : "1",
+    version: "1",
     async operations() {
       return [];
     },
@@ -9767,10 +9917,9 @@ function createGenerator(generator) {
   };
 }
 function createReactGenerator(generator) {
-  var _a;
   return {
     type: "react",
-    version: (_a = generator.version) != null ? _a : "1",
+    version: "1",
     Operations() {
       return null;
     },
@@ -209050,8 +209199,9 @@ const keywordTypeNodes = {
   never: factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
 };
 function createUrlTemplateType(path) {
-  if (!path.includes("{")) return factory.createLiteralTypeNode(factory.createStringLiteral(path));
-  const segments = path.split(/(\{[^}]+\})/);
+  const normalized = path.replace(/:([^/]+)/g, "{$1}");
+  if (!normalized.includes("{")) return factory.createLiteralTypeNode(factory.createStringLiteral(normalized));
+  const segments = normalized.split(/(\{[^}]+\})/);
   const parts = [];
   const parameterIndices = [];
   segments.forEach((segment) => {
@@ -209460,32 +209610,42 @@ function Type$1({ name, typedName, tree, keysToOmit, schema, optionalType, array
 }
 
 function useKubb() {
-  const { meta } = useApp();
+  const { meta } = useFabric();
+  const defaultPluginName = meta.plugin.name;
   return {
     plugin: meta.plugin,
     mode: meta.mode,
     config: meta.pluginManager.config,
-    getPluginByName: meta.pluginManager.getPluginByName.bind(meta.pluginManager),
-    getFile: meta.pluginManager.getFile.bind(meta.pluginManager),
-    resolveName: meta.pluginManager.resolveName.bind(meta.pluginManager),
-    resolvePath: meta.pluginManager.resolvePath.bind(meta.pluginManager)
+    getPluginByName: (pluginName = defaultPluginName) => meta.pluginManager.getPluginByName.call(meta.pluginManager, pluginName),
+    getFile: ({ pluginName = defaultPluginName, ...rest }) => meta.pluginManager.getFile.call(meta.pluginManager, {
+      pluginName,
+      ...rest
+    }),
+    resolveName: ({ pluginName = defaultPluginName, ...rest }) => meta.pluginManager.resolveName.call(meta.pluginManager, {
+      pluginName,
+      ...rest
+    }),
+    resolvePath: ({ pluginName = defaultPluginName, ...rest }) => meta.pluginManager.resolvePath.call(meta.pluginManager, {
+      pluginName,
+      ...rest
+    })
   };
 }
 function useMode() {
-  const { meta } = useApp();
+  const { meta } = useFabric();
   return meta.mode;
 }
 function usePlugin() {
-  const { meta } = useApp();
+  const { meta } = useFabric();
   return meta.plugin;
 }
 function usePluginManager() {
-  const { meta } = useApp();
+  const { meta } = useFabric();
   return meta.pluginManager;
 }
 
 function useOas() {
-  const { meta } = useApp();
+  const { meta } = useFabric();
   return meta.oas;
 }
 function useOperationManager(generator) {
@@ -209826,7 +209986,6 @@ function printResponseSchema({ baseName, schemas, pluginManager, unknownType })
 }
 const typeGenerator$1 = createReactGenerator({
   name: "typescript",
-  version: "1",
   Operation({ operation, generator, plugin }) {
     const { options, options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
     const mode = useMode();
@@ -210069,13 +210228,17 @@ const printerTs = definePrinter((options) => ({
     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: () => keywordTypeNodes.string,
+    url: (node) => {
+      if (node.path) return createUrlTemplateType(node.path);
+      return keywordTypeNodes.string;
+    },
     datetime: () => keywordTypeNodes.string,
     number: () => keywordTypeNodes.number,
     integer: () => keywordTypeNodes.number,
@@ -210137,6 +210300,7 @@ const printerTs = definePrinter((options) => ({
       const { print } = this;
       const propertyNodes = node.properties.map((prop) => {
         var _a;
+        if (this.options.mapper && Object.hasOwn(this.options.mapper, prop.name)) return this.options.mapper[prop.name];
         const baseType = (_a = print(prop.schema)) != null ? _a : keywordTypeNodes.unknown;
         const type = buildPropertyType(prop.schema, baseType, this.options.optionalType);
         return appendJSDocToNode({
@@ -210155,7 +210319,7 @@ const printerTs = definePrinter((options) => ({
     }
   }
 }));
-function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, ...rest }) {
+function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, mapper, ...rest }) {
   const typeNodes = [];
   const description = rest.description || (node == null ? void 0 : node.description);
   const enumSchemaNodes = collect(node, { schema(n) {
@@ -210164,7 +210328,8 @@ function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, synt
   let type = printerTs({
     optionalType,
     arrayType,
-    enumType
+    enumType,
+    mapper
   }).print(node);
   if (!type) return;
   if (["asConst", "asPascalConst"].includes(enumType) && enumSchemaNodes.length > 0) {
@@ -210254,28 +210419,144 @@ function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, synt
     children: safePrint(...typeNodes)
   })] });
 }
-const typeGenerator = createReactGenerator({
+function buildParamsSchema({ params, operationId, resolveName }) {
+  return createSchema({
+    type: "object",
+    properties: params.map((param) => createProperty({
+      name: param.name,
+      schema: createSchema({
+        type: "ref",
+        name: resolveName({
+          name: `${operationId} ${param.name}`,
+          type: "function"
+        }),
+        optional: !param.required
+      })
+    }))
+  });
+}
+function buildDataSchemaNode({ node, resolveName }) {
+  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",
+    properties: [
+      createProperty({
+        name: "data",
+        schema: node.requestBody ? createSchema({
+          type: "ref",
+          name: resolveName({
+            name: `${node.operationId} MutationRequest`,
+            type: "function"
+          }),
+          optional: true
+        }) : createSchema({
+          type: "never",
+          optional: true
+        })
+      }),
+      createProperty({
+        name: "pathParams",
+        schema: pathParams.length > 0 ? buildParamsSchema({
+          params: pathParams,
+          operationId: node.operationId,
+          resolveName
+        }) : createSchema({
+          type: "never",
+          optional: true
+        })
+      }),
+      createProperty({
+        name: "queryParams",
+        schema: queryParams.length > 0 ? createSchema({
+          ...buildParamsSchema({
+            params: queryParams,
+            operationId: node.operationId,
+            resolveName
+          }),
+          optional: true
+        }) : createSchema({
+          type: "never",
+          optional: true
+        })
+      }),
+      createProperty({
+        name: "headerParams",
+        schema: headerParams.length > 0 ? createSchema({
+          ...buildParamsSchema({
+            params: headerParams,
+            operationId: node.operationId,
+            resolveName
+          }),
+          optional: true
+        }) : createSchema({
+          type: "never",
+          optional: true
+        })
+      }),
+      createProperty({
+        name: "url",
+        schema: createSchema({
+          type: "url",
+          path: node.path
+        })
+      })
+    ]
+  });
+}
+function buildResponsesSchemaNode({ node, resolveName }) {
+  const responsesWithSchema = node.responses.filter((res) => res.schema);
+  if (responsesWithSchema.length === 0) return null;
+  return createSchema({
+    type: "object",
+    properties: responsesWithSchema.map((res) => createProperty({
+      name: String(res.statusCode),
+      schema: createSchema({
+        type: "ref",
+        name: resolveName({
+          name: `${node.operationId} ${res.statusCode}`,
+          type: "function"
+        })
+      })
+    }))
+  });
+}
+function buildResponseUnionSchemaNode({ node, resolveName }) {
+  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: resolveName({
+        name: `${node.operationId} ${res.statusCode}`,
+        type: "function"
+      })
+    }))
+  });
+}
+const typeGenerator = defineGenerator({
   name: "typescript",
-  version: "2",
+  type: "react",
   Operation({ node, adapter, options }) {
-    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType } = options;
-    const { plugin, mode, getFile, resolveName } = useKubb();
+    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, mapper } = options;
+    const { mode, getFile, resolveName } = useKubb();
     const file = getFile({
       name: node.operationId,
-      pluginName: plugin.name,
       extname: ".ts",
       mode
     });
+    const params = applyParamsCasing$1(node.parameters, paramsCasing);
     function renderSchemaType({ node: schemaNode, name, typedName, description }) {
+      if (!schemaNode) return null;
       const imports = adapter.getImports(schemaNode, (schemaName) => ({
         name: resolveName({
           name: schemaName,
-          pluginName: plugin.name,
           type: "type"
         }),
         path: getFile({
           name: schemaName,
-          pluginName: plugin.name,
           extname: ".ts",
           mode
         }).path
@@ -210298,63 +210579,90 @@ const typeGenerator = createReactGenerator({
         enumKeyCasing,
         optionalType,
         arrayType,
-        syntaxType
+        syntaxType,
+        mapper
       })] });
     }
-    const paramTypes = node.parameters.map((param) => {
-      const name = resolveName({
+    const paramTypes = params.map((param) => renderSchemaType({
+      node: param.schema,
+      name: resolveName({
         name: `${node.operationId} ${param.name}`,
-        pluginName: plugin.name,
         type: "function"
-      });
-      const typedName = resolveName({
+      }),
+      typedName: resolveName({
         name: `${node.operationId} ${param.name}`,
-        pluginName: plugin.name,
         type: "type"
-      });
-      return renderSchemaType({
-        node: param.schema,
-        name,
-        typedName
-      });
+      })
+    }));
+    const responseTypes = node.responses.filter((res) => res.schema).map((res) => renderSchemaType({
+      node: res.schema,
+      name: resolveName({
+        name: `${node.operationId} ${res.statusCode}`,
+        type: "function"
+      }),
+      typedName: resolveName({
+        name: `${node.operationId} ${res.statusCode}`,
+        type: "type"
+      }),
+      description: res.description
+    }));
+    const requestType = node.requestBody ? renderSchemaType({
+      node: node.requestBody,
+      name: resolveName({
+        name: `${node.operationId} MutationRequest`,
+        type: "function"
+      }),
+      typedName: resolveName({
+        name: `${node.operationId} MutationRequest`,
+        type: "type"
+      }),
+      description: node.requestBody.description
+    }) : null;
+    const dataType = renderSchemaType({
+      node: buildDataSchemaNode({
+        node: {
+          ...node,
+          parameters: params
+        },
+        resolveName
+      }),
+      name: resolveName({
+        name: `${node.operationId} Data`,
+        type: "function"
+      }),
+      typedName: resolveName({
+        name: `${node.operationId} Data`,
+        type: "type"
+      })
     });
-    const responseTypes = node.responses.filter((res) => res.schema).map((res) => {
-      const schemaNode = res.schema;
-      const responseName = `${node.operationId} ${res.statusCode}`;
-      return renderSchemaType({
-        node: schemaNode,
-        name: resolveName({
-          name: responseName,
-          pluginName: plugin.name,
-          type: "function"
-        }),
-        typedName: resolveName({
-          name: responseName,
-          pluginName: plugin.name,
-          type: "type"
-        }),
-        description: res.description
-      });
+    const responsesType = renderSchemaType({
+      node: buildResponsesSchemaNode({
+        node,
+        resolveName
+      }),
+      name: resolveName({
+        name: `${node.operationId} Responses`,
+        type: "function"
+      }),
+      typedName: resolveName({
+        name: `${node.operationId} Responses`,
+        type: "type"
+      })
     });
-    const requestType = node.requestBody ? (() => {
-      const requestName = `${node.operationId} MutationRequest`;
-      const resolvedName = resolveName({
-        name: requestName,
-        pluginName: plugin.name,
+    const responseType = renderSchemaType({
+      node: buildResponseUnionSchemaNode({
+        node,
+        resolveName
+      }),
+      name: resolveName({
+        name: `${node.operationId} Response`,
         type: "function"
-      });
-      const typedName = resolveName({
-        name: requestName,
-        pluginName: plugin.name,
+      }),
+      typedName: resolveName({
+        name: `${node.operationId} Response`,
         type: "type"
-      });
-      return renderSchemaType({
-        node: node.requestBody,
-        name: resolvedName,
-        typedName,
-        description: node.requestBody.description
-      });
-    })() : null;
+      })
+    });
     return /* @__PURE__ */ jsxs(File, {
       baseName: file.baseName,
       path: file.path,
@@ -210362,23 +210670,24 @@ const typeGenerator = createReactGenerator({
       children: [
         paramTypes,
         responseTypes,
-        requestType
+        requestType,
+        dataType,
+        responsesType,
+        responseType
       ]
     });
   },
   Schema({ node, adapter, options }) {
-    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType } = options;
-    const { plugin, mode, resolveName, getFile } = useKubb();
+    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, mapper } = options;
+    const { mode, resolveName, getFile } = useKubb();
     if (!node.name) return;
     const imports = adapter.getImports(node, (schemaName) => ({
       name: resolveName({
         name: schemaName,
-        pluginName: plugin.name,
         type: "type"
       }),
       path: getFile({
         name: schemaName,
-        pluginName: plugin.name,
         extname: ".ts",
         mode
       }).path
@@ -210386,20 +210695,17 @@ const typeGenerator = createReactGenerator({
     const isEnumSchema = node.type === "enum";
     let typedName = resolveName({
       name: node.name,
-      pluginName: plugin.name,
       type: "type"
     });
-    if (["asConst", "asPascalConst"].includes(enumType) && isEnumSchema) typedName = typedName += "Key";
+    if (["asConst", "asPascalConst"].includes(enumType) && isEnumSchema) typedName += "Key";
     const type = {
       name: resolveName({
         name: node.name,
-        pluginName: plugin.name,
         type: "function"
       }),
       typedName,
       file: getFile({
         name: node.name,
-        pluginName: plugin.name,
         extname: ".ts",
         mode
       })
@@ -210425,7 +210731,8 @@ const typeGenerator = createReactGenerator({
         enumKeyCasing,
         optionalType,
         arrayType,
-        syntaxType
+        syntaxType,
+        mapper
       })]
     });
   }
@@ -210479,7 +210786,7 @@ const pluginTs = definePlugin((options) => {
       return resolvedName;
     },
     async install() {
-      var _a;
+      var _a, _b;
       const { config, fabric, plugin, adapter, rootNode, pluginManager, openInStudio } = this;
       const root = path$2.resolve(config.root, config.output.path);
       const mode = getMode(path$2.resolve(root, output.path));
@@ -210487,34 +210794,63 @@ const pluginTs = definePlugin((options) => {
         await openInStudio({ ast: true });
         await walk(rootNode, {
           async schema(schemaNode) {
-            await generators.map(async (generator) => {
-              if (generator.type === "react" && generator.version === "2") await buildSchema(schemaNode, {
-                adapter,
-                config,
-                fabric,
-                Component: generator.Schema,
-                plugin,
-                pluginManager,
-                mode,
-                version: generator.version
-              });
+            const writeTasks = generators.map(async (generator) => {
+              if (generator.type === "react" && generator.version === "2") {
+                const options2 = resolveOptions(schemaNode, {
+                  options: plugin.options,
+                  exclude,
+                  include,
+                  override
+                });
+                if (options2 === null) return;
+                await buildSchema(schemaNode, {
+                  options: options2,
+                  adapter,
+                  config,
+                  fabric,
+                  Component: generator.Schema,
+                  plugin,
+                  pluginManager,
+                  mode,
+                  version: generator.version
+                });
+              }
             });
+            await Promise.all(writeTasks);
           },
           async operation(operationNode) {
-            await generators.map(async (generator) => {
-              if (generator.type === "react" && generator.version === "2") await buildOperation(operationNode, {
-                adapter,
-                config,
-                fabric,
-                Component: generator.Operation,
-                plugin,
-                pluginManager,
-                mode,
-                version: generator.version
-              });
+            const writeTasks = generators.map(async (generator) => {
+              if (generator.type === "react" && generator.version === "2") {
+                const options2 = resolveOptions(operationNode, {
+                  options: plugin.options,
+                  exclude,
+                  include,
+                  override
+                });
+                if (options2 === null) return;
+                await buildOperation(operationNode, {
+                  options: options2,
+                  adapter,
+                  config,
+                  fabric,
+                  Component: generator.Operation,
+                  plugin,
+                  pluginManager,
+                  mode,
+                  version: generator.version
+                });
+              }
             });
+            await Promise.all(writeTasks);
           }
         }, { depth: "shallow" });
+        const barrelFiles2 = await getBarrelFiles(this.fabric.files, {
+          type: (_a = output.barrelType) != null ? _a : "named",
+          root,
+          output,
+          meta: { pluginName: this.plugin.name }
+        });
+        await this.upsertFile(...barrelFiles2);
         return;
       }
       const oas = await this.getOas();
@@ -210546,7 +210882,7 @@ const pluginTs = definePlugin((options) => {
       }).build(...generators);
       await this.upsertFile(...operationFiles);
       const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: (_a = output.barrelType) != null ? _a : "named",
+        type: (_b = output.barrelType) != null ? _b : "named",
         root,
         output,
         meta: { pluginName: this.plugin.name }