@kubb/plugin-swr 5.0.0-beta.64 → 5.0.0-beta.73

package/dist/index.js

@@ -1,14 +1,37 @@
-import "./chunk-C0LytTxp.js";
-import { c as mutationKeyTransformer, o as queryKeyTransformer, u as camelCase } from "./components-mWBRE6E4.js";
-import { n as mutationGenerator, t as queryGenerator } from "./generators-D2blgLOY.js";
+import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
 import path from "node:path";
-import { ast, definePlugin, defineResolver } from "@kubb/core";
-import { isParserEnabled, pluginClientName } from "@kubb/plugin-client";
-import { source } from "@kubb/plugin-client/templates/clients/axios.source";
-import { source as source$1 } from "@kubb/plugin-client/templates/clients/fetch.source";
-import { source as source$2 } from "@kubb/plugin-client/templates/config.source";
-import { pluginTsName } from "@kubb/plugin-ts";
+import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
+import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { pluginZodName } from "@kubb/plugin-zod";
+import { File, Function, Type, jsxRenderer } from "@kubb/renderer-jsx";
+import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+//#endregion
 //#region ../../internals/utils/src/fs.ts
 /**
 * Builds a nested file path from a dotted name. Splits on dots that precede a letter
@@ -34,6 +57,386 @@ function toFilePath(name, caseLast = camelCase) {
 	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
 }
 //#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = new Set([
+	"abstract",
+	"arguments",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"let",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
+	"yield",
+	"Array",
+	"Date",
+	"hasOwnProperty",
+	"Infinity",
+	"isFinite",
+	"isNaN",
+	"isPrototypeOf",
+	"length",
+	"Math",
+	"name",
+	"NaN",
+	"Number",
+	"Object",
+	"prototype",
+	"String",
+	"toString",
+	"undefined",
+	"valueOf"
+]);
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
+*/
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+//#endregion
+//#region ../../internals/utils/src/url.ts
+function transformParam(raw, casing) {
+	const param = isValidVarName(raw) ? raw : camelCase(raw);
+	return casing === "camelcase" ? camelCase(param) : param;
+}
+function toParamsObject(path, { replacer, casing } = {}) {
+	const params = {};
+	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
+		const param = transformParam(match[1], casing);
+		const key = replacer ? replacer(param) : param;
+		params[key] = key;
+	}
+	return Object.keys(params).length > 0 ? params : null;
+}
+/**
+* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
+*/
+var Url = class Url {
+	/**
+	* Reports whether `url` is a parseable absolute URL. Delegates to the native `URL.canParse`.
+	*
+	* @example
+	* Url.canParse('https://petstore.swagger.io/v2') // true
+	* Url.canParse('/pet/{petId}')                   // false
+	*/
+	static canParse(url, base) {
+		return URL.canParse(url, base);
+	}
+	/**
+	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
+	*
+	* @example
+	* Url.toPath('/pet/{petId}') // '/pet/:petId'
+	*/
+	static toPath(path) {
+		return path.replace(/\{([^}]+)\}/g, ":$1");
+	}
+	/**
+	* Converts an OpenAPI/Swagger path to a TypeScript template literal string.
+	* `prefix` is prepended inside the literal, `replacer` transforms each parameter name,
+	* and `casing` controls parameter identifier casing.
+	*
+	* @example
+	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
+	*
+	* @example
+	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
+	*/
+	static toTemplateString(path, { prefix, replacer, casing } = {}) {
+		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = transformParam(part, casing);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("");
+		return `\`${prefix ?? ""}${result}\``;
+	}
+	/**
+	* Converts an OpenAPI/Swagger path to a template literal that reads each parameter off the
+	* grouped `path` request option, e.g. `/pet/{petId}` becomes `` `/pet/${path.petId}` ``. Parameter
+	* names are camelCased to match the generated `path` type, and `prefix` is prepended inside the
+	* literal. Shared by the client and cypress generators that pass a grouped `path` object.
+	*
+	* @example
+	* Url.toGroupedTemplateString('/pet/{petId}') // '`/pet/${path.petId}`'
+	*/
+	static toGroupedTemplateString(path, { prefix } = {}) {
+		return Url.toTemplateString(path, {
+			prefix,
+			casing: "camelcase",
+			replacer: (name) => `path.${name}`
+		});
+	}
+	/**
+	* Returns the path and its extracted params as a structured `URLObject`, or as a stringified
+	* expression when `stringify` is set.
+	*
+	* @example
+	* Url.toObject('/pet/{petId}')
+	* // { url: '/pet/:petId', params: { petId: 'petId' } }
+	*/
+	static toObject(path, { type = "path", replacer, stringify, casing } = {}) {
+		const object = {
+			url: type === "path" ? Url.toPath(path) : Url.toTemplateString(path, {
+				replacer,
+				casing
+			}),
+			params: toParamsObject(path, {
+				replacer,
+				casing
+			})
+		};
+		if (stringify) {
+			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+			return `{ url: '${object.url}' }`;
+		}
+		return object;
+	}
+};
+//#endregion
+//#region ../../internals/shared/src/params.ts
+const caseParamsCache = /* @__PURE__ */ new WeakMap();
+/**
+* Applies camelCase to parameter names and returns a new array without mutating the input.
+*
+* Run it before handing parameters to schema builders so output property keys get the right casing
+* while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, the
+* original array is returned unchanged. Results are cached per input array.
+*/
+function caseParams(params, casing) {
+	if (!casing) return params;
+	const cached = caseParamsCache.get(params);
+	if (cached) return cached;
+	const result = params.map((param) => ({
+		...param,
+		name: camelCase(param.name)
+	}));
+	caseParamsCache.set(params, result);
+	return result;
+}
+//#endregion
+//#region ../../internals/shared/src/operation.ts
+/**
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.resolveFile`: a file named `name`, tagged by the operation's first
+* tag (or `'default'`), at the operation's path. Centralizes the entry object
+* that was repeated at dozens of call sites across the client and query plugins.
+*
+* @example
+* ```ts
+* resolver.resolveFile(operationFileEntry(node, node.operationId), { root, output, group })
+* ```
+*/
+function operationFileEntry(node, name, extname = ".ts") {
+	return {
+		name,
+		extname,
+		tag: node.tags[0] ?? "default",
+		path: node.path
+	};
+}
+function getOperationLink(node, link) {
+	if (!link) return null;
+	if (typeof link === "function") return link(node) ?? null;
+	if (link === "urlPath") return node.path ? `{@link ${Url.toPath(node.path)}}` : null;
+	return node.path ? `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}` : null;
+}
+function getContentTypeInfo(node) {
+	const contentTypes = node.requestBody?.content?.map((e) => e.contentType) ?? [];
+	const isMultipleContentTypes = contentTypes.length > 1;
+	return {
+		contentTypes,
+		isMultipleContentTypes,
+		contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(" | ") : "",
+		defaultContentType: contentTypes[0] ?? "application/json",
+		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
+	};
+}
+function buildRequestConfigType(node) {
+	const { isMultipleContentTypes, contentTypeUnion } = getContentTypeInfo(node);
+	const configType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+	const contentTypeProp = isMultipleContentTypes ? `contentType?: ${contentTypeUnion}` : null;
+	return contentTypeProp ? `${configType} & { ${contentTypeProp} }` : configType;
+}
+/**
+* Builds the `client?:` option type shared by the generated query hooks (`useQuery`,
+* `useInfiniteQuery`, `useSWR`, ...). Unlike {@link buildRequestConfigType}, it never adds a
+* `contentType?:` member: query hooks wrap GET operations, which carry no request body to select a
+* content type for.
+*/
+function buildClientOptionType() {
+	return `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+}
+/**
+* Which of the grouped request options an operation carries.
+*/
+function getRequestGroups(node) {
+	const { path, query, header } = getOperationParameters(node);
+	return {
+		path: path.length > 0,
+		query: query.length > 0,
+		body: Boolean(node.requestBody?.content?.[0]?.schema),
+		headers: header.length > 0
+	};
+}
+/**
+* Resolves which grouped request options an operation carries together with whether each group
+* holds a required member. The grouped parameter stays optional only when nothing inside it is
+* required, matching the generated `RequestConfig` type.
+*/
+function getRequestGroupOptionality(node) {
+	const groups = getRequestGroups(node);
+	const { path, query, header } = getOperationParameters(node);
+	const hasRequiredPath = path.some((param) => param.required);
+	const hasRequiredQuery = query.some((param) => param.required);
+	const hasRequiredHeader = header.some((param) => param.required);
+	return {
+		groups,
+		hasRequiredPath,
+		hasRequiredQuery,
+		hasRequiredHeader,
+		isOptional: !hasRequiredPath && !hasRequiredQuery && !hasRequiredHeader && !groups.body
+	};
+}
+function buildOperationComments(node, options = {}) {
+	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
+	const linkComment = getOperationLink(node, link);
+	const filteredComments = (linkPosition === "beforeDeprecated" ? [
+		node.description && `@description ${node.description}`,
+		node.summary && `@summary ${node.summary}`,
+		linkComment,
+		node.deprecated && "@deprecated"
+	] : [
+		node.description && `@description ${node.description}`,
+		node.summary && `@summary ${node.summary}`,
+		node.deprecated && "@deprecated",
+		linkComment
+	]).filter((comment) => Boolean(comment));
+	if (!splitLines) return filteredComments;
+	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
+}
+function getOperationParameters(node, options = {}) {
+	const params = caseParams(node.parameters, options.paramsCasing === "original" ? void 0 : "camelcase");
+	return {
+		path: params.filter((param) => param.in === "path"),
+		query: params.filter((param) => param.in === "query"),
+		header: params.filter((param) => param.in === "header"),
+		cookie: params.filter((param) => param.in === "cookie")
+	};
+}
+function getStatusCodeNumber(statusCode) {
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? null : code;
+}
+function isErrorStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 400;
+}
+function resolveErrorNames(node, resolver) {
+	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+}
+function resolveStatusCodeNames(node, resolver) {
+	return node.responses.map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+}
+const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
+function resolveOperationTypeNames(node, resolver, options = {}) {
+	const cacheKey = `${node.operationId}\0${options.paramsCasing ?? ""}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${options.includeParams === false ? "noparams" : ""}\0${(options.exclude ?? []).join(",")}`;
+	let byResolver = typeNamesByResolver.get(resolver);
+	if (byResolver) {
+		const cached = byResolver.get(cacheKey);
+		if (cached) return cached;
+	} else {
+		byResolver = /* @__PURE__ */ new Map();
+		typeNamesByResolver.set(resolver, byResolver);
+	}
+	const { path, query, header } = getOperationParameters(node, { paramsCasing: options.paramsCasing });
+	const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
+	const exclude = new Set(options.exclude ?? []);
+	const paramNames = options.includeParams === false ? [] : [
+		...path.map((param) => resolver.resolvePathParamsName(node, param)),
+		...query.map((param) => resolver.resolveQueryParamsName(node, param)),
+		...header.map((param) => resolver.resolveHeaderParamsName(node, param))
+	];
+	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null, resolver.resolveResponseName(node)];
+	const result = (options.order === "body-response-first" ? [
+		...bodyAndResponseNames,
+		...paramNames,
+		...responseStatusNames
+	] : [
+		...paramNames,
+		...bodyAndResponseNames,
+		...responseStatusNames
+	]).filter((name) => Boolean(name) && !exclude.has(name));
+	byResolver.set(cacheKey, result);
+	return result;
+}
+//#endregion
 //#region ../../internals/shared/src/group.ts
 /**
 * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
@@ -65,6 +468,826 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
+//#region ../../internals/client/src/builders/parser.ts
+/**
+* Returns `true` when any direction of the parser uses zod (used for dependency checks).
+*/
+function isParserEnabled(parser) {
+	if (!parser) return false;
+	if (parser === "zod") return true;
+	return Boolean(parser.request || parser.response);
+}
+//#endregion
+//#region ../../internals/client/src/resolveClient.ts
+/**
+* Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
+* operation, shared so the selection rules and diagnostics stay in one place.
+*
+* Every client runtime lives in a dedicated client plugin, so a consumer always calls a registered
+* contract client plugin (plugin-fetch or plugin-axios) and never emits its own inline client:
+*
+* - `contract` — a registered contract client plugin owns the `<op>` functions and the consumer
+*   imports and calls them.
+* - `error` — no client plugin is registered, several are registered without a selector, or the
+*   requested one is missing.
+*
+* The `client` string selects explicitly (`'fetch'` / `'axios'`); when it is unset a lone registered
+* contract client plugin is picked up automatically.
+*/
+const pluginFetchName = "plugin-fetch";
+const pluginAxiosName = "plugin-axios";
+const selectorToPlugin = {
+	fetch: pluginFetchName,
+	axios: pluginAxiosName
+};
+const contractPlugins = [pluginFetchName, pluginAxiosName];
+/**
+* Applies the `client` resolution rules. See the module comment for the strategy shape.
+*
+* @example
+* ```ts
+* resolveClient({ client: 'fetch', pluginNames: ['plugin-ts', 'plugin-fetch'] })
+* // { kind: 'contract', pluginName: 'plugin-fetch' }
+* ```
+*
+* @example
+* ```ts
+* resolveClient({ client: undefined, pluginNames: ['plugin-ts'] })
+* // { kind: 'error', message: 'No client plugin is registered…' }
+* ```
+*/
+function resolveClient(options) {
+	const { client, pluginNames } = options;
+	const has = (name) => pluginNames.includes(name);
+	if (client === "fetch" || client === "axios") {
+		const pluginName = selectorToPlugin[client];
+		if (!has(pluginName)) return {
+			kind: "error",
+			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`. Add it, or drop \`client\` to use a different client plugin.`
+		};
+		return {
+			kind: "contract",
+			pluginName
+		};
+	}
+	const registered = contractPlugins.filter(has);
+	if (registered.length === 1) return {
+		kind: "contract",
+		pluginName: registered[0]
+	};
+	if (registered.length > 1) return {
+		kind: "error",
+		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}). Set \`client: 'fetch' | 'axios'\` to choose which client the hooks call, or register a single client plugin.`
+	};
+	return {
+		kind: "error",
+		message: "No client plugin is registered. Add `@kubb/plugin-axios` or `@kubb/plugin-fetch` to `plugins` so the generated code has an HTTP client to call."
+	};
+}
+//#endregion
+//#region ../../internals/client/src/resolveClientOperation.ts
+/**
+* Resolves the contract client `<op>` a consumer (query hook, MCP handler) imports, by looking up
+* the registered contract client plugin's resolver and output. Works for any contract client plugin
+* (plugin-fetch or plugin-axios). Returns `null` when no contract plugin is in play (the inline
+* path). The plugin injects `.kubb/client.ts` at the global output root, the same path consumers
+* read `RequestConfig` / `ResponseErrorConfig` from.
+*/
+function resolveClientOperation(options) {
+	const { clientPlugin, driver, node, root, output } = options;
+	if (!clientPlugin) return null;
+	const resolver = driver.getResolver(clientPlugin.pluginName);
+	if (!resolver) return null;
+	const plugin = driver.getPlugin(clientPlugin.pluginName);
+	const file = resolver.resolveFile(operationFileEntry(node, node.operationId), {
+		root,
+		output: plugin?.options?.output ?? output,
+		group: plugin?.options?.group ?? void 0
+	});
+	return {
+		name: resolver.resolveName(node.operationId),
+		path: file.path,
+		clientPath: path.resolve(root, ".kubb/client.ts")
+	};
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/components/MutationKey.tsx
+const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
+const mutationKeyTransformer = ({ node }) => {
+	if (!node.path) return [];
+	return [`{ url: '${Url.toPath(node.path)}' }`];
+};
+function MutationKey$1({ name, node, transformer }) {
+	const paramsNode = createFunctionParameters({ params: [] });
+	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
+	const keys = (transformer ?? mutationKeyTransformer)({
+		node,
+		casing: "camelcase"
+	});
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function.Arrow, {
+			name,
+			export: true,
+			params: paramsSignature,
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	});
+}
+__name(MutationKey$1, "MutationKey");
+//#endregion
+//#region ../../internals/tanstack-query/src/utils.ts
+/**
+* The grouped request options, ordered for both the destructured signature and the
+* call passed to the underlying client.
+*/
+const requestGroupOrder = [
+	"path",
+	"query",
+	"body",
+	"headers"
+];
+/**
+* Builds the grouped `{ path, query, body, headers }` parameter that mirrors the client
+* function signature. Only the groups the operation carries are emitted, typed from the
+* operation's `RequestConfig`. `keys` narrows the emitted groups, used by the query key which
+* never carries `headers`.
+*
+* By default the whole group is typed as the single `RequestConfig` reference. When
+* `memberTypeWrapper` is set, each group is emitted as its own member typed from the matching
+* `RequestConfig['<group>']` slice and wrapped, used by vue-query to apply
+* `MaybeRefOrGetter` per group.
+*/
+function buildGroupedRequestParam(node, options) {
+	const { resolver, keys = requestGroupOrder, memberTypeWrapper } = options;
+	const { groups, hasRequiredPath, hasRequiredQuery, hasRequiredHeader } = getRequestGroupOptionality(node);
+	const names = keys.filter((key) => groups[key]);
+	if (names.length === 0) return null;
+	const requiredByGroup = {
+		path: hasRequiredPath,
+		query: hasRequiredQuery,
+		body: groups.body,
+		headers: hasRequiredHeader
+	};
+	const isOptional = names.every((name) => !requiredByGroup[name]);
+	const requestConfigName = resolver.resolveRequestConfigName(node);
+	const omittedKeys = requestGroupOrder.filter((key) => !keys.includes(key));
+	const requestConfigType = omittedKeys.length > 0 ? `Omit<${requestConfigName}, ${omittedKeys.map((key) => `'${key}'`).join(" | ")}>` : requestConfigName;
+	if (memberTypeWrapper) {
+		const members = names.map((name) => ({
+			name,
+			type: memberTypeWrapper(`${requestConfigType}['${name}']`),
+			optional: !requiredByGroup[name]
+		}));
+		return createFunctionParameter({
+			name: createObjectBindingPattern({ elements: names.map((name) => ({ name })) }),
+			type: createTypeLiteral({ members }),
+			optional: false,
+			...isOptional ? { default: "{}" } : {}
+		});
+	}
+	return createFunctionParameter({
+		name: createObjectBindingPattern({ elements: names.map((name) => ({ name })) }),
+		type: requestConfigType,
+		optional: false,
+		...isOptional ? { default: "{}" } : {}
+	});
+}
+/**
+* Builds the shared `({ path, query, body, headers }, config = {})` parameter list for a
+* TanStack query-options function. The leading parameter mirrors the client signature, and the
+* trailing `config` is a partial `RequestConfig` minus the grouped data-shape keys, which are passed
+* explicitly. Framework plugins wrap the result when needed, for example vue-query applies `MaybeRefOrGetter`.
+*/
+function buildQueryOptionsParams(node, options) {
+	const { resolver, memberTypeWrapper } = options;
+	return createFunctionParameters({ params: [buildGroupedRequestParam(node, {
+		resolver,
+		memberTypeWrapper
+	}), createFunctionParameter({
+		name: "config",
+		type: `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`,
+		default: "{}"
+	})].filter((param) => param !== null) });
+}
+/**
+* Builds the call to a client `<op>` function inside a query/mutation hook body. The function takes
+* a single grouped options object, so the operation's request groups are passed as
+* shorthand alongside the spread `config`, with `throwOnError: true` pinned last so a caller's config
+* can't flip the query's error semantics. Queries thread the TanStack `signal`; mutations omit it.
+*
+* @example
+* ```ts
+* buildClientCall(node, { clientName: 'getPetById', signal: true })
+* // getPetById({ path, ...config, signal: config.signal ?? signal, throwOnError: true })
+* ```
+*/
+function buildClientCall(node, options) {
+	const { clientName, signal = false } = options;
+	const { groups } = getRequestGroupOptionality(node);
+	return `${clientName}({ ${[
+		"...config",
+		...requestGroupOrder.filter((key) => groups[key]),
+		signal ? "signal: config.signal ?? signal" : null,
+		"throwOnError: true"
+	].filter((part) => part !== null).join(", ")} })`;
+}
+/**
+* Returns `'zod'` when response-direction parsing is enabled.
+* The string shorthand `'zod'` also enables response parsing.
+*/
+function resolveResponseParser(parser) {
+	if (!parser) return null;
+	if (parser === "zod") return "zod";
+	return parser.response ?? null;
+}
+/**
+* Returns `'zod'` when request body parsing is enabled.
+* The string shorthand `'zod'` also enables request body parsing (existing behavior).
+*/
+function resolveRequestParser(parser) {
+	if (!parser) return null;
+	if (parser === "zod") return "zod";
+	return parser.request ?? null;
+}
+/**
+* Returns `'zod'` when query-params parsing is enabled.
+* Only the object form `{ request: 'zod' }` enables this. `parser: 'zod'` does not.
+*/
+function resolveQueryParamsParser(parser) {
+	if (!parser || parser === "zod") return null;
+	return parser.request ?? null;
+}
+/**
+* Collects the Zod schema import names for an operation based on the active parser directions.
+*
+* - `parser: 'zod'`: response and request body names (backward-compatible behavior).
+* - `parser: { request: 'zod' }`: request body and query params names.
+* - `parser: { response: 'zod' }`: response name only.
+* - `parser: { request: 'zod', response: 'zod' }`: all three.
+*
+* Returns an empty array when no resolver is provided or `parser` is falsy.
+*/
+function resolveZodSchemaNames(node, zodResolver, parser) {
+	if (!zodResolver || !parser) return [];
+	const { query: queryParams } = getOperationParameters(node, { paramsCasing: "original" });
+	return [
+		resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
+		resolveRequestParser(parser) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
+		resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null
+	].filter((n) => Boolean(n));
+}
+/**
+* Build QueryKey params as the grouped `{ path, query, body }` object (NO headers, NO config),
+* typed from the operation's `RequestConfig` minus `url`. The query key transformer reads the
+* grouped `path`/`query`/`body` bindings.
+*/
+function buildQueryKeyParams(node, options) {
+	const { resolver } = options;
+	const groupedParam = buildGroupedRequestParam(node, {
+		resolver,
+		keys: [
+			"path",
+			"query",
+			"body"
+		]
+	});
+	return createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/components/QueryKey.tsx
+const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
+const queryKeyTransformer = ({ node }) => {
+	if (!node.path) return [];
+	const hasPathParams = getOperationParameters(node).path.length > 0;
+	const hasQueryParams = getOperationParameters(node).query.length > 0;
+	const hasRequestBody = !!node.requestBody?.content?.[0]?.schema;
+	return [
+		hasPathParams ? `{ url: '${Url.toPath(node.path)}', params: path }` : `{ url: '${Url.toPath(node.path)}' }`,
+		hasQueryParams ? "...(query ? [query] : [])" : null,
+		hasRequestBody ? "...(body ? [body] : [])" : null
+	].filter(Boolean);
+};
+function QueryKey({ name, node, tsResolver, typeName, transformer }) {
+	const paramsNode = buildQueryKeyParams(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
+	const keys = (transformer ?? queryKeyTransformer)({
+		node,
+		casing: "camelcase"
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function.Arrow, {
+			name,
+			export: true,
+			params: paramsSignature,
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	}), /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ jsx(Type, {
+			name: typeName,
+			children: `ReturnType<typeof ${name}>`
+		})
+	})] });
+}
+//#endregion
+//#region src/components/Mutation.tsx
+const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
+const callPrinter$1 = functionPrinter({ mode: "call" });
+function buildMutationParamsNode(node, options) {
+	const { mutationKeyTypeName, mutationArgTypeName, resolver } = options;
+	const responseName = resolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, resolver);
+	return createFunctionParameters({ params: [createFunctionParameter({
+		name: "options",
+		type: `{
+  mutation?: SWRMutationConfiguration<${responseName}, ${`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`}, ${mutationKeyTypeName} | null, ${mutationArgTypeName}> & { throwOnError?: boolean },
+  client?: ${buildRequestConfigType(node)},
+  shouldFetch?: boolean,
+}`,
+		default: "{}"
+	})] });
+}
+function Mutation({ name, clientName, mutationKeyName, mutationKeyTypeName, mutationArgTypeName, node, tsResolver }) {
+	const responseName = tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TData = responseName;
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const groupedParam = buildGroupedRequestParam(node, { resolver: tsResolver });
+	const hasMutationParams = groupedParam !== null;
+	const groupedParamsNode = createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
+	const argTypeBody = hasMutationParams ? tsResolver.resolveRequestConfigName(node) : "";
+	const argBindingStr = hasMutationParams ? callPrinter$1.print(groupedParamsNode) ?? "" : "";
+	const mutationFnBody = `const { data } = await ${buildClientCall(node, {
+		clientName,
+		signal: false
+	})}
+            return data`;
+	const generics = [
+		TData,
+		TError,
+		`${mutationKeyTypeName} | null`,
+		mutationArgTypeName
+	];
+	const paramsNode = buildMutationParamsNode(node, {
+		mutationKeyTypeName,
+		mutationArgTypeName,
+		resolver: tsResolver
+	});
+	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
+		name: mutationArgTypeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ jsx(Type, {
+			name: mutationArgTypeName,
+			export: true,
+			children: hasMutationParams ? argTypeBody : "never"
+		})
+	}), /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			JSDoc: { comments: buildOperationComments(node) },
+			children: `
+        const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {}
+        const mutationKey = ${mutationKeyName}()
+
+        return useSWRMutation<${generics.join(", ")}>(
+          shouldFetch ? mutationKey : null,
+          async (_url${hasMutationParams ? `, { arg: ${argBindingStr} }` : ""}) => {
+            ${mutationFnBody}
+          },
+          mutationOptions
+        )
+    `
+		})
+	})] });
+}
+//#endregion
+//#region src/components/MutationKey.tsx
+function MutationKey({ name, typeName, node, transformer }) {
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MutationKey$1, {
+		name,
+		node,
+		transformer
+	}), /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ jsx(Type, {
+			export: true,
+			name: typeName,
+			children: `ReturnType<typeof ${name}>`
+		})
+	})] });
+}
+//#endregion
+//#region src/components/QueryOptions.tsx
+const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
+function getQueryOptionsParams(node, options) {
+	return buildQueryOptionsParams(node, options);
+}
+function QueryOptions({ name, clientName, node, tsResolver }) {
+	const paramsNode = getQueryOptionsParams(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
+	const fetcherBody = `const { data } = await ${buildClientCall(node, {
+		clientName,
+		signal: false
+	})}
+          return data`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			children: `
+      return {
+        fetcher: async () => {
+          ${fetcherBody}
+        },
+      }
+`
+		})
+	});
+}
+//#endregion
+//#region src/components/Query.tsx
+const declarationPrinter = functionPrinter({ mode: "declaration" });
+const callPrinter = functionPrinter({ mode: "call" });
+function buildQueryParamsNode(node, options) {
+	const { resolver } = options;
+	const responseName = resolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, resolver);
+	const optionsParam = createFunctionParameter({
+		name: "options",
+		type: `{
+  query?: SWRConfiguration<${[responseName, `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`].join(", ")}>,
+  client?: ${buildClientOptionType()},
+  shouldFetch?: boolean,
+  immutable?: boolean
+}`,
+		default: "{}"
+	});
+	return createFunctionParameters({ params: [buildGroupedRequestParam(node, { resolver }), optionsParam].filter((param) => param !== null) });
+}
+function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver }) {
+	const responseName = tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const generics = [
+		responseName,
+		`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
+		`${queryKeyTypeName} | null`
+	];
+	const queryKeyParamsNode = buildQueryKeyParams(node, { resolver: tsResolver });
+	const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? "";
+	const queryOptionsParamsNode = getQueryOptionsParams(node, { resolver: tsResolver });
+	const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? "";
+	const paramsNode = buildQueryParamsNode(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			JSDoc: { comments: buildOperationComments(node) },
+			children: `
+       const { query: queryOptions, client: config = {}, shouldFetch = true, immutable } = options ?? {}
+
+       const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+
+       return useSWR<${generics.join(", ")}>(
+        shouldFetch ? queryKey : null,
+        {
+          ...${queryOptionsName}(${queryOptionsParamsCall}),
+          ...(immutable ? {
+              revalidateIfStale: false,
+              revalidateOnFocus: false,
+              revalidateOnReconnect: false
+            } : { }),
+          ...queryOptions,
+        }
+       )
+       `
+		})
+	});
+}
+//#endregion
+//#region src/generators/mutationGenerator.tsx
+/**
+* Built-in generator for `useSWRMutation` hooks. Emits one `useFooMutation` hook
+* per POST/PUT/DELETE operation (configurable via `mutation.methods`) plus
+* the matching `fooMutationKey` helper.
+*/
+const mutationGenerator = defineGenerator({
+	name: "swr-mutation",
+	renderer: jsxRenderer,
+	operation(node, ctx) {
+		if (!ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, parser, client, group } = ctx.options;
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(pluginTsName);
+		const isQuery = query === false || !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase());
+		const queryMethods = new Set(query ? query.methods : []);
+		if (!(mutation !== false && !isQuery && (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase()))) return null;
+		const importPath = mutation ? mutation.importPath : "swr/mutation";
+		const contractOp = resolveClientOperation({
+			clientPlugin: { pluginName: client.pluginName },
+			driver,
+			node,
+			root,
+			output
+		});
+		if (!contractOp) return null;
+		const mutationHookName = resolver.resolveMutationName(node);
+		const mutationKeyName = resolver.resolveMutationKeyName(node);
+		const mutationKeyTypeName = resolver.resolveMutationKeyTypeName(node);
+		const mutationArgTypeName = resolver.resolveMutationArgTypeName(node);
+		const meta = {
+			file: resolver.resolveFile({
+				name: mutationHookName,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path
+			}, {
+				root,
+				output,
+				group
+			}),
+			fileTs: tsResolver.resolveFile({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path
+			}, {
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group
+			})
+		};
+		const importedTypeNames = [tsResolver.resolveRequestConfigName(node), ...resolveOperationTypeNames(node, tsResolver, {
+			order: "body-response-first",
+			includeParams: false
+		})].filter((name) => Boolean(name));
+		const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : void 0;
+		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : void 0;
+		const fileZod = zodResolver ? zodResolver.resolveFile({
+			name: node.operationId,
+			extname: ".ts",
+			tag: node.tags[0] ?? "default",
+			path: node.path
+		}, {
+			root,
+			output: pluginZod?.options?.output ?? output,
+			group: pluginZod?.options?.group
+		}) : void 0;
+		const zodSchemaNames = resolveZodSchemaNames(node, zodResolver, parser);
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.resolveFooter(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				fileZod && zodSchemaNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: zodSchemaNames,
+					root: meta.file.path,
+					path: fileZod.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(MutationKey, {
+					name: mutationKeyName,
+					typeName: mutationKeyTypeName,
+					node,
+					transformer: ctx.options.mutationKey
+				}),
+				mutation && /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx(File.Import, {
+						name: "useSWRMutation",
+						path: importPath
+					}),
+					/* @__PURE__ */ jsx(File.Import, {
+						name: ["SWRMutationConfiguration"],
+						path: importPath,
+						isTypeOnly: true
+					}),
+					/* @__PURE__ */ jsx(Mutation, {
+						name: mutationHookName,
+						clientName: calledClientName,
+						mutationKeyName,
+						mutationKeyTypeName,
+						mutationArgTypeName,
+						node,
+						tsResolver
+					})
+				] })
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/queryGenerator.tsx
+const queryGenerator = defineGenerator({
+	name: "swr-query",
+	renderer: jsxRenderer,
+	operation(node, ctx) {
+		if (!ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, parser, client, group } = ctx.options;
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(pluginTsName);
+		const isQuery = query === false || !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase());
+		const queryMethods = new Set(query ? query.methods : []);
+		const isMutation = mutation !== false && !isQuery && (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase());
+		if (!isQuery || isMutation) return null;
+		const importPath = query ? query.importPath : "swr";
+		const contractOp = resolveClientOperation({
+			clientPlugin: { pluginName: client.pluginName },
+			driver,
+			node,
+			root,
+			output
+		});
+		if (!contractOp) return null;
+		const queryName = resolver.resolveQueryName(node);
+		const queryOptionsName = resolver.resolveQueryOptionsName(node);
+		const queryKeyName = resolver.resolveQueryKeyName(node);
+		const queryKeyTypeName = resolver.resolveQueryKeyTypeName(node);
+		const meta = {
+			file: resolver.resolveFile({
+				name: queryName,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path
+			}, {
+				root,
+				output,
+				group
+			}),
+			fileTs: tsResolver.resolveFile({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path
+			}, {
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group
+			})
+		};
+		const importedTypeNames = [tsResolver.resolveRequestConfigName(node), ...resolveOperationTypeNames(node, tsResolver, {
+			exclude: [queryKeyTypeName],
+			order: "body-response-first",
+			includeParams: false
+		})].filter((name) => Boolean(name));
+		const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : void 0;
+		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : void 0;
+		const fileZod = zodResolver ? zodResolver.resolveFile({
+			name: node.operationId,
+			extname: ".ts",
+			tag: node.tags[0] ?? "default",
+			path: node.path
+		}, {
+			root,
+			output: pluginZod?.options?.output ?? output,
+			group: pluginZod?.options?.group
+		}) : void 0;
+		const zodSchemaNames = resolveZodSchemaNames(node, zodResolver, parser);
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.resolveFooter(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				fileZod && zodSchemaNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: zodSchemaNames,
+					root: meta.file.path,
+					path: fileZod.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(QueryKey, {
+					name: queryKeyName,
+					typeName: queryKeyTypeName,
+					node,
+					tsResolver,
+					transformer: ctx.options.queryKey
+				}),
+				/* @__PURE__ */ jsx(QueryOptions, {
+					name: queryOptionsName,
+					clientName: calledClientName,
+					node,
+					tsResolver
+				}),
+				query && /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx(File.Import, {
+						name: "useSWR",
+						path: importPath
+					}),
+					/* @__PURE__ */ jsx(File.Import, {
+						name: ["SWRConfiguration"],
+						path: importPath,
+						isTypeOnly: true
+					}),
+					/* @__PURE__ */ jsx(Query, {
+						name: queryName,
+						queryOptionsName,
+						queryKeyName,
+						queryKeyTypeName,
+						node,
+						tsResolver
+					})
+				] })
+			]
+		});
+	}
+});
+//#endregion
 //#region src/resolvers/resolverSwr.ts
 function capitalize(name) {
 	return `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
@@ -124,10 +1347,8 @@ const pluginSwr = definePlugin((options) => {
 	const { output = {
 		path: "hooks",
 		barrel: { type: "named" }
-	}, group, exclude = [], include, override = [], parser = false, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", mutation = {}, query = {}, mutationKey = mutationKeyTransformer, queryKey = queryKeyTransformer, paramsCasing, client, resolver: userResolver, macros: userMacros, generators: userGenerators = [] } = options;
-	const clientName = client?.client ?? "axios";
-	const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : void 0);
-	const selectedGenerators = options.generators ?? [queryGenerator, mutationGenerator].filter((generator) => Boolean(generator));
+	}, group, exclude = [], include, override = [], parser = false, mutation = {}, query = {}, mutationKey = mutationKeyTransformer, queryKey = queryKeyTransformer, client, resolver: userResolver, macros: userMacros } = options;
+	const selectedGenerators = [queryGenerator, mutationGenerator].filter((generator) => Boolean(generator));
 	const groupConfig = createGroupConfig(group) ?? void 0;
 	return {
 		name: pluginSwrName,
@@ -138,17 +1359,18 @@ const pluginSwr = definePlugin((options) => {
 				...resolverSwr,
 				...userResolver
 			} : resolverSwr;
+			const resolvedClient = resolveClient({
+				client,
+				pluginNames: (ctx.config.plugins ?? []).map((p) => p.name).filter((name) => Boolean(name))
+			});
+			if (resolvedClient.kind === "error") throw new Error(resolvedClient.message);
+			const resolvedClientDescriptor = {
+				kind: "contract",
+				pluginName: resolvedClient.pluginName
+			};
 			ctx.setOptions({
 				output,
-				client: {
-					bundle: client?.bundle,
-					baseURL: client?.baseURL,
-					client: clientName,
-					clientType: client?.clientType ?? "function",
-					importPath: clientImportPath,
-					dataReturnType: client?.dataReturnType ?? "data",
-					paramsCasing
-				},
+				client: resolvedClientDescriptor,
 				queryKey,
 				query: query === false ? false : {
 					importPath: "swr",
@@ -167,9 +1389,6 @@ const pluginSwr = definePlugin((options) => {
 					...mutation
 				},
 				parser,
-				paramsType,
-				pathParamsType,
-				paramsCasing,
 				group: groupConfig,
 				exclude,
 				include,
@@ -179,29 +1398,6 @@ const pluginSwr = definePlugin((options) => {
 			ctx.setResolver(resolver);
 			if (userMacros?.length) ctx.setMacros(userMacros);
 			for (const gen of selectedGenerators) ctx.addGenerator(gen);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
-			const root = path.resolve(ctx.config.root, ctx.config.output.path);
-			const hasClientPlugin = !!ctx.config.plugins?.some((p) => p.name === pluginClientName);
-			if (client?.bundle && !hasClientPlugin && !clientImportPath) ctx.injectFile({
-				baseName: "client.ts",
-				path: path.resolve(root, ".kubb/client.ts"),
-				sources: [ast.factory.createSource({
-					name: "client",
-					nodes: [ast.factory.createText(clientName === "fetch" ? source$1 : source)],
-					isExportable: true,
-					isIndexable: true
-				})]
-			});
-			if (!hasClientPlugin) ctx.injectFile({
-				baseName: "config.ts",
-				path: path.resolve(root, ".kubb/config.ts"),
-				sources: [ast.factory.createSource({
-					name: "config",
-					nodes: [ast.factory.createText(source$2)],
-					isExportable: false,
-					isIndexable: false
-				})]
-			});
 		} }
 	};
 });