@kubb/agent 5.0.0-alpha.11 → 5.0.0-alpha.12

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

@@ -14,7 +14,7 @@ import process$1, { version as version$2 } from 'node:process';
 import { Logtail } from '@logtail/node';
 import { consola } from 'consola';
 import { access, rm, readFile as readFile$1, readdir as readdir$1, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
-import { createFabric, createReactFabric, Fabric, File, Function as Function$1, Const, FunctionParams, Type as Type$2, useFabric } from '@kubb/react-fabric';
+import { createFabric, createReactFabric, Fabric, File, Function as Function$1, Const, FunctionParams, Type as Type$1, 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';
@@ -4713,7 +4713,7 @@ function toCamelOrPascal$f(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$f(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$f(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -4794,13 +4794,14 @@ function createLimit(concurrency) {
   };
 }
 function getChildren(node, recurse) {
+  var _a;
   switch (node.kind) {
     case "Root":
       return [...node.schemas, ...node.operations];
     case "Operation":
       return [
         ...node.parameters,
-        ...node.requestBody ? [node.requestBody] : [],
+        ...((_a = node.requestBody) == null ? void 0 : _a.schema) ? [node.requestBody.schema] : [],
         ...node.responses
       ];
     case "Schema": {
@@ -4870,6 +4871,79 @@ async function _walk(node, visitor, recurse, limit) {
   const children = getChildren(node, recurse);
   await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit)));
 }
+function transform(node, visitor, options = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const recurse = ((_a = options.depth) != null ? _a : visitorDepths.deep) === visitorDepths.deep;
+  switch (node.kind) {
+    case "Root": {
+      let root = node;
+      const replaced = (_b = visitor.root) == null ? void 0 : _b.call(visitor, root);
+      if (replaced) root = replaced;
+      return {
+        ...root,
+        schemas: root.schemas.map((s) => transform(s, visitor, options)),
+        operations: root.operations.map((op) => transform(op, visitor, options))
+      };
+    }
+    case "Operation": {
+      let op = node;
+      const replaced = (_c = visitor.operation) == null ? void 0 : _c.call(visitor, op);
+      if (replaced) op = replaced;
+      return {
+        ...op,
+        parameters: op.parameters.map((p) => transform(p, visitor, options)),
+        requestBody: op.requestBody ? {
+          ...op.requestBody,
+          schema: op.requestBody.schema ? transform(op.requestBody.schema, visitor, options) : void 0
+        } : void 0,
+        responses: op.responses.map((r) => transform(r, visitor, options))
+      };
+    }
+    case "Schema": {
+      let schema = node;
+      const replaced = (_d = visitor.schema) == null ? void 0 : _d.call(visitor, schema);
+      if (replaced) schema = replaced;
+      return {
+        ...schema,
+        ..."properties" in schema && recurse ? { properties: schema.properties.map((p) => transform(p, visitor, options)) } : {},
+        ..."items" in schema && recurse ? { items: (_e = schema.items) == null ? void 0 : _e.map((i) => transform(i, visitor, options)) } : {},
+        ..."members" in schema && recurse ? { members: (_f = schema.members) == null ? void 0 : _f.map((m) => transform(m, visitor, options)) } : {},
+        ..."additionalProperties" in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true ? { additionalProperties: transform(schema.additionalProperties, visitor, options) } : {}
+      };
+    }
+    case "Property": {
+      let prop = node;
+      const replaced = (_g = visitor.property) == null ? void 0 : _g.call(visitor, prop);
+      if (replaced) prop = replaced;
+      return {
+        ...prop,
+        schema: transform(prop.schema, visitor, options)
+      };
+    }
+    case "Parameter": {
+      let param = node;
+      const replaced = (_h = visitor.parameter) == null ? void 0 : _h.call(visitor, param);
+      if (replaced) param = replaced;
+      return {
+        ...param,
+        schema: transform(param.schema, visitor, options)
+      };
+    }
+    case "Response": {
+      let response = node;
+      const replaced = (_i = visitor.response) == null ? void 0 : _i.call(visitor, response);
+      if (replaced) response = replaced;
+      return {
+        ...response,
+        schema: transform(response.schema, visitor, options)
+      };
+    }
+    case "FunctionParameter":
+    case "ObjectBindingParameter":
+    case "FunctionParameters":
+      return node;
+  }
+}
 function collect(node, visitor, options = {}) {
   var _a, _b, _c, _d, _e, _f, _g;
   const recurse = ((_a = options.depth) != null ? _a : visitorDepths.deep) === visitorDepths.deep;
@@ -4984,7 +5058,7 @@ function toCamelOrPascal$e(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$e(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$e(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -5955,7 +6029,7 @@ const fsStorage = createStorage(() => ({
     await clean(resolve(base));
   }
 }));
-var version$1 = "5.0.0-alpha.11";
+var version$1 = "5.0.0-alpha.12";
 function getDiagnosticInfo() {
   return {
     nodeVersion: version$2,
@@ -6742,7 +6816,7 @@ function satisfiesDependency(dependency, version2, cwd) {
   return satisfies(semVer, version2);
 }
 
-var version = "5.0.0-alpha.11";
+var version = "5.0.0-alpha.12";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -6947,7 +7021,7 @@ function toCamelOrPascal$d(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$d(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$d(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -7097,7 +7171,7 @@ function toCamelOrPascal$c(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$c(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$c(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -7267,8 +7341,8 @@ function getDefaultValue(schema) {
   }
   if (schema.type === "object" || schema.properties) return "{}";
 }
-async function parse$3(pathOrApi, { oasClass = Oas, canBundle = true, enablePaths = true } = {}) {
-  if (typeof pathOrApi === "string" && canBundle) return parse$3((await bundle({
+async function parse$2(pathOrApi, { oasClass = Oas, canBundle = true, enablePaths = true } = {}) {
+  if (typeof pathOrApi === "string" && canBundle) return parse$2((await bundle({
     ref: pathOrApi,
     config: await loadConfig$1(),
     base: pathOrApi
@@ -7288,13 +7362,13 @@ async function parse$3(pathOrApi, { oasClass = Oas, canBundle = true, enablePath
   return new oasClass(document);
 }
 async function merge(pathOrApi, { oasClass = Oas } = {}) {
-  const instances = await Promise.all(pathOrApi.map((p) => parse$3(p, {
+  const instances = await Promise.all(pathOrApi.map((p) => parse$2(p, {
     oasClass,
     enablePaths: false,
     canBundle: false
   })));
   if (instances.length === 0) throw new Error("No OAS instances provided for merging.");
-  return parse$3(instances.reduce((acc, current) => {
+  return parse$2(instances.reduce((acc, current) => {
     return mergeDeep(acc, current.document);
   }, {
     openapi: "3.0.0",
@@ -7308,16 +7382,16 @@ async function merge(pathOrApi, { oasClass = Oas } = {}) {
 }
 function parseFromConfig(config, oasClass = Oas) {
   if ("data" in config.input) {
-    if (typeof config.input.data === "object") return parse$3(structuredClone(config.input.data), { oasClass });
+    if (typeof config.input.data === "object") return parse$2(structuredClone(config.input.data), { oasClass });
     try {
-      return parse$3(yaml.parse(config.input.data), { oasClass });
+      return parse$2(yaml.parse(config.input.data), { oasClass });
     } catch (_e) {
-      return parse$3(config.input.data, { oasClass });
+      return parse$2(config.input.data, { oasClass });
     }
   }
   if (Array.isArray(config.input)) return merge(config.input.map((input) => path$2.resolve(config.root, input.path)), { oasClass });
-  if (new URLPath$9(config.input.path).isURL) return parse$3(config.input.path, { oasClass });
-  return parse$3(path$2.resolve(config.root, config.input.path), { oasClass });
+  if (new URLPath$9(config.input.path).isURL) return parse$2(config.input.path, { oasClass });
+  return parse$2(path$2.resolve(config.root, config.input.path), { oasClass });
 }
 function flattenSchema(schema) {
   if (!(schema == null ? void 0 : schema.allOf) || schema.allOf.length === 0) return schema || null;
@@ -9234,7 +9308,7 @@ function toCamelOrPascal$b(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$b(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$b(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -10296,7 +10370,7 @@ function Operations({ name, operations }) {
       name: "OperationSchema",
       isExportable: true,
       isIndexable: true,
-      children: /* @__PURE__ */ jsx(Type$2, {
+      children: /* @__PURE__ */ jsx(Type$1, {
         name: "OperationSchema",
         export: true,
         children: `{
@@ -10320,7 +10394,7 @@ function Operations({ name, operations }) {
       name: "OperationsMap",
       isExportable: true,
       isIndexable: true,
-      children: /* @__PURE__ */ jsx(Type$2, {
+      children: /* @__PURE__ */ jsx(Type$1, {
         name: "OperationsMap",
         export: true,
         children: "Record<string, OperationSchema>"
@@ -10631,11 +10705,26 @@ const miniModifierKeywords = [
 function extractMiniModifiers(schemas) {
   const defaultSchema = schemas.find((item) => isKeyword(item, schemaKeywords.default));
   const isBigInt = schemas.some((item) => isKeyword(item, schemaKeywords.bigint));
+  let defaultValue = defaultSchema == null ? void 0 : defaultSchema.args;
+  if (defaultValue !== void 0) {
+    const enumSchema = schemas.find((it) => isKeyword(it, schemaKeywords.enum));
+    if (enumSchema) {
+      let rawDefault = defaultValue;
+      if (typeof rawDefault === "string") try {
+        rawDefault = JSON.parse(rawDefault);
+      } catch {
+      }
+      if (!enumSchema.args.items.map((item) => {
+        var _a;
+        return (_a = item.value) != null ? _a : item.name;
+      }).includes(rawDefault)) defaultValue = void 0;
+    }
+  }
   return {
     hasOptional: schemas.some((item) => isKeyword(item, schemaKeywords.optional)),
     hasNullable: schemas.some((item) => isKeyword(item, schemaKeywords.nullable)),
     hasNullish: schemas.some((item) => isKeyword(item, schemaKeywords.nullish)),
-    defaultValue: defaultSchema == null ? void 0 : defaultSchema.args,
+    defaultValue,
     isBigInt
   };
 }
@@ -10657,7 +10746,7 @@ const shouldCoerce = (coercion, type) => {
   if (typeof coercion === "boolean") return coercion;
   return !!coercion[type];
 };
-const parse$2 = createParser({
+const parse$1 = createParser({
   mapper: zodKeywordMapper,
   handlers: {
     union(tree, options) {
@@ -10848,7 +10937,21 @@ const parse$2 = createParser({
       const { current, siblings } = tree;
       if (options.mini) return;
       const isBigInt = siblings.some((it) => isKeyword(it, schemaKeywords.bigint));
-      if (current.args !== void 0) return zodKeywordMapper.default(current.args, void 0, void 0, isBigInt);
+      if (current.args !== void 0) {
+        const enumSchema = siblings.find((it) => isKeyword(it, schemaKeywords.enum));
+        if (enumSchema) {
+          let rawDefault = current.args;
+          if (typeof rawDefault === "string") try {
+            rawDefault = JSON.parse(rawDefault);
+          } catch {
+          }
+          if (!enumSchema.args.items.map((item) => {
+            var _a;
+            return (_a = item.value) != null ? _a : item.name;
+          }).includes(rawDefault)) return;
+        }
+        return zodKeywordMapper.default(current.args, void 0, void 0, isBigInt);
+      }
       return zodKeywordMapper.default();
     },
     describe(tree, options) {
@@ -10927,7 +11030,7 @@ function Zod({ name, typeName, tree, schema, inferTypeName, mapper, coercion, ke
   });
   const baseSchemas = mini ? filterMiniModifiers(schemas) : schemas;
   const output = baseSchemas.map((schemaKeyword, index) => {
-    return parse$2({
+    return parse$1({
       schema,
       parent: void 0,
       current: schemaKeyword,
@@ -10952,7 +11055,7 @@ function Zod({ name, typeName, tree, schema, inferTypeName, mapper, coercion, ke
     if (firstSchema && isKeyword(firstSchema, schemaKeywords.ref)) if (version === "3") suffix = ".schema";
     else suffix = ".unwrap()";
   }
-  const emptyValue = parse$2({
+  const emptyValue = parse$1({
     schema,
     parent: void 0,
     current: { keyword: schemaKeywords[emptySchemaType] },
@@ -10987,11 +11090,11 @@ function Zod({ name, typeName, tree, schema, inferTypeName, mapper, coercion, ke
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: [typeName && /* @__PURE__ */ jsx(Type$2, {
+    children: [typeName && /* @__PURE__ */ jsx(Type$1, {
       export: true,
       name: inferTypeName,
       children: typeName
-    }), !typeName && /* @__PURE__ */ jsx(Type$2, {
+    }), !typeName && /* @__PURE__ */ jsx(Type$1, {
       export: true,
       name: inferTypeName,
       children: `z.infer<typeof ${name}>`
@@ -208891,7 +208994,7 @@ function toCamelOrPascal$a(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$a(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$a(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -208945,6 +209048,27 @@ function jsStringEscape$1(input) {
     }
   });
 }
+function stringify$1(value) {
+  if (value === void 0 || value === null) return '""';
+  return JSON.stringify(trimQuotes$1(value.toString()));
+}
+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
+]);
 const { SyntaxKind, factory } = ts;
 const modifiers = {
   async: factory.createModifier(ts.SyntaxKind.AsyncKeyword),
@@ -208957,11 +209081,6 @@ const syntaxKind = {
   literalType: SyntaxKind.LiteralType,
   stringLiteral: SyntaxKind.StringLiteral
 };
-function getUnknownType(unknownType) {
-  if (unknownType === "any") return keywordTypeNodes.any;
-  if (unknownType === "void") return keywordTypeNodes.void;
-  return keywordTypeNodes.unknown;
-}
 function isValidIdentifier(str) {
   if (!str.length || str.trim() !== str) return false;
   const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest);
@@ -209148,376 +209267,290 @@ const createTupleTypeNode = factory.createTupleTypeNode;
 const createRestTypeNode = factory.createRestTypeNode;
 const createTrue = factory.createTrue;
 const createFalse = factory.createFalse;
-const createIndexedAccessTypeNode = factory.createIndexedAccessTypeNode;
-const createTypeOperatorNode = factory.createTypeOperatorNode;
+factory.createIndexedAccessTypeNode;
+factory.createTypeOperatorNode;
 const createPrefixUnaryExpression = factory.createPrefixUnaryExpression;
-const typeKeywordMapper = {
-  any: () => keywordTypeNodes.any,
-  unknown: () => keywordTypeNodes.unknown,
-  void: () => keywordTypeNodes.void,
-  number: () => keywordTypeNodes.number,
-  integer: () => keywordTypeNodes.number,
-  bigint: () => keywordTypeNodes.bigint,
-  object: (nodes) => {
-    if (!nodes || !nodes.length) return keywordTypeNodes.object;
-    return createTypeLiteralNode(nodes);
-  },
-  string: () => keywordTypeNodes.string,
-  boolean: () => keywordTypeNodes.boolean,
-  undefined: () => keywordTypeNodes.undefined,
-  nullable: void 0,
-  null: () => keywordTypeNodes.null,
-  nullish: void 0,
-  array: (nodes, arrayType) => {
-    if (!nodes) return;
-    return createArrayDeclaration({
-      nodes,
-      arrayType
-    });
-  },
-  tuple: (nodes, rest, min, max) => {
-    if (!nodes) return;
-    if (max) {
-      nodes = nodes.slice(0, max);
-      if (nodes.length < max && rest) nodes = [...nodes, ...Array(max - nodes.length).fill(rest)];
-    }
-    if (min) nodes = nodes.map((node, index) => index >= min ? createOptionalTypeNode(node) : node);
-    if (typeof max === "undefined" && rest) nodes.push(createRestTypeNode(createArrayTypeNode(rest)));
-    return createTupleTypeNode(nodes);
-  },
-  enum: (name) => {
-    if (!name) return;
-    return createTypeReferenceNode(name, void 0);
-  },
-  union: (nodes) => {
-    if (!nodes) return;
-    return createUnionDeclaration({
-      withParentheses: true,
-      nodes
-    });
-  },
-  const: (name, format) => {
-    if (name === null || name === void 0 || name === "") return;
-    if (format === "boolean") {
-      if (name === true) return createLiteralTypeNode(createTrue());
-      return createLiteralTypeNode(createFalse());
+function constToTypeNode(value, format) {
+  if (format === "boolean") return createLiteralTypeNode(value === true ? createTrue() : createFalse());
+  if (format === "number" && typeof value === "number") {
+    if (value < 0) return createLiteralTypeNode(createPrefixUnaryExpression(SyntaxKind.MinusToken, createNumericLiteral(Math.abs(value))));
+    return createLiteralTypeNode(createNumericLiteral(value));
+  }
+  return createLiteralTypeNode(createStringLiteral(String(value)));
+}
+function dateOrStringNode(node) {
+  return node.representation === "date" ? createTypeReferenceNode(createIdentifier("Date")) : keywordTypeNodes.string;
+}
+function buildMemberNodes(members, print) {
+  return (members != null ? members : []).map(print).filter(Boolean);
+}
+function buildTupleNode(node, print) {
+  var _a, _b;
+  let items = ((_a = node.items) != null ? _a : []).map(print).filter(Boolean);
+  const restNode = node.rest ? (_b = print(node.rest)) != null ? _b : void 0 : void 0;
+  const { min, max } = node;
+  if (max !== void 0) {
+    items = items.slice(0, max);
+    if (items.length < max && restNode) items = [...items, ...Array(max - items.length).fill(restNode)];
+  }
+  if (min !== void 0) items = items.map((item, i) => i >= min ? createOptionalTypeNode(item) : item);
+  if (max === void 0 && restNode) items.push(createRestTypeNode(createArrayTypeNode(restNode)));
+  return createTupleTypeNode(items);
+}
+function buildPropertyType(schema, baseType, optionalType) {
+  const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
+  let type = baseType;
+  if (schema.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
+  if ((schema.nullish || schema.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
+  return type;
+}
+function buildPropertyJSDocComments(schema) {
+  return [
+    "description" in schema && schema.description ? `@description ${jsStringEscape$1(schema.description)}` : void 0,
+    "deprecated" in schema && schema.deprecated ? "@deprecated" : void 0,
+    "min" in schema && schema.min !== void 0 ? `@minLength ${schema.min}` : void 0,
+    "max" in schema && schema.max !== void 0 ? `@maxLength ${schema.max}` : void 0,
+    "pattern" in schema && schema.pattern ? `@pattern ${schema.pattern}` : void 0,
+    "default" in schema && schema.default !== void 0 ? `@default ${"primitive" in schema && schema.primitive === "string" ? stringify$1(schema.default) : schema.default}` : void 0,
+    "example" in schema && schema.example !== void 0 ? `@example ${schema.example}` : void 0,
+    "primitive" in schema && schema.primitive ? [`@type ${schema.primitive || "unknown"}`, "optional" in schema && schema.optional ? " | undefined" : void 0].filter(Boolean).join("") : void 0
+  ];
+}
+function buildIndexSignatures(node, propertyCount, print) {
+  var _a, _b;
+  const elements = [];
+  if (node.additionalProperties && node.additionalProperties !== true) {
+    const additionalType = (_a = print(node.additionalProperties)) != null ? _a : keywordTypeNodes.unknown;
+    elements.push(createIndexSignature(propertyCount > 0 ? keywordTypeNodes.unknown : additionalType));
+  } else if (node.additionalProperties === true) elements.push(createIndexSignature(keywordTypeNodes.unknown));
+  if (node.patternProperties) {
+    const first = Object.values(node.patternProperties)[0];
+    if (first) {
+      let patternType = (_b = print(first)) != null ? _b : keywordTypeNodes.unknown;
+      if (first.nullable) patternType = createUnionDeclaration({ nodes: [patternType, keywordTypeNodes.null] });
+      elements.push(createIndexSignature(patternType));
     }
-    if (format === "number" && typeof name === "number") return createLiteralTypeNode(createNumericLiteral(name));
-    return createLiteralTypeNode(createStringLiteral(name.toString()));
-  },
-  datetime: () => keywordTypeNodes.string,
-  date: (type = "string") => type === "string" ? keywordTypeNodes.string : createTypeReferenceNode(createIdentifier("Date")),
-  time: (type = "string") => type === "string" ? keywordTypeNodes.string : createTypeReferenceNode(createIdentifier("Date")),
-  uuid: () => keywordTypeNodes.string,
-  url: () => keywordTypeNodes.string,
-  default: void 0,
-  and: (nodes) => {
-    if (!nodes) return;
-    return createIntersectionDeclaration({
-      withParentheses: true,
-      nodes
-    });
-  },
-  describe: void 0,
-  min: void 0,
-  max: void 0,
-  optional: void 0,
-  matches: () => keywordTypeNodes.string,
-  email: () => keywordTypeNodes.string,
-  firstName: void 0,
-  lastName: void 0,
-  password: void 0,
-  phone: void 0,
-  readOnly: void 0,
-  writeOnly: void 0,
-  ref: (propertyName2) => {
-    if (!propertyName2) return;
-    return createTypeReferenceNode(propertyName2, void 0);
-  },
-  blob: () => createTypeReferenceNode("Blob", []),
-  deprecated: void 0,
-  example: void 0,
-  schema: void 0,
-  catchall: void 0,
-  name: void 0,
-  interface: void 0,
-  exclusiveMaximum: void 0,
-  exclusiveMinimum: void 0
-};
-const parse$1 = createParser({
-  mapper: typeKeywordMapper,
-  handlers: {
-    union(tree, options) {
-      const { current, schema, name } = tree;
-      return typeKeywordMapper.union(current.args.map((it) => this.parse({
-        schema,
-        parent: current,
-        name,
-        current: it,
-        siblings: []
-      }, options)).filter(Boolean));
-    },
-    and(tree, options) {
-      const { current, schema, name } = tree;
-      return typeKeywordMapper.and(current.args.map((it) => this.parse({
-        schema,
-        parent: current,
-        name,
-        current: it,
-        siblings: []
-      }, options)).filter(Boolean));
-    },
-    array(tree, options) {
-      const { current, schema, name } = tree;
-      return typeKeywordMapper.array(current.args.items.map((it) => this.parse({
-        schema,
-        parent: current,
-        name,
-        current: it,
-        siblings: []
-      }, options)).filter(Boolean), options.arrayType);
-    },
-    enum(tree, options) {
-      const { current } = tree;
-      if (options.enumType === "inlineLiteral") {
-        const enumValues = current.args.items.map((item) => item.value).filter((value) => value !== void 0 && value !== null).map((value) => {
-          const format = typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "string";
-          return typeKeywordMapper.const(value, format);
-        }).filter(Boolean);
-        return typeKeywordMapper.union(enumValues);
-      }
-      return typeKeywordMapper.enum(["asConst", "asPascalConst"].includes(options.enumType) ? `${current.args.typeName}Key` : current.args.typeName);
-    },
-    ref(tree, _options) {
-      const { current } = tree;
-      return typeKeywordMapper.ref(current.args.name);
-    },
-    blob() {
-      return typeKeywordMapper.blob();
-    },
-    tuple(tree, options) {
-      var _a;
-      const { current, schema, name } = tree;
-      return typeKeywordMapper.tuple(current.args.items.map((it) => this.parse({
-        schema,
-        parent: current,
-        name,
-        current: it,
-        siblings: []
-      }, options)).filter(Boolean), current.args.rest && ((_a = this.parse({
-        schema,
-        parent: current,
-        name,
-        current: current.args.rest,
-        siblings: []
-      }, options)) != null ? _a : void 0), current.args.min, current.args.max);
-    },
-    const(tree, _options) {
-      const { current } = tree;
-      return typeKeywordMapper.const(current.args.name, current.args.format);
-    },
-    object(tree, options) {
-      var _a, _b, _c, _d, _e;
-      const { current, schema, name } = tree;
-      const properties = Object.entries(((_a = current.args) == null ? void 0 : _a.properties) || {}).filter((item) => {
-        const schemas = item[1];
-        return schemas && typeof schemas.map === "function";
-      }).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;
-        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);
-        const isReadonly = schemas.some((schema2) => schema2.keyword === schemaKeywords.readOnly);
-        const describeSchema = schemas.find((schema2) => schema2.keyword === schemaKeywords.describe);
-        const deprecatedSchema = schemas.find((schema2) => schema2.keyword === schemaKeywords.deprecated);
-        const defaultSchema = schemas.find((schema2) => schema2.keyword === schemaKeywords.default);
-        const exampleSchema = schemas.find((schema2) => schema2.keyword === schemaKeywords.example);
-        const schemaSchema = schemas.find((schema2) => schema2.keyword === schemaKeywords.schema);
-        const minSchema = schemas.find((schema2) => schema2.keyword === schemaKeywords.min);
-        const maxSchema = schemas.find((schema2) => schema2.keyword === schemaKeywords.max);
-        const matchesSchema = schemas.find((schema2) => schema2.keyword === schemaKeywords.matches);
-        let type = schemas.map((it) => this.parse({
-          schema,
-          parent: current,
-          name: name2,
-          current: it,
-          siblings: schemas
-        }, options)).filter(Boolean)[0];
-        if (isNullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-        if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-        if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-        return appendJSDocToNode({
-          node: createPropertySignature({
-            questionToken: isOptional || isNullish ? ["questionToken", "questionTokenAndUndefined"].includes(options.optionalType) : false,
-            name: mappedName,
-            type,
-            readOnly: isReadonly
-          }),
-          comments: [
-            describeSchema ? `@description ${jsStringEscape$1(describeSchema.args)}` : void 0,
-            deprecatedSchema ? "@deprecated" : void 0,
-            minSchema ? `@minLength ${minSchema.args}` : void 0,
-            maxSchema ? `@maxLength ${maxSchema.args}` : void 0,
-            matchesSchema ? `@pattern ${matchesSchema.args}` : void 0,
-            defaultSchema ? `@default ${defaultSchema.args}` : void 0,
-            exampleSchema ? `@example ${exampleSchema.args}` : void 0,
-            ((_b2 = schemaSchema == null ? void 0 : schemaSchema.args) == null ? void 0 : _b2.type) || ((_c2 = schemaSchema == null ? void 0 : schemaSchema.args) == null ? void 0 : _c2.format) ? [`@type ${((_d2 = schemaSchema == null ? void 0 : schemaSchema.args) == null ? void 0 : _d2.type) || "unknown"}${!isOptional ? "" : " | undefined"}`, (_e2 = schemaSchema == null ? void 0 : schemaSchema.args) == null ? void 0 : _e2.format].filter(Boolean).join(", ") : void 0
-          ].filter(Boolean)
+  }
+  return elements;
+}
+const printerTs = definePrinter((options) => {
+  const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(options.optionalType);
+  return {
+    name: "typescript",
+    options,
+    nodes: {
+      any: () => keywordTypeNodes.any,
+      unknown: () => keywordTypeNodes.unknown,
+      void: () => keywordTypeNodes.void,
+      never: () => keywordTypeNodes.never,
+      boolean: () => keywordTypeNodes.boolean,
+      null: () => keywordTypeNodes.null,
+      blob: () => createTypeReferenceNode("Blob", []),
+      string: () => keywordTypeNodes.string,
+      uuid: () => keywordTypeNodes.string,
+      email: () => keywordTypeNodes.string,
+      url: (node) => {
+        if (node.path) return createUrlTemplateType(node.path);
+        return keywordTypeNodes.string;
+      },
+      datetime: () => keywordTypeNodes.string,
+      number: () => keywordTypeNodes.number,
+      integer: () => keywordTypeNodes.number,
+      bigint: () => keywordTypeNodes.bigint,
+      date: dateOrStringNode,
+      time: dateOrStringNode,
+      ref(node) {
+        var _a;
+        if (!node.name) return;
+        const refName = node.ref ? (_a = node.ref.split("/").at(-1)) != null ? _a : node.name : node.name;
+        return createTypeReferenceNode(node.ref ? this.options.resolver.default(refName, "type") : refName, void 0);
+      },
+      enum(node) {
+        var _a, _b, _c, _d;
+        const values = (_c = (_b = (_a = node.namedEnumValues) == null ? void 0 : _a.map((v) => v.value)) != null ? _b : node.enumValues) != null ? _c : [];
+        if (this.options.enumType === "inlineLiteral" || !node.name) return (_d = createUnionDeclaration({
+          withParentheses: true,
+          nodes: values.filter((v) => v !== null).map((value) => constToTypeNode(value, typeof value)).filter(Boolean)
+        })) != null ? _d : void 0;
+        const resolvedName = this.options.resolver.default(node.name, "type");
+        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" || m.primitive === "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 { 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)
+          });
         });
-      });
-      let additionalProperties;
-      if ((_c = (_b = current.args) == null ? void 0 : _b.additionalProperties) == null ? void 0 : _c.length) {
-        let additionalPropertiesType = current.args.additionalProperties.map((it) => this.parse({
-          schema,
-          parent: current,
-          name,
-          current: it,
-          siblings: []
-        }, options)).filter(Boolean).at(0);
-        if ((_d = current.args) == null ? void 0 : _d.additionalProperties.some((schema2) => isKeyword(schema2, schemaKeywords.nullable))) additionalPropertiesType = createUnionDeclaration({ nodes: [additionalPropertiesType, keywordTypeNodes.null] });
-        additionalProperties = createIndexSignature(properties.length > 0 ? keywordTypeNodes.unknown : additionalPropertiesType);
-      }
-      let patternProperties;
-      if ((_e = current.args) == null ? void 0 : _e.patternProperties) {
-        const allPatternSchemas = Object.values(current.args.patternProperties).flat();
-        if (allPatternSchemas.length > 0) {
-          patternProperties = allPatternSchemas.map((it) => this.parse({
-            schema,
-            parent: current,
-            name,
-            current: it,
-            siblings: []
-          }, options)).filter(Boolean).at(0);
-          if (allPatternSchemas.some((schema2) => isKeyword(schema2, schemaKeywords.nullable))) patternProperties = createUnionDeclaration({ nodes: [patternProperties, keywordTypeNodes.null] });
-          patternProperties = createIndexSignature(patternProperties);
-        }
+        const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, print)];
+        if (!allElements.length) return keywordTypeNodes.object;
+        return createTypeLiteralNode(allElements);
       }
-      return typeKeywordMapper.object([
-        ...properties,
-        additionalProperties,
-        patternProperties
-      ].filter(Boolean));
-    },
-    datetime() {
-      return typeKeywordMapper.datetime();
-    },
-    date(tree) {
-      const { current } = tree;
-      return typeKeywordMapper.date(current.args.type);
     },
-    time(tree) {
-      const { current } = tree;
-      return typeKeywordMapper.time(current.args.type);
+    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
+        ]
+      });
     }
-  }
+  };
 });
-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);
-  const enumSchemas = SchemaGenerator.deepSearch(tree, schemaKeywords.enum);
-  let type = tree.map((current, _index, siblings) => parse$1({
-    name,
-    schema,
-    parent: void 0,
-    current,
-    siblings
-  }, {
+function getEnumNames({ node, enumType, resolver }) {
+  const resolved = resolver.default(node.name, "type");
+  return {
+    enumName: enumType === "asPascalConst" ? resolved : camelCase$a(node.name),
+    typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? `${resolved}Key` : resolved,
+    refName: resolved
+  };
+}
+function Enum({ node, enumType, enumKeyCasing, resolver }) {
+  var _a, _b, _c, _d;
+  const { enumName, typeName, refName } = getEnumNames({
+    node,
+    enumType,
+    resolver
+  });
+  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
+  });
+  const needsRefAlias = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && refName !== typeName;
+  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)
+    }),
+    needsRefAlias && /* @__PURE__ */ jsx(File.Source, {
+      name: refName,
+      isExportable: true,
+      isIndexable: true,
+      isTypeOnly: true,
+      children: `export type ${refName} = ${typeName}`
+    })
+  ] });
+}
+function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, description, resolver }) {
+  const resolvedDescription = description || (node == null ? void 0 : node.description);
+  const enumSchemaNodes = collect(node, { schema(n) {
+    if (n.type === "enum" && n.name) return n;
+  } });
+  const typeNode = printerTs({
     optionalType,
     arrayType,
-    enumType
-  })).filter(Boolean).at(0) || typeKeywordMapper.undefined();
-  if (["asConst", "asPascalConst"].includes(enumType) && enumSchemas.length > 0) {
-    const isDirectEnum = schema.type === "array" && schema.items !== void 0;
-    const isEnumOnly = "enum" in schema && schema.enum;
-    if (isDirectEnum || isEnumOnly) {
-      type = createTypeReferenceNode(`${enumSchemas[0].args.typeName}Key`);
-      if (schema.type === "array") if (arrayType === "generic") type = createTypeReferenceNode(createIdentifier("Array"), [type]);
-      else type = createArrayTypeNode(type);
-    }
-  }
-  if (schemaFromTree && isKeyword(schemaFromTree, schemaKeywords.schema)) {
-    const isNullish = tree.some((item) => item.keyword === schemaKeywords.nullish);
-    const isNullable = tree.some((item) => item.keyword === schemaKeywords.nullable);
-    const isOptional = tree.some((item) => item.keyword === schemaKeywords.optional);
-    if (isNullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-    if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-    if (isOptional && ["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: [
-      schema.title ? `${jsStringEscape$1(schema.title)}` : void 0,
-      description ? `@description ${jsStringEscape$1(description)}` : void 0,
-      schema.deprecated ? "@deprecated" : void 0,
-      schema.minLength ? `@minLength ${schema.minLength}` : void 0,
-      schema.maxLength ? `@maxLength ${schema.maxLength}` : void 0,
-      schema.pattern ? `@pattern ${schema.pattern}` : void 0,
-      schema.default ? `@default ${schema.default}` : void 0,
-      schema.example ? `@example ${schema.example}` : void 0
-    ]
-  }));
-  const enums = [...new Set(enumSchemas)].map((enumSchema) => {
-    const name2 = enumType === "asPascalConst" ? pascalCase$6(enumSchema.args.name) : camelCase$a(enumSchema.args.name);
-    const typeName = ["asConst", "asPascalConst"].includes(enumType) ? `${enumSchema.args.typeName}Key` : enumSchema.args.typeName;
-    const [nameNode, typeNode] = createEnumDeclaration({
-      name: name2,
-      typeName,
-      enums: enumSchema.args.items.map((item) => {
-        var _a;
-        return item.value === void 0 ? void 0 : [trimQuotes$1((_a = item.name) == null ? void 0 : _a.toString()), item.value];
-      }).filter(Boolean),
-      type: enumType,
-      enumKeyCasing
-    });
+    enumType,
+    typeName: name,
+    syntaxType,
+    description: resolvedDescription,
+    keysToOmit,
+    resolver
+  }).print(node);
+  if (!typeNode) return;
+  const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node2) => {
     return {
-      nameNode,
-      typeNode,
-      name: name2,
-      typeName
+      node: node2,
+      ...getEnumNames({
+        node: node2,
+        enumType,
+        resolver
+      })
     };
   });
   const shouldExportEnums = enumType !== "inlineLiteral";
   const shouldExportType = enumType === "inlineLiteral" || enums.every((item) => item.typeName !== name);
-  return /* @__PURE__ */ jsxs(Fragment, { children: [shouldExportEnums && enums.map(({ name: name2, nameNode, typeName, typeNode }) => /* @__PURE__ */ jsxs(Fragment, { children: [nameNode && /* @__PURE__ */ jsx(File.Source, {
-    name: name2,
-    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,
+    resolver
+  })), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
     name: typedName,
     isTypeOnly: true,
     isExportable: true,
     isIndexable: true,
-    children: safePrint(...typeNodes)
+    children: safePrint(typeNode)
   })] });
 }
 
@@ -209599,871 +209632,21 @@ function usePluginDriver() {
   return meta.driver;
 }
 
-function useOas() {
-  const { meta } = useFabric();
-  return meta.oas;
-}
-function useOperationManager(generator) {
-  const plugin = usePlugin();
-  const driver = usePluginDriver();
-  const defaultPluginName = plugin.name;
-  const getName = (operation, { prefix = "", suffix = "", pluginName = defaultPluginName, type }) => {
-    return driver.resolveName({
-      name: `${prefix} ${operation.getOperationId()} ${suffix}`,
-      pluginName,
-      type
-    });
-  };
-  const getGroup = (operation) => {
-    var _a;
-    return {
-      tag: (_a = operation.getTags().at(0)) == null ? void 0 : _a.name,
-      path: operation.path
-    };
-  };
-  const getSchemas = (operation, params) => {
-    if (!generator) throw new Error(`useOperationManager: 'generator' parameter is required but was not provided`);
-    return generator.getSchemas(operation, { resolveName: (name) => {
-      var _a;
-      return driver.resolveName({
-        name,
-        pluginName: (_a = params == null ? void 0 : params.pluginName) != null ? _a : defaultPluginName,
-        type: params == null ? void 0 : params.type
-      });
-    } });
-  };
-  const getFile = (operation, { prefix, suffix, pluginName = defaultPluginName, extname = ".ts" } = {}) => {
-    const name = getName(operation, {
-      type: "file",
-      pluginName,
-      prefix,
-      suffix
-    });
-    const group = getGroup(operation);
-    const file = driver.getFile({
-      name,
-      extname,
-      pluginName,
-      options: {
-        type: "file",
-        pluginName,
-        group
-      }
-    });
-    return {
-      ...file,
-      meta: {
-        ...file.meta,
-        name,
-        pluginName,
-        group
-      }
-    };
-  };
-  const groupSchemasByName = (operation, { pluginName = defaultPluginName, type }) => {
-    var _a, _b, _c, _d;
-    if (!generator) throw new Error(`useOperationManager: 'generator' parameter is required but was not provided`);
-    const schemas = getSchemas(operation);
-    const errors = (schemas.errors || []).reduce((prev, acc) => {
-      if (!acc.statusCode) return prev;
-      prev[acc.statusCode] = driver.resolveName({
-        name: acc.name,
-        pluginName,
-        type
-      });
-      return prev;
-    }, {});
-    const responses = (schemas.responses || []).reduce((prev, acc) => {
-      if (!acc.statusCode) return prev;
-      prev[acc.statusCode] = driver.resolveName({
-        name: acc.name,
-        pluginName,
-        type
-      });
-      return prev;
-    }, {});
-    return {
-      request: ((_a = schemas.request) == null ? void 0 : _a.name) ? driver.resolveName({
-        name: schemas.request.name,
-        pluginName,
-        type
-      }) : void 0,
-      parameters: {
-        path: ((_b = schemas.pathParams) == null ? void 0 : _b.name) ? driver.resolveName({
-          name: schemas.pathParams.name,
-          pluginName,
-          type
-        }) : void 0,
-        query: ((_c = schemas.queryParams) == null ? void 0 : _c.name) ? driver.resolveName({
-          name: schemas.queryParams.name,
-          pluginName,
-          type
-        }) : void 0,
-        header: ((_d = schemas.headerParams) == null ? void 0 : _d.name) ? driver.resolveName({
-          name: schemas.headerParams.name,
-          pluginName,
-          type
-        }) : void 0
-      },
-      responses: {
-        ...responses,
-        ["default"]: driver.resolveName({
-          name: schemas.response.name,
-          pluginName,
-          type
-        }),
-        ...errors
-      },
-      errors
-    };
-  };
-  return {
-    getName,
-    getFile,
-    getSchemas,
-    groupSchemasByName,
-    getGroup
-  };
-}
-function useSchemaManager() {
-  const plugin = usePlugin();
-  const driver = usePluginDriver();
-  const getName = (name, { pluginName = plugin.name, type }) => {
-    return driver.resolveName({
-      name,
-      pluginName,
-      type
-    });
-  };
-  const getFile = (name, { mode = "split", pluginName = plugin.name, extname = ".ts", group } = {}) => {
-    const resolvedName = mode === "single" ? "" : getName(name, {
-      type: "file",
-      pluginName
-    });
-    const file = driver.getFile({
-      name: resolvedName,
-      extname,
-      pluginName,
-      options: {
-        type: "file",
-        pluginName,
-        group
-      }
-    });
-    return {
-      ...file,
-      meta: {
-        ...file.meta,
-        name: resolvedName,
-        pluginName
-      }
-    };
-  };
-  return {
-    getName,
-    getFile
-  };
-}
-
-function stringify$1(value) {
-  if (value === void 0 || value === null) return '""';
-  return JSON.stringify(trimQuotes$1(value.toString()));
-}
-function printCombinedSchema({ name, schemas, driver }) {
-  const properties = {};
-  if (schemas.response) properties["response"] = createUnionDeclaration({ nodes: schemas.responses.map((res) => {
-    return createTypeReferenceNode(createIdentifier(driver.resolveName({
-      name: res.name,
-      pluginName: pluginTsName,
-      type: "function"
-    })), void 0);
-  }) });
-  if (schemas.request) properties["request"] = createTypeReferenceNode(createIdentifier(driver.resolveName({
-    name: schemas.request.name,
-    pluginName: pluginTsName,
-    type: "function"
-  })), void 0);
-  if (schemas.pathParams) properties["pathParams"] = createTypeReferenceNode(createIdentifier(driver.resolveName({
-    name: schemas.pathParams.name,
-    pluginName: pluginTsName,
-    type: "function"
-  })), void 0);
-  if (schemas.queryParams) properties["queryParams"] = createTypeReferenceNode(createIdentifier(driver.resolveName({
-    name: schemas.queryParams.name,
-    pluginName: pluginTsName,
-    type: "function"
-  })), void 0);
-  if (schemas.headerParams) properties["headerParams"] = createTypeReferenceNode(createIdentifier(driver.resolveName({
-    name: schemas.headerParams.name,
-    pluginName: pluginTsName,
-    type: "function"
-  })), void 0);
-  if (schemas.errors) properties["errors"] = createUnionDeclaration({ nodes: schemas.errors.map((error) => {
-    return createTypeReferenceNode(createIdentifier(driver.resolveName({
-      name: error.name,
-      pluginName: pluginTsName,
-      type: "function"
-    })), void 0);
-  }) });
-  return safePrint(createTypeAliasDeclaration({
-    name,
-    type: createTypeLiteralNode(Object.keys(properties).map((key) => {
-      const type = properties[key];
-      if (!type) return;
-      return createPropertySignature({
-        name: pascalCase$6(key),
-        type
-      });
-    }).filter(Boolean)),
-    modifiers: [modifiers.export]
-  }));
-}
-function printRequestSchema({ baseName, operation, schemas, driver }) {
-  const name = driver.resolveName({
-    name: `${baseName} Request`,
-    pluginName: pluginTsName,
-    type: "type"
-  });
-  const results = [];
-  const dataRequestProperties = [];
-  if (schemas.request) {
-    const identifier = driver.resolveName({
-      name: schemas.request.name,
-      pluginName: pluginTsName,
-      type: "type"
-    });
-    dataRequestProperties.push(createPropertySignature({
-      name: "data",
-      questionToken: true,
-      type: createTypeReferenceNode(createIdentifier(identifier), void 0)
-    }));
-  } else dataRequestProperties.push(createPropertySignature({
-    name: "data",
-    questionToken: true,
-    type: keywordTypeNodes.never
-  }));
-  if (schemas.pathParams) {
-    const identifier = driver.resolveName({
-      name: schemas.pathParams.name,
-      pluginName: pluginTsName,
-      type: "type"
-    });
-    dataRequestProperties.push(createPropertySignature({
-      name: "pathParams",
-      type: createTypeReferenceNode(createIdentifier(identifier), void 0)
-    }));
-  } else dataRequestProperties.push(createPropertySignature({
-    name: "pathParams",
-    questionToken: true,
-    type: keywordTypeNodes.never
-  }));
-  if (schemas.queryParams) {
-    const identifier = driver.resolveName({
-      name: schemas.queryParams.name,
-      pluginName: pluginTsName,
-      type: "type"
-    });
-    dataRequestProperties.push(createPropertySignature({
-      name: "queryParams",
-      questionToken: true,
-      type: createTypeReferenceNode(createIdentifier(identifier), void 0)
-    }));
-  } else dataRequestProperties.push(createPropertySignature({
-    name: "queryParams",
-    questionToken: true,
-    type: keywordTypeNodes.never
-  }));
-  if (schemas.headerParams) {
-    const identifier = driver.resolveName({
-      name: schemas.headerParams.name,
-      pluginName: pluginTsName,
-      type: "type"
-    });
-    dataRequestProperties.push(createPropertySignature({
-      name: "headerParams",
-      questionToken: true,
-      type: createTypeReferenceNode(createIdentifier(identifier), void 0)
-    }));
-  } else dataRequestProperties.push(createPropertySignature({
-    name: "headerParams",
-    questionToken: true,
-    type: keywordTypeNodes.never
-  }));
-  dataRequestProperties.push(createPropertySignature({
-    name: "url",
-    type: createUrlTemplateType(operation.path)
-  }));
-  const dataRequestNode = createTypeAliasDeclaration({
-    name,
-    type: createTypeLiteralNode(dataRequestProperties),
-    modifiers: [modifiers.export]
-  });
-  results.push(safePrint(dataRequestNode));
-  return results.join("\n\n");
-}
-function printResponseSchema({ baseName, schemas, driver, unknownType }) {
-  const results = [];
-  const name = driver.resolveName({
-    name: `${baseName} ResponseData`,
-    pluginName: pluginTsName,
-    type: "type"
-  });
-  if (schemas.responses && schemas.responses.length > 0) {
-    const responsesProperties = schemas.responses.map((res) => {
-      var _a, _b;
-      const identifier = driver.resolveName({
-        name: res.name,
-        pluginName: pluginTsName,
-        type: "type"
-      });
-      return createPropertySignature({
-        name: (_b = (_a = res.statusCode) == null ? void 0 : _a.toString()) != null ? _b : "default",
-        type: createTypeReferenceNode(createIdentifier(identifier), void 0)
-      });
-    });
-    const responsesNode = createTypeAliasDeclaration({
-      name: `${baseName}Responses`,
-      type: createTypeLiteralNode(responsesProperties),
-      modifiers: [modifiers.export]
-    });
-    results.push(safePrint(responsesNode));
-    const responseNode = createTypeAliasDeclaration({
-      name,
-      type: createIndexedAccessTypeNode(createTypeReferenceNode(createIdentifier(`${baseName}Responses`), void 0), createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, createTypeReferenceNode(createIdentifier(`${baseName}Responses`), void 0))),
-      modifiers: [modifiers.export]
-    });
-    results.push(safePrint(responseNode));
-  } else {
-    const responseNode = createTypeAliasDeclaration({
-      name,
-      modifiers: [modifiers.export],
-      type: getUnknownType(unknownType)
-    });
-    results.push(safePrint(responseNode));
-  }
-  return results.join("\n\n");
-}
-const typeGenerator$1 = createReactGenerator({
-  name: "typescript",
-  Operation({ operation, generator, plugin }) {
-    const { options, options: { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing } } = plugin;
-    const mode = useMode();
-    const driver = usePluginDriver();
-    const oas = useOas();
-    const { getSchemas, getFile, getName, getGroup } = useOperationManager(generator);
-    const schemaManager = useSchemaManager();
-    const name = getName(operation, {
-      type: "type",
-      pluginName: pluginTsName
-    });
-    const file = getFile(operation);
-    const schemas = getSchemas(operation);
-    const schemaGenerator = new SchemaGenerator(options, {
-      fabric: generator.context.fabric,
-      oas,
-      events: generator.context.events,
-      plugin,
-      driver,
-      mode,
-      override: options.override
-    });
-    const operationSchemas = [
-      schemas.pathParams,
-      schemas.queryParams,
-      schemas.headerParams,
-      schemas.statusCodes,
-      schemas.request,
-      schemas.response
-    ].flat().filter(Boolean);
-    const mapOperationSchema = ({ name: name2, schema, description, keysToOmit, ...options2 }) => {
-      const transformedSchema = paramsCasing && isParameterSchema(name2) ? applyParamsCasing(schema, paramsCasing) : schema;
-      const tree = schemaGenerator.parse({
-        schema: transformedSchema,
-        name: name2,
-        parentName: null
-      });
-      const imports = getImports(tree);
-      const group = options2.operation ? getGroup(options2.operation) : void 0;
-      const type = {
-        name: schemaManager.getName(name2, { type: "type" }),
-        typedName: schemaManager.getName(name2, { type: "type" }),
-        file: schemaManager.getFile(options2.operationName || name2, { group })
-      };
-      return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
-        root: file.path,
-        path: imp.path,
-        name: imp.name,
-        isTypeOnly: true
-      }, [
-        name2,
-        imp.name,
-        imp.path,
-        imp.isTypeOnly
-      ].join("-"))), /* @__PURE__ */ jsx(Type$1, {
-        name: type.name,
-        typedName: type.typedName,
-        description,
-        tree,
-        schema: transformedSchema,
-        enumType,
-        enumKeyCasing,
-        optionalType,
-        arrayType,
-        keysToOmit,
-        syntaxType
-      })] });
-    };
-    const responseName = schemaManager.getName(schemas.response.name, { type: "type" });
-    const combinedSchemaName = operation.method === "get" ? `${name}Query` : `${name}Mutation`;
-    return /* @__PURE__ */ jsxs(File, {
-      baseName: file.baseName,
-      path: file.path,
-      meta: file.meta,
-      banner: getBanner({
-        oas,
-        output: plugin.options.output,
-        config: driver.config
-      }),
-      footer: getFooter({
-        oas,
-        output: plugin.options.output
-      }),
-      children: [operationSchemas.map(mapOperationSchema), generator.context.UNSTABLE_NAMING ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
-        name: `${name}Request`,
-        isExportable: true,
-        isIndexable: true,
-        isTypeOnly: true,
-        children: printRequestSchema({
-          baseName: name,
-          operation,
-          schemas,
-          driver
-        })
-      }), /* @__PURE__ */ jsx(File.Source, {
-        name: responseName,
-        isExportable: true,
-        isIndexable: true,
-        isTypeOnly: true,
-        children: printResponseSchema({
-          baseName: name,
-          schemas,
-          driver,
-          unknownType
-        })
-      })] }) : /* @__PURE__ */ jsx(File.Source, {
-        name: combinedSchemaName,
-        isExportable: true,
-        isIndexable: true,
-        isTypeOnly: true,
-        children: printCombinedSchema({
-          name: combinedSchemaName,
-          schemas,
-          driver
-        })
-      })]
-    });
-  },
-  Schema({ schema, plugin }) {
-    const { options: { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output } } = plugin;
-    const mode = useMode();
-    const oas = useOas();
-    const driver = usePluginDriver();
-    const { getName, getFile } = useSchemaManager();
-    const imports = getImports(schema.tree);
-    const schemaFromTree = schema.tree.find((item) => item.keyword === schemaKeywords.schema);
-    let typedName = getName(schema.name, { type: "type" });
-    if (["asConst", "asPascalConst"].includes(enumType) && schemaFromTree && isKeyword(schemaFromTree, schemaKeywords.enum)) typedName = typedName += "Key";
-    const type = {
-      name: getName(schema.name, { type: "function" }),
-      typedName,
-      file: getFile(schema.name)
-    };
-    return /* @__PURE__ */ jsxs(File, {
-      baseName: type.file.baseName,
-      path: type.file.path,
-      meta: type.file.meta,
-      banner: getBanner({
-        oas,
-        output,
-        config: driver.config
-      }),
-      footer: getFooter({
-        oas,
-        output
-      }),
-      children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
-        root: type.file.path,
-        path: imp.path,
-        name: imp.name,
-        isTypeOnly: true
-      }, [
-        schema.name,
-        imp.path,
-        imp.isTypeOnly
-      ].join("-"))), /* @__PURE__ */ jsx(Type$1, {
-        name: type.name,
-        typedName: type.typedName,
-        description: schema.value.description,
-        tree: schema.tree,
-        schema: schema.value,
-        enumType,
-        enumKeyCasing,
-        optionalType,
-        arrayType,
-        syntaxType
-      })]
-    });
-  }
-});
-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") {
-    if (value < 0) return createLiteralTypeNode(createPrefixUnaryExpression(SyntaxKind.MinusToken, createNumericLiteral(Math.abs(value))));
-    return createLiteralTypeNode(createNumericLiteral(value));
-  }
-  return createLiteralTypeNode(createStringLiteral(String(value)));
-}
-function dateOrStringNode(node) {
-  return node.representation === "date" ? createTypeReferenceNode(createIdentifier("Date")) : keywordTypeNodes.string;
-}
-function buildMemberNodes(members, print) {
-  return (members != null ? members : []).map(print).filter(Boolean);
-}
-function buildTupleNode(node, print) {
-  var _a, _b;
-  let items = ((_a = node.items) != null ? _a : []).map(print).filter(Boolean);
-  const restNode = node.rest ? (_b = print(node.rest)) != null ? _b : void 0 : void 0;
-  const { min, max } = node;
-  if (max !== void 0) {
-    items = items.slice(0, max);
-    if (items.length < max && restNode) items = [...items, ...Array(max - items.length).fill(restNode)];
-  }
-  if (min !== void 0) items = items.map((item, i) => i >= min ? createOptionalTypeNode(item) : item);
-  if (max === void 0 && restNode) items.push(createRestTypeNode(createArrayTypeNode(restNode)));
-  return createTupleTypeNode(items);
-}
-function buildPropertyType(schema, baseType, optionalType) {
-  const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
-  let type = baseType;
-  if (schema.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
-  if ((schema.nullish || schema.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
-  return type;
-}
-function buildPropertyJSDocComments(schema) {
-  return [
-    "description" in schema && schema.description ? `@description ${jsStringEscape$1(schema.description)}` : void 0,
-    "deprecated" in schema && schema.deprecated ? "@deprecated" : void 0,
-    "min" in schema && schema.min !== void 0 ? `@minLength ${schema.min}` : void 0,
-    "max" in schema && schema.max !== void 0 ? `@maxLength ${schema.max}` : void 0,
-    "pattern" in schema && schema.pattern ? `@pattern ${schema.pattern}` : void 0,
-    "default" in schema && schema.default !== void 0 ? `@default ${"primitive" in schema && schema.primitive === "string" ? stringify$1(schema.default) : schema.default}` : void 0,
-    "example" in schema && schema.example !== void 0 ? `@example ${schema.example}` : void 0,
-    "primitive" in schema && schema.primitive ? [`@type ${schema.primitive || "unknown"}`, "optional" in schema && schema.optional ? " | undefined" : void 0].filter(Boolean).join("") : void 0
-  ];
-}
-function buildIndexSignatures(node, propertyCount, print) {
-  var _a, _b;
-  const elements = [];
-  if (node.additionalProperties && node.additionalProperties !== true) {
-    const additionalType = (_a = print(node.additionalProperties)) != null ? _a : keywordTypeNodes.unknown;
-    elements.push(createIndexSignature(propertyCount > 0 ? keywordTypeNodes.unknown : additionalType));
-  } else if (node.additionalProperties === true) elements.push(createIndexSignature(keywordTypeNodes.unknown));
-  if (node.patternProperties) {
-    const first = Object.values(node.patternProperties)[0];
-    if (first) {
-      let patternType = (_b = print(first)) != null ? _b : keywordTypeNodes.unknown;
-      if (first.nullable) patternType = createUnionDeclaration({ nodes: [patternType, keywordTypeNodes.null] });
-      elements.push(createIndexSignature(patternType));
-    }
-  }
-  return elements;
-}
-const printerTs = definePrinter((options) => {
-  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" || m.primitive === "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 { 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
-        ]
-      });
-    }
-  };
-});
-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;
-  } });
-  const typeNode = printerTs({
-    optionalType,
-    arrayType,
-    enumType,
-    typeName: name,
-    syntaxType,
-    description: resolvedDescription,
-    keysToOmit
-  }).print(node);
-  if (!typeNode) return;
-  const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node2) => {
-    return {
-      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(({ node: node2 }) => /* @__PURE__ */ jsx(Enum, {
-    node: node2,
-    enumType,
-    enumKeyCasing
-  })), shouldExportType && /* @__PURE__ */ jsx(File.Source, {
-    name: typedName,
-    isTypeOnly: true,
-    isExportable: true,
-    isIndexable: true,
-    children: safePrint(typeNode)
-  })] });
-}
-const resolverTs = defineResolver(() => {
-  return {
-    default(name, type) {
-      return pascalCase$6(name, { isFile: type === "file" });
-    },
-    resolveName(name) {
-      return this.default(name, "function");
-    },
-    resolveTypedName(name) {
-      return this.default(name, "type");
-    },
-    resolvePathName(name, type) {
-      return this.default(name, type);
-    },
-    resolveParamName(node, param) {
-      return this.resolveName(`${node.operationId} ${this.default(param.in)} ${param.name}`);
-    },
-    resolveParamTypedName(node, param) {
-      return this.resolveTypedName(`${node.operationId} ${this.default(param.in)} ${param.name}`);
-    },
-    resolveResponseStatusName(node, statusCode) {
-      return this.resolveName(`${node.operationId} Status ${statusCode}`);
-    },
-    resolveResponseStatusTypedName(node, statusCode) {
-      return this.resolveTypedName(`${node.operationId} Status ${statusCode}`);
-    },
-    resolveDataName(node) {
-      return this.resolveName(`${node.operationId} Data`);
-    },
-    resolveDataTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} Data`);
-    },
-    resolveRequestConfigName(node) {
-      return this.resolveName(`${node.operationId} RequestConfig`);
-    },
-    resolveRequestConfigTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} RequestConfig`);
-    },
-    resolveResponsesName(node) {
-      return this.resolveName(`${node.operationId} Responses`);
-    },
-    resolveResponsesTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} Responses`);
-    },
-    resolveResponseName(node) {
-      return this.resolveName(`${node.operationId} Response`);
-    },
-    resolveResponseTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} Response`);
-    },
-    resolveEnumKeyTypedName(node) {
-      var _a;
-      return `${this.resolveTypedName((_a = node.name) != null ? _a : "")}Key`;
-    }
-  };
-});
-function buildParamsSchema({ params, operationId, resolveName }) {
+function buildParamsSchema({ params, node, resolver }) {
   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"
-        }),
+        name: resolver.resolveParamName(node, param),
         optional: !param.required
       })
     }))
   });
 }
-function buildDataSchemaNode({ node, resolveName }) {
+function buildDataSchemaNode({ node, resolver }) {
+  var _a;
   const pathParams = node.parameters.filter((p) => p.in === "path");
   const queryParams = node.parameters.filter((p) => p.in === "query");
   const headerParams = node.parameters.filter((p) => p.in === "header");
@@ -210473,12 +209656,9 @@ function buildDataSchemaNode({ node, resolveName }) {
     properties: [
       createProperty({
         name: "data",
-        schema: node.requestBody ? createSchema({
+        schema: ((_a = node.requestBody) == null ? void 0 : _a.schema) ? createSchema({
           type: "ref",
-          name: resolveName({
-            name: `${node.operationId} Data`,
-            type: "function"
-          }),
+          name: resolver.resolveDataTypedName(node),
           optional: true
         }) : createSchema({
           type: "never",
@@ -210489,8 +209669,8 @@ function buildDataSchemaNode({ node, resolveName }) {
         name: "pathParams",
         schema: pathParams.length > 0 ? buildParamsSchema({
           params: pathParams,
-          operationId: node.operationId,
-          resolveName
+          node,
+          resolver
         }) : createSchema({
           type: "never",
           optional: true
@@ -210501,8 +209681,8 @@ function buildDataSchemaNode({ node, resolveName }) {
         schema: queryParams.length > 0 ? createSchema({
           ...buildParamsSchema({
             params: queryParams,
-            operationId: node.operationId,
-            resolveName
+            node,
+            resolver
           }),
           optional: true
         }) : createSchema({
@@ -210515,8 +209695,8 @@ function buildDataSchemaNode({ node, resolveName }) {
         schema: headerParams.length > 0 ? createSchema({
           ...buildParamsSchema({
             params: headerParams,
-            operationId: node.operationId,
-            resolveName
+            node,
+            resolver
           }),
           optional: true
         }) : createSchema({
@@ -210534,7 +209714,7 @@ function buildDataSchemaNode({ node, resolveName }) {
     ]
   });
 }
-function buildResponsesSchemaNode({ node, resolveName }) {
+function buildResponsesSchemaNode({ node, resolver }) {
   if (node.responses.length === 0) return null;
   return createSchema({
     type: "object",
@@ -210542,48 +209722,174 @@ function buildResponsesSchemaNode({ node, resolveName }) {
       name: String(res.statusCode),
       schema: createSchema({
         type: "ref",
-        name: resolveName({
-          name: `${node.operationId} Status ${res.statusCode}`,
-          type: "function"
-        })
+        name: resolver.resolveResponseStatusTypedName(node, res.statusCode)
       })
     }))
   });
 }
-function buildResponseUnionSchemaNode({ node, resolveName }) {
+function buildResponseUnionSchemaNode({ node, resolver }) {
   const responsesWithSchema = node.responses.filter((res) => res.schema);
   if (responsesWithSchema.length === 0) return null;
   return createSchema({
     type: "union",
     members: responsesWithSchema.map((res) => createSchema({
       type: "ref",
-      name: resolveName({
-        name: `${node.operationId} Status ${res.statusCode}`,
-        type: "function"
-      })
+      name: resolver.resolveResponseStatusTypedName(node, res.statusCode)
+    }))
+  });
+}
+function buildGroupedParamsSchema({ params, parentName }) {
+  return createSchema({
+    type: "object",
+    properties: params.map((param) => {
+      let schema = {
+        ...param.schema,
+        optional: !param.required
+      };
+      if (narrowSchema(schema, "enum") && !schema.name && parentName) schema = {
+        ...schema,
+        name: pascalCase$6([
+          parentName,
+          param.name,
+          "enum"
+        ].join(" "))
+      };
+      return createProperty({
+        name: param.name,
+        schema
+      });
+    })
+  });
+}
+function buildLegacyResponsesSchemaNode({ node, resolver }) {
+  var _a;
+  const isGet = node.method.toLowerCase() === "get";
+  const successResponses = node.responses.filter((res) => {
+    const code = Number(res.statusCode);
+    return !Number.isNaN(code) && code >= 200 && code < 300;
+  });
+  const errorResponses = node.responses.filter((res) => res.statusCode === "default" || Number(res.statusCode) >= 400);
+  const responseSchema = successResponses.length > 0 ? successResponses.length === 1 ? createSchema({
+    type: "ref",
+    name: resolver.resolveResponseStatusTypedName(node, successResponses[0].statusCode)
+  }) : createSchema({
+    type: "union",
+    members: successResponses.map((res) => createSchema({
+      type: "ref",
+      name: resolver.resolveResponseStatusTypedName(node, res.statusCode)
+    }))
+  }) : createSchema({ type: "any" });
+  const errorsSchema = errorResponses.length > 0 ? errorResponses.length === 1 ? createSchema({
+    type: "ref",
+    name: resolver.resolveResponseStatusTypedName(node, errorResponses[0].statusCode)
+  }) : createSchema({
+    type: "union",
+    members: errorResponses.map((res) => createSchema({
+      type: "ref",
+      name: resolver.resolveResponseStatusTypedName(node, res.statusCode)
     }))
+  }) : createSchema({ type: "any" });
+  const properties = [createProperty({
+    name: "Response",
+    schema: responseSchema
+  })];
+  if (!isGet && ((_a = node.requestBody) == null ? void 0 : _a.schema)) properties.push(createProperty({
+    name: "Request",
+    schema: createSchema({
+      type: "ref",
+      name: resolver.resolveDataTypedName(node)
+    })
+  }));
+  else if (isGet && node.parameters.some((p) => p.in === "query")) properties.push(createProperty({
+    name: "QueryParams",
+    schema: createSchema({
+      type: "ref",
+      name: resolver.resolveQueryParamsTypedName(node)
+    })
+  }));
+  if (node.parameters.some((p) => p.in === "path") && resolver.resolvePathParamsTypedName) properties.push(createProperty({
+    name: "PathParams",
+    schema: createSchema({
+      type: "ref",
+      name: resolver.resolvePathParamsTypedName(node)
+    })
+  }));
+  if (node.parameters.some((p) => p.in === "header") && resolver.resolveHeaderParamsTypedName) properties.push(createProperty({
+    name: "HeaderParams",
+    schema: createSchema({
+      type: "ref",
+      name: resolver.resolveHeaderParamsTypedName(node)
+    })
+  }));
+  properties.push(createProperty({
+    name: "Errors",
+    schema: errorsSchema
+  }));
+  return createSchema({
+    type: "object",
+    properties
+  });
+}
+function buildLegacyResponseUnionSchemaNode({ node, resolver }) {
+  const successResponses = node.responses.filter((res) => {
+    const code = Number(res.statusCode);
+    return !Number.isNaN(code) && code >= 200 && code < 300;
+  });
+  if (successResponses.length === 0) return createSchema({ type: "any" });
+  if (successResponses.length === 1) return createSchema({
+    type: "ref",
+    name: resolver.resolveResponseStatusTypedName(node, successResponses[0].statusCode)
+  });
+  return createSchema({
+    type: "union",
+    members: successResponses.map((res) => createSchema({
+      type: "ref",
+      name: resolver.resolveResponseStatusTypedName(node, res.statusCode)
+    }))
+  });
+}
+function nameUnnamedEnums(node, parentName) {
+  return transform(node, {
+    schema(n) {
+      if (n.type === "enum" && !n.name) return {
+        ...n,
+        name: pascalCase$6([parentName, "enum"].join(" "))
+      };
+    },
+    property(p) {
+      const enumNode = narrowSchema(p.schema, "enum");
+      if (enumNode && !enumNode.name) return {
+        ...p,
+        schema: {
+          ...enumNode,
+          name: pascalCase$6([
+            parentName,
+            p.name,
+            "enum"
+          ].join(" "))
+        }
+      };
+    }
   });
 }
 const typeGenerator = defineGenerator({
   name: "typescript",
   type: "react",
   Operation({ node, adapter, options }) {
-    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group } = options;
-    const { mode, getFile, resolveName, resolveBanner, resolveFooter } = useKubb();
+    var _a, _b;
+    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, resolver, legacy } = options;
+    const { mode, getFile, resolveBanner, resolveFooter } = useKubb();
     const file = getFile({
       name: node.operationId,
       extname: ".ts",
       mode,
-      options: { group: group ? group.type === "tag" ? { tag: node.tags[0] } : { path: node.path } : void 0 }
+      options: { group: group ? group.type === "tag" ? { tag: (_a = node.tags[0]) != null ? _a : "default" } : { path: node.path } : void 0 }
     });
     const params = applyParamsCasing$1(node.parameters, paramsCasing);
-    function renderSchemaType({ node: schemaNode, name, typedName, description }) {
+    function renderSchemaType({ node: schemaNode, name, typedName, description, keysToOmit }) {
       if (!schemaNode) return null;
       const imports = adapter.getImports(schemaNode, (schemaName) => ({
-        name: resolveName({
-          name: schemaName,
-          type: "type"
-        }),
+        name: resolver.default(schemaName, "type"),
         path: getFile({
           name: schemaName,
           extname: ".ts",
@@ -210608,52 +209914,126 @@ const typeGenerator = defineGenerator({
         enumKeyCasing,
         optionalType,
         arrayType,
-        syntaxType
+        syntaxType,
+        resolver,
+        keysToOmit
       })] });
     }
-    const paramTypes = params.map((param) => renderSchemaType({
-      node: param.schema,
-      name: resolverTs.resolveParamName(node, param),
-      typedName: resolverTs.resolveParamTypedName(node, param)
-    }));
-    const responseTypes = node.responses.map((res) => renderSchemaType({
+    const responseTypes = legacy ? node.responses.map((res) => {
+      const responseName = resolver.resolveResponseStatusName(node, res.statusCode);
+      return renderSchemaType({
+        node: res.schema ? nameUnnamedEnums(res.schema, responseName) : res.schema,
+        name: responseName,
+        typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
+        description: res.description,
+        keysToOmit: res.keysToOmit
+      });
+    }) : node.responses.map((res) => renderSchemaType({
       node: res.schema,
-      name: resolverTs.resolveResponseStatusName(node, res.statusCode),
-      typedName: resolverTs.resolveResponseStatusTypedName(node, res.statusCode),
-      description: res.description
+      name: resolver.resolveResponseStatusName(node, res.statusCode),
+      typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
+      description: res.description,
+      keysToOmit: res.keysToOmit
     }));
-    const requestType = node.requestBody ? renderSchemaType({
-      node: node.requestBody,
-      name: resolverTs.resolveDataName(node),
-      typedName: resolverTs.resolveDataTypedName(node),
-      description: node.requestBody.description
+    const requestType = ((_b = node.requestBody) == null ? void 0 : _b.schema) ? renderSchemaType({
+      node: legacy ? nameUnnamedEnums(node.requestBody.schema, resolver.resolveDataName(node)) : node.requestBody.schema,
+      name: resolver.resolveDataName(node),
+      typedName: resolver.resolveDataTypedName(node),
+      description: node.requestBody.schema.description,
+      keysToOmit: node.requestBody.keysToOmit
     }) : null;
+    if (legacy) {
+      const pathParams = params.filter((p) => p.in === "path");
+      const queryParams = params.filter((p) => p.in === "query");
+      const headerParams = params.filter((p) => p.in === "header");
+      const legacyParamTypes = [
+        pathParams.length > 0 ? renderSchemaType({
+          node: buildGroupedParamsSchema({
+            params: pathParams,
+            parentName: resolver.resolvePathParamsName(node)
+          }),
+          name: resolver.resolvePathParamsName(node),
+          typedName: resolver.resolvePathParamsTypedName(node)
+        }) : null,
+        queryParams.length > 0 ? renderSchemaType({
+          node: buildGroupedParamsSchema({
+            params: queryParams,
+            parentName: resolver.resolveQueryParamsName(node)
+          }),
+          name: resolver.resolveQueryParamsName(node),
+          typedName: resolver.resolveQueryParamsTypedName(node)
+        }) : null,
+        headerParams.length > 0 ? renderSchemaType({
+          node: buildGroupedParamsSchema({
+            params: headerParams,
+            parentName: resolver.resolveHeaderParamsName(node)
+          }),
+          name: resolver.resolveHeaderParamsName(node),
+          typedName: resolver.resolveHeaderParamsTypedName(node)
+        }) : null
+      ];
+      const legacyResponsesType = renderSchemaType({
+        node: buildLegacyResponsesSchemaNode({
+          node,
+          resolver
+        }),
+        name: resolver.resolveResponsesName(node),
+        typedName: resolver.resolveResponsesTypedName(node)
+      });
+      const legacyResponseType = renderSchemaType({
+        node: buildLegacyResponseUnionSchemaNode({
+          node,
+          resolver
+        }),
+        name: resolver.resolveResponseName(node),
+        typedName: resolver.resolveResponseTypedName(node)
+      });
+      return /* @__PURE__ */ jsxs(File, {
+        baseName: file.baseName,
+        path: file.path,
+        meta: file.meta,
+        banner: resolveBanner(),
+        footer: resolveFooter(),
+        children: [
+          legacyParamTypes,
+          responseTypes,
+          requestType,
+          legacyResponsesType,
+          legacyResponseType
+        ]
+      });
+    }
+    const paramTypes = params.map((param) => renderSchemaType({
+      node: param.schema,
+      name: resolver.resolveParamName(node, param),
+      typedName: resolver.resolveParamTypedName(node, param)
+    }));
     const dataType = renderSchemaType({
       node: buildDataSchemaNode({
         node: {
           ...node,
           parameters: params
         },
-        resolveName
+        resolver
       }),
-      name: resolverTs.resolveRequestConfigName(node),
-      typedName: resolverTs.resolveRequestConfigTypedName(node)
+      name: resolver.resolveRequestConfigName(node),
+      typedName: resolver.resolveRequestConfigTypedName(node)
     });
     const responsesType = renderSchemaType({
       node: buildResponsesSchemaNode({
         node,
-        resolveName
+        resolver
       }),
-      name: resolverTs.resolveResponsesName(node),
-      typedName: resolverTs.resolveResponsesTypedName(node)
+      name: resolver.resolveResponsesName(node),
+      typedName: resolver.resolveResponsesTypedName(node)
     });
     const responseType = renderSchemaType({
       node: buildResponseUnionSchemaNode({
         node,
-        resolveName
+        resolver
       }),
-      name: resolverTs.resolveResponseName(node),
-      typedName: resolverTs.resolveResponseTypedName(node),
+      name: resolver.resolveResponseName(node),
+      typedName: resolver.resolveResponseTypedName(node),
       description: "Union of all possible responses"
     });
     return /* @__PURE__ */ jsxs(File, {
@@ -210673,14 +210053,11 @@ const typeGenerator = defineGenerator({
     });
   },
   Schema({ node, adapter, options }) {
-    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType } = options;
-    const { mode, resolveName, getFile, resolveBanner, resolveFooter } = useKubb();
+    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, resolver } = options;
+    const { mode, getFile, resolveBanner, resolveFooter } = useKubb();
     if (!node.name) return;
     const imports = adapter.getImports(node, (schemaName) => ({
-      name: resolveName({
-        name: schemaName,
-        type: "type"
-      }),
+      name: resolver.default(schemaName, "type"),
       path: getFile({
         name: schemaName,
         extname: ".ts",
@@ -210688,9 +210065,9 @@ const typeGenerator = defineGenerator({
       }).path
     }));
     const isEnumSchema = node.type === "enum";
-    const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolverTs.resolveEnumKeyTypedName(node) : resolverTs.resolveTypedName(node.name);
+    const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyTypedName(node) : resolver.resolveTypedName(node.name);
     const type = {
-      name: resolverTs.resolveName(node.name),
+      name: resolver.resolveName(node.name),
       typedName,
       file: getFile({
         name: node.name,
@@ -210721,38 +210098,176 @@ const typeGenerator = defineGenerator({
         enumKeyCasing,
         optionalType,
         arrayType,
-        syntaxType
+        syntaxType,
+        resolver
       })]
     });
   }
 });
+
+function resolveName(name, type) {
+  return pascalCase$6(name, { isFile: type === "file" });
+}
+const resolverTs = defineResolver(() => {
+  return {
+    default(name, type) {
+      return resolveName(name, type);
+    },
+    resolveName(name) {
+      return this.default(name, "function");
+    },
+    resolveTypedName(name) {
+      return this.default(name, "type");
+    },
+    resolvePathName(name, type) {
+      return this.default(name, type);
+    },
+    resolveParamName(node, param) {
+      return this.resolveName(`${node.operationId} ${this.default(param.in)} ${param.name}`);
+    },
+    resolveParamTypedName(node, param) {
+      return this.resolveTypedName(`${node.operationId} ${this.default(param.in)} ${param.name}`);
+    },
+    resolveResponseStatusName(node, statusCode) {
+      return this.resolveName(`${node.operationId} Status ${statusCode}`);
+    },
+    resolveResponseStatusTypedName(node, statusCode) {
+      return this.resolveTypedName(`${node.operationId} Status ${statusCode}`);
+    },
+    resolveDataName(node) {
+      return this.resolveName(`${node.operationId} Data`);
+    },
+    resolveDataTypedName(node) {
+      return this.resolveTypedName(`${node.operationId} Data`);
+    },
+    resolveRequestConfigName(node) {
+      return this.resolveName(`${node.operationId} RequestConfig`);
+    },
+    resolveRequestConfigTypedName(node) {
+      return this.resolveTypedName(`${node.operationId} RequestConfig`);
+    },
+    resolveResponsesName(node) {
+      return this.resolveName(`${node.operationId} Responses`);
+    },
+    resolveResponsesTypedName(node) {
+      return this.resolveTypedName(`${node.operationId} Responses`);
+    },
+    resolveResponseName(node) {
+      return this.resolveName(`${node.operationId} Response`);
+    },
+    resolveResponseTypedName(node) {
+      return this.resolveTypedName(`${node.operationId} Response`);
+    },
+    resolveEnumKeyTypedName(node) {
+      var _a;
+      return `${this.resolveTypedName((_a = node.name) != null ? _a : "")}Key`;
+    },
+    resolvePathParamsName(_node) {
+      throw new Error("resolvePathParamsName is only available in legacy mode (legacy: true). Use resolveParamName per individual parameter instead.");
+    },
+    resolvePathParamsTypedName(_node) {
+      throw new Error("resolvePathParamsTypedName is only available in legacy mode (legacy: true). Use resolveParamTypedName per individual parameter instead.");
+    },
+    resolveQueryParamsName(_node) {
+      throw new Error("resolveQueryParamsName is only available in legacy mode (legacy: true). Use resolveParamName per individual parameter instead.");
+    },
+    resolveQueryParamsTypedName(_node) {
+      throw new Error("resolveQueryParamsTypedName is only available in legacy mode (legacy: true). Use resolveParamTypedName per individual parameter instead.");
+    },
+    resolveHeaderParamsName(_node) {
+      throw new Error("resolveHeaderParamsName is only available in legacy mode (legacy: true). Use resolveParamName per individual parameter instead.");
+    },
+    resolveHeaderParamsTypedName(_node) {
+      throw new Error("resolveHeaderParamsTypedName is only available in legacy mode (legacy: true). Use resolveParamTypedName per individual parameter instead.");
+    }
+  };
+});
+const resolverTsLegacy = defineResolver(() => {
+  return {
+    ...resolverTs,
+    resolveResponseStatusName(node, statusCode) {
+      if (statusCode === "default") return this.resolveName(`${node.operationId} Error`);
+      return this.resolveName(`${node.operationId} ${statusCode}`);
+    },
+    resolveResponseStatusTypedName(node, statusCode) {
+      if (statusCode === "default") return this.resolveTypedName(`${node.operationId} Error`);
+      return this.resolveTypedName(`${node.operationId} ${statusCode}`);
+    },
+    resolveDataName(node) {
+      const suffix = node.method === "GET" ? "QueryRequest" : "MutationRequest";
+      return this.resolveName(`${node.operationId} ${suffix}`);
+    },
+    resolveDataTypedName(node) {
+      const suffix = node.method === "GET" ? "QueryRequest" : "MutationRequest";
+      return this.resolveTypedName(`${node.operationId} ${suffix}`);
+    },
+    resolveResponsesName(node) {
+      const suffix = node.method === "GET" ? "Query" : "Mutation";
+      return this.resolveName(`${node.operationId} ${suffix}`);
+    },
+    resolveResponsesTypedName(node) {
+      const suffix = node.method === "GET" ? "Query" : "Mutation";
+      return this.resolveTypedName(`${node.operationId} ${suffix}`);
+    },
+    resolveResponseName(node) {
+      const suffix = node.method === "GET" ? "QueryResponse" : "MutationResponse";
+      return this.resolveName(`${node.operationId} ${suffix}`);
+    },
+    resolveResponseTypedName(node) {
+      const suffix = node.method === "GET" ? "QueryResponse" : "MutationResponse";
+      return this.resolveTypedName(`${node.operationId} ${suffix}`);
+    },
+    resolvePathParamsName(node) {
+      return this.resolveName(`${node.operationId} PathParams`);
+    },
+    resolvePathParamsTypedName(node) {
+      return this.resolveTypedName(`${node.operationId} PathParams`);
+    },
+    resolveQueryParamsName(node) {
+      return this.resolveName(`${node.operationId} QueryParams`);
+    },
+    resolveQueryParamsTypedName(node) {
+      return this.resolveTypedName(`${node.operationId} QueryParams`);
+    },
+    resolveHeaderParamsName(node) {
+      return this.resolveName(`${node.operationId} HeaderParams`);
+    },
+    resolveHeaderParamsTypedName(node) {
+      return this.resolveTypedName(`${node.operationId} HeaderParams`);
+    }
+  };
+});
 const pluginTsName = "plugin-ts";
 const pluginTs = createPlugin((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 = {}, paramsCasing, generators = [typeGenerator$1, typeGenerator].filter(Boolean), contentType, UNSTABLE_NAMING } = options;
+  }, group, exclude = [], include, override = [], enumType = "asConst", enumKeyCasing = "none", optionalType = "questionToken", arrayType = "array", syntaxType = "type", transformers = {}, paramsCasing, generators = [typeGenerator].filter(Boolean), legacy = false } = options;
+  const baseResolver = legacy ? resolverTsLegacy : resolverTs;
+  const resolver = (transformers == null ? void 0 : transformers.name) ? {
+    ...baseResolver,
+    default(name, type) {
+      const resolved = baseResolver.default(name, type);
+      return transformers.name(resolved, type) || resolved;
+    }
+  } : baseResolver;
+  let resolveNameWarning = false;
   return {
     name: pluginTsName,
     options: {
       output,
       transformers,
-      dateType,
-      integerType,
       optionalType,
       arrayType,
       enumType,
       enumKeyCasing,
-      enumSuffix,
-      unknownType,
-      emptySchemaType,
       syntaxType,
       group,
       override,
       paramsCasing,
-      usedEnumNames: {}
+      legacy,
+      resolver
     },
-    pre: [pluginOasName],
     resolvePath(baseName, pathMode, options2) {
       var _a, _b;
       const root = path$2.resolve(this.config.root, this.config.output.path);
@@ -210768,107 +210283,71 @@ const pluginTs = createPlugin((options) => {
       return path$2.resolve(root, output.path, baseName);
     },
     resolveName(name, type) {
-      var _a;
-      const resolvedName = resolverTs.default(name, type);
-      if (type) return ((_a = transformers == null ? void 0 : transformers.name) == null ? void 0 : _a.call(transformers, resolvedName, type)) || resolvedName;
-      return resolvedName;
+      if (!resolveNameWarning) {
+        this.driver.events.emit("warn", "Do not use resolveName for pluginTs, use resolverTs instead");
+        resolveNameWarning = true;
+      }
+      return resolver.default(name, type);
     },
     async install() {
-      var _a, _b;
+      var _a;
       const { config, fabric, plugin, adapter, rootNode, driver, openInStudio } = this;
       const root = path$2.resolve(config.root, config.output.path);
       const mode = getMode(path$2.resolve(root, output.path));
-      if (adapter) {
-        await openInStudio({ ast: true });
-        await walk(rootNode, {
-          async schema(schemaNode) {
-            const writeTasks = generators.map(async (generator) => {
-              if (generator.type === "react" && generator.version === "2") {
-                const options2 = resolverTs.resolveOptions(schemaNode, {
-                  options: plugin.options,
-                  exclude,
-                  include,
-                  override
-                });
-                if (options2 === null) return;
-                await renderSchema$1(schemaNode, {
-                  options: options2,
-                  adapter,
-                  config,
-                  fabric,
-                  Component: generator.Schema,
-                  plugin,
-                  driver,
-                  mode
-                });
-              }
-            });
-            await Promise.all(writeTasks);
-          },
-          async operation(operationNode) {
-            const writeTasks = generators.map(async (generator) => {
-              if (generator.type === "react" && generator.version === "2") {
-                const options2 = resolverTs.resolveOptions(operationNode, {
-                  options: plugin.options,
-                  exclude,
-                  include,
-                  override
-                });
-                if (options2 === null) return;
-                await renderOperation$1(operationNode, {
-                  options: options2,
-                  adapter,
-                  config,
-                  fabric,
-                  Component: generator.Operation,
-                  plugin,
-                  driver,
-                  mode
-                });
-              }
-            });
-            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();
-      const schemaFiles = await new SchemaGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        include: void 0,
-        override,
-        mode,
-        output: output.path
-      }).build(...generators);
-      await this.upsertFile(...schemaFiles);
-      const operationFiles = await new OperationGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        exclude,
-        include,
-        override,
-        mode,
-        UNSTABLE_NAMING
-      }).build(...generators);
-      await this.upsertFile(...operationFiles);
+      if (!adapter) throw new Error("Plugin cannot work without adapter being set");
+      await openInStudio({ ast: true });
+      await walk(rootNode, {
+        async schema(schemaNode) {
+          const writeTasks = generators.map(async (generator) => {
+            if (generator.type === "react" && generator.version === "2") {
+              const options2 = resolver.resolveOptions(schemaNode, {
+                options: plugin.options,
+                exclude,
+                include,
+                override
+              });
+              if (options2 === null) return;
+              await renderSchema$1(schemaNode, {
+                options: options2,
+                adapter,
+                config,
+                fabric,
+                Component: generator.Schema,
+                plugin,
+                driver,
+                mode
+              });
+            }
+          });
+          await Promise.all(writeTasks);
+        },
+        async operation(operationNode) {
+          const writeTasks = generators.map(async (generator) => {
+            if (generator.type === "react" && generator.version === "2") {
+              const options2 = resolver.resolveOptions(operationNode, {
+                options: plugin.options,
+                exclude,
+                include,
+                override
+              });
+              if (options2 === null) return;
+              await renderOperation$1(operationNode, {
+                options: options2,
+                adapter,
+                config,
+                fabric,
+                Component: generator.Operation,
+                plugin,
+                driver,
+                mode
+              });
+            }
+          });
+          await Promise.all(writeTasks);
+        }
+      }, { depth: "shallow" });
       const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: (_b = output.barrelType) != null ? _b : "named",
+        type: (_a = output.barrelType) != null ? _a : "named",
         root,
         output,
         meta: { pluginName: this.plugin.name }
@@ -210878,6 +210357,172 @@ const pluginTs = createPlugin((options) => {
   };
 });
 
+function useOas() {
+  const { meta } = useFabric();
+  return meta.oas;
+}
+function useOperationManager(generator) {
+  const plugin = usePlugin();
+  const driver = usePluginDriver();
+  const defaultPluginName = plugin.name;
+  const getName = (operation, { prefix = "", suffix = "", pluginName = defaultPluginName, type }) => {
+    return driver.resolveName({
+      name: `${prefix} ${operation.getOperationId()} ${suffix}`,
+      pluginName,
+      type
+    });
+  };
+  const getGroup = (operation) => {
+    var _a, _b;
+    return {
+      tag: (_b = (_a = operation.getTags().at(0)) == null ? void 0 : _a.name) != null ? _b : "default",
+      path: operation.path
+    };
+  };
+  const getSchemas = (operation, params) => {
+    if (!generator) throw new Error(`useOperationManager: 'generator' parameter is required but was not provided`);
+    return generator.getSchemas(operation, { resolveName: (name) => {
+      var _a;
+      return driver.resolveName({
+        name,
+        pluginName: (_a = params == null ? void 0 : params.pluginName) != null ? _a : defaultPluginName,
+        type: params == null ? void 0 : params.type
+      });
+    } });
+  };
+  const getFile = (operation, { prefix, suffix, pluginName = defaultPluginName, extname = ".ts" } = {}) => {
+    const name = getName(operation, {
+      type: "file",
+      pluginName,
+      prefix,
+      suffix
+    });
+    const group = getGroup(operation);
+    const file = driver.getFile({
+      name,
+      extname,
+      pluginName,
+      options: {
+        type: "file",
+        pluginName,
+        group
+      }
+    });
+    return {
+      ...file,
+      meta: {
+        ...file.meta,
+        name,
+        pluginName,
+        group
+      }
+    };
+  };
+  const groupSchemasByName = (operation, { pluginName = defaultPluginName, type }) => {
+    var _a, _b, _c, _d;
+    if (!generator) throw new Error(`useOperationManager: 'generator' parameter is required but was not provided`);
+    const schemas = getSchemas(operation);
+    const errors = (schemas.errors || []).reduce((prev, acc) => {
+      if (!acc.statusCode) return prev;
+      prev[acc.statusCode] = driver.resolveName({
+        name: acc.name,
+        pluginName,
+        type
+      });
+      return prev;
+    }, {});
+    const responses = (schemas.responses || []).reduce((prev, acc) => {
+      if (!acc.statusCode) return prev;
+      prev[acc.statusCode] = driver.resolveName({
+        name: acc.name,
+        pluginName,
+        type
+      });
+      return prev;
+    }, {});
+    return {
+      request: ((_a = schemas.request) == null ? void 0 : _a.name) ? driver.resolveName({
+        name: schemas.request.name,
+        pluginName,
+        type
+      }) : void 0,
+      parameters: {
+        path: ((_b = schemas.pathParams) == null ? void 0 : _b.name) ? driver.resolveName({
+          name: schemas.pathParams.name,
+          pluginName,
+          type
+        }) : void 0,
+        query: ((_c = schemas.queryParams) == null ? void 0 : _c.name) ? driver.resolveName({
+          name: schemas.queryParams.name,
+          pluginName,
+          type
+        }) : void 0,
+        header: ((_d = schemas.headerParams) == null ? void 0 : _d.name) ? driver.resolveName({
+          name: schemas.headerParams.name,
+          pluginName,
+          type
+        }) : void 0
+      },
+      responses: {
+        ...responses,
+        ["default"]: driver.resolveName({
+          name: schemas.response.name,
+          pluginName,
+          type
+        }),
+        ...errors
+      },
+      errors
+    };
+  };
+  return {
+    getName,
+    getFile,
+    getSchemas,
+    groupSchemasByName,
+    getGroup
+  };
+}
+function useSchemaManager() {
+  const plugin = usePlugin();
+  const driver = usePluginDriver();
+  const getName = (name, { pluginName = plugin.name, type }) => {
+    return driver.resolveName({
+      name,
+      pluginName,
+      type
+    });
+  };
+  const getFile = (name, { mode = "split", pluginName = plugin.name, extname = ".ts", group } = {}) => {
+    const resolvedName = mode === "single" ? "" : getName(name, {
+      type: "file",
+      pluginName
+    });
+    const file = driver.getFile({
+      name: resolvedName,
+      extname,
+      pluginName,
+      options: {
+        type: "file",
+        pluginName,
+        group
+      }
+    });
+    return {
+      ...file,
+      meta: {
+        ...file.meta,
+        name: resolvedName,
+        pluginName
+      }
+    };
+  };
+  return {
+    getName,
+    getFile
+  };
+}
+
 const operationsGenerator$1 = createReactGenerator({
   name: "operations",
   Operations({ operations, generator, plugin }) {
@@ -211162,7 +210807,7 @@ function toCamelOrPascal$9(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$9(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$9(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -212129,7 +211774,7 @@ function toCamelOrPascal$8(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$8(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$8(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -213038,7 +212683,7 @@ function toCamelOrPascal$7(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$7(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$7(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -213146,7 +212791,7 @@ function toCamelOrPascal$6(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$6(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$6(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -213664,7 +213309,7 @@ function toCamelOrPascal$5(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$5(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$5(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -214128,7 +213773,7 @@ function toCamelOrPascal$4(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$4(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$4(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -214281,7 +213926,7 @@ function MutationKey$4({ name, typeSchemas, pathParamsType, paramsCasing, operat
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$2, {
+    children: /* @__PURE__ */ jsx(Type$1, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -214349,7 +213994,7 @@ function QueryKey$4({ name, typeSchemas, paramsCasing, pathParamsType, operation
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$2, {
+    children: /* @__PURE__ */ jsx(Type$1, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -215842,7 +215487,7 @@ const hookOptionsGenerator = createReactGenerator({
         isExportable: true,
         isIndexable: true,
         isTypeOnly: true,
-        children: /* @__PURE__ */ jsx(Type$2, {
+        children: /* @__PURE__ */ jsx(Type$1, {
           export: true,
           name,
           children: `{ ${Object.keys(hookOptions).map((key) => `${JSON.stringify(key)}: ${hookOptions[key]}`)} }`
@@ -217203,7 +216848,7 @@ function toCamelOrPascal$3(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$3(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$3(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -217351,7 +216996,7 @@ function MutationKey$3({ name, typeSchemas, pathParamsType, paramsCasing, operat
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$2, {
+    children: /* @__PURE__ */ jsx(Type$1, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -217419,7 +217064,7 @@ function QueryKey$3({ name, typeSchemas, paramsCasing, pathParamsType, operation
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$2, {
+    children: /* @__PURE__ */ jsx(Type$1, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -218353,7 +217998,7 @@ function toCamelOrPascal$2(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$2(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$2(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -218501,7 +218146,7 @@ function MutationKey$2({ name, typeSchemas, pathParamsType, paramsCasing, operat
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$2, {
+    children: /* @__PURE__ */ jsx(Type$1, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -218569,7 +218214,7 @@ function QueryKey$2({ name, typeSchemas, paramsCasing, pathParamsType, operation
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$2, {
+    children: /* @__PURE__ */ jsx(Type$1, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -219503,7 +219148,7 @@ function toCamelOrPascal$1(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts$1(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase$1(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -219651,7 +219296,7 @@ function MutationKey$1({ name, typeSchemas, pathParamsType, paramsCasing, operat
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$2, {
+    children: /* @__PURE__ */ jsx(Type$1, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -219719,7 +219364,7 @@ function QueryKey$1({ name, typeSchemas, paramsCasing, pathParamsType, operation
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$2, {
+    children: /* @__PURE__ */ jsx(Type$1, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -219848,7 +219493,7 @@ function Mutation$1({ name, clientName, mutationKeyName, mutationKeyTypeName, pa
       isExportable: true,
       isIndexable: true,
       isTypeOnly: true,
-      children: /* @__PURE__ */ jsx(Type$2, {
+      children: /* @__PURE__ */ jsx(Type$1, {
         name: mutationArgTypeName,
         export: true,
         children: hasMutationParams ? `{${mutationArg}}` : "never"
@@ -220675,7 +220320,7 @@ function toCamelOrPascal(text, pascal) {
   }).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function applyToFileParts(text, transformPart) {
-  const parts = text.split(".");
+  const parts = text.split(/\.(?=[a-zA-Z])/);
   return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
@@ -220862,7 +220507,7 @@ function QueryKey({ name, typeSchemas, paramsCasing, pathParamsType, operation,
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$2, {
+    children: /* @__PURE__ */ jsx(Type$1, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`
@@ -221340,7 +220985,7 @@ function MutationKey({ name, typeSchemas, pathParamsType, paramsCasing, operatio
     isExportable: true,
     isIndexable: true,
     isTypeOnly: true,
-    children: /* @__PURE__ */ jsx(Type$2, {
+    children: /* @__PURE__ */ jsx(Type$1, {
       name: typeName,
       export: true,
       children: `ReturnType<typeof ${name}>`