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

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,6 +4653,24 @@ 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;
 }
@@ -4663,22 +4681,65 @@ const isOperationNode = isKind("Operation");
 const isSchemaNode = isKind("Schema");
 function definePrinter(build) {
   return (options) => {
-    const { name, options: resolvedOptions, nodes } = build(options != null ? options : {});
+    const { name, options: resolvedOptions, nodes, print: printOverride } = build(options != null ? options : {});
     const context = {
       options: resolvedOptions,
       print: (node) => {
         const handler = nodes[node.type];
-        return handler ? handler.call(context, node) : void 0;
+        if (!handler) return void 0;
+        return handler.call(context, node);
       }
     };
     return {
       name,
       options: resolvedOptions,
-      print: context.print,
-      for: (nodes2) => nodes2.map(context.print)
+      print: printOverride ? printOverride.bind(context) : context.print
     };
   };
 }
+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",
@@ -4693,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 = [];
@@ -5885,7 +5956,7 @@ const fsStorage = defineStorage(() => ({
     await clean(resolve(base));
   }
 }));
-var version$1 = "5.0.0-alpha.4";
+var version$1 = "5.0.0-alpha.6";
 function getDiagnosticInfo() {
   return {
     nodeVersion: version$2,
@@ -6695,7 +6766,7 @@ function resolveOptions(node, { options, exclude = [], include, override = [] })
   return options;
 }
 
-var version = "5.0.0-alpha.4";
+var version = "5.0.0-alpha.6";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -7907,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,
@@ -7923,7 +7994,7 @@ 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,
@@ -7947,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,
@@ -7963,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,
@@ -7991,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,
@@ -8007,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,
@@ -209128,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) => {
@@ -209339,7 +209411,6 @@ const parse$1 = createParser({
       }).map(([name2, schemas]) => {
         var _a2, _b2, _c2, _d2, _e2;
         const mappedName = ((_a2 = schemas.find((schema2) => schema2.keyword === schemaKeywords.name)) == null ? void 0 : _a2.args) || name2;
-        if (options.mapper && Object.hasOwn(options.mapper, mappedName)) return options.mapper[mappedName];
         const isNullish = schemas.some((schema2) => schema2.keyword === schemaKeywords.nullish);
         const isNullable = schemas.some((schema2) => schema2.keyword === schemaKeywords.nullable);
         const isOptional = schemas.some((schema2) => schema2.keyword === schemaKeywords.optional);
@@ -209427,7 +209498,7 @@ const parse$1 = createParser({
     }
   }
 });
-function Type$1({ name, typedName, tree, keysToOmit, schema, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, mapper, description }) {
+function Type$1({ name, typedName, tree, keysToOmit, schema, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, description }) {
   const typeNodes = [];
   if (!tree.length) return "";
   const schemaFromTree = tree.find((item) => item.keyword === schemaKeywords.schema);
@@ -209441,8 +209512,7 @@ function Type$1({ name, typedName, tree, keysToOmit, schema, optionalType, array
   }, {
     optionalType,
     arrayType,
-    enumType,
-    mapper
+    enumType
   })).filter(Boolean).at(0) || typeKeywordMapper.undefined();
   if (["asConst", "asPascalConst"].includes(enumType) && enumSchemas.length > 0) {
     const isDirectEnum = schema.type === "array" && schema.items !== void 0;
@@ -209538,32 +209608,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) {
@@ -209905,7 +209985,7 @@ function printResponseSchema({ baseName, schemas, pluginManager, unknownType })
 const typeGenerator$1 = createReactGenerator({
   name: "typescript",
   Operation({ operation, generator, plugin }) {
-    const { options, options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
+    const { options, options: { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
     const mode = useMode();
     const pluginManager = usePluginManager();
     const oas = useOas();
@@ -209964,7 +210044,6 @@ const typeGenerator$1 = createReactGenerator({
         description,
         tree,
         schema: transformedSchema,
-        mapper,
         enumType,
         enumKeyCasing,
         optionalType,
@@ -210024,7 +210103,7 @@ const typeGenerator$1 = createReactGenerator({
     });
   },
   Schema({ schema, plugin }) {
-    const { options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output } } = plugin;
+    const { options: { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output } } = plugin;
     const mode = useMode();
     const oas = useOas();
     const pluginManager = usePluginManager();
@@ -210066,7 +210145,6 @@ const typeGenerator$1 = createReactGenerator({
         description: schema.value.description,
         tree: schema.tree,
         schema: schema.value,
-        mapper,
         enumType,
         enumKeyCasing,
         optionalType,
@@ -210076,6 +210154,23 @@ const typeGenerator$1 = createReactGenerator({
     });
   }
 });
+const OPTIONAL_ADDS_UNDEFINED = /* @__PURE__ */ new Set(["undefined", "questionTokenAndUndefined"]);
+const OPTIONAL_ADDS_QUESTION_TOKEN = /* @__PURE__ */ new Set(["questionToken", "questionTokenAndUndefined"]);
+const ENUM_TYPES_WITH_KEY_SUFFIX = /* @__PURE__ */ new Set(["asConst", "asPascalConst"]);
+const ENUM_TYPES_WITH_RUNTIME_VALUE = /* @__PURE__ */ new Set([
+  "enum",
+  "asConst",
+  "asPascalConst",
+  "constEnum",
+  "literal",
+  void 0
+]);
+const ENUM_TYPES_WITH_TYPE_ONLY = /* @__PURE__ */ new Set([
+  "asConst",
+  "asPascalConst",
+  "literal",
+  void 0
+]);
 function constToTypeNode(value, format) {
   if (format === "boolean") return createLiteralTypeNode(value === true ? createTrue() : createFalse());
   if (format === "number" && typeof value === "number") {
@@ -210104,7 +210199,7 @@ function buildTupleNode(node, print) {
   return createTupleTypeNode(items);
 }
 function buildPropertyType(schema, baseType, optionalType) {
-  const addsUndefined = ["undefined", "questionTokenAndUndefined"].includes(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] });
@@ -210139,220 +210234,341 @@ function buildIndexSignatures(node, propertyCount, print) {
   }
   return elements;
 }
-const printerTs = definePrinter((options) => ({
-  name: "typescript",
-  options,
-  nodes: {
-    any: () => keywordTypeNodes.any,
-    unknown: () => keywordTypeNodes.unknown,
-    void: () => keywordTypeNodes.void,
-    boolean: () => keywordTypeNodes.boolean,
-    null: () => keywordTypeNodes.null,
-    blob: () => createTypeReferenceNode("Blob", []),
-    string: () => keywordTypeNodes.string,
-    uuid: () => keywordTypeNodes.string,
-    email: () => keywordTypeNodes.string,
-    url: () => keywordTypeNodes.string,
-    datetime: () => keywordTypeNodes.string,
-    number: () => keywordTypeNodes.number,
-    integer: () => keywordTypeNodes.number,
-    bigint: () => keywordTypeNodes.bigint,
-    date: (node) => dateOrStringNode(node),
-    time: (node) => dateOrStringNode(node),
-    ref(node) {
-      if (!node.name) return;
-      return createTypeReferenceNode(node.name, void 0);
-    },
-    enum(node) {
-      var _a, _b, _c, _d;
-      const values = (_c = (_b = (_a = node.namedEnumValues) == null ? void 0 : _a.map((v) => v.value)) != null ? _b : node.enumValues) != null ? _c : [];
-      if (this.options.enumType === "inlineLiteral" || !node.name) return (_d = createUnionDeclaration({
-        withParentheses: true,
-        nodes: values.filter((v) => v !== null).map((value) => constToTypeNode(value, typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "string")).filter(Boolean)
-      })) != null ? _d : void 0;
-      return createTypeReferenceNode(["asConst", "asPascalConst"].includes(this.options.enumType) ? `${node.name}Key` : node.name, void 0);
-    },
-    union(node) {
-      var _a, _b, _c;
-      const members = (_a = node.members) != null ? _a : [];
-      const hasStringLiteral = members.some((m) => m.type === "enum" && m.enumType === "string");
-      const hasPlainString = members.some((m) => isPlainStringType(m));
-      if (hasStringLiteral && hasPlainString) return (_b = createUnionDeclaration({
-        withParentheses: true,
-        nodes: members.map((m) => {
-          if (isPlainStringType(m)) return createIntersectionDeclaration({
-            nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
-            withParentheses: true
-          });
-          return this.print(m);
-        }).filter(Boolean)
-      })) != null ? _b : void 0;
-      return (_c = createUnionDeclaration({
-        withParentheses: true,
-        nodes: buildMemberNodes(members, this.print)
-      })) != null ? _c : void 0;
-    },
-    intersection(node) {
-      var _a;
-      return (_a = createIntersectionDeclaration({
-        withParentheses: true,
-        nodes: buildMemberNodes(node.members, this.print)
-      })) != null ? _a : void 0;
-    },
-    array(node) {
-      var _a, _b;
-      return (_b = createArrayDeclaration({
-        nodes: ((_a = node.items) != null ? _a : []).map((item) => this.print(item)).filter(Boolean),
-        arrayType: this.options.arrayType
-      })) != null ? _b : void 0;
-    },
-    tuple(node) {
-      return buildTupleNode(node, this.print);
-    },
-    object(node) {
-      const addsQuestionToken = ["questionToken", "questionTokenAndUndefined"].includes(this.options.optionalType);
-      const { print } = this;
-      const propertyNodes = node.properties.map((prop) => {
+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) {
+        if (!node.name) return;
+        return createTypeReferenceNode(node.name, void 0);
+      },
+      enum(node) {
+        var _a, _b, _c, _d;
+        const values = (_c = (_b = (_a = node.namedEnumValues) == null ? void 0 : _a.map((v) => v.value)) != null ? _b : node.enumValues) != null ? _c : [];
+        if (this.options.enumType === "inlineLiteral" || !node.name) return (_d = createUnionDeclaration({
+          withParentheses: true,
+          nodes: values.filter((v) => v !== null).map((value) => constToTypeNode(value, typeof value)).filter(Boolean)
+        })) != null ? _d : void 0;
+        const resolvedName = pascalCase$6(node.name);
+        return createTypeReferenceNode(ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) ? `${resolvedName}Key` : resolvedName, void 0);
+      },
+      union(node) {
+        var _a, _b, _c;
+        const members = (_a = node.members) != null ? _a : [];
+        const hasStringLiteral = members.some((m) => m.type === "enum" && m.enumType === "string");
+        const hasPlainString = members.some((m) => isPlainStringType(m));
+        if (hasStringLiteral && hasPlainString) return (_b = createUnionDeclaration({
+          withParentheses: true,
+          nodes: members.map((m) => {
+            if (isPlainStringType(m)) return createIntersectionDeclaration({
+              nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
+              withParentheses: true
+            });
+            return this.print(m);
+          }).filter(Boolean)
+        })) != null ? _b : void 0;
+        return (_c = createUnionDeclaration({
+          withParentheses: true,
+          nodes: buildMemberNodes(members, this.print)
+        })) != null ? _c : void 0;
+      },
+      intersection(node) {
         var _a;
-        const baseType = (_a = print(prop.schema)) != null ? _a : keywordTypeNodes.unknown;
-        const type = buildPropertyType(prop.schema, baseType, this.options.optionalType);
-        return appendJSDocToNode({
-          node: createPropertySignature({
-            questionToken: prop.schema.optional || prop.schema.nullish ? addsQuestionToken : false,
-            name: prop.name,
-            type,
-            readOnly: prop.schema.readOnly
-          }),
-          comments: buildPropertyJSDocComments(prop.schema)
+        return (_a = createIntersectionDeclaration({
+          withParentheses: true,
+          nodes: buildMemberNodes(node.members, this.print)
+        })) != null ? _a : void 0;
+      },
+      array(node) {
+        var _a, _b;
+        return (_b = createArrayDeclaration({
+          nodes: ((_a = node.items) != null ? _a : []).map((item) => this.print(item)).filter(Boolean),
+          arrayType: this.options.arrayType
+        })) != null ? _b : void 0;
+      },
+      tuple(node) {
+        return buildTupleNode(node, this.print);
+      },
+      object(node) {
+        const { print, options: options2 } = this;
+        const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options2.optionalType);
+        const propertyNodes = node.properties.map((prop) => {
+          var _a;
+          const baseType = (_a = print(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, print)];
+        if (!allElements.length) return keywordTypeNodes.object;
+        return createTypeLiteralNode(allElements);
+      }
+    },
+    print(node) {
+      let type = this.print(node);
+      if (!type) return;
+      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 type;
+      const useTypeGeneration = syntaxType === "type" || type.kind === syntaxKind.union || !!(keysToOmit == null ? void 0 : keysToOmit.length);
+      return 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
+        ]
       });
-      const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, print)];
-      if (!allElements.length) return keywordTypeNodes.object;
-      return createTypeLiteralNode(allElements);
     }
-  }
-}));
-function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, ...rest }) {
-  const typeNodes = [];
-  const description = rest.description || (node == null ? void 0 : node.description);
+  };
+});
+function getEnumNames(node, enumType) {
+  const resolved = pascalCase$6(node.name);
+  return {
+    enumName: enumType === "asPascalConst" ? resolved : camelCase$a(node.name),
+    typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? `${resolved}Key` : resolved
+  };
+}
+function Enum({ node, enumType, enumKeyCasing }) {
+  var _a, _b, _c, _d;
+  const { enumName, typeName } = getEnumNames(node, enumType);
+  const [nameNode, typeNode] = createEnumDeclaration({
+    name: enumName,
+    typeName,
+    enums: (_d = (_c = (_a = node.namedEnumValues) == null ? void 0 : _a.map((v) => [trimQuotes$1(v.name.toString()), v.value])) != null ? _c : (_b = node.enumValues) == null ? void 0 : _b.filter((v) => v !== null && v !== void 0).map((v) => [trimQuotes$1(v.toString()), v])) != null ? _d : [],
+    type: enumType,
+    enumKeyCasing
+  });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [nameNode && /* @__PURE__ */ jsx(File.Source, {
+    name: enumName,
+    isExportable: true,
+    isIndexable: true,
+    isTypeOnly: false,
+    children: safePrint(nameNode)
+  }), /* @__PURE__ */ jsx(File.Source, {
+    name: typeName,
+    isIndexable: true,
+    isExportable: ENUM_TYPES_WITH_RUNTIME_VALUE.has(enumType),
+    isTypeOnly: ENUM_TYPES_WITH_TYPE_ONLY.has(enumType),
+    children: safePrint(typeNode)
+  })] });
+}
+function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, description }) {
+  const resolvedDescription = description || (node == null ? void 0 : node.description);
   const enumSchemaNodes = collect(node, { schema(n) {
     if (n.type === "enum" && n.name) return n;
   } });
-  let type = printerTs({
+  const typeNode = printerTs({
     optionalType,
     arrayType,
-    enumType
+    enumType,
+    typeName: name,
+    syntaxType,
+    description: resolvedDescription,
+    keysToOmit
   }).print(node);
-  if (!type) return;
-  if (["asConst", "asPascalConst"].includes(enumType) && enumSchemaNodes.length > 0) {
-    const isDirectEnum = node.type === "array" && node.items !== void 0;
-    const isEnumOnly = "enum" in node && node.enum;
-    if (isDirectEnum || isEnumOnly) {
-      type = createTypeReferenceNode(`${enumSchemaNodes[0].name}Key`);
-      if (isDirectEnum) if (arrayType === "generic") type = createTypeReferenceNode(createIdentifier("Array"), [type]);
-      else type = createArrayTypeNode(type);
-    }
-  }
-  if (node) {
-    if (node.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-    if (node.nullish && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-    if (node.optional && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-  }
-  const useTypeGeneration = syntaxType === "type" || [syntaxKind.union].includes(type.kind) || !!(keysToOmit == null ? void 0 : keysToOmit.length);
-  typeNodes.push(createTypeDeclaration({
-    name,
-    isExportable: true,
-    type: (keysToOmit == null ? void 0 : keysToOmit.length) ? createOmitDeclaration({
-      keys: keysToOmit,
-      type,
-      nonNullable: true
-    }) : type,
-    syntax: useTypeGeneration ? "type" : "interface",
-    comments: [
-      (node == null ? void 0 : node.title) ? `${jsStringEscape$1(node.title)}` : void 0,
-      description ? `@description ${jsStringEscape$1(description)}` : void 0,
-      (node == null ? void 0 : node.deprecated) ? "@deprecated" : void 0,
-      node && "min" in node && node.min !== void 0 ? `@minLength ${node.min}` : void 0,
-      node && "max" in node && node.max !== void 0 ? `@maxLength ${node.max}` : void 0,
-      node && "pattern" in node && node.pattern ? `@pattern ${node.pattern}` : void 0,
-      (node == null ? void 0 : node.default) ? `@default ${node.default}` : void 0,
-      (node == null ? void 0 : node.example) ? `@example ${node.example}` : void 0
-    ]
-  }));
-  const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((enumSchemaNode) => {
-    var _a, _b, _c, _d;
-    const enumName = enumType === "asPascalConst" ? pascalCase$6(enumSchemaNode.name) : camelCase$a(enumSchemaNode.name);
-    const typeName = ["asConst", "asPascalConst"].includes(enumType) ? `${enumSchemaNode.name}Key` : enumSchemaNode.name;
-    const [nameNode, typeNode] = createEnumDeclaration({
-      name: enumName,
-      typeName,
-      enums: (_d = (_c = (_a = enumSchemaNode.namedEnumValues) == null ? void 0 : _a.map((v) => [trimQuotes$1(v.name.toString()), v.value])) != null ? _c : (_b = enumSchemaNode.enumValues) == null ? void 0 : _b.filter((v) => v !== null && v !== void 0).map((v) => [trimQuotes$1(v.toString()), v])) != null ? _d : [],
-      type: enumType,
-      enumKeyCasing
-    });
+  if (!typeNode) return;
+  const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node2) => {
     return {
-      nameNode,
-      typeNode,
-      name: enumName,
-      typeName
+      node: node2,
+      ...getEnumNames(node2, enumType)
     };
   });
   const shouldExportEnums = enumType !== "inlineLiteral";
   const shouldExportType = enumType === "inlineLiteral" || enums.every((item) => item.typeName !== name);
-  return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ name: enumName, nameNode, typeName, typeNode }) => /* @__PURE__ */ jsxs(Fragment, { children: [nameNode && /* @__PURE__ */ jsx(File.Source, {
-    name: enumName,
-    isExportable: true,
-    isIndexable: true,
-    isTypeOnly: false,
-    children: safePrint(nameNode)
-  }), /* @__PURE__ */ jsx(File.Source, {
-    name: typeName,
-    isIndexable: true,
-    isExportable: [
-      "enum",
-      "asConst",
-      "asPascalConst",
-      "constEnum",
-      "literal",
-      void 0
-    ].includes(enumType),
-    isTypeOnly: [
-      "asConst",
-      "asPascalConst",
-      "literal",
-      void 0
-    ].includes(enumType),
-    children: safePrint(typeNode)
-  })] })), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ node: node2 }) => /* @__PURE__ */ jsx(Enum, {
+    node: node2,
+    enumType,
+    enumKeyCasing
+  })), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
     name: typedName,
     isTypeOnly: true,
     isExportable: true,
     isIndexable: true,
