@kubb/plugin-client 5.7.0-canary.20261024T190549 → 5.7.1

package/dist/index.cjs

@@ -454,7 +454,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.7.0-canary.20261024T190549";
+var version = "5.7.1";
 //#endregion
 //#region ../../internals/client/src/builders/validatorOptions.ts
 /**
@@ -463,7 +463,7 @@ var version = "5.7.0-canary.20261024T190549";
 function isValidatorEnabled(validator) {
 	if (!validator) return false;
 	if (validator === "zod") return true;
-	return Boolean(validator.request || validator.response);
+	return Boolean(validator.request || validator.params || validator.response);
 }
 /**
 * Returns `'zod'` when request body parsing is enabled, `null` otherwise. The string shorthand
@@ -474,6 +474,14 @@ function resolveRequestValidator(validator) {
 	return validator.request ?? null;
 }
 /**
+* Returns `'zod'` when path, query, and header params parsing is enabled, `null` otherwise. Only the
+* object form `{ params: 'zod' }` enables it.
+*/
+function resolveParamsValidator(validator) {
+	if (!validator || validator === "zod") return null;
+	return validator.params ?? null;
+}
+/**
 * Returns `'zod'` when response parsing is enabled, `null` otherwise. The string shorthand `'zod'`
 * maps to response parsing.
 */
@@ -492,30 +500,6 @@ function buildZodErrorParse(node, zodResolver) {
 	return zodResolver.response.error?.(node) || null;
 }
 //#endregion
