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

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

@@ -4635,6 +4635,32 @@ function createParameter(props) {
     schema: syncOptionality(props.schema, required)
   };
 }
+function createFunctionParameter(props) {
+  return {
+    optional: false,
+    ...props,
+    kind: "FunctionParameter"
+  };
+}
+function createTypeNode(props) {
+  return {
+    ...props,
+    kind: "Type"
+  };
+}
+function createParameterGroup(props) {
+  return {
+    ...props,
+    kind: "ParameterGroup"
+  };
+}
+function createFunctionParameters(props = {}) {
+  return {
+    params: [],
+    ...props,
+    kind: "FunctionParameters"
+  };
+}
 function narrowSchema(node, type) {
   return (node == null ? void 0 : node.type) === type ? node : void 0;
 }
@@ -4995,6 +5021,198 @@ function caseParams(params, casing) {
     };
   });
 }
+function resolveType({ node, param, resolver }) {
+  var _a;
+  if (!resolver) return createTypeNode({
+    variant: "reference",
+    name: (_a = param.schema.primitive) != null ? _a : "unknown"
+  });
+  const individualName = resolver.resolveParamName(node, param);
+  const groupLocation = param.in === "path" || param.in === "query" || param.in === "header" ? param.in : void 0;
+  const groupResolvers = {
+    path: resolver.resolvePathParamsName,
+    query: resolver.resolveQueryParamsName,
+    header: resolver.resolveHeaderParamsName
+  };
+  const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : void 0;
+  if (groupName && groupName !== individualName) return createTypeNode({
+    variant: "member",
+    base: groupName,
+    key: param.name
+  });
+  return createTypeNode({
+    variant: "reference",
+    name: individualName
+  });
+}
+function createOperationParams(node, options) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
+  const dataName = (_a = paramNames == null ? void 0 : paramNames.data) != null ? _a : "data";
+  const paramsName = (_b = paramNames == null ? void 0 : paramNames.params) != null ? _b : "params";
+  const headersName = (_c = paramNames == null ? void 0 : paramNames.headers) != null ? _c : "headers";
+  const pathName = (_d = paramNames == null ? void 0 : paramNames.path) != null ? _d : "pathParams";
+  const wrapType = (type) => createTypeNode({
+    variant: "reference",
+    name: typeWrapper ? typeWrapper(type) : type
+  });
+  const wrapTypeNode = (type) => type.variant === "reference" ? wrapType(type.name) : type;
+  const casedParams = caseParams(node.parameters, paramsCasing);
+  const pathParams = casedParams.filter((p) => p.in === "path");
+  const queryParams = casedParams.filter((p) => p.in === "query");
+  const headerParams = casedParams.filter((p) => p.in === "header");
+  const bodyType = ((_e = node.requestBody) == null ? void 0 : _e.schema) ? wrapType((_f = resolver == null ? void 0 : resolver.resolveDataName(node)) != null ? _f : "unknown") : void 0;
+  const bodyRequired = (_h = (_g = node.requestBody) == null ? void 0 : _g.required) != null ? _h : false;
+  const queryGroupType = resolver ? resolveGroupType({
+    node,
+    params: queryParams,
+    groupMethod: resolver.resolveQueryParamsName,
+    resolver
+  }) : void 0;
+  const headerGroupType = resolver ? resolveGroupType({
+    node,
+    params: headerParams,
+    groupMethod: resolver.resolveHeaderParamsName,
+    resolver
+  }) : void 0;
+  const params = [];
+  if (paramsType === "object") {
+    const children = [
+      ...pathParams.map((p) => {
+        const type = resolveType({
+          node,
+          param: p,
+          resolver
+        });
+        return createFunctionParameter({
+          name: p.name,
+          type: wrapTypeNode(type),
+          optional: !p.required
+        });
+      }),
+      ...bodyType ? [createFunctionParameter({
+        name: dataName,
+        type: bodyType,
+        optional: !bodyRequired
+      })] : [],
+      ...buildGroupParam({
+        name: paramsName,
+        node,
+        params: queryParams,
+        groupType: queryGroupType,
+        resolver,
+        wrapType
+      }),
+      ...buildGroupParam({
+        name: headersName,
+        node,
+        params: headerParams,
+        groupType: headerGroupType,
+        resolver,
+        wrapType
+      })
+    ];
+    if (children.length) params.push(createParameterGroup({
+      properties: children,
+      default: children.every((c) => c.optional) ? "{}" : void 0
+    }));
+  } else {
+    if (pathParams.length) if (pathParamsType === "inlineSpread") {
+      const spreadType = (_i = resolver == null ? void 0 : resolver.resolvePathParamsName(node, pathParams[0])) != null ? _i : void 0;
+      params.push(createFunctionParameter({
+        name: pathName,
+        type: spreadType ? wrapType(spreadType) : void 0,
+        rest: true
+      }));
+    } else {
+      const pathChildren = pathParams.map((p) => {
+        const type = resolveType({
+          node,
+          param: p,
+          resolver
+        });
+        return createFunctionParameter({
+          name: p.name,
+          type: wrapTypeNode(type),
+          optional: !p.required
+        });
+      });
+      params.push(createParameterGroup({
+        properties: pathChildren,
+        inline: pathParamsType === "inline",
+        default: pathParamsDefault != null ? pathParamsDefault : pathChildren.every((c) => c.optional) ? "{}" : void 0
+      }));
+    }
+    if (bodyType) params.push(createFunctionParameter({
+      name: dataName,
+      type: bodyType,
+      optional: !bodyRequired
+    }));
+    params.push(...buildGroupParam({
+      name: paramsName,
+      node,
+      params: queryParams,
+      groupType: queryGroupType,
+      resolver,
+      wrapType
+    }));
+    params.push(...buildGroupParam({
+      name: headersName,
+      node,
+      params: headerParams,
+      groupType: headerGroupType,
+      resolver,
+      wrapType
+    }));
+  }
+  params.push(...extraParams);
+  return createFunctionParameters({ params });
+}
+function buildGroupParam({ name, node, params, groupType, resolver, wrapType }) {
+  if (groupType) return [createFunctionParameter({
+    name,
+    type: groupType.type.variant === "reference" ? wrapType(groupType.type.name) : groupType.type,
+    optional: groupType.optional
+  })];
+  if (params.length) return [createFunctionParameter({
+    name,
+    type: toStructType({
+      node,
+      params,
+      resolver
+    }),
+    optional: params.every((p) => !p.required)
+  })];
+  return [];
+}
+function resolveGroupType({ node, params, groupMethod, resolver }) {
+  if (!params.length) return;
+  const firstParam = params[0];
+  const groupName = groupMethod.call(resolver, node, firstParam);
+  if (groupName === resolver.resolveParamName(node, firstParam)) return;
+  const allOptional = params.every((p) => !p.required);
+  return {
+    type: createTypeNode({
+      variant: "reference",
+      name: groupName
+    }),
+    optional: allOptional
+  };
+}
+function toStructType({ node, params, resolver }) {
+  return createTypeNode({
+    variant: "struct",
+    properties: params.map((p) => ({
+      name: p.name,
+      optional: !p.required,
+      type: resolveType({
+        node,
+        param: p,
+        resolver
+      })
+    }))
+  });
+}
 
 var __defProp$h = Object.defineProperty;
 var __typeError$c = (msg) => {
@@ -6071,7 +6289,7 @@ const fsStorage = createStorage(() => ({
     await clean(resolve(base));
   }
 }));
-var version$1 = "5.0.0-alpha.23";
+var version$1 = "5.0.0-alpha.24";
 function getDiagnosticInfo() {
   return {
     nodeVersion: version$2,
@@ -6977,7 +7195,7 @@ function satisfiesDependency(dependency, version2, cwd) {
   return satisfies(semVer, version2);
 }
 
-var version = "5.0.0-alpha.23";
+var version = "5.0.0-alpha.24";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -209564,8 +209782,7 @@ function getEnumNames({ node, enumType, enumTypeSuffix, resolver }) {
   const resolved = resolver.default(node.name, "type");
   return {
     enumName: enumType === "asPascalConst" ? resolved : camelCase$a(node.name),
-    typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolved,
-    refName: resolved
+    typeName: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolved
   };
 }
 function Enum({ node, enumType, enumTypeSuffix, enumKeyCasing, resolver }) {
@@ -209688,10 +209905,10 @@ const printerTs = definePrinter((options) => {
       date: dateOrStringNode,
       time: dateOrStringNode,
       ref(node) {
-        var _a;
+        var _a, _b;
         if (!node.name) return;
         const refName = node.ref ? (_a = node.ref.split("/").at(-1)) != null ? _a : node.name : node.name;
-        return createTypeReferenceNode(node.ref ? this.options.resolver.default(refName, "type") : refName, void 0);
+        return createTypeReferenceNode(node.ref && ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix && ((_b = this.options.enumSchemaNames) == null ? void 0 : _b.has(refName)) ? this.options.resolver.resolveEnumKeyName({ name: refName }, this.options.enumTypeSuffix) : node.ref ? this.options.resolver.default(refName, "type") : refName, void 0);
       },
       enum(node) {
         var _a, _b, _c, _d;
@@ -209795,7 +210012,7 @@ const printerTs = definePrinter((options) => {
     }
   };
 });
-function Type({ name, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumTypeSuffix, enumKeyCasing, description, resolver }) {
+function Type({ name, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumTypeSuffix, enumKeyCasing, description, resolver, enumSchemaNames }) {
   const resolvedDescription = description || (node == null ? void 0 : node.description);
   const enumSchemaNodes = collect(node, { schema(n) {
     const enumNode = narrowSchema(n, schemaTypes.enum);
@@ -209810,7 +210027,8 @@ function Type({ name, node, keysToOmit, optionalType, arrayType, syntaxType, enu
     syntaxType,
     description: resolvedDescription,
     keysToOmit,
-    resolver
+    resolver,
+    enumSchemaNames
   }).print(node);
   if (!output) return;
   const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node2) => {
@@ -209950,7 +210168,7 @@ const typeGenerator = defineGenerator({
   name: "typescript",
   type: "react",
   Operation({ node, adapter, options, config, resolver }) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options;
     const root = path$2.resolve(config.root, config.output.path);
     const mode = getMode(path$2.resolve(root, output.path));
@@ -209965,11 +210183,16 @@ const typeGenerator = defineGenerator({
       group
     });
     const params = caseParams(node.parameters, paramsCasing);
+    const enumSchemaNames = new Set(((_c = (_b = adapter.rootNode) == null ? void 0 : _b.schemas) != null ? _c : []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name));
+    function resolveImportName(schemaName) {
+      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
+      return resolver.default(schemaName, "type");
+    }
     function renderSchemaType({ node: schemaNode, name, description, keysToOmit }) {
       if (!schemaNode) return null;
       const transformedNode = transform(schemaNode, composeTransformers(...transformers));
       const imports = adapter.getImports(transformedNode, (schemaName) => ({
-        name: resolver.default(schemaName, "type"),
+        name: resolveImportName(schemaName),
         path: resolver.resolveFile({
           name: schemaName,
           extname: ".ts"
@@ -209999,17 +210222,18 @@ const typeGenerator = defineGenerator({
         arrayType,
         syntaxType,
         resolver,
-        keysToOmit
+        keysToOmit,
+        enumSchemaNames
       })] });
     }
     const paramTypes = params.map((param) => renderSchemaType({
       node: param.schema,
       name: resolver.resolveParamName(node, param)
     }));
-    const requestType = ((_b = node.requestBody) == null ? void 0 : _b.schema) ? renderSchemaType({
+    const requestType = ((_d = node.requestBody) == null ? void 0 : _d.schema) ? renderSchemaType({
       node: node.requestBody.schema,
       name: resolver.resolveDataName(node),
-      description: (_c = node.requestBody.description) != null ? _c : node.requestBody.schema.description,
+      description: (_e = node.requestBody.description) != null ? _e : node.requestBody.schema.description,
       keysToOmit: node.requestBody.keysToOmit
     }) : null;
     const responseTypes = node.responses.map((res) => renderSchemaType({
@@ -210066,13 +210290,19 @@ const typeGenerator = defineGenerator({
     });
   },
   Schema({ node, adapter, options, config, resolver }) {
+    var _a, _b;
     const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options;
     const root = path$2.resolve(config.root, config.output.path);
     const mode = getMode(path$2.resolve(root, output.path));
     if (!node.name) return;
     const transformedNode = transform(node, composeTransformers(...transformers));
+    const enumSchemaNames = new Set(((_b = (_a = adapter.rootNode) == null ? void 0 : _a.schemas) != null ? _b : []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name));
+    function resolveImportName(schemaName) {
+      if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && enumTypeSuffix && enumSchemaNames.has(schemaName)) return resolver.resolveEnumKeyName({ name: schemaName }, enumTypeSuffix);
+      return resolver.default(schemaName, "type");
+    }
     const imports = adapter.getImports(transformedNode, (schemaName) => ({
-      name: resolver.default(schemaName, "type"),
+      name: resolveImportName(schemaName),
       path: resolver.resolveFile({
         name: schemaName,
         extname: ".ts"
@@ -210124,7 +210354,8 @@ const typeGenerator = defineGenerator({
         optionalType,
         arrayType,
         syntaxType,
-        resolver
+        resolver,
+        enumSchemaNames
       })]
     });
   }
@@ -210548,7 +210779,7 @@ const typeGeneratorLegacy = defineGenerator({
     });
   }
 });
-const presets = definePresets({
+const presets$1 = definePresets({
   default: {
     name: "default",
     resolvers: [resolverTs],
@@ -210568,7 +210799,7 @@ const pluginTs = createPlugin((options) => {
   }, group, exclude = [], include, override = [], enumType = "asConst", enumTypeSuffix = "Key", enumKeyCasing = "none", optionalType = "questionToken", arrayType = "array", syntaxType = "type", paramsCasing, compatibilityPreset = "default", resolvers: userResolvers = [], transformers: userTransformers = [], generators: userGenerators = [] } = options;
   const preset = getPreset({
     preset: compatibilityPreset,
-    presets,
+    presets: presets$1,
     resolvers: userResolvers,
     transformers: userTransformers,
     generators: userGenerators
@@ -210692,6 +210923,89 @@ const pluginTs = createPlugin((options) => {
     }
   };
 });
+const kindToHandlerKey = {
+  FunctionParameter: "functionParameter",
+  ParameterGroup: "parameterGroup",
+  FunctionParameters: "functionParameters",
+  Type: "type"
+};
+const defineFunctionPrinter = createPrinterFactory((node) => kindToHandlerKey[node.kind]);
+function rank(param) {
+  var _a;
+  if (param.kind === "ParameterGroup") {
+    if (param.default) return 2;
+    return ((_a = param.optional) != null ? _a : param.properties.every((p) => p.optional || p.default !== void 0)) ? 1 : 0;
+  }
+  if (param.rest) return 3;
+  if (param.default) return 2;
+  return param.optional ? 1 : 0;
+}
+function sortParams(params) {
+  return [...params].sort((a, b) => rank(a) - rank(b));
+}
+function sortChildParams(params) {
+  return [...params].sort((a, b) => rank(a) - rank(b));
+}
+const functionPrinter = defineFunctionPrinter((options) => ({
+  name: "functionParameters",
+  options,
+  nodes: {
+    type(node) {
+      if (node.variant === "member") return `${node.base}['${node.key}']`;
+      if (node.variant === "struct") return `{ ${node.properties.map((p) => {
+        const typeStr = this.transform(p.type);
+        return p.optional ? `${p.name}?: ${typeStr}` : `${p.name}: ${typeStr}`;
+      }).join("; ")} }`;
+      if (node.variant === "reference") return node.name;
+      return null;
+    },
+    functionParameter(node) {
+      const { mode, transformName, transformType } = this.options;
+      const name = transformName ? transformName(node.name) : node.name;
+      const rawType = node.type ? this.transform(node.type) : void 0;
+      const type = rawType != null && transformType ? transformType(rawType) : rawType;
+      if (mode === "keys" || mode === "values") return node.rest ? `...${name}` : name;
+      if (mode === "call") return node.rest ? `...${name}` : name;
+      if (node.rest) return type ? `...${name}: ${type}` : `...${name}`;
+      if (type) {
+        if (node.optional) return `${name}?: ${type}`;
+        return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`;
+      }
+      return node.default ? `${name} = ${node.default}` : name;
+    },
+    parameterGroup(node) {
+      var _a, _b, _c;
+      const { mode, transformName, transformType } = this.options;
+      const sorted = sortChildParams(node.properties);
+      const isOptional = (_a = node.optional) != null ? _a : sorted.every((p) => p.optional || p.default !== void 0);
+      if (node.inline) return sorted.map((p) => this.transform(p)).filter(Boolean).join(", ");
+      if (mode === "keys" || mode === "values") return `{ ${sorted.map((p) => p.name).join(", ")} }`;
+      if (mode === "call") return `{ ${sorted.map((p) => p.name).join(", ")} }`;
+      const names = sorted.map((p) => {
+        return transformName ? transformName(p.name) : p.name;
+      });
+      const nameStr = names.length ? `{ ${names.join(", ")} }` : void 0;
+      if (!nameStr) return null;
+      let typeAnnotation = node.type ? (_b = this.transform(node.type)) != null ? _b : void 0 : void 0;
+      if (!typeAnnotation) {
+        const typeParts = sorted.filter((p) => p.type).map((p) => {
+          const rawT = p.type ? this.transform(p.type) : void 0;
+          const t = rawT != null && transformType ? transformType(rawT) : rawT;
+          return p.optional || p.default !== void 0 ? `${p.name}?: ${t}` : `${p.name}: ${t}`;
+        });
+        typeAnnotation = typeParts.length ? `{ ${typeParts.join("; ")} }` : void 0;
+      }
+      if (typeAnnotation) {
+        if (isOptional) return `${nameStr}: ${typeAnnotation} = ${(_c = node.default) != null ? _c : "{}"}`;
+        return node.default ? `${nameStr}: ${typeAnnotation} = ${node.default}` : `${nameStr}: ${typeAnnotation}`;
+      }
+      return node.default ? `${nameStr} = ${node.default}` : nameStr;
+    },
+    functionParameters(node) {
+      return sortParams(node.params).map((p) => this.transform(p)).filter(Boolean).join(", ");
+    }
+  }
+}));
 
 function useDriver() {
   const { meta } = useFabric();
@@ -212142,14 +212456,14 @@ function isValidVarName$7(name) {
   return true;
 }
 var URLPath$6 = (_a$6 = class {
-  constructor(path, options = {}) {
+  constructor(path2, options = {}) {
     __privateAdd$6(this, _URLPath_instances$6);
     /**
     * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
     */
     __publicField$6(this, "path");
     __privateAdd$6(this, _options$6);
-    this.path = path;
+    this.path = path2;
     __privateSet$6(this, _options$6, options);
   }
   /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
@@ -212276,80 +212590,63 @@ eachParam_fn$6 = function(fn) {
     fn(raw, __privateMethod$6(this, _URLPath_instances$6, transformParam_fn$6).call(this, raw));
   }
 }, _a$6);
-function getParams$c({ paramsType, paramsCasing, pathParamsType, typeSchemas }) {
-  var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
-  if (paramsType === "object") {
-    const pathParams = getPathParams(typeSchemas.pathParams, {
-      typed: true,
-      casing: paramsCasing
-    });
-    return FunctionParams.factory({
-      data: {
-        mode: "object",
-        children: {
-          ...pathParams,
-          data: ((_a2 = typeSchemas.request) == null ? void 0 : _a2.name) ? {
-            type: (_b = typeSchemas.request) == null ? void 0 : _b.name,
-            optional: isOptional((_c = typeSchemas.request) == null ? void 0 : _c.schema)
-          } : void 0,
-          params: ((_d = typeSchemas.queryParams) == null ? void 0 : _d.name) ? {
-            type: (_e = typeSchemas.queryParams) == null ? void 0 : _e.name,
-            optional: isOptional((_f = typeSchemas.queryParams) == null ? void 0 : _f.schema)
-          } : void 0,
-          headers: ((_g = typeSchemas.headerParams) == null ? void 0 : _g.name) ? {
-            type: (_h = typeSchemas.headerParams) == null ? void 0 : _h.name,
-            optional: isOptional((_i = typeSchemas.headerParams) == null ? void 0 : _i.schema)
-          } : void 0
-        }
-      },
-      options: {
-        type: "Partial<Cypress.RequestOptions>",
-        default: "{}"
-      }
-    });
-  }
-  return FunctionParams.factory({
-    pathParams: ((_j = typeSchemas.pathParams) == null ? void 0 : _j.name) ? {
-      mode: pathParamsType === "object" ? "object" : "inlineSpread",
-      children: getPathParams(typeSchemas.pathParams, {
-        typed: true,
-        casing: paramsCasing
+const declarationPrinter = functionPrinter({ mode: "declaration" });
+function getParams$c({ paramsType, pathParamsType, paramsCasing, resolver, node }) {
+  var _a2;
+  const paramsNode = createOperationParams(node, {
+    paramsType,
+    pathParamsType,
+    paramsCasing,
+    resolver,
+    extraParams: [createFunctionParameter({
+      name: "options",
+      type: createTypeNode({
+        variant: "reference",
+        name: "Partial<Cypress.RequestOptions>"
       }),
-      default: isAllOptional((_k = typeSchemas.pathParams) == null ? void 0 : _k.schema) ? "{}" : void 0
-    } : void 0,
-    data: ((_l = typeSchemas.request) == null ? void 0 : _l.name) ? {
-      type: (_m = typeSchemas.request) == null ? void 0 : _m.name,
-      optional: isOptional((_n = typeSchemas.request) == null ? void 0 : _n.schema)
-    } : void 0,
-    params: ((_o = typeSchemas.queryParams) == null ? void 0 : _o.name) ? {
-      type: (_p = typeSchemas.queryParams) == null ? void 0 : _p.name,
-      optional: isOptional((_q = typeSchemas.queryParams) == null ? void 0 : _q.schema)
-    } : void 0,
-    headers: ((_r = typeSchemas.headerParams) == null ? void 0 : _r.name) ? {
-      type: (_s = typeSchemas.headerParams) == null ? void 0 : _s.name,
-      optional: isOptional((_t = typeSchemas.headerParams) == null ? void 0 : _t.schema)
-    } : void 0,
-    options: {
-      type: "Partial<Cypress.RequestOptions>",
       default: "{}"
-    }
+    })]
   });
+  return (_a2 = declarationPrinter.print(paramsNode)) != null ? _a2 : "";
 }
-function Request({ baseURL = "", name, dataReturnType, typeSchemas, url, method, paramsType, paramsCasing, pathParamsType }) {
-  var _a2, _b, _c;
-  const path = new URLPath$6(url, { casing: paramsCasing });
-  const params = getParams$c({
+function Request({ baseURL = "", name, dataReturnType, resolver, node, paramsType, pathParamsType, paramsCasing }) {
+  var _a2;
+  const paramsSignature = getParams$c({
     paramsType,
-    paramsCasing,
     pathParamsType,
-    typeSchemas
+    paramsCasing,
+    resolver,
+    node
+  });
+  const responseType = resolver.resolveResponseName(node);
+  const returnType = dataReturnType === "data" ? `Cypress.Chainable<${responseType}>` : `Cypress.Chainable<Cypress.Response<${responseType}>>`;
+  const casedPathParams = caseParams(node.parameters.filter((p) => p.in === "path"), paramsCasing);
+  const pathParamNameMap = new Map(casedPathParams.map((p) => [camelCase$8(p.name), p.name]));
+  const urlTemplate = new URLPath$6(node.path, { casing: paramsCasing }).toTemplateString({
+    prefix: baseURL,
+    replacer: (param) => {
+      var _a3;
+      return (_a3 = pathParamNameMap.get(camelCase$8(param))) != null ? _a3 : param;
+    }
   });
-  const returnType = dataReturnType === "data" ? `Cypress.Chainable<${typeSchemas.response.name}>` : `Cypress.Chainable<Cypress.Response<${typeSchemas.response.name}>>`;
-  const urlTemplate = path.toTemplateString({ prefix: baseURL });
-  const requestOptions = [`method: '${method}'`, `url: ${urlTemplate}`];
-  if ((_a2 = typeSchemas.queryParams) == null ? void 0 : _a2.name) requestOptions.push("qs: params");
-  if ((_b = typeSchemas.headerParams) == null ? void 0 : _b.name) requestOptions.push("headers");
-  if ((_c = typeSchemas.request) == null ? void 0 : _c.name) requestOptions.push("body: data");
+  const requestOptions = [`method: '${node.method}'`, `url: ${urlTemplate}`];
+  const queryParams = node.parameters.filter((p) => p.in === "query");
+  if (queryParams.length > 0) {
+    const casedQueryParams = caseParams(queryParams, paramsCasing);
+    if (casedQueryParams.some((p, i) => p.name !== queryParams[i].name)) {
+      const pairs = queryParams.map((orig, i) => `${orig.name}: params.${casedQueryParams[i].name}`).join(", ");
+      requestOptions.push(`qs: params ? { ${pairs} } : undefined`);
+    } else requestOptions.push("qs: params");
+  }
+  const headerParams = node.parameters.filter((p) => p.in === "header");
+  if (headerParams.length > 0) {
+    const casedHeaderParams = caseParams(headerParams, paramsCasing);
+    if (casedHeaderParams.some((p, i) => p.name !== headerParams[i].name)) {
+      const pairs = headerParams.map((orig, i) => `'${orig.name}': headers.${casedHeaderParams[i].name}`).join(", ");
+      requestOptions.push(`headers: headers ? { ${pairs} } : undefined`);
+    } else requestOptions.push("headers");
+  }
+  if ((_a2 = node.requestBody) == null ? void 0 : _a2.schema) requestOptions.push("body: data");
   requestOptions.push("...options");
   return /* @__PURE__ */ jsx(File.Source, {
     name,
@@ -212358,135 +212655,185 @@ function Request({ baseURL = "", name, dataReturnType, typeSchemas, url, method,
     children: /* @__PURE__ */ jsx(Function$1, {
       name,
       export: true,
-      params: params.toConstructor(),
+      params: paramsSignature,
       returnType,
-      children: dataReturnType === "data" ? `return cy.request<${typeSchemas.response.name}>({
+      children: dataReturnType === "data" ? `return cy.request<${responseType}>({
   ${requestOptions.join(",\n  ")}
-}).then((res) => res.body)` : `return cy.request<${typeSchemas.response.name}>({
+}).then((res) => res.body)` : `return cy.request<${responseType}>({
   ${requestOptions.join(",\n  ")}
 })`
     })
   });
 }
 Request.getParams = getParams$c;
-
-const cypressGenerator = createReactGenerator({
+const cypressGenerator = defineGenerator({
   name: "cypress",
-  Operation({ operation, generator, plugin }) {
-    var _a, _b, _c, _d, _e;
-    const { options: { output, baseURL, dataReturnType, paramsCasing, paramsType, pathParamsType } } = plugin;
-    const driver = useDriver();
-    const oas = useOas();
-    const { getSchemas, getName, getFile } = useOperationManager(generator);
-    const request = {
-      name: getName(operation, { type: "function" }),
-      file: getFile(operation)
-    };
-    const type = {
-      file: getFile(operation, { pluginName: pluginTsName }),
-      schemas: getSchemas(operation, {
-        pluginName: pluginTsName,
-        type: "type"
-      })
-    };
+  type: "react",
+  Operation({ node, adapter, options, config, driver, resolver }) {
+    var _a2, _b, _c, _d, _e, _f;
+    const { output, baseURL, dataReturnType, paramsCasing, paramsType, pathParamsType, group } = options;
+    const root = path$2.resolve(config.root, config.output.path);
+    const pluginTs = driver.getPlugin(pluginTsName);
+    if (!pluginTs) return null;
+    const file = resolver.resolveFile({
+      name: node.operationId,
+      extname: ".ts",
+      tag: (_a2 = node.tags[0]) != null ? _a2 : "default",
+      path: node.path
+    }, {
+      root,
+      output,
+      group
+    });
+    const tsFile = pluginTs.resolver.resolveFile({
+      name: node.operationId,
+      extname: ".ts",
+      tag: (_b = node.tags[0]) != null ? _b : "default",
+      path: node.path
+    }, {
+      root,
+      output: (_d = (_c = pluginTs.options) == null ? void 0 : _c.output) != null ? _d : output,
+      group: (_e = pluginTs.options) == null ? void 0 : _e.group
+    });
+    const name = resolver.resolveName(node.operationId);
+    const casedParams = caseParams(node.parameters, paramsCasing);
+    const tsResolver = pluginTs.resolver;
+    const pathParams = casedParams.filter((p) => p.in === "path");
+    const queryParams = casedParams.filter((p) => p.in === "query");
+    const headerParams = casedParams.filter((p) => p.in === "header");
+    const importedTypeNames = [
+      ...pathParams.length && tsResolver.resolvePathParamsName ? pathParams.map((p) => tsResolver.resolvePathParamsName(node, p)) : pathParams.map((p) => tsResolver.resolveParamName(node, p)),
+      ...queryParams.length && tsResolver.resolveQueryParamsName ? queryParams.map((p) => tsResolver.resolveQueryParamsName(node, p)) : queryParams.map((p) => tsResolver.resolveParamName(node, p)),
+      ...headerParams.length && tsResolver.resolveHeaderParamsName ? headerParams.map((p) => tsResolver.resolveHeaderParamsName(node, p)) : headerParams.map((p) => tsResolver.resolveParamName(node, p)),
+      ((_f = node.requestBody) == null ? void 0 : _f.schema) ? tsResolver.resolveDataName(node) : void 0,
+      tsResolver.resolveResponseName(node)
+    ].filter(Boolean);
     return /* @__PURE__ */ jsxs(File, {
-      baseName: request.file.baseName,
-      path: request.file.path,
-      meta: request.file.meta,
-      banner: getBanner({
-        oas,
+      baseName: file.baseName,
+      path: file.path,
+      meta: file.meta,
+      banner: resolver.resolveBanner(adapter.rootNode, {
         output,
-        config: driver.config
+        config
       }),
-      footer: getFooter({
-        oas,
-        output
+      footer: resolver.resolveFooter(adapter.rootNode, {
+        output,
+        config
       }),
-      children: [/* @__PURE__ */ jsx(File.Import, {
-        name: [
-          (_a = type.schemas.request) == null ? void 0 : _a.name,
-          type.schemas.response.name,
-          (_b = type.schemas.pathParams) == null ? void 0 : _b.name,
-          (_c = type.schemas.queryParams) == null ? void 0 : _c.name,
-          (_d = type.schemas.headerParams) == null ? void 0 : _d.name,
-          ...((_e = type.schemas.statusCodes) == null ? void 0 : _e.map((item) => item.name)) || []
-        ].filter(Boolean),
-        root: request.file.path,
-        path: type.file.path,
+      children: [tsFile && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+        name: Array.from(new Set(importedTypeNames)),
+        root: file.path,
+        path: tsFile.path,
         isTypeOnly: true
       }), /* @__PURE__ */ jsx(Request, {
-        name: request.name,
+        name,
+        node,
+        resolver: tsResolver,
         dataReturnType,
         paramsCasing,
         paramsType,
         pathParamsType,
-        typeSchemas: type.schemas,
-        method: operation.method,
-        baseURL,
-        url: operation.path
+        baseURL
       })]
     });
   }
 });
-
+const resolverCypress = defineResolver(() => ({
+  name: "default",
+  pluginName: "plugin-cypress",
+  default(name, type) {
+    return camelCase$8(name, { isFile: type === "file" });
+  },
+  resolveName(name) {
+    return this.default(name, "function");
+  }
+}));
+const presets = definePresets({
+  default: {
+    name: "default",
+    resolvers: [resolverCypress],
+    generators: [cypressGenerator]
+  },
+  kubbV4: {
+    name: "kubbV4",
+    resolvers: [resolverCypress],
+    generators: [cypressGenerator]
+  }
+});
 const pluginCypressName = "plugin-cypress";
 const pluginCypress = createPlugin((options) => {
   const { output = {
     path: "cypress",
     barrelType: "named"
-  }, group, dataReturnType = "data", exclude = [], include, override = [], transformers = {}, generators = [cypressGenerator].filter(Boolean), contentType, baseURL, paramsCasing, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline" } = options;
+  }, group, dataReturnType = "data", exclude = [], include, override = [], baseURL, paramsCasing, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", compatibilityPreset = "default", resolvers: userResolvers = [], transformers: userTransformers = [], generators: userGenerators = [] } = options;
+  const preset = getPreset({
+    preset: compatibilityPreset,
+    presets,
+    resolvers: [resolverCypress, ...userResolvers],
+    transformers: userTransformers,
+    generators: userGenerators
+  });
   return {
     name: pluginCypressName,
-    options: {
-      output,
-      dataReturnType,
-      group,
-      baseURL,
-      paramsCasing,
-      paramsType,
-      pathParamsType
-    },
-    pre: [pluginOasName, pluginTsName].filter(Boolean),
-    resolvePath(baseName, pathMode, options2) {
-      var _a, _b;
-      const root = path$2.resolve(this.config.root, this.config.output.path);
-      if ((pathMode != null ? pathMode : getMode(path$2.resolve(root, output.path))) === "single")
-        return path$2.resolve(root, output.path);
-      if (group && (((_a = options2 == null ? void 0 : options2.group) == null ? void 0 : _a.path) || ((_b = options2 == null ? void 0 : options2.group) == null ? void 0 : _b.tag))) {
-        const groupName = (group == null ? void 0 : group.name) ? group.name : (ctx) => {
-          if ((group == null ? void 0 : group.type) === "path") return `${ctx.group.split("/")[1]}`;
-          return `${camelCase$8(ctx.group)}Requests`;
-        };
-        return path$2.resolve(root, output.path, groupName({ group: group.type === "path" ? options2.group.path : options2.group.tag }), baseName);
-      }
-      return path$2.resolve(root, output.path, baseName);
+    get resolver() {
+      return preset.resolver;
     },
-    resolveName(name, type) {
-      var _a;
-      const resolvedName = camelCase$8(name, { isFile: type === "file" });
-      if (type) return ((_a = transformers == null ? void 0 : transformers.name) == null ? void 0 : _a.call(transformers, resolvedName, type)) || resolvedName;
-      return resolvedName;
+    get options() {
+      var _a2;
+      return {
+        output,
+        dataReturnType,
+        group: group ? {
+          ...options.group,
+          name: ((_a2 = options.group) == null ? void 0 : _a2.name) ? options.group.name : (ctx) => {
+            if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+            return `${camelCase$8(ctx.group)}Requests`;
+          }
+        } : void 0,
+        baseURL,
+        paramsCasing,
+        paramsType,
+        pathParamsType,
+        resolver: preset.resolver,
+        transformers: preset.transformers
+      };
     },
+    pre: [pluginTsName].filter(Boolean),
     async install() {
-      var _a;
-      const root = path$2.resolve(this.config.root, this.config.output.path);
-      const mode = getMode(path$2.resolve(root, output.path));
-      const oas = await this.getOas();
-      const files = await new OperationGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        exclude,
-        include,
-        override,
-        mode
-      }).build(...generators);
-      await this.upsertFile(...files);
+      var _a2;
+      const { config, fabric, plugin, adapter, rootNode, driver } = this;
+      const root = path$2.resolve(config.root, config.output.path);
+      const resolver = preset.resolver;
+      if (!adapter) throw new Error("Plugin cannot work without adapter being set");
+      await walk(rootNode, {
+        depth: "shallow",
+        async operation(operationNode) {
+          const writeTasks = preset.generators.map(async (generator) => {
+            if (generator.type === "react" && generator.version === "2") {
+              const resolvedOptions = resolver.resolveOptions(operationNode, {
+                options: plugin.options,
+                exclude,
+                include,
+                override
+              });
+              if (resolvedOptions === null) return;
+              await renderOperation$1(operationNode, {
+                options: resolvedOptions,
+                adapter,
+                config,
+                fabric,
+                Component: generator.Operation,
+                plugin,
+                driver,
+                resolver
+              });
+            }
+          });
+          await Promise.all(writeTasks);
+        }
+      });
       const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: (_a = output.barrelType) != null ? _a : "named",
+        type: (_a2 = output.barrelType) != null ? _a2 : "named",
         root,
         output,
         meta: { pluginName: this.plugin.name }