@kubb/plugin-fetch 5.9.0 → 5.10.0-canary.20261024T203516

package/dist/index.cjs

@@ -882,14 +882,35 @@ function Operation({ name, node, types, zodResolver, validator, returnType, thro
 //#endregion
 //#region ../../internals/client/src/resolveOperationTypes.ts
 /**
-* Picks the plugin a generated client takes its `Options` and `Responses` types from.
+* 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),
+		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))
+		},
+		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.
 *
-* `plugin-ts` wins whenever it is in the pipeline, so existing configs keep the types they generate
-* today. Without it, `pluginZod({ inferred: true })` takes over: its inferred options and responses
-* types are built from the same shared schemas as the `plugin-ts` ones, so a client typed off
-* `z.infer` carries what the codecs decode to (a `Temporal` instance, a `Date`) rather than the raw
-* wire type. Throws `KUBB_MISSING_DEPENDENCY` for `pluginName` when neither is available, since the
-* client has nothing to type against.
+* `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
@@ -899,16 +920,16 @@ function Operation({ name, node, types, zodResolver, validator, returnType, thro
 */
 function resolveOperationTypes(driver, pluginName) {
 	const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
-	if (pluginTs) {
+	const pluginZod = driver.getPlugin(_kubb_plugin_zod.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
+			group: pluginTs.options?.group ?? void 0
 		};
 	}
-	const pluginZod = driver.getPlugin(_kubb_plugin_zod.pluginZodName);
 	if (!pluginZod?.options?.inferred) throw new kubb_kit.Diagnostics.Error({
 		code: kubb_kit.Diagnostics.code.missingDependency,
 		severity: "error",
@@ -917,15 +938,12 @@ function resolveOperationTypes(driver, pluginName) {
 		location: { kind: "config" },
 		plugin: pluginName
 	});
-	const resolver = driver.getResolver(_kubb_plugin_zod.pluginZodName);
+	const resolver = toZodTypeResolver(driver.getResolver(_kubb_plugin_zod.pluginZodName));
 	return {
-		response: {
-			options: resolver.response.options,
-			responses: (node) => resolver.schema.type(resolver.response.responses(node))
-		},
+		response: resolver.response,
 		resolver,
 		output: pluginZod.options.output,
-		group: pluginZod.options.group
+		group: pluginZod.options.group ?? void 0
 	};
 }
 //#endregion
@@ -1488,7 +1506,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.9.0";
+var version = "5.10.0-canary.20261024T203516";
 //#endregion
 //#region src/templates.ts
 /** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */