@kubb/plugin-fetch 5.6.0 → 5.6.2

package/dist/index.js

@@ -1,29 +1,11 @@
 import "./rolldown-runtime-C0LytTxp.js";
-import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, injectFile, macroSimplifyUnion, setMacros, setResolver, useConfig } from "kubb/kit";
+import { Diagnostics, Resolver, Url, addGenerator, assertPluginOption, ast, createResolver, defineExtension, defineGenerator, injectFile, macroSimplifyUnion, setMacros, setResolver, useConfig } from "kubb/kit";
 import path from "node:path";
-import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+import { pluginZodName } from "@kubb/plugin-zod";
 import { File, Function, jsxRenderer } from "kubb/jsx";
+import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
-import { pluginZodName } from "@kubb/plugin-zod";
 import { fileURLToPath } from "node:url";
-//#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
@@ -185,11 +167,19 @@ const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 function getOperationParameters(node) {
 	const cached = operationParameterGroupsByNode.get(node);
 	if (cached) return cached;
+	const group = (location) => {
+		const seen = /* @__PURE__ */ new Set();
+		return node.parameters.filter((param) => {
+			if (param.in !== location || seen.has(param.name)) return false;
+			seen.add(param.name);
+			return true;
+		});
+	};
 	const groups = {
-		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"))
+		path: group("path"),
+		query: group("query"),
+		header: group("header"),
+		cookie: group("cookie")
 	};
 	operationParameterGroupsByNode.set(node, groups);
 	return groups;
@@ -438,6 +428,134 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
+//#region ../../internals/client/src/builders/validatorOptions.ts
+/**
+* Returns `true` when any direction of the validator uses zod (used for dependency checks).
+*/
+function isValidatorEnabled(validator) {
+	if (!validator) return false;
+	if (validator === "zod") return true;
+	return Boolean(validator.request || validator.response);
+}
+/**
+* Returns `'zod'` when request body parsing is enabled, `null` otherwise. The string shorthand
+* `'zod'` validates the response only, so it does not enable request parsing.
+*/
+function resolveRequestValidator(validator) {
+	if (!validator || validator === "zod") return null;
+	return validator.request ?? null;
+}
+/**
+* Returns `'zod'` when response parsing is enabled, `null` otherwise. The string shorthand `'zod'`
+* maps to response parsing.
+*/
+function resolveResponseValidator(validator) {
+	if (!validator) return null;
+	if (validator === "zod") return "zod";
+	return validator.response ?? null;
+}
+/**
+* Resolves the zod schema name a generated client validates an error body with on the non-throw path.
+* Uses the error-only `<operation>ErrorSchema` (the union of non-2xx statuses); returns `null` when the
+* operation documents no error responses with a schema.
+*/
+function buildZodErrorParse(node, zodResolver) {
+	if (!node.responses.some((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema))) return null;
+	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}'`];
+	if (auth.scheme) parts.push(`scheme: '${auth.scheme}'`);
+	if (auth.name) parts.push(`name: '${auth.name}'`);
+	if (auth.in) parts.push(`in: '${auth.in}'`);
+	return `{ ${parts.join(", ")} }`;
+}
+/**
+* Maps an OpenAPI security scheme to the inline `Auth` object, or `null` when the runtime cannot
+* place it (an unresolved `$ref`, or an `apiKey` without a name or outside `header` / `query` /
+* `cookie`). `http` schemes other than `basic` are treated as bearer.
+*/
+function resolveSecurityScheme(scheme) {
+	if (!scheme || "$ref" in scheme) return null;
+	if (scheme.type === "apiKey") {
+		if (!scheme.name || scheme.in !== "header" && scheme.in !== "query" && scheme.in !== "cookie") return null;
+		return {
+			type: "apiKey",
+			name: scheme.name,
+			in: scheme.in
+		};
+	}
+	if (scheme.type === "http") return {
+		type: "http",
+		scheme: scheme.scheme?.toLowerCase() === "basic" ? "basic" : "bearer"
+	};
+	if (scheme.type === "oauth2") return { type: "oauth2" };
+	if (scheme.type === "openIdConnect") return { type: "openIdConnect" };
+	return null;
+}
+/**
+* Derives the per-operation security metadata from the OpenAPI document. The operation's own
+* `security` overrides the global `security` (an explicit empty array disables auth), and every
+* referenced scheme is resolved from `components.securitySchemes` into a flat, de-duplicated list of
+* `Auth` objects the runtime walks in order.
+*
+* @example
+* `getOperationSecurity({ document, method: 'POST', path: '/pet' })`
+* `// [{ type: 'http', scheme: 'bearer' }]`
+*/
+function getOperationSecurity({ document, method, path }) {
+	if (!document) return void 0;
+	const requirements = (document.paths?.[path]?.[method.toLowerCase()])?.security ?? document.security;
+	if (!requirements?.length) return void 0;
+	const definitions = document.components?.securitySchemes ?? {};
+	const security = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const requirement of requirements) for (const schemeName of Object.keys(requirement)) {
+		if (seen.has(schemeName)) continue;
+		seen.add(schemeName);
+		const auth = resolveSecurityScheme(definitions[schemeName]);
+		if (auth) security.push(auth);
+	}
+	return security.length ? security : void 0;
+}
+/**
+* Serializes the per-operation security into the literal emitted on each generated call's `security`
+* field. The runtime `resolveAuth` helper walks it, calling the configured `auth` resolver per entry.
+*
+* @example
+* `buildSecurityMetadata({ security: [{ type: 'http', scheme: 'bearer' }] }) // "[{ type: 'http', scheme: 'bearer' }]"`
+*/
+function buildSecurityMetadata({ security }) {
+	if (!security?.length) return null;
+	return `[${security.map(serializeAuth).join(", ")}]`;
+}
+//#endregion
 //#region ../../internals/client/src/builders/contentType.ts
 /**
 * Builds the `contentType` entry baked into the call config, or `null` for the JSON default.
@@ -530,74 +648,6 @@ function buildReturnStatement({ node, types, callConfig, returnType, throwOnErro
 	})}>>)`;
 }
 //#endregion
-//#region ../../internals/client/src/builders/security.ts
-function serializeAuth(auth) {
-	const parts = [`type: '${auth.type}'`];
-	if (auth.scheme) parts.push(`scheme: '${auth.scheme}'`);
-	if (auth.name) parts.push(`name: '${auth.name}'`);
-	if (auth.in) parts.push(`in: '${auth.in}'`);
-	return `{ ${parts.join(", ")} }`;
-}
-/**
-* Maps an OpenAPI security scheme to the inline `Auth` object, or `null` when the runtime cannot
-* place it (an unresolved `$ref`, or an `apiKey` without a name or outside `header` / `query` /
-* `cookie`). `http` schemes other than `basic` are treated as bearer.
-*/
-function resolveSecurityScheme(scheme) {
-	if (!scheme || "$ref" in scheme) return null;
-	if (scheme.type === "apiKey") {
-		if (!scheme.name || scheme.in !== "header" && scheme.in !== "query" && scheme.in !== "cookie") return null;
-		return {
-			type: "apiKey",
-			name: scheme.name,
-			in: scheme.in
-		};
-	}
-	if (scheme.type === "http") return {
-		type: "http",
-		scheme: scheme.scheme?.toLowerCase() === "basic" ? "basic" : "bearer"
-	};
-	if (scheme.type === "oauth2") return { type: "oauth2" };
-	if (scheme.type === "openIdConnect") return { type: "openIdConnect" };
-	return null;
-}
-/**
-* Derives the per-operation security metadata from the OpenAPI document. The operation's own
-* `security` overrides the global `security` (an explicit empty array disables auth), and every
-* referenced scheme is resolved from `components.securitySchemes` into a flat, de-duplicated list of
-* `Auth` objects the runtime walks in order.
-*
-* @example
-* `getOperationSecurity({ document, method: 'POST', path: '/pet' })`
-* `// [{ type: 'http', scheme: 'bearer' }]`
-*/
-function getOperationSecurity({ document, method, path }) {
-	if (!document) return void 0;
-	const requirements = (document.paths?.[path]?.[method.toLowerCase()])?.security ?? document.security;
-	if (!requirements?.length) return void 0;
-	const definitions = document.components?.securitySchemes ?? {};
-	const security = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const requirement of requirements) for (const schemeName of Object.keys(requirement)) {
-		if (seen.has(schemeName)) continue;
-		seen.add(schemeName);
-		const auth = resolveSecurityScheme(definitions[schemeName]);
-		if (auth) security.push(auth);
-	}
-	return security.length ? security : void 0;
-}
-/**
-* Serializes the per-operation security into the literal emitted on each generated call's `security`
-* field. The runtime `resolveAuth` helper walks it, calling the configured `auth` resolver per entry.
-*
-* @example
-* `buildSecurityMetadata({ security: [{ type: 'http', scheme: 'bearer' }] }) // "[{ type: 'http', scheme: 'bearer' }]"`
-*/
-function buildSecurityMetadata({ security }) {
-	if (!security?.length) return null;
-	return `[${security.map(serializeAuth).join(", ")}]`;
-}
-//#endregion
 //#region ../../internals/client/src/builders/signature.ts
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 /**
@@ -627,161 +677,6 @@ function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDef
 	};
 }
 //#endregion
-//#region ../../internals/client/src/builders/validatorOptions.ts
-/**
-* Returns `true` when any direction of the validator uses zod (used for dependency checks).
-*/
-function isValidatorEnabled(validator) {
-	if (!validator) return false;
-	if (validator === "zod") return true;
-	return Boolean(validator.request || validator.response);
-}
-/**
-* Returns `'zod'` when request body parsing is enabled, `null` otherwise. The string shorthand
-* `'zod'` validates the response only, so it does not enable request parsing.
-*/
-function resolveRequestValidator(validator) {
-	if (!validator || validator === "zod") return null;
-	return validator.request ?? null;
-}
-/**
-* Returns `'zod'` when query-parameters parsing is enabled, `null` otherwise. Only the object form
-* `{ request: 'zod' }` enables it.
-*/
-function resolveQueryParamsValidator(validator) {
-	if (!validator || validator === "zod") return null;
-	return validator.request ?? null;
-}
-/**
-* Returns `'zod'` when response parsing is enabled, `null` otherwise. The string shorthand `'zod'`
-* maps to response parsing.
-*/
-function resolveResponseValidator(validator) {
-	if (!validator) return null;
-	if (validator === "zod") return "zod";
-	return validator.response ?? null;
-}
-/**
-* Resolves the zod expression a generated client validates a success response with. Only success
-* (2xx) bodies reach the parse under the throw-on-error contract, so the success-only
-* `<operation>ResponseSchema` is used; error bodies are never zod-parsed.
-*/
-function buildZodResponseParse(node, zodResolver) {
-	const name = zodResolver.response.response(node);
-	return name ? {
-		expression: name,
-		importNames: [name]
-	} : null;
-}
-/**
-* Resolves the zod expression a generated client validates an error body with on the non-throw path.
-* Uses the error-only `<operation>ErrorSchema` (the union of non-2xx statuses); returns `null` when the
-* operation documents no error responses with a schema.
-*/
-function buildZodErrorParse(node, zodResolver) {
-	if (!node.responses.some((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema))) return null;
-	const name = zodResolver.response.error?.(node);
-	return name ? {
-		expression: name,
-		importNames: [name]
-	} : 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 importedZodNames = [];
-	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
-	const zodRequestName = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body(node) : null;
-	const request = zodRequestName ?? null;
-	if (zodRequestName) importedZodNames.push(zodRequestName);
-	const responseParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodResponseParse(node, zodResolver) : null;
-	const response = responseParse ? responseParse.expression : null;
-	if (responseParse) importedZodNames.push(...responseParse.importNames);
-	const errorParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver) : null;
-	const error = errorParse ? errorParse.expression : null;
-	if (errorParse) importedZodNames.push(...errorParse.importNames);
-	return {
-		request,
-		response,
-		error,
-		importedZodNames
-	};
-}
-//#endregion
-//#region ../../internals/client/src/builders/sdkMethod.ts
-/**
-* Builds the call config literal forwarded to the contract client, mirroring the shared `Operation`
-* component: `{ method, url, security?, validator?, ...config }`. The `...config` spread carries every
-* per-call field. The plugin's `throwOnError` fallback is applied after the spread so it also wins
-* over a client instance's runtime config when the call omits an override.
-*/
-function buildCallConfig({ node, validator, zodResolver, security, throwOnErrorDefault }) {
-	const validators = buildValidatorHooks({
-		node,
-		validator,
-		zodResolver
-	});
-	const validatorEntries = [validators.request ? `request: ${validators.request}` : null, validators.response ? `response: ${validators.response}` : null].filter(Boolean);
-	const validatorLiteral = validatorEntries.length ? `validator: { ${validatorEntries.join(", ")} }` : null;
-	const securityLiteral = buildSecurityMetadata({ security });
-	const { literal: contentTypeLiteral } = buildContentType({ node });
-	return `{ ${[
-		`method: '${node.method.toUpperCase()}'`,
-		`url: '${node.path}'`,
-		securityLiteral ? `security: ${securityLiteral}` : null,
-		validatorLiteral,
-		contentTypeLiteral,
-		"...config",
-		`throwOnError: config.throwOnError ?? ${throwOnErrorDefault}`
-	].filter(Boolean).join(", ")} }`;
-}
-/**
-* Builds a single instance method for a generated SDK class. The body forwards the single grouped
-* `options` object to the instance's own client (`this.client`, built once in the constructor) and
-* returns the `Unwrappable<RequestResult>`. A per-call `options.client` still overrides the
-* instance client, so one operation can be routed to a different environment without a new
-* instance.
-*/
-function buildSdkMethod({ node, name, types, zodResolver, validator, security, returnType, throwOnErrorDefault }) {
-	if (!ast.isHttpOperationNode(node)) return "";
-	const signature = buildGroupedOptionsSignature({
-		node,
-		types,
-		returnType,
-		throwOnErrorDefault
-	});
-	const returnStatement = buildReturnStatement({
-		node,
-		types,
-		callConfig: buildCallConfig({
-			node,
-			validator,
-			zodResolver,
-			security,
-			throwOnErrorDefault
-		}),
-		returnType,
-		throwOnErrorDefault
-	});
-	const generics = signature.generics.length ? `<${signature.generics.join(", ")}>` : "";
-	const jsdoc = buildJSDoc(buildOperationComments(node, {
-		link: "urlPath",
-		linkPosition: "beforeDeprecated",
-		splitLines: true
-	}));
-	const methodBody = [
-		buildContentType({ node }).merge ? "const { client: request = this.client, contentType, ...config } = options" : "const { client: request = this.client, ...config } = options",
-		"",
-		returnStatement
-	].map((line) => line ? `    ${line}` : "").join("\n");
-	return `${jsdoc}  public ${name}${generics}(${signature.paramsSignature}): ${signature.returnType} {\n${methodBody}\n  }`;
-}
-//#endregion
 //#region ../../internals/client/src/builders/styles.ts
 /**
 * Renders a parameter name as an object-literal key, quoted when it is not a bare identifier.
@@ -842,7 +737,7 @@ function buildStyles({ node }) {
 * type, signature, and call config are built with the AST factory, and only the jsx-renderer emits
 * the source.
 */