-//#region ../../internals/client/src/builders/validator.ts
-/**
-* Builds the validator-hook references for one operation. Request validation runs before the send;
-* response validation runs on the success body only. Returns `null` references when the matching
-* direction is disabled or the schema is absent.
-*/
-function buildValidatorHooks({ node, validator, zodResolver }) {
-	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
-	const parsesResponse = zodResolver && resolveResponseValidator(validator) === "zod";
-	const response = parsesResponse ? zodResolver.response.response(node) || null : null;
-	const error = parsesResponse ? buildZodErrorParse(node, zodResolver) : null;
-	const request = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body(node) || null : null;
-	return {
-		request,
-		response,
-		error,
-		importedZodNames: [
-			response,
-			error,
-			request
-		].filter((name) => Boolean(name))
-	};
-}
-//#endregion
 //#region ../../internals/client/src/builders/security.ts
 function serializeAuth(auth) {
 	const parts = [`type: '${auth.type}'`];
@@ -588,6 +572,49 @@ function buildSecurityMetadata({ security }) {
 	return `[${security.map(serializeAuth).join(", ")}]`;
 }
 //#endregion
+//#region ../../internals/client/src/builders/validator.ts
+/**
+* Builds the validator-hook references for one operation. Request body and params validation run before the send.
+* Response validation runs on the success body only. Returns `null` references when the matching
+* direction is disabled or the schema is absent.
+*/
+function buildValidatorHooks({ node, validator, zodResolver }) {
+	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const parsesResponse = zodResolver && resolveResponseValidator(validator) === "zod";
+	const response = parsesResponse ? zodResolver.response.response(node) || null : null;
+	const error = parsesResponse ? buildZodErrorParse(node, zodResolver) : null;
+	const request = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body(node) || null : null;
+	const paramGroups = getOperationParameters(node);
+	const resolveParamsName = (kind, params) => zodResolver && resolveParamsValidator(validator) === "zod" && params.length > 0 ? zodResolver.param[kind](node, params[0]) : null;
+	const path = resolveParamsName("path", paramGroups.path);
+	const query = resolveParamsName("query", paramGroups.query);
+	const headers = resolveParamsName("headers", paramGroups.header);
+	const importedZodNames = [
+		response,
+		error,
+		request,
+		path,
+		query,
+		headers
+	].filter((name) => Boolean(name));
+	return {
+		request,
+		path,
+		query,
+		headers: headers ? `toHeadersStandardSchema(${headers}, ${headers}.shape)` : null,
+		response,
+		error,
+		importedZodNames
+	};
+}
+/**
+* Prints the `validator: { … }` entry of a call config from the hooks named in `keys`, or `null` when none is set.
+*/
+function buildValidatorLiteral(hooks, keys) {
+	const entries = keys.flatMap((key) => hooks?.[key] ? [`${key}: ${hooks[key]}`] : []);
+	return entries.length ? `validator: { ${entries.join(", ")} }` : null;
+}
+//#endregion
 //#region ../../internals/client/src/builders/contentType.ts
 /**
 * Builds the `contentType` entry baked into the call config, or `null` for the JSON default.
@@ -792,12 +819,14 @@ function Operation({ name, node, types, zodResolver, validator, returnType, thro
 	const eventStream = isEventStream(node);
 	const responseType = getResponseType(node);
 	const responseTypeLiteral = responseType ? `responseType: '${responseType}'` : null;
-	const validatorEntries = [
-		validators.request ? `request: ${validators.request}` : null,
-		validators.response ? `response: ${validators.response}` : null,
-		validators.error ? `error: ${validators.error}` : null
-	].filter(Boolean);
-	const validatorLiteral = validatorEntries.length ? `validator: { ${validatorEntries.join(", ")} }` : null;
+	const validatorLiteral = buildValidatorLiteral(validators, [
+		"request",
+		"path",
+		"query",
+		"headers",
+		"response",
+		"error"
+	]);
 	const callConfig = `{ ${[
 		`method: '${node.method.toUpperCase()}'`,
 		`url: '${node.path}'`,
@@ -844,14 +873,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
@@ -861,16 +911,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",
@@ -879,15 +929,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
@@ -909,14 +956,15 @@ function createClientGenerator(name, resolveClientPath) {
 			const { config, driver, resolver, root } = ctx;
 			const { output, validator, returnType, throwOnErrorDefault, group } = ctx.options;
 			const types = resolveOperationTypes(driver, ctx.plugin.name);
-			const pluginZod = resolveResponseValidator(validator) === "zod" || resolveRequestValidator(validator) === "zod" ? driver.getPlugin(_kubb_plugin_zod.pluginZodName) : null;
+			const pluginZod = isValidatorEnabled(validator) ? driver.getPlugin(_kubb_plugin_zod.pluginZodName) : null;
 			const zodResolver = pluginZod ? driver.getResolver(_kubb_plugin_zod.pluginZodName) : null;
 			const importedTypeNames = [types.response.options(node), types.response.responses(node)];
-			const importedZodNames = buildValidatorHooks({
+			const validatorHooks = buildValidatorHooks({
 				node,
 				validator,
 				zodResolver
-			}).importedZodNames;
+			});
+			const importedZodNames = validatorHooks.importedZodNames;
 			const meta = {
 				name: resolver.name(node.operationId),
 				file: resolver.file({
@@ -948,6 +996,7 @@ function createClientGenerator(name, resolveClientPath) {
 			const customClientPath = resolveClientPath?.(ctx.options, root);
 			const clientPath = customClientPath ?? node_path.default.resolve(root, ".kubb/client.ts");
 			const clientRoot = customClientPath === void 0 ? meta.file.path : void 0;
+			const standardSchemaPath = customClientPath ?? node_path.default.resolve(root, ".kubb/standardSchema.ts");
 			const eventStream = isEventStream(node);
 			const clientValueImports = (() => {
 				if (eventStream) return ["client", "toEventStream"];
@@ -1012,6 +1061,11 @@ function createClientGenerator(name, resolveClientPath) {
 						root: meta.file.path,
 						path: meta.fileZod.path
 					}),
+					validatorHooks.headers && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+						name: ["toHeadersStandardSchema"],
+						root: clientRoot,
+						path: standardSchemaPath
+					}),
 					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Operation, {
 						name: meta.name,
 						node,