-    children: safePrint(...typeNodes)
+    children: safePrint(typeNode)
   })] });
 }
+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} ${pascalCase$6(param.in)} ${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} Data`,
+            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} Status ${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} Status ${res.statusCode}`,
+        type: "function"
+      })
+    }))
+  });
+}
 const typeGenerator = defineGenerator({
   name: "typescript",
   type: "react",
   Operation({ node, adapter, options }) {
-    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType } = options;
-    const { plugin, mode, getFile, resolveName } = useKubb();
+    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group } = options;
+    const { mode, getFile, resolveName } = useKubb();
     const file = getFile({
       name: node.operationId,
-      pluginName: plugin.name,
       extname: ".ts",
-      mode
+      mode,
+      options: { group: group ? group.type === "tag" ? { tag: node.tags[0] } : { path: node.path } : void 0 }
     });
+    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
@@ -210378,60 +210594,87 @@ const typeGenerator = defineGenerator({
         syntaxType
       })] });
     }
-    const paramTypes = node.parameters.map((param) => {
-      const name = resolveName({
-        name: `${node.operationId} ${param.name}`,
-        pluginName: plugin.name,
+    const paramTypes = params.map((param) => renderSchemaType({
+      node: param.schema,
+      name: resolveName({
+        name: `${node.operationId} ${pascalCase$6(param.in)} ${param.name}`,
         type: "function"
-      });
-      const typedName = resolveName({
-        name: `${node.operationId} ${param.name}`,
-        pluginName: plugin.name,
+      }),
+      typedName: resolveName({
+        name: `${node.operationId} ${pascalCase$6(param.in)} ${param.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} Status ${res.statusCode}`,
+        type: "function"
+      }),
+      typedName: resolveName({
+        name: `${node.operationId} Status ${res.statusCode}`,
+        type: "type"
+      }),
+      description: res.description
+    }));
+    const requestType = node.requestBody ? renderSchemaType({
+      node: node.requestBody,
+      name: resolveName({
+        name: `${node.operationId} Data`,
+        type: "function"
+      }),
+      typedName: resolveName({
+        name: `${node.operationId} Data`,
+        type: "type"
+      }),
+      description: node.requestBody.description
+    }) : null;
+    const dataType = renderSchemaType({
+      node: buildDataSchemaNode({
+        node: {
+          ...node,
+          parameters: params
+        },
+        resolveName
+      }),
+      name: resolveName({
+        name: `${node.operationId} RequestConfig`,
+        type: "function"
+      }),
+      typedName: resolveName({
+        name: `${node.operationId} RequestConfig`,
+        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;
+      }),
+      description: "Union of all possible responses"
+    });
     return /* @__PURE__ */ jsxs(File, {
       baseName: file.baseName,
       path: file.path,
@@ -210439,23 +210682,24 @@ const typeGenerator = defineGenerator({
       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 { 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
@@ -210463,20 +210707,17 @@ const typeGenerator = defineGenerator({
     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 (ENUM_TYPES_WITH_KEY_SUFFIX.has(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
       })
@@ -210512,7 +210753,7 @@ const pluginTs = definePlugin((options) => {
   const { output = {
     path: "types",
     barrelType: "named"
-  }, group, exclude = [], include, override = [], enumType = "asConst", enumKeyCasing = "none", enumSuffix = "enum", dateType = "string", integerType = "number", unknownType = "any", optionalType = "questionToken", arrayType = "array", emptySchemaType = unknownType, syntaxType = "type", transformers = {}, mapper = {}, paramsCasing, generators = [typeGenerator$1, typeGenerator].filter(Boolean), contentType, UNSTABLE_NAMING } = options;
+  }, group, exclude = [], include, override = [], enumType = "asConst", enumKeyCasing = "none", enumSuffix = "enum", dateType = "string", integerType = "number", unknownType = "any", optionalType = "questionToken", arrayType = "array", emptySchemaType = unknownType, syntaxType = "type", transformers = {}, paramsCasing, generators = [typeGenerator$1, typeGenerator].filter(Boolean), contentType, UNSTABLE_NAMING } = options;
   return {
     name: pluginTsName,
     options: {
@@ -210530,7 +210771,6 @@ const pluginTs = definePlugin((options) => {
       syntaxType,
       group,
       override,
-      mapper,
       paramsCasing,
       usedEnumNames: {}
     },
@@ -210556,7 +210796,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));
@@ -210614,6 +210854,13 @@ const pluginTs = definePlugin((options) => {
             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();
@@ -210645,7 +210892,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 }