@kubb/plugin-swr 5.0.0-alpha.8 → 5.0.0-beta.100

package/dist/index.js

@@ -1,144 +1,1212 @@
-import "./chunk--u3MIqq1.js";
-import { a as MutationKey, i as QueryKey, o as camelCase, s as pascalCase } from "./components-DRDGvgXG.js";
-import { n as mutationGenerator, t as queryGenerator } from "./generators-CRSl6u2M.js";
+import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
+import { Resolver, Url, ast, createResolver, defineGenerator, definePlugin } from "kubb/kit";
 import path from "node:path";
-import { createPlugin, getBarrelFiles, getMode } from "@kubb/core";
-import { 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 { OperationGenerator, pluginOasName } from "@kubb/plugin-oas";
-import { pluginTsName } from "@kubb/plugin-ts";
-import { pluginZodName } from "@kubb/plugin-zod";
+import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+import { File, Function, Type, jsxRenderer } from "kubb/jsx";
+import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
+//#region ../../internals/shared/src/params.ts
+/**
+* Drops parameters that share the same name, keeping the first.
+*
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
+*/
+function dedupeParams(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
+		return true;
+	});
+}
+//#endregion
+//#region ../../internals/shared/src/operation.ts
+/**
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.file`: 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.file(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;
+	return node.path ? `{@link ${Url.toPath(node.path)}}` : null;
+}
+/**
+* Derives the shared `ContentTypeInfo` shape from a list of content types, tracking whether several
+* are present and the union, default, and form-data flags the client uses to pick one.
+*/
+function buildContentTypeInfo(contentTypes) {
+	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 getContentTypeInfo(node) {
+	return buildContentTypeInfo(node.requestBody?.content?.map((e) => e.contentType) ?? []);
+}
+/**
+* The request-body counterpart for the primary success response: the content types it documents and
+* whether several are present, so the client can let a caller pick which one to accept.
+*/
+function getResponseContentTypeInfo(node) {
+	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
+}
+function buildRequestConfigType(node) {
+	const request = getContentTypeInfo(node);
+	const response = getResponseContentTypeInfo(node);
+	const configType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+	const members = [request.isMultipleContentTypes ? `request?: ${request.contentTypeUnion}` : null, response.isMultipleContentTypes ? `response?: ${response.contentTypeUnion}` : null].filter(Boolean);
+	return members.length ? `${configType} & { contentType?: { ${members.join("; ")} } }` : 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) {
+	return {
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
+	};
+}
+function getStatusCodeNumber(statusCode) {
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? null : code;
+}
+function isSuccessStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 200 && code < 300;
+}
+function isErrorStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 400;
+}
+function getSuccessResponses(responses) {
+	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
+}
+function getOperationSuccessResponses(node) {
+	return getSuccessResponses(node.responses);
+}
+function getPrimarySuccessResponse(node) {
+	return getOperationSuccessResponses(node)[0] ?? null;
+}
+function resolveErrorNames(node, resolver) {
+	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.response.status(node, response.statusCode));
+}
+function resolveStatusCodeNames(node, resolver) {
+	return node.responses.map((response) => resolver.response.status(node, response.statusCode));
+}
+const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
+function resolveOperationTypeNames(node, resolver, options = {}) {
+	const cacheKey = `${node.operationId}\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);
+	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.param.path(node, param)),
+		...query.map((param) => resolver.param.query(node, param)),
+		...header.map((param) => resolver.param.headers(node, param))
+	];
+	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.response.body(node) : null, resolver.response.response(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/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);
+}
+/**
+* Uppercases only the first character of `text`, leaving the rest untouched.
+* Unlike {@link pascalCase} it never re-splits word boundaries or strips characters.
+*
+* @example
+* `capitalize('getPetById') // 'GetPetById'`
+*/
+function capitalize(text) {
+	return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
+}
+//#endregion
+//#region ../../internals/shared/src/group.ts
+/**
+* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
+* shared default naming so every plugin groups output consistently:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
+*
+* A user-provided `group.name` always wins over the default namer, so callers stay in
+* control of their output folders. Returns `null` when grouping is disabled, matching the
+* per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+*
+* @example
+* ```ts
+* createGroupConfig(group) // shared across every plugin
+* ```
+*/
+function createGroupConfig(group) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return camelCase(ctx.group);
+	};
+	return {
+		...group,
+		name: group.name ? group.name : defaultName
+	};
+}
+//#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."
+	};
+}
+/**
+* Resolves the contract client during a consumer plugin's setup hook. Extracts the plugin names
+* from the raw `plugins` config, applies {@link resolveClient}, and throws the diagnostic on a
+* misconfiguration so every consumer fails fast with the same message.
+*/
+function resolveContractClient(options) {
+	const { client, plugins = [] } = options;
+	const resolved = resolveClient({
+		client,
+		pluginNames: plugins.map((plugin) => plugin.name).filter((name) => Boolean(name))
+	});
+	if (resolved.kind === "error") throw new Error(resolved.message);
+	return resolved;
+}
+//#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);
+	const plugin = driver.getPlugin(clientPlugin.pluginName);
+	const file = resolver.file({
+		...operationFileEntry(node, node.operationId),
+		root,
+		output: plugin?.options?.output ?? output,
+		group: plugin?.options?.group ?? void 0
+	});
+	return {
+		name: resolver.name(node.operationId),
+		path: file.path,
+		clientPath: path.resolve(root, ".kubb/client.ts")
+	};
+}
+//#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 `Options`. `keys` narrows the emitted groups, used by the query key which
+* never carries `headers`.
+*
+* By default the whole group is typed as the single `Options` reference. When
+* `memberTypeWrapper` is set, each group is emitted as its own member typed from the matching
+* `Options['<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 optionsName = resolver.response.options(node);
+	const omittedKeys = requestGroupOrder.filter((key) => !keys.includes(key));
+	const optionsType = omittedKeys.length > 0 ? `Omit<${optionsName}, ${omittedKeys.map((key) => `'${key}'`).join(" | ")}>` : optionsName;
+	if (memberTypeWrapper) {
+		const members = names.map((name) => ({
+			name,
+			type: memberTypeWrapper(`${optionsType}['${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: optionsType,
+		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.
+*
+* When `unwrapName` is set, each request group is passed as an explicit member unwrapped through it,
+* used by vue-query to resolve refs and getters with `toValue(...)` at call time.
+*
+* @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, unwrapName } = options;
+	const { groups } = getRequestGroupOptionality(node);
+	return `${clientName}({ ${[
+		"...config",
+		...requestGroupOrder.filter((key) => groups[key]).map((name) => unwrapName ? `${name}: ${unwrapName(name)}` : name),
+		signal ? "signal: config.signal ?? signal" : null,
+		"throwOnError: true"
+	].filter((part) => part !== null).join(", ")} })`;
+}
+/**
+* Applies the shared query defaults during plugin setup: `false` disables query generation, and an
+* object merges over `methods: ['GET']` and the plugin's runtime `importPath`.
+*/
+function resolveQueryConfig(query, options) {
+	if (query === false) return false;
+	return {
+		importPath: options.importPath,
+		methods: ["GET"],
+		...query
+	};
+}
+/**
+* Applies the shared mutation defaults during plugin setup: `false` disables mutation generation,
+* and an object merges over `methods: ['POST', 'PUT', 'PATCH', 'DELETE']` and the plugin's runtime
+* `importPath`.
+*/
+function resolveMutationConfig(mutation, options) {
+	if (mutation === false) return false;
+	return {
+		importPath: options.importPath,
+		methods: [
+			"POST",
+			"PUT",
+			"PATCH",
+			"DELETE"
+		],
+		...mutation
+	};
+}
+/**
+* Classifies an operation as a query or a mutation from the resolved `query` / `mutation` method lists.
+* `query: false` still marks the operation as a query so the query-family generators keep matching it,
+* and a method already claimed by `query` never counts as a mutation.
+*/
+function classifyOperation(node, { query, mutation }) {
+	const isQuery = query === false || !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase());
+	const queryMethods = new Set(query ? query.methods : []);
+	return {
+		isQuery,
+		isMutation: mutation !== false && !isQuery && (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase())
+	};
+}
+/**
+* Build QueryKey params as the grouped `{ path, query, body }` object (NO headers, NO config),
+* typed from the operation's `Options` 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/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/resolver.ts
+/**
+* Builds the shared query namespace for a variant. Spread the result into
+* `createResolver` once per variant the plugin supports.
+*
+* @example
+* ```ts
+* createResolver<PluginReactQuery>({
+*   query: createQueryResolver(),
+*   suspenseQuery: createQueryResolver('Suspense'),
+* })
+* ```
+*/
+function createQueryResolver(variant = "") {
+	return {
+		name(node) {
+			return `use${capitalize(this.name(node.operationId))}${variant}`;
+		},
+		optionsName(node) {
+			return `${this.name(node.operationId)}${variant}QueryOptions`;
+		},
+		keyName(node) {
+			return `${this.name(node.operationId)}${variant}QueryKey`;
+		},
+		keyTypeName(node) {
+			return `${capitalize(this.name(node.operationId))}${variant}QueryKey`;
+		},
+		clientName(node) {
+			return `${this.name(node.operationId)}${variant}`;
+		}
+	};
+}
+/**
+* Builds the shared mutation namespace. Spread the result into
+* `createResolver` and add plugin-specific methods (`optionsName`,
+* `typeName`, `argTypeName`) next to it.
+*
+* @example
+* ```ts
+* createResolver<PluginSwr>({ mutation: { ...createMutationResolver(), argTypeName(node) {...} } })
+* ```
+*/
+function createMutationResolver() {
+	return {
+		name(node) {
+			return `use${capitalize(this.name(node.operationId))}`;
+		},
+		keyName(node) {
+			return `${this.name(node.operationId)}MutationKey`;
+		}
+	};
+}
+//#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.response.response(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.response.response(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.response.options(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/Query.tsx
+const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
+const callPrinter = functionPrinter({ mode: "call" });
+function buildQueryParamsNode(node, options) {
+	const { resolver } = options;
+	const responseName = resolver.response.response(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.response.response(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 = buildQueryOptionsParams(node, { resolver: tsResolver });
+	const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? "";
+	const paramsNode = buildQueryParamsNode(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$1.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/components/QueryOptions.tsx
+const declarationPrinter = functionPrinter({ mode: "declaration" });
+function QueryOptions({ name, clientName, node, tsResolver }) {
+	const paramsNode = buildQueryOptionsParams(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter.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/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, client, group } = ctx.options;
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(pluginTsName);
+		const { isMutation } = classifyOperation(node, {
+			query,
+			mutation
+		});
+		if (!isMutation) 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.mutation.name(node);
+		const mutationKeyName = resolver.mutation.keyName(node);
+		const mutationKeyTypeName = resolver.mutation.keyTypeName(node);
+		const mutationArgTypeName = resolver.mutation.argTypeName(node);
+		const meta = {
+			file: resolver.file({
+				name: mutationHookName,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path,
+				root,
+				output,
+				group
+			}),
+			fileTs: tsResolver.file({
+				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.response.options(node), ...resolveOperationTypeNames(node, tsResolver, {
+			order: "body-response-first",
+			includeParams: false
+		})].filter((name) => Boolean(name));
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__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
+/**
+* Built-in generator for `useSWR` hooks. Emits one `useFoo` hook per read operation plus the
+* matching `fooQueryKey` helper and `fooQueryOptions` factory.
+*/
+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, client, group } = ctx.options;
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(pluginTsName);
+		const { isQuery } = classifyOperation(node, {
+			query,
+			mutation
+		});
+		if (!isQuery) 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.query.name(node);
+		const queryOptionsName = resolver.query.optionsName(node);
+		const queryKeyName = resolver.query.keyName(node);
+		const queryKeyTypeName = resolver.query.keyTypeName(node);
+		const meta = {
+			file: resolver.file({
+				name: queryName,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path,
+				root,
+				output,
+				group
+			}),
+			fileTs: tsResolver.file({
+				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.response.options(node), ...resolveOperationTypeNames(node, tsResolver, {
+			exclude: [queryKeyTypeName],
+			order: "body-response-first",
+			includeParams: false
+		})].filter((name) => Boolean(name));
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__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
+/**
+* Default resolver used by `@kubb/plugin-swr`. Decides the names and file paths for every generated
+* SWR hook (`useFoo`, `useFooMutation`) and its companion helpers (`fooQueryKey`, `fooQueryOptions`,
+* `fooMutationKey`).
+*
+* Functions and files use the built-in camelCase casing; hooks get the `use` prefix.
+*
+* @example Resolve hook and helper names
+* ```ts
+* import { resolverSwr } from '@kubb/plugin-swr'
+*
+* resolverSwr.query.name(operationNode)       // 'useGetPetById'
+* resolverSwr.query.keyName(operationNode)     // 'getPetByIdQueryKey'
+* resolverSwr.mutation.name(operationNode)     // 'useUpdatePet'
+* ```
+*/
+const resolverSwr = createResolver({
+	pluginName: "plugin-swr",
+	query: createQueryResolver(),
+	mutation: {
+		...createMutationResolver(),
+		keyTypeName(node) {
+			return `${capitalize(this.name(node.operationId))}MutationKey`;
+		},
+		argTypeName(node) {
+			return `${capitalize(this.name(node.operationId))}MutationArg`;
+		}
+	}
+});
+//#endregion
 //#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-swr`. Used for driver lookups and cross-plugin
+* dependency references.
+*/
 const pluginSwrName = "plugin-swr";
-const pluginSwr = createPlugin((options) => {
+/**
+* Generates SWR hooks from OpenAPI operations. Read operations become `useFoo` hooks built on
+* `useSWR` and write operations become `useFoo` hooks built on `useSWRMutation`, wrapping the
+* client functions from `@kubb/plugin-axios` or `@kubb/plugin-fetch`.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'kubb/config'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginSwr } from '@kubb/plugin-swr'
+*
+* export default defineConfig({
+*   input: './petStore.yaml',
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginSwr({ output: { path: './hooks' } }),
+*   ],
+* })
+* ```
+*/
+const pluginSwr = definePlugin((options) => {
 	const { output = {
 		path: "hooks",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], parser = "client", transformers = {}, query, mutation, client, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", mutationKey = MutationKey.getTransformer, queryKey = QueryKey.getTransformer, generators = [queryGenerator, mutationGenerator].filter(Boolean), paramsCasing, contentType } = options;
-	const clientName = client?.client ?? "axios";
-	const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : void 0);
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], mutation = {}, query = {}, mutationKey = mutationKeyTransformer, queryKey = queryKeyTransformer, client, resolver: userResolver, macros: userMacros } = options;
+	const selectedGenerators = [queryGenerator, mutationGenerator];
+	const groupConfig = createGroupConfig(group) ?? void 0;
 	return {
 		name: pluginSwrName,
-		options: {
-			output,
-			client: {
-				bundle: client?.bundle,
-				baseURL: client?.baseURL,
-				client: clientName,
-				clientType: client?.clientType ?? "function",
-				importPath: clientImportPath,
-				dataReturnType: client?.dataReturnType ?? "data",
-				paramsCasing
-			},
-			queryKey,
-			query: query === false ? false : {
-				importPath: "swr",
-				methods: ["get"],
-				...query
-			},
-			mutationKey,
-			mutation: mutation === false ? false : {
-				importPath: "swr/mutation",
-				methods: [
-					"post",
-					"put",
-					"delete",
-					"patch"
-				],
-				...mutation
-			},
-			parser,
-			paramsType,
-			pathParamsType,
-			paramsCasing,
-			group
-		},
-		pre: [
-			pluginOasName,
-			pluginTsName,
-			parser === "zod" ? pluginZodName : void 0
-		].filter(Boolean),
-		resolvePath(baseName, pathMode, options) {
-			const root = path.resolve(this.config.root, this.config.output.path);
-			if ((pathMode ?? getMode(path.resolve(root, output.path))) === "single")
- /**
-			* when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-			* Other plugins then need to call addOrAppend instead of just add from the fileManager class
-			*/
-			return path.resolve(root, output.path);
-			if (group && (options?.group?.path || options?.group?.tag)) {
-				const groupName = group?.name ? group.name : (ctx) => {
-					if (group?.type === "path") return `${ctx.group.split("/")[1]}`;
-					return `${camelCase(ctx.group)}Controller`;
-				};
-				return path.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
-			}
-			return path.resolve(root, output.path, baseName);
-		},
-		resolveName(name, type) {
-			let resolvedName = camelCase(name);
-			if (type === "file" || type === "function") resolvedName = camelCase(name, { isFile: type === "file" });
-			if (type === "type") resolvedName = pascalCase(name);
-			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
-			return resolvedName;
-		},
-		async install() {
-			const root = path.resolve(this.config.root, this.config.output.path);
-			const mode = getMode(path.resolve(root, output.path));
-			const oas = await this.getOas();
-			const baseURL = await this.getBaseURL();
-			if (baseURL) this.plugin.options.client.baseURL = baseURL;
-			const hasClientPlugin = !!this.driver.getPluginByName(pluginClientName);
-			if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) await this.upsertFile({
-				baseName: "fetch.ts",
-				path: path.resolve(root, ".kubb/fetch.ts"),
-				sources: [{
-					name: "fetch",
-					value: this.plugin.options.client.client === "fetch" ? source$1 : source,
-					isExportable: true,
-					isIndexable: true
-				}],
-				imports: [],
-				exports: []
-			});
-			if (!hasClientPlugin) await this.addFile({
-				baseName: "config.ts",
-				path: path.resolve(root, ".kubb/config.ts"),
-				sources: [{
-					name: "config",
-					value: source$2,
-					isExportable: false,
-					isIndexable: false
-				}],
-				imports: [],
-				exports: []
-			});
-			const files = await new OperationGenerator(this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				driver: this.driver,
-				events: this.events,
-				plugin: this.plugin,
-				contentType,
+		options,
+		dependencies: [pluginTsName],
+		hooks: { "kubb:plugin:setup"(ctx) {
+			const resolver = userResolver ? Resolver.merge(resolverSwr, userResolver) : resolverSwr;
+			ctx.setOptions({
+				output,
+				client: resolveContractClient({
+					client,
+					plugins: ctx.config.plugins
+				}),
+				queryKey,
+				query: resolveQueryConfig(query, { importPath: "swr" }),
+				mutationKey,
+				mutation: resolveMutationConfig(mutation, { importPath: "swr/mutation" }),
+				group: groupConfig,
 				exclude,
 				include,
 				override,
-				mode
-			}).build(...generators);
-			await this.upsertFile(...files);
-			const barrelFiles = await getBarrelFiles(this.fabric.files, {
-				type: output.barrelType ?? "named",
-				root,
-				output,
-				meta: { pluginName: this.plugin.name }
+				resolver
 			});
-			await this.upsertFile(...barrelFiles);
-		}
+			ctx.setResolver(resolver);
+			if (userMacros?.length) ctx.setMacros(userMacros);
+			ctx.addGenerator(...selectedGenerators);
+		} }
 	};
 });
 //#endregion
-export { pluginSwr, pluginSwrName };
+export { pluginSwr as default, pluginSwr, pluginSwrName, resolverSwr };
 
 //# sourceMappingURL=index.js.map