@kubb/plugin-react-query 5.11.0-canary.20261109T211530 → 5.11.0-canary.20261109T224728

package/dist/index.cjs

@@ -26,8 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 let _kubb_kit = require("@kubb/kit");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
-let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
+let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
 let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
 let node_fs = require("node:fs");
 node_fs = __toESM(node_fs, 1);
@@ -550,78 +550,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.11.0-canary.20261109T211530";
-// ../../internals/client/src/resolveOperationTypes.ts
-const pluginZodName = "plugin-zod";
-/**
-* A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
-* exports next to each schema, so code written against `plugin-ts` names picks up the zod types.
-*/
-function toZodTypeResolver(resolver) {
-	const type = (name) => resolver.schema.type(name);
-	return {
-		...resolver,
-		file: resolver.file.bind(resolver),
-		memo: (key, compute) => resolver.memo(`zodTypes:${key}`, compute),
-		param: {
-			name: (node, p) => type(resolver.param.name(node, p)),
-			path: (node, p) => type(resolver.param.path(node, p)),
-			query: (node, p) => type(resolver.param.query(node, p)),
-			headers: (node, p) => type(resolver.param.headers(node, p)),
-			cookies: (node, p) => type(resolver.param.cookies(node, p))
-		},
-		response: {
-			body: (node) => type(resolver.response.body(node)),
-			status: (node, statusCode) => type(resolver.response.status(node, statusCode)),
-			response: (node) => type(resolver.response.response(node)),
-			responses: (node) => type(resolver.response.responses(node)),
-			options: (node) => resolver.response.options(node)
-		}
-	};
-}
-/**
-* Picks the plugin generated clients, query hooks, and MCP handlers take their operation types from.
-*
-* `pluginZod({ inferred: 'codec' })` wins, so a codec param takes its domain value. Otherwise `plugin-ts`
-* wins when it is in the pipeline, and without it any `pluginZod({ inferred })`. Throws
-* `KUBB_MISSING_DEPENDENCY` for `pluginName` when neither is available.
-*
-* @example
-* ```ts
-* const types = resolveOperationTypes(ctx.driver, ctx.plugin.name)
-* types.response.options(node) // 'GetPetByIdOptions', or 'GetPetByIdOptionsSchemaType' from zod
-* ```
-*/
-function resolveOperationTypes(driver, pluginName) {
-	return driver.memo(`operationTypes:${pluginName}`, () => {
-		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
-		const pluginZod = driver.getPlugin(pluginZodName);
-		if (pluginTs && pluginZod?.options?.inferred !== "codec") {
-			const resolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
-			return {
-				response: resolver.response,
-				resolver,
-				output: pluginTs.options?.output,
-				group: pluginTs.options?.group ?? void 0
-			};
-		}
-		if (!pluginZod?.options?.inferred) throw new _kubb_kit.Diagnostics.Error({
-			code: _kubb_kit.Diagnostics.code.missingDependency,
-			severity: "error",
-			message: `Plugin "${pluginName}" has no source for operation types.`,
-			help: `Add \`pluginTs()\` before "${pluginName}", or add \`pluginZod({ inferred: true })\`.`,
-			location: { kind: "config" },
-			plugin: pluginName
-		});
-		const resolver = toZodTypeResolver(driver.getResolver(pluginZodName));
-		return {
-			response: resolver.response,
-			resolver,
-			output: pluginZod.options.output,
-			group: pluginZod.options.group ?? void 0
-		};
-	});
-}
+var version = "5.11.0-canary.20261109T224728";
 // ../../internals/client/src/resolveClient.ts
 /**
 * Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
@@ -795,6 +724,77 @@ function resolveClientOperation(options) {
 		};
 	});
 }
+// ../../internals/client/src/resolveOperationTypes.ts
+const pluginZodName = "plugin-zod";
+/**
+* A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
+* exports next to each schema, so code written against `plugin-ts` names picks up the zod types.
+*/
+function toZodTypeResolver(resolver) {
+	const type = (name) => resolver.schema.type(name);
+	return {
+		...resolver,
+		file: resolver.file.bind(resolver),
+		memo: (key, compute) => resolver.memo(`zodTypes:${key}`, compute),
+		param: {
+			name: (node, p) => type(resolver.param.name(node, p)),
+			path: (node, p) => type(resolver.param.path(node, p)),
+			query: (node, p) => type(resolver.param.query(node, p)),
+			headers: (node, p) => type(resolver.param.headers(node, p)),
+			cookies: (node, p) => type(resolver.param.cookies(node, p))
+		},
+		response: {
+			body: (node) => type(resolver.response.body(node)),
+			status: (node, statusCode) => type(resolver.response.status(node, statusCode)),
+			response: (node) => type(resolver.response.response(node)),
+			responses: (node) => type(resolver.response.responses(node)),
+			options: (node) => resolver.response.options(node)
+		}
+	};
+}
+/**
+* Picks the plugin generated clients, query hooks, and MCP handlers take their operation types from.
+*
+* `pluginZod({ inferred: 'codec' })` wins, so a codec param takes its domain value. Otherwise `plugin-ts`
+* wins when it is in the pipeline, and without it any `pluginZod({ inferred })`. Throws
+* `KUBB_MISSING_DEPENDENCY` for `pluginName` when neither is available.
+*
+* @example
+* ```ts
+* const types = resolveOperationTypes(ctx.driver, ctx.plugin.name)
+* types.response.options(node) // 'GetPetByIdOptions', or 'GetPetByIdOptionsSchemaType' from zod
+* ```
+*/
+function resolveOperationTypes(driver, pluginName) {
+	return driver.memo(`operationTypes:${pluginName}`, () => {
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		const pluginZod = driver.getPlugin(pluginZodName);
+		if (pluginTs && pluginZod?.options?.inferred !== "codec") {
+			const resolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+			return {
+				response: resolver.response,
+				resolver,
+				output: pluginTs.options?.output,
+				group: pluginTs.options?.group ?? void 0
+			};
+		}
+		if (!pluginZod?.options?.inferred) throw new _kubb_kit.Diagnostics.Error({
+			code: _kubb_kit.Diagnostics.code.missingDependency,
+			severity: "error",
+			message: `Plugin "${pluginName}" has no source for operation types.`,
+			help: `Add \`pluginTs()\` before "${pluginName}", or add \`pluginZod({ inferred: true })\`.`,
+			location: { kind: "config" },
+			plugin: pluginName
+		});
+		const resolver = toZodTypeResolver(driver.getResolver(pluginZodName));
+		return {
+			response: resolver.response,
+			resolver,
+			output: pluginZod.options.output,
+			group: pluginZod.options.group ?? void 0
+		};
+	});
+}
 // ../../internals/tanstack-query/src/components/HookFile.tsx
 /**
 * Resolves what every TanStack hook file shares: its file, the operation types file and names (`@kubb/plugin-ts`, or