-function Operation({ name, node, types, zodResolver, validator, returnType, throwOnErrorDefault, security, isExportable = true, isIndexable = true }) {
+function Operation({ name, node, types, zodResolver, validator, returnType, throwOnErrorDefault, security }) {
 	if (!ast.isHttpOperationNode(node)) return null;
 	const signature = buildGroupedOptionsSignature({
 		node,
@@ -889,11 +784,11 @@ function Operation({ name, node, types, zodResolver, validator, returnType, thro
 	});
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
-		isExportable,
-		isIndexable,
+		isExportable: true,
+		isIndexable: true,
 		children: /* @__PURE__ */ jsxs(Function, {
 			name,
-			export: isExportable,
+			export: true,
 			generics: signature.generics,
 			params: signature.paramsSignature,
 			returnType: functionReturnType,
@@ -911,62 +806,24 @@ function Operation({ name, node, types, zodResolver, validator, returnType, thro
 	});
 }
 //#endregion
-//#region ../../internals/client/src/components/SdkClient.tsx
-/**
-* Renders one instance class per tag with one method per operation. The constructor takes a client
-* config object and builds its own client through `createClient`, so each environment is a separate
-* instance: `const api = new PetClient({ baseURL }); api.getPetById(...)`. A per-call `client` option
-* still overrides the instance client for a one-off call.
-*/
-function SdkClient({ name, isExportable = true, isIndexable = true, operations, validator, returnType, throwOnErrorDefault, children }) {
-	const methods = operations.map(({ node, name: methodName, types, zodResolver, security }) => buildSdkMethod({
-		node,
-		name: methodName,
-		types,
-		zodResolver,
-		validator,
-		security,
-		returnType,
-		throwOnErrorDefault
-	}));
-	const classCode = `export class ${name} {\n${[
-		"  private readonly client: ClientInstance",
-		"",
-		"  constructor(config: ClientConfig = {}) {",
-		"    this.client = createClient(config)",
-		"  }"
-	].join("\n")}\n\n${methods.join("\n\n")}\n}`;
-	return /* @__PURE__ */ jsxs(File.Source, {
-		name,
-		isExportable,
-		isIndexable,
-		children: [classCode, children]
-	});
-}
-//#endregion
 //#region ../../internals/client/src/resolveOperationTypes.ts
 /**
-* Warning a client generator reports when neither plugin can supply the operation types, so the
-* pipeline says why nothing was generated instead of silently emitting no files.
-*/
-const MISSING_OPERATION_TYPES_WARNING = "Skipped: no operation types available. Add `pluginTs()`, or `pluginZod({ inferred: true })` to type the client from its zod schemas.";
-/**
 * Picks the plugin a generated client takes its `Options` and `Responses` 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. Returns `null` when neither is available, leaving the caller nothing to type against.
+* wire type. Throws `KUBB_MISSING_DEPENDENCY` for `pluginName` when neither is available, since the
+* client has nothing to type against.
 *
 * @example
 * ```ts
-* const types = resolveOperationTypes(ctx.driver)
-* if (!types) return null
+* const types = resolveOperationTypes(ctx.driver, ctx.plugin.name)
 * types.response.options(node) // 'GetPetByIdOptions', or 'GetPetByIdOptionsSchemaType' from zod
 * ```
 */
-function resolveOperationTypes(driver) {
+function resolveOperationTypes(driver, pluginName) {
 	const pluginTs = driver.getPlugin(pluginTsName);
 	if (pluginTs) {
 		const resolver = driver.getResolver(pluginTsName);
@@ -978,7 +835,14 @@ function resolveOperationTypes(driver) {
 		};
 	}
 	const pluginZod = driver.getPlugin(pluginZodName);
-	if (!pluginZod?.options?.inferred) return null;
+	if (!pluginZod?.options?.inferred) throw new Diagnostics.Error({
+		code: 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 = driver.getResolver(pluginZodName);
 	return {
 		response: {
@@ -1008,20 +872,15 @@ function createClientGenerator(name, resolveClientPath) {
 			if (!ast.isHttpOperationNode(node)) return null;
 			const { config, driver, resolver, root } = ctx;
 			const { output, validator, returnType, throwOnErrorDefault, group } = ctx.options;
-			const types = resolveOperationTypes(driver);
-			if (!types) {
-				ctx.warn(MISSING_OPERATION_TYPES_WARNING);
-				return null;
-			}
+			const types = resolveOperationTypes(driver, ctx.plugin.name);
 			const pluginZod = resolveResponseValidator(validator) === "zod" || resolveRequestValidator(validator) === "zod" ? driver.getPlugin(pluginZodName) : null;
 			const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
-			const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
 			const importedTypeNames = [types.response.options(node), types.response.responses(node)];
-			const importedZodNames = zodResolver ? [
-				resolveResponseValidator(validator) === "zod" ? zodResolver.response.response?.(node) : null,
-				resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,
-				resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body?.(node) : null
-			].filter((name) => Boolean(name)) : [];
+			const importedZodNames = buildValidatorHooks({
+				node,
+				validator,
+				zodResolver
+			}).importedZodNames;
 			const meta = {
 				name: resolver.name(node.operationId),
 				file: resolver.file({
@@ -1133,13 +992,106 @@ function createClientGenerator(name, resolveClientPath) {
 	});
 }
 //#endregion
+//#region ../../internals/client/src/components/SdkClient.tsx
+/**
+* Builds the call config literal forwarded to the contract client; the `throwOnError` fallback is applied after the `...config` spread.
+*/
+function buildCallConfig({ node, validator, zodResolver, security, throwOnErrorDefault }) {
+	const validators = buildValidatorHooks({
+		node,
+		validator,
+		zodResolver
+	});
+	const validatorEntries = [validators.request ? `request: ${validators.request}` : null, validators.response ? `response: ${validators.response}` : null].filter(Boolean);
+	const validatorLiteral = validatorEntries.length ? `validator: { ${validatorEntries.join(", ")} }` : null;
+	const securityLiteral = buildSecurityMetadata({ security });
+	const { literal: contentTypeLiteral } = buildContentType({ node });
+	return `{ ${[
+		`method: '${node.method.toUpperCase()}'`,
+		`url: '${node.path}'`,
+		securityLiteral ? `security: ${securityLiteral}` : null,
+		validatorLiteral,
+		contentTypeLiteral,
+		"...config",
+		`throwOnError: config.throwOnError ?? ${throwOnErrorDefault}`
+	].filter(Boolean).join(", ")} }`;
+}
+/**
+* Builds one instance method of a generated SDK class; a per-call `options.client` overrides `this.client`.
+*/
+function buildSdkMethod({ node, name, types, zodResolver, validator, security, returnType, throwOnErrorDefault }) {
+	if (!ast.isHttpOperationNode(node)) return "";
+	const signature = buildGroupedOptionsSignature({
+		node,
+		types,
+		returnType,
+		throwOnErrorDefault
+	});
+	const returnStatement = buildReturnStatement({
+		node,
+		types,
+		callConfig: buildCallConfig({
+			node,
+			validator,
+			zodResolver,
+			security,
+			throwOnErrorDefault
+		}),
+		returnType,
+		throwOnErrorDefault
+	});
+	const generics = signature.generics.length ? `<${signature.generics.join(", ")}>` : "";
+	const jsdoc = buildJSDoc(buildOperationComments(node, {
+		link: "urlPath",
+		linkPosition: "beforeDeprecated",
+		splitLines: true
+	}));
+	const methodBody = [
+		buildContentType({ node }).merge ? "const { client: request = this.client, contentType, ...config } = options" : "const { client: request = this.client, ...config } = options",
+		"",
+		returnStatement
+	].map((line) => line ? `    ${line}` : "").join("\n");
+	return `${jsdoc}  public ${name}${generics}(${signature.paramsSignature}): ${signature.returnType} {\n${methodBody}\n  }`;
+}
+/**
+* Renders one instance class per tag with one method per operation. The constructor takes a client
+* config object and builds its own client through `createClient`, so each environment is a separate
+* instance: `const api = new PetClient({ baseURL }); api.getPetById(...)`. A per-call `client` option
+* still overrides the instance client for a one-off call.
+*/
+function SdkClient({ name, operations, validator, returnType, throwOnErrorDefault }) {
+	const methods = operations.map(({ node, name: methodName, types, zodResolver, security }) => buildSdkMethod({
+		node,
+		name: methodName,
+		types,
+		zodResolver,
+		validator,
+		security,
+		returnType,
+		throwOnErrorDefault
+	}));
+	const classCode = `export class ${name} {\n${[
+		"  private readonly client: ClientInstance",
+		"",
+		"  constructor(config: ClientConfig = {}) {",
+		"    this.client = createClient(config)",
+		"  }"
+	].join("\n")}\n\n${methods.join("\n\n")}\n}`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: classCode
+	});
+}
+//#endregion
 //#region ../../internals/client/src/components/SdkFacade.tsx
 /**
 * Renders a composed root SDK class that instantiates every tag client from one shared config, so
 * `new PetStore({ baseURL }).petClient.getPetById(...)` reaches an operation through a single entry
 * point bound to one environment. The per-tag clients are read-only fields built in the constructor.
 */
-function SdkFacade({ name, isExportable = true, isIndexable = true, members, children }) {
+function SdkFacade({ name, members }) {
 	const fields = members.map((member) => `  readonly ${member.propName}: ${member.className}`);
 	const assignments = members.map((member) => `    this.${member.propName} = new ${member.className}(config)`);
 	const classCode = `export class ${name} {\n${[
@@ -1149,11 +1101,11 @@ function SdkFacade({ name, isExportable = true, isIndexable = true, members, chi
 		...assignments,
 		"  }"
 	].join("\n")}\n}`;
-	return /* @__PURE__ */ jsxs(File.Source, {
+	return /* @__PURE__ */ jsx(File.Source, {
 		name,
-		isExportable,
-		isIndexable,
-		children: [classCode, children]
+		isExportable: true,
+		isIndexable: true,
+		children: classCode
 	});
 }
 //#endregion
@@ -1162,13 +1114,7 @@ function resolveTypeImportNames(node, types) {
 	return [types.response.options(node), types.response.responses(node)];
 }
 function resolveZodImportNames(node, zodResolver, validator) {
-	const { query: queryParams } = getOperationParameters(node);
-	return [
-		resolveResponseValidator(validator) === "zod" ? zodResolver.response.response(node) : null,
-		resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,
-		resolveRequestValidator(validator) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.response.body(node) : null,
-		resolveQueryParamsValidator(validator) === "zod" && queryParams.length > 0 ? zodResolver.param.query(node, queryParams[0]) : null
-	].filter((n) => Boolean(n));
+	return [resolveResponseValidator(validator) === "zod" ? zodResolver.response.response(node) : null, resolveRequestValidator(validator) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.response.body(node) : null].filter((n) => Boolean(n));
 }
 /**
 * Groups operations into one controller per tag. Operations without a tag fall back to a single
@@ -1275,12 +1221,7 @@ function createSdkGenerator() {
 				location: { kind: "config" },
 				plugin: ctx.plugin.name
 			});
-			const types = resolveOperationTypes(ctx.driver);
-			if (!types) {
-				ctx.warn(MISSING_OPERATION_TYPES_WARNING);
-				return null;
-			}
-			const controllers = buildControllers(nodes, ctx, types);
+			const controllers = buildControllers(nodes, ctx, resolveOperationTypes(ctx.driver, ctx.plugin.name));
 			const clientPath = path.resolve(root, ".kubb/client.ts");
 			const banner = (file) => resolver.default.banner(ctx.meta, {
 				output,
@@ -1461,7 +1402,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.6.0";
+var version = "5.6.2";
 //#endregion
 //#region src/templates.ts
 /** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */
@@ -1509,10 +1450,10 @@ const pluginFetch = defineExtension({
 		version,
 		compatibility
 	},
-	dependencies: {
+	dependencies: (options) => ({
 		[pluginTsName]: { optional: true },
-		[pluginZodName]: { optional: true }
-	},
+		[pluginZodName]: { optional: !isValidatorEnabled(options.validator) }
+	}),
 	setup(options) {
 		const config = useConfig();
 		const { output = {
@@ -1535,6 +1476,32 @@ const pluginFetch = defineExtension({
 			} : void 0,
 			resolver: userResolver ? Resolver.merge(resolverClient, userResolver) : resolverClient
 		};
+		const allowedReturnTypes = [
+			"full",
+			"data",
+			"plain"
+		];
+		assertPluginOption({
+			plugin: pluginFetchName,
+			option: "returnType",
+			value: returnType,
+			allowed: allowedReturnTypes
+		});
+		for (const [index, entry] of override.entries()) {
+			if (entry.options.returnType === void 0) continue;
+			assertPluginOption({
+				plugin: pluginFetchName,
+				option: `override[${index}].options.returnType`,
+				value: entry.options.returnType,
+				allowed: allowedReturnTypes
+			});
+		}
+		if (resolved.sdk) assertPluginOption({
+			plugin: pluginFetchName,
+			option: "sdk.mode",
+			value: resolved.sdk.mode,
+			allowed: ["tag", "flat"]
+		});
 		setResolver(resolved.resolver);
 		setMacros([...defaultMacros, ...options.macros ?? []]);
 		addGenerator(resolved.sdk ? createSdkGenerator() : clientGenerator);