@kubb/plugin-client 5.12.0 → 6.0.1

package/dist/index.js

@@ -1,287 +1,17 @@
-import { Diagnostics, Resolver, Url, addGenerator, ast, camelCase, createResolver, defineExtension, defineGenerator, macroDedupeUnion, pascalCase, setMacros, setResolver } from "@kubb/kit";
+import { Diagnostics, Resolver, addGenerator, ast, casing, createResolver, defineExtension, defineGenerator, injectFile, macroDedupeUnion, memo, setMacros, setResolver, text, 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/renderer-jsx";
+import { pluginZodName as pluginZodName$1 } from "@kubb/plugin-zod";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
-// ../../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
-	};
-}
-/**
-* Resolves a dependency plugin's generated file for `node.operationId`, cached in `memo` (the
-* build's `ctx.memo`) under the resolver's own plugin name and the operation. Several dependents reading the
-* same dependency for the same operation in one pass (a query plugin's several hook generators, the
-* MCP handler, ...) share one computed name and path instead of each calling `resolver.file` again.
-*
-* @example Cache `plugin-ts`'s file for the current operation
-* ```ts
-* const fileTs = resolveDependencyOperationFile({ memo: ctx.memo, node, resolver: tsResolver, root, output })
-* ```
-*/
-function resolveDependencyOperationFile(options) {
-	const { memo, node, resolver, root, output, group } = options;
-	return memo(`${resolver.pluginName}:operationFile:${node.operationId}`, () => resolver.file({
-		...operationFileEntry(node, node.operationId),
-		root,
-		output,
-		group: group ?? void 0
-	}));
-}
-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) ?? []);
-}
-/**
-* Reads the single base content type of an operation's primary success response, lowercased and
-* stripped of any `; charset=...` suffix. Returns `undefined` when the response declares zero or
-* more than one content type, since neither case has a single type to act on.
-*/
-function getPrimarySuccessContentType(node) {
-	const contentTypes = getPrimarySuccessResponse(node)?.content?.map((entry) => entry.contentType) ?? [];
-	if (contentTypes.length !== 1) return void 0;
-	return contentTypes[0].split(";")[0].trim().toLowerCase();
-}
-/**
-* The `text/event-stream` content of the primary success response, when it is the only content type. A response that also
-* declares another type stays a normal call with its query hooks.
-*/
-function getEventStreamContent(node) {
-	return getPrimarySuccessContentType(node) === "text/event-stream" ? getPrimarySuccessResponse(node)?.content?.[0] : void 0;
-}
-/**
-* Whether an operation streams its primary success response as Server-Sent Events (`text/event-stream`). The client
-* generator uses this to return a typed event stream instead of a one-shot `RequestResult`.
-*/
-function isEventStream(node) {
-	return getEventStreamContent(node) !== void 0;
-}
-/**
-* How the document types a `text/event-stream` response, as the adapter read it from `itemSchema`: `event` when each item is
-* the parsed event with its own `event` and `data`, `data` when it is only the payload. Returns `null` without an event stream.
-*/
-function getEventStream(node) {
-	const content = getEventStreamContent(node);
-	return content ? content.stream?.shape ?? "data" : null;
-}
-function baseContentType(contentType) {
-	return contentType.split(";")[0].trim().toLowerCase();
-}
-function isJsonContentType(baseType) {
-	return baseType === "application/json" || baseType.endsWith("+json") || baseType === "text/json";
-}
-/**
-* Parser for one response content entry.
-*
-* JSON stays unset so the runtime detects it. `text/event-stream` is a stream. A binary schema
-* (`format: binary` / `contentMediaType`) is a blob even when the media type is not a well-known
-* binary type. Other `text/*` is text, and `application/octet-stream`, `application/pdf`,
-* `image/*`, `audio/*`, and `video/*` are blobs.
-*/
-function responseTypeForContent(contentType, schema) {
-	const baseType = baseContentType(contentType);
-	if (!baseType) return void 0;
-	if (isJsonContentType(baseType)) return void 0;
-	if (baseType === "text/event-stream") return "stream";
-	if (schema?.type === "blob") return "blob";
-	if (baseType.startsWith("text/")) return "text";
-	if (baseType === "application/octet-stream" || baseType === "application/pdf" || /^(image|audio|video)\//.test(baseType)) return "blob";
-}
-/**
-* Derives the default `responseType` string for an operation from its primary success response.
-*
-* One content type uses {@link responseTypeForContent}. Several content types that all use the same
-* parser collapse to that string, so a call can keep `responseType: 'blob'`. Mixed parsers return
-* `undefined`; {@link getResponseTypeMap} carries the per-type choice.
-*/
-function getResponseType(node) {
-	const entries = getPrimarySuccessResponse(node)?.content ?? [];
-	if (entries.length === 0) return void 0;
-	const responseTypes = entries.map((entry) => responseTypeForContent(entry.contentType, entry.schema));
-	const first = responseTypes[0];
-	if (!first) return void 0;
-	if (responseTypes.every((responseType) => responseType === first)) return first;
-}
-/**
-* Maps each base content type of a primary success response to its parser when those parsers differ.
-*
-* Keys are lowercased and stripped of parameters. JSON entries are kept as `'json'` so a catch-all
-* entry cannot claim a JSON response. Returns `undefined` when {@link getResponseType} already
-* covers the response with one string, or when no content type needs a parser other than JSON.
-* The runtime matches the response `Content-Type` against this map instead of guessing from the media type.
-*/
-function getResponseTypeMap(node) {
-	if (getResponseType(node)) return void 0;
-	const entries = getPrimarySuccessResponse(node)?.content ?? [];
-	if (entries.length <= 1) return void 0;
-	const map = {};
-	for (const entry of entries) {
-		const baseType = baseContentType(entry.contentType);
-		const responseType = responseTypeForContent(entry.contentType, entry.schema) ?? (isJsonContentType(baseType) ? "json" : void 0);
-		if (baseType && responseType) map[baseType] = responseType;
-	}
-	return Object.values(map).some((responseType) => responseType !== "json") ? map : void 0;
-}
-/**
-* 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 && node.requestBody?.required === true)
-	};
-}
-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));
-}
-const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
-/**
-* An OpenAPI 3.2 `querystring` parameter is the whole query string, so a form-encoded object becomes one query parameter
-* per property, typed and serialized like any other.
-* Another content type, such as JSON, stays one parameter named after it, and the runtime sends its value as the whole query string.
-*/
-function spreadQuerystring(param) {
-	const schema = param.schema.type === "ref" ? param.schema.schema : param.schema;
-	const formEncoded = !param.contentType || param.contentType.split(";")[0].trim().toLowerCase() === "application/x-www-form-urlencoded";
-	if (schema?.type !== "object" || !formEncoded) return [param];
-	return schema.properties.map((property) => ast.factory.createParameter({
-		name: property.name,
-		in: "query",
-		schema: property.schema,
-		required: param.required && property.required
-	}));
-}
-/**
-* Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
-* group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
-* (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
-* same parameters once per plugin.
-*/
-function getOperationParameters(node) {
-	const cached = operationParameterGroupsByNode.get(node);
-	if (cached) return cached;
-	const dedupe = (params) => {
-		const seen = /* @__PURE__ */ new Set();
-		return params.filter((param) => {
-			if (seen.has(param.name)) return false;
-			seen.add(param.name);
-			return true;
-		});
-	};
-	const group = (location) => dedupe(node.parameters.filter((param) => param.in === location));
-	const groups = {
-		path: group("path"),
-		query: dedupe([...group("query"), ...group("querystring").flatMap(spreadQuerystring)]),
-		header: group("header"),
-		cookie: group("cookie")
-	};
-	operationParameterGroupsByNode.set(node, groups);
-	return groups;
-}
-/**
-* Builds the combined `{ body, path, query, headers }` options object schema for an operation,
-* referencing the already-resolved body and grouped param names. Shared by `@kubb/plugin-ts`'s
-* `Options` type and `@kubb/plugin-zod`'s inferred options schema, so both printers emit the same
-* shape from the same inputs. `primitive: 'object'` is a no-op for the TS printer and tells the Zod
-* printer to emit `z.object(…)` rather than a record.
-*/
-function hasRequestContentTypeChoice(node) {
-	return (node.requestBody?.content ?? []).filter((entry) => entry.schema).length > 1;
-}
-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 getSuccessResponses(responses) {
-	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
-}
-function getOperationSuccessResponses(node) {
-	return getSuccessResponses(node.responses);
-}
-function getPrimarySuccessResponse(node) {
-	return getOperationSuccessResponses(node)[0] ?? null;
-}
+import { fileURLToPath } from "node:url";
+// kubb-extension.json
+var compatibility = {
+	"kubb": ">=5.18.4",
+	"node": ">=22.22"
+};
+// package.json
+var version = "6.0.1";
 // ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
@@ -421,18 +151,302 @@ function ensureValidVarName(name) {
 function isIdentifier(name) {
 	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
+// ../../internals/utils/src/codegen.ts
+/**
+* Builds a JSDoc comment block from an array of lines. Returns `fallback` when there are no
+* comments.
+*
+* @example
+* ```ts
+* buildJSDoc(['@type string', '@example hello'])
+* // '/**\n   * @type string\n   * @example hello\n   *\/\n  '
+* ```
+*/
+function buildJSDoc(comments, options = {}) {
+	const { indent = "   * ", suffix = "\n  ", fallback = "  " } = options;
+	if (comments.length === 0) return fallback;
+	return `/**\n${comments.map((c) => `${indent}${c}`).join("\n")}\n   */${suffix}`;
+}
+/**
+* An object key, quoted only when it is not identifier-shaped. Reserved words such as `class` stay bare.
+*
+* @example
+* ```ts
+* objectKey('x-total') // "'x-total'"
+* ```
+*/
+function objectKey(name) {
+	return isIdentifier(name) ? name : text.quote(name);
+}
+/**
+* A JSON value as a JavaScript literal, with single-quoted strings and identifier keys left unquoted.
+*
+* @example
+* ```ts
+* toLiteral({ id: 1, 'x-tag': ['a'] }) // "{ id: 1, 'x-tag': ['a'] }"
+* ```
+*/
+function toLiteral(value) {
+	if (typeof value === "string") return text.quote(value);
+	if (Array.isArray(value)) return `[${value.map(toLiteral).join(", ")}]`;
+	if (value && typeof value === "object") return `{ ${Object.entries(value).map(([key, item]) => `${objectKey(key)}: ${toLiteral(item)}`).join(", ")} }`;
+	return String(value);
+}
+// ../../internals/utils/src/strings.ts
+/**
+* Escapes an `@` at the start of a line, so a multi-line description can't start a new JSDoc tag.
+* Editors render `\@` as `@` in hovers.
+*
+* @example
+* ```ts
+* jsDocEscape('intro\n@example value') // 'intro\n\\@example value'
+* ```
+*/
+function jsDocEscape(input) {
+	return `${input}`.replace(/^(\s*)@/gm, "$1\\@");
+}
+// ../../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
+	};
+}
+/**
+* Resolves the file a schema-emitting plugin (`plugin-ts`, `plugin-zod`, `plugin-faker`) writes
+* `node` to, cached in `ctx.memo` under the resolver's plugin name and the
+* operation. The plugin itself and every plugin that imports from it call this, so they all get
+* the same path.
+*
+* When that path matches the file of a component schema in `ctx.driver.inputNode`, ignoring case, the file name
+* gets an `Operation` suffix: operation `point` goes to `PointOperation.ts` next to schema `Point.ts`.
+* Otherwise the two merge into one file, or overwrite each other on a case-insensitive file system.
+* Only the file name changes. The declarations keep their names.
+*
+* @example Resolve `plugin-ts`'s file for the current operation
+* ```ts
+* const fileTs = resolveOperationFile({ ctx, node, resolver: tsResolver, root, output })
+* ```
+*/
+function resolveOperationFile(options) {
+	const { ctx, node, resolver, root, output } = options;
+	const { memo } = ctx;
+	const location = {
+		root,
+		output,
+		group: options.group ?? void 0
+	};
+	return memo(`${resolver.pluginName}:operationFile:${node.operationId}`, () => {
+		const schemaPaths = memo(`${resolver.pluginName}:schemaFilePaths`, () => new Set((ctx.driver.inputNode?.schemas ?? []).flatMap((schema) => schema.name ? [resolver.file({
+			name: schema.name,
+			extname: ".ts",
+			...location
+		}).path.toLowerCase()] : [])));
+		let file = resolver.file({
+			...operationFileEntry(node, node.operationId),
+			...location
+		});
+		for (let name = `${node.operationId}Operation`; schemaPaths.has(file.path.toLowerCase()); name += "Operation") {
+			const next = resolver.file({
+				...operationFileEntry(node, name),
+				...location
+			});
+			if (next.path === file.path) break;
+			file = next;
+		}
+		return file;
+	});
+}
+/**
+* The operation's method and path as plain text, such as `` `GET /pet/{petId}` ``. A path is not a valid `{@link}` target.
+*/
+function getOperationRequestLine(node) {
+	return ast.http.isOperation(node) && node.path ? `\`${node.method.toUpperCase()} ${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(ast.http.responses.findPrimary(node)?.content?.map((e) => e.contentType) ?? []);
+}
+/**
+* How an operation streams its primary success response item by item, when that response declares one content type:
+* - `'event'` for `text/event-stream` whose `itemSchema` types the whole event with its own `event` and `data`
+* - `'data'` for `text/event-stream` typed by its payload only
+* - `'line'` for JSON Lines, one parsed JSON value per line
+*
+* Returns `null` for any other response, and for a response that also declares another content type, which stays a normal
+* call with its query hooks.
+*/
+function getEventStream(node) {
+	const content = ast.http.responses.findPrimary(node)?.content ?? [];
+	if (content.length !== 1) return null;
+	const entry = content[0];
+	const framing = getStreamFraming(entry);
+	if (framing === "events") return entry.stream?.shape ?? "data";
+	return framing === "lines" ? "line" : null;
+}
+/**
+* How a content entry is framed as a stream: `'events'` for Server-Sent Events, `'lines'` for JSON Lines.
+*/
+function getStreamFraming(entry) {
+	if (ast.mediaType.getBase(entry) === "text/event-stream") return "events";
+	return entry.stream && ast.mediaType.isStream(entry) ? "lines" : void 0;
+}
+/**
+* Whether an operation streams its primary success response, as Server-Sent Events or JSON Lines. The client generator uses
+* this to return a typed stream of items instead of a one-shot `RequestResult`.
+*/
+function isEventStream(node) {
+	return getEventStream(node) !== null;
+}
+function isTextSchema(schema) {
+	if (!schema) return false;
+	const resolved = ast.ref.getSchema(schema);
+	return resolved.type !== "blob" && resolved.primitive === "string";
+}
+/**
+* Whether an operation streams Server-Sent Events whose `data` the document types as a string, so the client keeps each
+* `data` as text instead of JSON-parsing it. With an event-shaped `itemSchema` where only some events type `data` as a
+* string, it returns the names of those events, or `false` when one of them has no fixed name.
+*/
+function hasTextEventData(node) {
+	const shape = getEventStream(node);
+	const entry = ast.http.responses.findPrimary(node)?.content?.[0];
+	if (!entry || shape !== "data" && shape !== "event") return false;
+	if (shape === "data") return isTextSchema(entry.stream?.schema ?? entry.schema);
+	const item = entry.stream?.schema ? ast.ref.getSchema(entry.stream.schema) : void 0;
+	if (!item) return false;
+	const events = item.type === "union" ? ast.schema.narrow(item, "union")?.members ?? [] : [item];
+	const propertySchemas = (event, propertyName) => ast.schema.findProperties({
+		node: event,
+		propertyName
+	}).map(({ schema }) => schema);
+	const textEvents = events.filter((event) => {
+		const dataSchemas = propertySchemas(event, "data");
+		return dataSchemas.length > 0 && dataSchemas.every(isTextSchema);
+	});
+	if (textEvents.length === events.length) return events.length > 0;
+	const eventNames = textEvents.map((event) => propertySchemas(event, "event").flatMap((schema) => ast.schema.getLiterals(ast.ref.getSchema(schema))));
+	return eventNames.length > 0 && eventNames.every((values) => values.length > 0) && [...new Set(eventNames.flat().map(String))];
+}
+/**
+* Whether the primary success response offers `text/event-stream`, alone or next to other content types. The client asks
+* for the stream by default and ships the `sse.ts` runtime, so a mixed response can be read as events too.
+*/
+function hasEventStreamContent(node) {
+	const entries = ast.http.responses.findPrimary(node)?.content ?? [];
+	return entries.some((entry) => getStreamFraming(entry) === "events" && (entries.length === 1 || Boolean(entry.schema)));
+}
+/**
+* Whether a success response offers a stream media type next to other content types. The client returns that variant's
+* body as a `ReadableStream`, so the stream runtime is registered and a hook's data type includes the stream.
+*/
+function hasStreamVariant(node) {
+	return ast.http.responses.filterSuccess(node).some((response) => {
+		const variants = (response.content ?? []).filter((entry) => entry.schema);
+		return variants.length > 1 && variants.some((entry) => ast.mediaType.isStream(entry));
+	});
+}
+const formContentTypes = ["multipart/form-data", "application/x-www-form-urlencoded"];
+/**
+* The form media types the operation's request body offers, `multipart/form-data` and `application/x-www-form-urlencoded`,
+* which the client needs a handler for.
+*/
+function getFormContentTypes(node) {
+	const request = new Set((node.requestBody?.content ?? []).map((entry) => ast.mediaType.getBase(entry)));
+	return formContentTypes.filter((contentType) => request.has(contentType));
+}
+/**
+* Which of the grouped request options an operation carries.
+*/
+function getRequestGroups(node) {
+	const { path, query, header, cookie } = ast.http.groupParameters(node);
+	return {
+		path: path.length > 0,
+		query: query.length > 0,
+		body: Boolean(ast.http.requestBody.getSchema(node)),
+		headers: header.length > 0,
+		cookies: cookie.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 } = ast.http.groupParameters(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 && node.requestBody?.required === true)
+	};
+}
+function buildOperationComments(node, options = {}) {
+	const { splitLines = false } = options;
+	const filteredComments = [
+		getOperationRequestLine(node),
+		node.description && `@description ${node.description}`,
+		node.summary && `@summary ${node.summary}`,
+		node.deprecated && "@deprecated",
+		node.externalDocs && `@see ${jsDocEscape([node.externalDocs.url, node.externalDocs.description].filter(Boolean).join(" "))}`
+	].filter((comment) => Boolean(comment));
+	if (!splitLines) return filteredComments;
+	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
+}
 // ../../internals/shared/src/resolver.ts
 /**
 * The shared top-level `name` of the operation plugins, computed once per operation name and build.
 */
 function resolveOperationName(name) {
-	return this.memo(`operation:${name}`, () => ensureValidVarName(camelCase(name)));
+	return this.memo(`operation:${name}`, () => ensureValidVarName(casing.camel(name)));
 }
 /**
 * Builds the allocation key for a declaration an operation owns. `scope` names which declaration
 * it is, so two of them never share an allocation even when a custom resolver gives both the same
 * name. Leave `scope` empty for the operation's own declaration.
 *
+* The key starts from the operation's input `pointer`, which macros keep, so a plugin whose macro
+* rewrites the method or path still resolves another plugin's names for the same operation.
+*
 * @example
 * ```ts
 * resolver.resolveName({ key: operationKey(node, 'response', 'status', 404), name })
@@ -441,49 +455,228 @@ function resolveOperationName(name) {
 function operationKey(node, ...scope) {
 	return [
 		"operation",
-		node.method,
-		node.path,
+		...node.pointer ? [node.pointer] : [node.method, node.path],
 		...scope.map(String)
 	];
 }
-// ../../internals/shared/src/group.ts
+// ../../internals/client/src/resolveOperationTypes.ts
+const pluginZodName = "plugin-zod";
+function getResponseHeadersEntries({ node, types }) {
+	const resolve = types.response.headers;
+	if (!resolve) return [];
+	return node.responses.filter((response) => response.headers?.length).map((response) => [response.statusCode, resolve.call(types.response, node, response.statusCode)]);
+}
 /**
-* 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.
+* The headers type argument of `RequestResult`, such as `{ '200': LoginUserStatus200Headers }`, or `null` when no response declares headers.
+*/
+function buildResponseHeadersType({ node, types }) {
+	const entries = getResponseHeadersEntries({
+		node,
+		types
+	}).map(([statusCode, name]) => `'${statusCode}': ${name}`);
+	return entries.length ? `{ ${entries.join("; ")} }` : null;
+}
+/**
+* A runtime result type, such as `RequestResult`, in its `WithHeaders` form when `headers` is set.
+*/
+function resultTypeName(name, headers) {
+	return headers ? `${name}WithHeaders` : name;
+}
+/**
+* A runtime result type with its arguments, such as `RequestResultWithHeaders<Responses, Headers, ThrowOnError>`.
+*/
+function buildResultTypeRef(name, responses, headers, rest = []) {
+	return `${resultTypeName(name, headers !== null)}<${[
+		responses,
+		headers,
+		...rest
+	].filter(Boolean).join(", ")}>`;
+}
+/**
+* The names of the headers types `buildResponseHeadersType` references, for the file's imports.
+*/
+function getResponseHeadersTypeNames({ node, types }) {
+	return getResponseHeadersEntries({
+		node,
+		types
+	}).map(([, name]) => name);
+}
+/**
+* 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)),
+			headers: (node, statusCode) => type(resolver.response.headers(node, statusCode)),
+			options: (node) => resolver.response.options(node)
+		}
+	};
+}
+/**
+* Picks the plugin generated clients, query hooks, and MCP handlers take their operation types from.
 *
-* @param group - The user-supplied group option, or `undefined` to disable grouping.
+* `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
-* createGroupConfig(group) // shared across every plugin
+* const types = resolveOperationTypes(ctx.driver, ctx.plugin.name)
+* types.response.options(node) // 'GetPetByIdOptions', or 'GetPetByIdOptionsSchemaType' from zod
 * ```
 */
-function createGroupConfig(group) {
-	if (!group) return null;
-	const defaultName = (ctx) => {
-		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-		return camelCase(ctx.group);
+function resolveOperationTypes(driver, pluginName) {
+	return driver.memo(`operationTypes:${pluginName}`, () => {
+		const pluginTs = driver.getPlugin(pluginTsName);
+		const pluginZod = driver.getPlugin(pluginZodName);
+		if (pluginTs && pluginZod?.options?.inferred !== "codec") {
+			const resolver = driver.getResolver(pluginTsName);
+			return {
+				response: resolver.response,
+				resolver,
+				output: pluginTs.options?.output,
+				group: pluginTs.options?.group ?? void 0
+			};
+		}
+		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 = toZodTypeResolver(driver.getResolver(pluginZodName));
+		return {
+			response: resolver.response,
+			resolver,
+			output: pluginZod.options.output,
+			group: pluginZod.options.group ?? void 0
+		};
+	});
+}
+// src/builders/security.ts
+const inlineAuthKeys = [
+	"type",
+	"scheme",
+	"name",
+	"in",
+	"scopes",
+	"flows",
+	"metadataUrl",
+	"url"
+];
+function serializeScheme({ ref, ...auth }) {
+	const scopes = auth.scopes?.length ? auth.scopes : void 0;
+	if (ref) {
+		const schemeRef = isValidVarName(ref) ? `securitySchemes.${ref}` : `securitySchemes[${text.quote(ref)}]`;
+		return scopes ? `{ ...${schemeRef}, scopes: ${toLiteral(scopes)} }` : schemeRef;
+	}
+	return `{ ${inlineAuthKeys.flatMap((key) => {
+		const entryValue = key === "scopes" ? scopes : auth[key];
+		return entryValue ? [`${key}: ${toLiteral(entryValue)}`] : [];
+	}).join(", ")} }`;
+}
+function serializeRequirement(requirement) {
+	return Array.isArray(requirement) ? `[${requirement.map(serializeScheme).join(", ")}]` : serializeScheme(requirement);
+}
+/**
+* Maps an AST credential to the inline `Auth` object, or `null` for `mutualTLS`, which the runtime cannot send.
+* `http` schemes other than `basic` are treated as bearer. OAuth2 and OpenID Connect keep their URLs for the `auth` resolver.
+*/
+function resolveCredential(credential) {
+	if (credential.type === "apiKey") return {
+		type: "apiKey",
+		name: credential.name,
+		in: credential.in
 	};
-	return {
-		...group,
-		name: group.name ? group.name : defaultName
+	if (credential.type === "http") return {
+		type: "http",
+		scheme: credential.scheme === "basic" ? "basic" : "bearer"
+	};
+	if (credential.type === "oauth2") {
+		const flows = Object.fromEntries(Object.entries(credential.flows).map(([name, { scopes: _scopes, ...urls }]) => [name, urls]));
+		return {
+			type: "oauth2",
+			...Object.keys(flows).length ? { flows } : {},
+			...credential.metadataUrl ? { metadataUrl: credential.metadataUrl } : {}
+		};
+	}
+	if (credential.type === "openIdConnect") return {
+		type: "openIdConnect",
+		...credential.url ? { url: credential.url } : {}
 	};
+	return null;
 }
-// kubb-extension.json
-var compatibility = {
-	"kubb": ">=5.16.0",
-	"node": ">=22.22"
-};
-// package.json
-var version = "5.12.0";
-// ../../internals/client/src/builders/validatorOptions.ts
+/**
+* Derives the per-operation security metadata from `OperationNode.auth` and the document's `meta.auth` schemes. Each
+* requirement becomes one entry: its scheme, or an array of its schemes when it needs several together. A requirement
+* with a scheme the runtime cannot place or that is not declared is left out, since it can never be met, and so is a
+* repeated one. With `hoist`, each scheme carries its name as `ref`.
+*
+* @example
+* `getOperationSecurity({ auth: [[{ scheme: 'bearerAuth' }]], schemes: meta.auth })`
+* `// [{ type: 'http', scheme: 'bearer' }]`
+* @example
+* `// auth: [[{ scheme: 'api_key' }, { scheme: 'session' }]] gives [[{ type: 'apiKey', ... }, { type: 'apiKey', ... }]]`
+*/
+function getOperationSecurity({ auth, schemes, hoist }) {
+	const security = ast.auth.getRequirements({
+		auth,
+		schemes
+	}).flatMap((requirement) => {
+		const resolved = requirement.map(({ name, credential, scopes }) => {
+			const entry = resolveCredential(credential);
+			return entry && {
+				...entry,
+				...scopes.length ? { scopes } : {},
+				...hoist ? { ref: name } : {}
+			};
+		});
+		if (!resolved.length || !resolved.every((entry) => entry !== null)) return [];
+		return [resolved.length === 1 ? resolved[0] : resolved];
+	});
+	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 scheme.
+*
+* @example
+* `buildSecurityMetadata({ security: [{ type: 'http', scheme: 'bearer' }] }) // "[{ type: 'http', scheme: 'bearer' }]"`
+*/
+function buildSecurityMetadata({ security }) {
+	if (!security?.length) return null;
+	return `[${security.map(serializeRequirement).join(", ")}]`;
+}
+/**
+* The `securitySchemes` const of `.kubb/client.ts`: every scheme the runtime can place, by name, or `null` without one.
+*/
+function buildSecuritySchemes(schemes) {
+	const entries = (schemes ?? []).flatMap(({ name, credential }) => {
+		const auth = resolveCredential(credential);
+		return auth ? [`${objectKey(name)}: ${serializeScheme(auth)}`] : [];
+	});
+	if (!entries.length) return null;
+	return `/**\n * The security schemes from the spec by name. A generated call sends one of them to the \`auth\` resolver.\n */\nexport const securitySchemes = { ${entries.join(", ")} } as const`;
+}
+// src/builders/validatorOptions.ts
 /**
 * Returns `true` when any direction of the validator uses zod (used for dependency checks).
 */
@@ -518,25 +711,136 @@ function resolveResponseValidator(validator) {
 	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.
+* Builds the `validator.error` map of a call, one plugin-zod `<operation>StatusNNNSchema` per non-2xx response with a
+* schema, such as `{ 404: getPetStatus404Schema, '5xx': getPetStatus5xxSchema }`. Returns `null` without one.
 */
 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;
+	const entries = node.responses.filter((res) => !ast.http.status.isSuccess(res) && res.content?.some((entry) => entry.schema)).map((res) => ({
+		key: String(res.statusCode),
+		name: zodResolver.response.status(node, res.statusCode)
+	}));
+	if (!entries.length) return null;
+	return {
+		literal: `{ ${entries.map(({ key, name }) => `${/^\d+$/.test(key) ? key : text.quote(key)}: ${name}`).join(", ")} }`,
+		names: entries.map(({ name }) => name)
+	};
+}
+// 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(ast.http.requestBody.getSchema(node));
+	const parsesResponse = zodResolver && resolveResponseValidator(validator) === "zod";
+	const hasResponseSchema = node.responses.some((res) => res.content?.some((entry) => entry.schema));
+	const response = parsesResponse && hasResponseSchema ? zodResolver.response.response(node) || null : null;
+	const errorParse = parsesResponse ? buildZodErrorParse(node, zodResolver) : null;
+	const request = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body(node) || null : null;
+	const paramGroups = ast.http.groupParameters(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 cookies = resolveParamsName("cookies", paramGroups.cookie);
+	const importedZodNames = [
+		response,
+		...errorParse?.names ?? [],
+		request,
+		path,
+		query,
+		headers,
+		cookies
+	].filter((name) => Boolean(name));
+	return {
+		request,
+		path,
+		query,
+		headers: headers ? `toHeadersStandardSchema(${headers}, ${headers}.shape)` : null,
+		cookies,
+		response,
+		error: errorParse?.literal ?? null,
+		importedZodNames
+	};
+}
+/**
+* Prints the `validator: { … }` entry of a call config from the hooks named in `keys`, or `null` when none is set.
+* The entry spreads `config.validator` last, so a per-call hook overrides the generated one for its key only.
+*/
+function buildValidatorLiteral(hooks, keys) {
+	const entries = keys.flatMap((key) => hooks?.[key] ? [`${key}: ${hooks[key]}`] : []);
+	return entries.length ? `validator: { ${entries.join(", ")}, ...config.validator }` : null;
 }
-// ../../internals/client/src/builders/generics.ts
+// src/builders/operationData.ts
 /**
-* Builds the `RequestResult` generic arguments for one operation: the per-status responses record
-* plus the per-call `ThrowOnError` flag. `SuccessOf` / `ErrorOf` split the record inside the
-* runtime, so this only names the record and threads `ThrowOnError`.
+* Resolves what the function and SDK generators both print for one operation: its name, the files its types and zod
+* schemas come from, and its validator hooks, security, base URL and response headers types.
+*/
+function resolveOperationData({ node, ctx, types }) {
+	const { driver, resolver, root } = ctx;
+	const { output, validator, importPath } = ctx.options;
+	const pluginZod = isValidatorEnabled(validator) ? driver.getPlugin(pluginZodName$1) : null;
+	const zodResolver = pluginZod ? driver.getResolver(pluginZodName$1) : null;
+	return {
+		node,
+		name: resolver.resolveName({
+			key: operationKey(node),
+			name: resolver.name(node.operationId)
+		}),
+		types,
+		typeFile: resolveOperationFile({
+			ctx,
+			node,
+			resolver: types.resolver,
+			root,
+			output: types.output ?? output,
+			group: types.group
+		}),
+		zodFile: zodResolver && pluginZod?.options ? resolveOperationFile({
+			ctx,
+			node,
+			resolver: zodResolver,
+			root,
+			output: pluginZod.options.output ?? output,
+			group: pluginZod.options.group ?? void 0
+		}) : null,
+		validatorHooks: buildValidatorHooks({
+			node,
+			validator,
+			zodResolver
+		}),
+		headerTypeNames: getResponseHeadersTypeNames({
+			node,
+			types
+		}),
+		security: getOperationSecurity({
+			auth: node.auth,
+			schemes: ctx.meta.auth,
+			hoist: importPath === void 0
+		}),
+		baseURL: ast.http.getBaseURL(ast.server.get({
+			servers: node.servers,
+			index: ctx.adapter.options?.server?.index
+		}))
+	};
+}
+// src/builders/generics.ts
+/**
+* Builds the `RequestResult` type arguments of one operation: responses, `ThrowOnError` and the response headers, when a response declares any.
 *
 * @example
-* `buildRequestResultGenerics({ node, types }) // 'AddPetResponses, ThrowOnError'`
+* `buildRequestResultGenerics({ node, types }) // "LoginUserResponses, ThrowOnError, { '200': LoginUserStatus200Headers }"`
 */
 function buildRequestResultGenerics({ node, types }) {
-	return `${types.response.responses(node)}, ThrowOnError`;
+	return [
+		types.response.responses(node),
+		"ThrowOnError",
+		buildResponseHeadersType({
+			node,
+			types
+		})
+	].filter(Boolean).join(", ");
 }
 /**
 * Builds the full return type an operation's function signature uses: `Unwrappable<RequestResult>`
@@ -549,225 +853,127 @@ function buildRequestResultGenerics({ node, types }) {
 * `buildResultType({ node, types, returnType: 'data' }) // 'Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>'`
 */
 function buildResultType({ node, types, returnType }) {
-	const generics = buildRequestResultGenerics({
+	const result = buildResultTypeRef(returnType === "data" ? "UnwrappedResult" : "RequestResult", types.response.responses(node), buildResponseHeadersType({
 		node,
 		types
-	});
-	if (returnType === "data") return `Promise<UnwrappedResult<${generics}>>`;
-	if (returnType === "plain") return `Promise<RequestResult<${generics}>>`;
-	return `Unwrappable<RequestResult<${generics}>>`;
-}
-// ../../internals/client/src/builders/returnStatement.ts
-/**
-* Builds the return statement of a generated operation function. With the default
-* `returnType: 'full'` the runtime call already resolves to `{ data, error, request, response }`.
-* The generated code casts that result to the operation's `RequestResult`, then wraps it with
-* `withUnwrap`, so the caller can `await` it directly or call `.unwrap()` for the bare success
-* body. With `returnType: 'data'` it instead routes the call through the runtime's `unwrapResult`,
-* which narrows the resolved value down to the bare success body the same way `RequestResult`
-* already does, using the plugin default when the call leaves `throwOnError` unset.
-* With `returnType: 'plain'` it returns the runtime call as is, cast to `RequestResult`, with no helper.
-*
-* Cast first, wrap second, for the `'full'` path. That order keeps `withUnwrap`'s generic inferred
-* as `RequestResult` instead of the runtime's own internal result type. Casting an `Unwrappable<A>`
-* straight to `Unwrappable<B>` does not work: the `.then` overload stays pinned to `A`, and `as`
-* rejects that two-generic swap even where `A` and `B` on their own would satisfy it.
+	}), ["ThrowOnError"]);
+	return returnType === "full" ? `Unwrappable<${result}>` : `Promise<${result}>`;
+}
+// src/builders/returnStatement.ts
+/**
+* Builds the return statement of a generated operation function. The client call takes the responses record and
+* `ThrowOnError` as type arguments, so its result is already the operation's `RequestResult` and needs no cast. With the
+* default `returnType: 'full'` it is wrapped in `withUnwrap`, so the caller can `await` it or call `.unwrap()`. With
+* `returnType: 'data'` it goes through `unwrapResult`, which keeps the success body when the call throws on errors.
+* With `returnType: 'plain'` it is returned as is.
 *
 * @example
-* `return withUnwrap(request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>)`
+* `return withUnwrap(apiClient<AddPetResponses, ThrowOnError>({ method: 'POST', url: '/pet', ...config }))`
 * @example
-* `return unwrapResult(request({ method: 'POST', url: '/pet', ...config }), config.throwOnError ?? false) as Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>`
+* `return unwrapResult(apiClient<AddPetResponses, ThrowOnError>({ ... }), resolveThrowOnError(config.throwOnError, true))`
 * @example
-* `return request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>`
+* `return apiClient<AddPetResponses, ThrowOnError>({ method: 'POST', url: '/pet', ...config })`
 */
 function buildReturnStatement({ node, types, callConfig, returnType, throwOnErrorDefault }) {
-	const request = returnType !== "plain" && hasRequestContentTypeChoice(node) ? `request<${types.response.options(node)}['body']>` : "request";
-	if (returnType === "data") return `return unwrapResult(${request}(${callConfig}), config.throwOnError ?? ${throwOnErrorDefault}) as ${buildResultType({
-		node,
-		types,
-		returnType
-	})}`;
-	if (returnType === "plain") return `return ${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
+	const call = `apiClient<${buildRequestResultGenerics({
 		node,
 		types
-	})}>>`;
-	return `return withUnwrap(${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
-		node,
-		types
-	})}>>)`;
-}
-/**
-* Builds the return type and statement of a `text/event-stream` operation. The item type is `TypedEvent<...>` when each item
-* declares its own `event` and `data`, and otherwise the payload type, which `EventStreamResult` wraps in `ServerSentEvent`. The call's
-* promise goes through `toEventStream` with the `client` for its defaults, the call's `config`, the shape and the per-event
-* validator. A `returnType: 'plain'` client receives only the promise,
-* `toEventStream(request(config))`, and keeps its response validator in the call config.
-*/
-function buildEventStreamReturn({ node, types, callConfig, returnType, validatorHooks, throwOnErrorDefault }) {
-	const shape = getEventStream(node) ?? "data";
-	const responses = types.response.responses(node);
-	const success = `SuccessOf<${responses}>`;
-	const eventType = shape === "event" ? `TypedEvent<${success}>` : success;
-	if (returnType === "plain") return {
-		returnType: `Promise<EventStreamResult<${eventType}>>`,
-		statement: `return toEventStream<${eventType}>(request(${callConfig}))`
-	};
-	const generics = `${responses}, ThrowOnError${shape === "event" ? `, ${eventType}` : ""}`;
-	const call = `toEventStream<${eventType}>(request(${callConfig}), { client: request, config, ${[`shape: '${shape}'`, validatorHooks?.response ? `validator: ${validatorHooks.response}` : null].filter(Boolean).join(", ")} })`;
-	if (returnType === "data") {
-		const result = `Promise<UnwrappedStreamResult<${generics}>>`;
-		return {
-			returnType: result,
-			statement: `return unwrapResult(${call}, config.throwOnError ?? ${throwOnErrorDefault}) as ${result}`
-		};
-	}
-	return {
-		returnType: `Unwrappable<StreamResult<${generics}>>`,
-		statement: `return withUnwrap(${call} as Promise<StreamResult<${generics}>>)`
-	};
-}
-/** The stream types an operation file imports: `StreamResult` and `StreamOptions`, `EventStreamResult` for a plain client, and `TypedEvent` for named events. */
-function buildEventStreamImports({ returnType, typed }) {
-	return [...{
-		plain: ["EventStreamResult"],
-		full: ["StreamResult", "StreamOptions"],
-		data: ["UnwrappedStreamResult", "StreamOptions"]
-	}[returnType], ...typed ? ["TypedEvent"] : []];
-}
-// ../../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}'`);
-	if (auth.scopes?.length) parts.push(`scopes: [${auth.scopes.map((scope) => `'${scope}'`).join(", ")}]`);
-	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, scopes] of Object.entries(requirement)) {
-		if (seen.has(schemeName)) continue;
-		seen.add(schemeName);
-		const auth = resolveSecurityScheme(definitions[schemeName]);
-		if (auth) security.push(scopes.length ? {
-			...auth,
-			scopes
-		} : 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(", ")}]`;
+	})}>(${callConfig})`;
+	if (returnType === "data") return `return unwrapResult(${call}, resolveThrowOnError(config.throwOnError, ${throwOnErrorDefault}))`;
+	if (returnType === "plain") return `return ${call}`;
+	return `return withUnwrap(${call})`;
 }
-// ../../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.
+* Builds the return type and statement of a streamed operation, which calls `apiClient.stream`. The item type is
+* `TypedEvent<...>` when each event declares its own `event` and `data`, the success type itself for JSON Lines, and
+* otherwise the default, `ServerSentEvent` around the payload, which needs no type argument.
 */
-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,
+function buildEventStreamReturn({ node, types, callConfig, returnType, throwOnErrorDefault }) {
+	const shape = getEventStream(node) ?? "data";
+	const responses = types.response.responses(node);
+	const headers = buildResponseHeadersType({
+		node,
+		types
+	});
+	const success = `SuccessOf<${responses}>`;
+	const item = {
+		event: `TypedEvent<${success}>`,
+		data: null,
+		line: success
+	}[shape];
+	const call = `apiClient.stream<${[
+		responses,
+		"ThrowOnError",
+		item ?? (headers ? `ServerSentEvent<${success}>` : null),
 		headers
-	].filter((name) => Boolean(name));
+	].filter(Boolean).join(", ")}>(${callConfig})`;
+	const result = (name) => buildResultTypeRef(name, responses, headers, ["ThrowOnError", item]);
+	if (returnType === "plain") return {
+		returnType: `Promise<${result("StreamResult")}>`,
+		statement: `return ${call}`
+	};
+	if (returnType === "data") return {
+		returnType: `Promise<${result("UnwrappedStreamResult")}>`,
+		statement: `return unwrapResult(${call}, resolveThrowOnError(config.throwOnError, ${throwOnErrorDefault}))`
+	};
 	return {
-		request,
-		path,
-		query,
-		headers: headers ? `toHeadersStandardSchema(${headers}, ${headers}.shape)` : null,
-		response,
-		error,
-		importedZodNames
+		returnType: `Unwrappable<${result("StreamResult")}>`,
+		statement: `return withUnwrap(${call})`
 	};
 }
 /**
-* Prints the `validator: { … }` entry of a call config from the hooks named in `keys`, or `null` when none is set.
+* The stream types an operation file imports from the client for one streamed operation: the result and options types
+* for `returnType`, their `WithHeaders` form when the response declares headers, and `SuccessOf` with `TypedEvent` or
+* `ServerSentEvent` for an item type the call spells out.
 */
-function buildValidatorLiteral(hooks, keys) {
-	const entries = keys.flatMap((key) => hooks?.[key] ? [`${key}: ${hooks[key]}`] : []);
-	return entries.length ? `validator: { ${entries.join(", ")} }` : null;
+function buildEventStreamImports({ node, types, returnType }) {
+	const shape = getEventStream(node) ?? "data";
+	const headers = buildResponseHeadersType({
+		node,
+		types
+	}) !== null;
+	const result = {
+		plain: ["Options", "StreamResult"],
+		full: [
+			"StreamOptions",
+			"Unwrappable",
+			"StreamResult"
+		],
+		data: ["StreamOptions", "UnwrappedStreamResult"]
+	}[returnType].map((name) => name.endsWith("Result") ? resultTypeName(name, headers) : name);
+	const item = {
+		event: ["SuccessOf", "TypedEvent"],
+		data: headers ? ["SuccessOf", "ServerSentEvent"] : [],
+		line: ["SuccessOf"]
+	}[shape];
+	return [...result, ...item];
 }
-// ../../internals/client/src/builders/contentType.ts
+// src/builders/contentType.ts
 /**
-* Builds the `contentType` entry baked into the call config, or `null` without a request body.
+* Builds the `contentType` entry baked into the call config. It holds the request default when the operation has a body
+* and `response` set to the streamed media type when it streams items, or `text/event-stream` when it offers events next to
+* another type, and is `null` with neither.
 *
-* `merge` is `true` when the generated function must destructure `contentType` from `options` and
-* merge it over the baked request default, because the caller can also pick a response content type.
+* `merge` is `true` when the generated function must destructure `contentType` from `options` and merge it over the
+* baked defaults, because the caller can also pick a response content type or a stream must keep its `Accept`.
 */
 function buildContentType({ node }) {
 	const { defaultContentType } = getContentTypeInfo(node);
-	const requestContentType = Boolean(node.requestBody?.content?.[0]?.schema) ? defaultContentType : null;
+	const requestContentType = Boolean(ast.http.requestBody.getSchema(node)) ? defaultContentType : null;
+	const streamType = isEventStream(node) ? ast.mediaType.getBase(getResponseContentTypeInfo(node).defaultContentType) : null;
+	const response = streamType || hasEventStreamContent(node) ? `response: ${text.quote(streamType ?? "text/event-stream")}` : null;
 	if (!requestContentType) return {
-		literal: null,
+		literal: response && `contentType: { ${response} }`,
 		merge: false
 	};
-	const merge = getResponseContentTypeInfo(node).isMultipleContentTypes;
+	const merge = Boolean(response) || getResponseContentTypeInfo(node).isMultipleContentTypes;
+	const defaults = [`request: ${text.quote(requestContentType)}`, response].filter(Boolean).join(", ");
 	return {
 		merge,
-		literal: merge ? `contentType: { request: '${requestContentType}', ...(typeof contentType === 'string' ? { request: contentType } : contentType) }` : `contentType: { request: '${requestContentType}' }`
+		literal: merge ? `contentType: { ${defaults}, ...(typeof contentType === 'string' ? { request: contentType } : contentType) }` : `contentType: { ${defaults} }`
 	};
 }
-// ../../internals/client/src/builders/styles.ts
+// src/builders/styles.ts
 /**
 * Renders a parameter name as an object-literal key, quoted when it is not a bare identifier. Every
 * location keeps the spec name: the runtime looks path styles up by the `{name}` placeholder in the
@@ -779,27 +985,35 @@ function toKey(name) {
 /**
 * Serializes one parameter's metadata into a `{ style, explode, allowReserved, contentType }`
 * literal, or `null` when the parameter carries none. Path and query carry the serialization
-* `style`; header and cookie use a fixed style (`simple` and `form`), so only `explode` is emitted
-* for them. `allowReserved` only applies to query parameters, and `contentType` to every location
-* except path.
+* `style`. Header and cookie have a fixed style (`simple` and `form`), so they emit only `explode`,
+* plus `style: 'cookie'` when a cookie parameter sets the OpenAPI 3.2 `cookie` style.
+* `allowReserved` only applies to query parameters, and `contentType` to every location except path.
 */
 function serializeParameter(parameter) {
-	const parts = [];
-	if ((parameter.in === "path" || parameter.in === "query") && parameter.style) parts.push(`style: '${parameter.style}'`);
-	if (parameter.explode !== void 0) parts.push(`explode: ${parameter.explode}`);
-	if (parameter.in === "query" && parameter.allowReserved !== void 0) parts.push(`allowReserved: ${parameter.allowReserved}`);
-	if (parameter.in !== "path" && parameter.contentType) parts.push(`contentType: '${parameter.contentType}'`);
-	if (parameter.in === "querystring") parts.push("querystring: true");
+	const parts = [
+		(parameter.in === "path" || parameter.in === "query") && parameter.style && `style: '${parameter.style}'`,
+		parameter.in === "cookie" && parameter.style === "cookie" && `style: 'cookie'`,
+		parameter.explode !== void 0 && `explode: ${parameter.explode}`,
+		parameter.in === "query" && parameter.allowReserved !== void 0 && `allowReserved: ${parameter.allowReserved}`,
+		parameter.in !== "path" && parameter.contentType && `contentType: ${text.quote(parameter.contentType)}`,
+		parameter.in === "querystring" && "querystring: true"
+	].filter(Boolean);
 	return parts.length > 0 ? `{ ${parts.join(", ")} }` : null;
 }
 /**
-* Serializes the `encoding` of the request body's default content type into a `{ property: { ... } }`
-* literal, or `null` when it carries none. Only an operation with a single request content type
+* Whether a query parameter of the operation has a style entry, so the call needs the styled query serializer.
+*/
+function hasQueryStyles(node) {
+	return ast.http.isOperation(node) && ast.http.groupParameters(node).query.some((parameter) => serializeParameter(parameter) !== null);
+}
+/**
+* Serializes the `encoding` of the request body's default content type into `property: { ... }`
+* entries, empty when it carries none. Only an operation with a single request content type
 * emits it, because the runtime applies `styles.body` to whichever type the caller selects.
 */
 function serializeBodyEncoding(node) {
 	const content = node.requestBody?.content;
-	const entries = Object.entries(content?.length === 1 ? content[0]?.encoding ?? {} : {}).map(([property, { contentType, style, explode, allowReserved }]) => {
+	return Object.entries(content?.length === 1 ? content[0]?.encoding ?? {} : {}).map(([property, { contentType, style, explode, allowReserved }]) => {
 		const parts = [
 			style && `style: ${JSON.stringify(style)}`,
 			explode !== void 0 && `explode: ${explode}`,
@@ -808,7 +1022,6 @@ function serializeBodyEncoding(node) {
 		].filter(Boolean);
 		return `${isValidVarName(property) ? property : JSON.stringify(property)}: { ${parts.join(", ")} }`;
 	});
-	return entries.length > 0 ? `body: { ${entries.join(", ")} }` : null;
 }
 /**
 * Builds the per-operation `styles` literal from the operation's parameters, grouped by location.
@@ -818,83 +1031,94 @@ function serializeBodyEncoding(node) {
 * is unchanged. A form request body adds a `body` group keyed by property name from its `encoding`.
 * Returns `null` when nothing carries metadata.
 *
+* With `merge`, the literal spreads `config.styles` per parameter, so a per-call entry overrides the generated one for
+* that parameter and leaves the others in place.
+*
 * @example
 * ```ts
 * // a path param with { style: 'matrix', explode: true } and a query param with { explode: false }
 * buildStyles({ node }) // "{ path: { id: { style: 'matrix', explode: true } }, query: { tags: { explode: false } } }"
 * ```
 */
-function buildStyles({ node }) {
-	if (!ast.isHttpOperationNode(node)) return null;
+function buildStyles({ node, merge }) {
+	if (!ast.http.isOperation(node)) return null;
 	const groups = {
 		path: [],
 		query: [],
 		header: [],
-		cookie: []
+		cookie: [],
+		body: serializeBodyEncoding(node)
 	};
-	for (const [location, parameters] of Object.entries(getOperationParameters(node))) for (const parameter of parameters) {
+	for (const [location, parameters] of Object.entries(ast.http.groupParameters(node))) for (const parameter of parameters) {
 		const literal = serializeParameter(parameter);
 		if (literal) groups[location].push(`${toKey(parameter.name)}: ${literal}`);
 	}
-	const entries = [...Object.keys(groups).filter((location) => groups[location].length > 0).map((location) => `${location}: { ${groups[location].join(", ")} }`), serializeBodyEncoding(node)].filter(Boolean);
-	return entries.length > 0 ? `{ ${entries.join(", ")} }` : null;
+	const entries = Object.entries(groups).filter(([, items]) => items.length > 0).map(([location, items]) => `${location}: { ${(merge ? [...items, `...config.styles?.${location}`] : items).join(", ")} }`);
+	if (entries.length === 0) return null;
+	return `{ ${(merge ? ["...config.styles", ...entries] : entries).join(", ")} }`;
 }
-// ../../internals/client/src/builders/callConfig.ts
+// src/builders/callConfig.ts
 /**
-* `responseType` baked into a call. One parser is a string. Several parsers become a map from content
-* type to parser so the runtime can choose from the response `Content-Type`.
+* `parseAs: 'blob'` when every success content type is binary, so a download is a `Blob` whatever its media type, and
+* also when the server sends no `Content-Type`. Any other body is decoded by its media type at runtime.
 */
-function buildResponseTypeLiteral(node) {
-	const responseType = getResponseType(node);
-	if (responseType) return `responseType: '${responseType}'`;
-	const responseTypes = getResponseTypeMap(node);
-	if (!responseTypes) return null;
-	return `responseType: { ${Object.entries(responseTypes).map(([contentType, type]) => `${JSON.stringify(contentType)}: '${type}'`).join(", ")} }`;
+function buildParseAsLiteral(content) {
+	return content.length > 0 && content.every((entry) => entry.schema?.type === "blob") ? `parseAs: 'blob'` : null;
 }
 /**
 * Builds the call config literal a generated operation forwards to the client, shared by the standalone
-* functions and the SDK methods. The `throwOnError` fallback is applied after the `...config` spread.
+* functions and the SDK methods. The operation's own `baseURL` comes before the `...config` spread, so a per-call one wins. The
+* `validator` and `throwOnError` entries come after it, so a per-call `validator` is merged per key with the generated one instead
+* of replacing it. `styles` is merged the same way, per parameter, unless `returnType` is `'plain'`.
 *
 * `mergeContentType` is `true` when the caller must destructure `contentType` from `options`, and
-* `eventStream` is `true` when the operation returns `text/event-stream`. Unless `returnType` is `'plain'`, a
-* stream's literal leaves the `response` validator to `toEventStream`, which runs it per event.
+* `eventStream` is `true` when the operation streams `text/event-stream` or JSON Lines. A Server-Sent Events call
+* carries its `eventShape`, which tells the runtime what the `response` validator checks on each event, and `rawData` when
+* the document types each event's `data` as a string, so the runtime keeps it as text.
 */
-function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault, returnType }) {
-	const eventStream = isEventStream(node);
+function buildCallConfig({ node, validatorHooks, security, baseURL, throwOnErrorDefault, returnType }) {
+	const stream = getEventStream(node);
+	const content = ast.http.responses.findPrimary(node)?.content ?? [];
 	const securityLiteral = buildSecurityMetadata({ security });
-	const stylesLiteral = buildStyles({ node });
-	const validatorLiteral = buildValidatorLiteral(validatorHooks, eventStream && returnType !== "plain" ? [
-		"request",
-		"path",
-		"query",
-		"headers",
-		"error"
-	] : [
+	const ownRuntime = returnType !== "plain";
+	const stylesLiteral = buildStyles({
+		node,
+		merge: ownRuntime
+	});
+	const styles = stylesLiteral ? `styles: ${stylesLiteral}` : null;
+	const validatorLiteral = buildValidatorLiteral(validatorHooks, [
 		"request",
 		"path",
 		"query",
 		"headers",
+		"cookies",
 		"response",
 		"error"
 	]);
 	const { literal: contentTypeLiteral, merge: mergeContentType } = buildContentType({ node });
+	const throwOnError = ownRuntime ? `throwOnError: resolveThrowOnError(config.throwOnError, ${throwOnErrorDefault})` : `throwOnError: config.throwOnError ?? ${throwOnErrorDefault}`;
+	const rawData = hasTextEventData(node);
 	return {
 		callConfig: `{ ${[
-			`method: '${node.method.toUpperCase()}'`,
-			`url: '${node.path}'`,
+			`method: ${text.quote(node.method.toUpperCase())}`,
+			`url: ${text.quote(node.path)}`,
+			baseURL ? `baseURL: ${JSON.stringify(baseURL)}` : null,
 			securityLiteral ? `security: ${securityLiteral}` : null,
-			stylesLiteral ? `styles: ${stylesLiteral}` : null,
-			validatorLiteral,
+			ownRuntime ? null : styles,
 			contentTypeLiteral,
-			buildResponseTypeLiteral(node),
+			buildParseAsLiteral(content),
+			stream === "event" || stream === "data" ? `eventShape: '${stream}'` : null,
+			rawData ? `rawData: ${toLiteral(rawData)}` : null,
 			"...config",
-			`throwOnError: config.throwOnError ?? ${throwOnErrorDefault}`
+			ownRuntime ? styles : null,
+			validatorLiteral,
+			throwOnError
 		].filter(Boolean).join(", ")} }`,
 		mergeContentType,
-		eventStream
+		eventStream: stream !== null
 	};
 }
-// ../../internals/client/src/builders/signature.ts
+// src/builders/signature.ts
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 /**
 * Builds the grouped-options signature for one operation: a single `options` object whose `TData`
@@ -923,17 +1147,18 @@ function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDef
 		generics: [`ThrowOnError extends boolean = ${throwOnErrorDefault}`]
 	};
 }
-// ../../internals/client/src/builders/operationBody.ts
+// src/builders/operationBody.ts
 /**
 * The pieces of a generated operation: its generics, `options` parameter, return type, return statement, and whether the
 * body destructures `contentType` from `options`. Shared by the standalone functions and the SDK methods, so a
-* `text/event-stream` operation is wired to `toEventStream` in one place.
+* streamed operation is wired to `apiClient.stream` in one place.
 */
-function buildOperationBody({ node, types, validatorHooks, security, returnType, throwOnErrorDefault }) {
+function buildOperationBody({ node, types, validatorHooks, security, baseURL, returnType, throwOnErrorDefault }) {
 	const { callConfig, mergeContentType, eventStream } = buildCallConfig({
 		node,
 		validatorHooks,
 		security,
+		baseURL,
 		throwOnErrorDefault,
 		returnType
 	});
@@ -949,7 +1174,6 @@ function buildOperationBody({ node, types, validatorHooks, security, returnType,
 		types,
 		callConfig,
 		returnType,
-		validatorHooks,
 		throwOnErrorDefault
 	}) : null;
 	return {
@@ -966,20 +1190,21 @@ function buildOperationBody({ node, types, validatorHooks, security, returnType,
 		mergeContentType
 	};
 }
-// ../../internals/client/src/components/Operation.tsx
+// src/components/Operation.tsx
 /**
 * Renders one client operation: the grouped `<Name>Request` type and the function that forwards a
 * single `options` object to the resolved client and returns the `Unwrappable<RequestResult>`. The
 * type, signature, and call config are built with the AST factory, and only the jsx-renderer emits
 * the source.
 */
-function Operation({ name, node, types, validatorHooks, returnType, throwOnErrorDefault, security }) {
-	if (!ast.isHttpOperationNode(node)) return null;
+function Operation({ name, node, types, validatorHooks, returnType, throwOnErrorDefault, security, baseURL }) {
+	if (!ast.http.isOperation(node)) return null;
 	const body = buildOperationBody({
 		node,
 		types,
 		validatorHooks,
 		security,
+		baseURL,
 		returnType,
 		throwOnErrorDefault
 	});
@@ -993,231 +1218,232 @@ function Operation({ name, node, types, validatorHooks, returnType, throwOnError
 			generics: body.generics,
 			params: body.paramsSignature,
 			returnType: body.returnType,
-			JSDoc: { comments: buildOperationComments(node, {
-				link: "urlPath",
-				linkPosition: "beforeDeprecated",
-				splitLines: true
-			}) },
+			JSDoc: { comments: buildOperationComments(node, { splitLines: true }) },
 			children: [
-				body.mergeContentType ? "const { client: request = client, contentType, ...config } = options" : "const { client: request = client, ...config } = options",
+				body.mergeContentType ? "const { client: apiClient = client, contentType, ...config } = options" : "const { client: apiClient = client, ...config } = options",
 				/* @__PURE__ */ jsx("br", {}),
 				body.statement
 			]
 		})
 	});
 }
-// ../../internals/client/src/components/StreamRuntime.tsx
-/**
-* The `footer` of `.kubb/client.ts`: the `baseURL` set at generation time, and the `sse.ts` re-export when the document
-* streams events, so `ServerSentEvent` and `toEventStream` stay importable from the client as in earlier releases.
-*/
-function buildClientFooter({ baseURL, sse }) {
-	const baseURLExpression = baseURL ? baseURL.includes("${") ? `\`${baseURL.replaceAll("`", "\\`")}\`` : JSON.stringify(baseURL) : void 0;
-	return [baseURLExpression ? `client.setConfig({ baseURL: ${baseURLExpression} })` : null, sse ? `export * from './sse.ts'` : null].filter(Boolean).join("\n") || void 0;
-}
-/**
-* Writes the footer of the `.kubb/client.ts` the plugin injected, the one place it is built, and copies `sse.ts` into
-* `.kubb/` only for a document with a `text/event-stream` operation, so a document without streams ships no stream runtime.
-* `sse` is set by the plugins that ship the runtime, so a custom client from `@kubb/plugin-client` gets neither file.
-*/
-function StreamRuntime({ nodes, root, sse, baseURL }) {
-	if (!sse) return null;
-	const streams = nodes.some(isEventStream);
-	const footer = buildClientFooter({
-		baseURL,
-		sse: streams
-	});
-	return /* @__PURE__ */ jsxs(Fragment, { children: [streams && /* @__PURE__ */ jsx(File, {
-		baseName: "sse.ts",
-		path: path.resolve(root, ".kubb/sse.ts"),
-		copy: sse
-	}), footer && /* @__PURE__ */ jsx(File, {
-		baseName: "client.ts",
-		path: path.resolve(root, ".kubb/client.ts"),
-		footer
-	})] });
+// src/components/ClientRuntime.tsx
+function buildServersExport(servers) {
+	const named = ast.server.groupByName(servers);
+	if (!named.size) return null;
+	return `/**\n * The servers from the spec by name, for \`baseURL\`.\n */\nexport const servers = { ${[...named].map(([name, { url }]) => `${objectKey(name)}: ${text.quote(url)}`).join(", ")} } as const`;
 }
-// ../../internals/client/src/resolveOperationTypes.ts
+const formMediaTypes = {
+	"multipart/form-data": {
+		file: "mediaTypes/formData",
+		name: "multipartFormData"
+	},
+	"application/x-www-form-urlencoded": {
+		file: "mediaTypes/urlencoded",
+		name: "urlencoded"
+	}
+};
 /**
-* 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.
+* Writes the runtime a document needs into `.kubb/`: the optional media type, serializer and `sse.ts` files, and a
+* `config.ts` that imports them, which `client.ts` passes to `setConfig`. The footer of `client.ts` gets the named
+* `servers` and `securitySchemes` and the `sse.ts` re-export. `templates` is the folder the runtime is copied from, set
+* by the plugins that ship it, so a custom client from `@kubb/plugin-client` gets none of this.
 */
-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))
+function ClientRuntime({ nodes, root, templates, baseURL, servers, auth }) {
+	if (!templates) return null;
+	const hasParameter = (match) => nodes.some((node) => node.parameters.some(match));
+	const streams = nodes.some((node) => hasEventStreamContent(node) || isEventStream(node) || hasStreamVariant(node));
+	const forms = [...new Set(nodes.flatMap(getFormContentTypes))].sort().map((contentType) => ({
+		contentType,
+		...formMediaTypes[contentType]
+	}));
+	const serializers = [
+		nodes.some(hasQueryStyles) ? {
+			key: "query",
+			file: "serializers/queryStyles",
+			name: "serializeStyledQuery"
+		} : {
+			key: "query",
+			file: "serializers/query",
+			name: "serializeQuery"
 		},
-		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(pluginTsName);
-		const pluginZod = driver.getPlugin(pluginZodName);
-		if (pluginTs && pluginZod?.options?.inferred !== "codec") {
-			const resolver = driver.getResolver(pluginTsName);
-			return {
-				response: resolver.response,
-				resolver,
-				output: pluginTs.options?.output,
-				group: pluginTs.options?.group ?? void 0
-			};
-		}
-		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 = toZodTypeResolver(driver.getResolver(pluginZodName));
-		return {
-			response: resolver.response,
-			resolver,
-			output: pluginZod.options.output,
-			group: pluginZod.options.group ?? void 0
-		};
-	});
+		hasParameter((parameter) => parameter.in === "path" && (parameter.style === "label" || parameter.style === "matrix")) ? {
+			key: "path",
+			file: "serializers/pathStyles",
+			name: "serializeStyledPath"
+		} : {
+			key: "path",
+			file: "serializers/path",
+			name: "serializePath"
+		},
+		hasParameter((parameter) => parameter.in === "header") ? {
+			key: "header",
+			file: "serializers/headers",
+			name: "serializeHeaders"
+		} : null,
+		hasParameter((parameter) => parameter.in === "cookie") ? {
+			key: "cookie",
+			file: "serializers/cookies",
+			name: "serializeCookies"
+		} : null
+	].filter((serializer) => serializer !== null);
+	const imports = [
+		...forms,
+		...streams ? [{
+			file: "sse",
+			name: "streamMediaTypes"
+		}] : [],
+		...serializers
+	];
+	const files = /* @__PURE__ */ new Set([
+		...imports.map(({ file }) => file),
+		"serializers/path",
+		...forms.some(({ name }) => name === "urlencoded") ? ["serializers/queryStyles"] : []
+	]);
+	const baseURLExpression = baseURL ? baseURL.includes("${") ? `\`${baseURL.replaceAll("`", "\\`")}\`` : JSON.stringify(baseURL) : void 0;
+	const mediaTypes = [...forms.map(({ contentType, name }) => `'${contentType}': ${name}`), streams ? "...streamMediaTypes" : null].filter(Boolean);
+	const config = [
+		baseURLExpression ? `baseURL: ${baseURLExpression}` : null,
+		mediaTypes.length ? `mediaTypes: { ${mediaTypes.join(", ")} }` : null,
+		`serializer: { ${serializers.map(({ key, name }) => `${key}: ${name}`).join(", ")} }`
+	].filter(Boolean);
+	const footer = [
+		buildServersExport(servers),
+		buildSecuritySchemes(auth),
+		streams ? `export * from './sse.ts'` : null
+	].filter(Boolean).join("\n");
+	const configPath = path.resolve(root, ".kubb/config.ts");
+	const runtimePath = (file) => path.resolve(root, ".kubb", `${file}.ts`);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		[...files].map((file) => /* @__PURE__ */ jsx(File, {
+			baseName: `${path.basename(file)}.ts`,
+			path: runtimePath(file),
+			copy: path.join(templates, `${file}.ts`)
+		}, file)),
+		/* @__PURE__ */ jsxs(File, {
+			baseName: "config.ts",
+			path: configPath,
+			children: [
+				imports.map(({ file, name }) => /* @__PURE__ */ jsx(File.Import, {
+					name: [name],
+					root: configPath,
+					path: runtimePath(file)
+				}, name)),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["ClientConfig"],
+					root: configPath,
+					path: runtimePath("core"),
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(File.Source, {
+					name: "defaultConfig",
+					isExportable: true,
+					children: `/**\n * The config \`client.ts\` starts with: what this spec needs from the runtime.\n */\nexport const defaultConfig: ClientConfig = { ${config.join(", ")} }`
+				})
+			]
+		}),
+		footer && /* @__PURE__ */ jsx(File, {
+			baseName: "client.ts",
+			path: path.resolve(root, ".kubb/client.ts"),
+			footer
+		})
+	] });
 }
-// ../../internals/client/src/generators/clientGenerator.tsx
+// src/generators/clientGenerator.tsx
 /**
-* Builds the built-in per-operation generator shared by the client plugins (`@kubb/plugin-fetch`,
-* `@kubb/plugin-axios`). Emits one async function per OpenAPI operation using the shared
-* `Operation` component: a grouped `<Name>Request` type and a function that forwards a single
-* `options` object to the bundled `client` and returns the `Unwrappable<RequestResult>`. Only the
-* generator `name` and the runtime templates differ between plugins. Every other resolution, import,
-* and rendering step is identical.
-*
-* `sse` is the Server-Sent Events runtime template, copied into `.kubb/sse.ts` only for a document with a
-* `text/event-stream` operation.
+* Builds the per-operation client generator shared by the client plugins. `templates` is the folder the optional runtime, such as `sse.ts`, is copied from.
 */
-function createClientGenerator(name, { sse } = {}) {
+function createClientGenerator(name, { templates } = {}) {
 	return defineGenerator({
 		name,
 		renderer: jsxRenderer,
 		operations(nodes, ctx) {
-			return /* @__PURE__ */ jsx(StreamRuntime, {
+			return /* @__PURE__ */ jsx(ClientRuntime, {
 				nodes,
 				root: ctx.root,
-				sse,
-				baseURL: ctx.options.baseURL
+				templates,
+				baseURL: ctx.options.baseURL,
+				servers: ctx.meta.servers,
+				auth: ctx.meta.auth
 			});
 		},
 		operation(node, ctx) {
-			if (!ast.isHttpOperationNode(node)) return null;
+			if (!ast.http.isOperation(node)) return null;
 			const { config, driver, resolver, root } = ctx;
-			const { output, validator, returnType, throwOnErrorDefault, group, importPath } = ctx.options;
-			const types = resolveOperationTypes(driver, ctx.plugin.name);
-			const pluginZod = isValidatorEnabled(validator) ? driver.getPlugin(pluginZodName) : null;
-			const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
-			const importedTypeNames = [types.response.options(node), types.response.responses(node)];
-			const validatorHooks = buildValidatorHooks({
+			const { output, returnType, throwOnErrorDefault, group, importPath } = ctx.options;
+			const resolvedTypes = resolveOperationTypes(driver, ctx.plugin.name);
+			const types = importPath === void 0 ? resolvedTypes : {
+				...resolvedTypes,
+				response: {
+					...resolvedTypes.response,
+					headers: void 0
+				}
+			};
+			const data = resolveOperationData({
 				node,
-				validator,
-				zodResolver
+				ctx,
+				types
 			});
-			const importedZodNames = validatorHooks.importedZodNames;
-			const operationName = resolver.name(node.operationId);
-			const meta = {
-				name: resolver.resolveName({
-					key: operationKey(node),
-					name: operationName
-				}),
-				file: resolver.file({
-					...operationFileEntry(node, node.operationId),
-					root,
-					output,
-					group: group ?? void 0
-				}),
-				fileTypes: resolveDependencyOperationFile({
-					memo: ctx.memo,
-					node,
-					resolver: types.resolver,
-					root,
-					output: types.output ?? output,
-					group: types.group
-				}),
-				fileZod: zodResolver && pluginZod?.options ? zodResolver.file({
-					...operationFileEntry(node, node.operationId),
-					root,
-					output: pluginZod.options.output ?? output,
-					group: pluginZod.options?.group ?? void 0
-				}) : null
-			};
-			const security = getOperationSecurity({
-				document: ctx.adapter.document,
-				method: node.method,
-				path: node.path
+			const { validatorHooks, headerTypeNames } = data;
+			const file = resolver.file({
+				...operationFileEntry(node, node.operationId),
+				root,
+				output,
+				group: group ?? void 0
 			});
+			const importedTypeNames = [
+				types.response.options(node),
+				types.response.responses(node),
+				...headerTypeNames
+			];
 			const clientPath = importPath ?? path.resolve(root, ".kubb/client.ts");
-			const clientRoot = importPath === void 0 ? meta.file.path : void 0;
+			const clientRoot = importPath === void 0 ? file.path : void 0;
 			const standardSchemaPath = importPath ?? path.resolve(root, ".kubb/standardSchema.ts");
-			const ssePath = importPath ?? path.resolve(root, ".kubb/sse.ts");
 			const stream = getEventStream(node);
-			const clientValueImports = (() => {
-				if (returnType === "plain") return ["client"];
-				if (returnType === "data") return ["client", "unwrapResult"];
-				return ["client", "withUnwrap"];
-			})();
-			const clientTypeImports = (() => {
-				if (stream) return {
-					plain: ["Options", "SuccessOf"],
-					data: ["SuccessOf"],
-					full: ["SuccessOf", "Unwrappable"]
-				}[returnType];
-				if (returnType === "plain") return ["Options", "RequestResult"];
-				if (returnType === "data") return ["Options", "UnwrappedResult"];
-				return [
+			const clientValueImports = [...{
+				plain: ["client"],
+				data: [
+					"client",
+					"unwrapResult",
+					"resolveThrowOnError"
+				],
+				full: [
+					"client",
+					"withUnwrap",
+					"resolveThrowOnError"
+				]
+			}[returnType], ...importPath === void 0 && data.security ? ["securitySchemes"] : []];
+			const clientTypeImports = stream ? buildEventStreamImports({
+				node,
+				types,
+				returnType
+			}) : {
+				plain: ["Options", "RequestResult"],
+				data: ["Options", "UnwrappedResult"],
+				full: [
 					"Options",
 					"Unwrappable",
 					"RequestResult"
-				];
-			})();
+				]
+			}[returnType].map((name) => name.endsWith("Result") ? resultTypeName(name, headerTypeNames.length > 0) : name);
 			return /* @__PURE__ */ jsxs(File, {
-				baseName: meta.file.baseName,
-				path: meta.file.path,
-				meta: meta.file.meta,
+				baseName: file.baseName,
+				path: file.path,
+				meta: file.meta,
 				banner: resolver.default.banner(ctx.meta, {
 					output,
 					config,
 					file: {
-						path: meta.file.path,
-						baseName: meta.file.baseName
+						path: file.path,
+						baseName: file.baseName
 					}
 				}),
 				footer: resolver.default.footer(ctx.meta, {
 					output,
 					config,
 					file: {
-						path: meta.file.path,
-						baseName: meta.file.baseName
+						path: file.path,
+						baseName: file.baseName
 					}
 				}),
 				children: [
@@ -1232,30 +1458,16 @@ function createClientGenerator(name, { sse } = {}) {
 						path: clientPath,
 						isTypeOnly: true
 					}),
-					stream && /* @__PURE__ */ jsx(File.Import, {
-						name: ["toEventStream"],
-						root: clientRoot,
-						path: ssePath
-					}),
-					stream && /* @__PURE__ */ jsx(File.Import, {
-						name: buildEventStreamImports({
-							returnType,
-							typed: stream === "event"
-						}),
-						root: clientRoot,
-						path: ssePath,
-						isTypeOnly: true
-					}),
-					meta.fileTypes && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					/* @__PURE__ */ jsx(File.Import, {
 						name: Array.from(new Set(importedTypeNames)),
-						root: meta.file.path,
-						path: meta.fileTypes.path,
+						root: file.path,
+						path: data.typeFile.path,
 						isTypeOnly: true
 					}),
-					meta.fileZod && importedZodNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-						name: importedZodNames,
-						root: meta.file.path,
-						path: meta.fileZod.path
+					data.zodFile && validatorHooks.importedZodNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+						name: validatorHooks.importedZodNames,
+						root: file.path,
+						path: data.zodFile.path
 					}),
 					validatorHooks.headers && /* @__PURE__ */ jsx(File.Import, {
 						name: ["toHeadersStandardSchema"],
@@ -1263,27 +1475,28 @@ function createClientGenerator(name, { sse } = {}) {
 						path: standardSchemaPath
 					}),
 					/* @__PURE__ */ jsx(Operation, {
-						name: meta.name,
+						name: data.name,
 						node,
 						types,
 						validatorHooks,
 						returnType,
 						throwOnErrorDefault,
-						security
+						security: data.security,
+						baseURL: data.baseURL
 					})
 				]
 			});
 		}
 	});
 }
-// ../../internals/client/src/macros.ts
+// src/macros.ts
 /**
 * Macros the client plugins apply by default, ahead of any user macros. `macroDedupeUnion`
 * drops repeated union members, keeping the generated response and error
 * unions tidy. A plugin wires them with `ctx.setMacros([...defaultMacros, ...userMacros])`.
 */
 const defaultMacros = [macroDedupeUnion];
-// ../../internals/client/src/resolver.ts
+// src/resolver.ts
 /**
 * Default resolver shared by the client plugins. Functions use safe camelCase identifiers and
 * files inherit the built-in casing; classes and tag groups use PascalCase.
@@ -1298,22 +1511,401 @@ const resolverClient = createResolver({
 	pluginName: "plugin-contract-client",
 	name: resolveOperationName,
 	className(name) {
-		return ensureValidVarName(pascalCase(name));
+		return ensureValidVarName(casing.pascal(name));
 	},
 	groupName(name) {
-		return ensureValidVarName(pascalCase(`${name} Client`));
+		return ensureValidVarName(casing.pascal(`${name} Client`));
 	},
 	propertyName(name) {
-		return ensureValidVarName(camelCase(name));
+		return ensureValidVarName(casing.camel(name));
 	}
 });
-// src/generators/clientGenerator.tsx
+// src/components/SdkClient.tsx
+/**
+* Builds one instance method of a generated SDK class; a per-call `options.client` overrides `this.client`.
+*/
+function buildSdkMethod({ node, name, types, validatorHooks, security, baseURL, returnType, throwOnErrorDefault }) {
+	if (!ast.http.isOperation(node)) return "";
+	const body = buildOperationBody({
+		node,
+		types,
+		validatorHooks,
+		security,
+		baseURL,
+		returnType,
+		throwOnErrorDefault
+	});
+	const generics = body.generics.length ? `<${body.generics.join(", ")}>` : "";
+	const jsdoc = buildJSDoc(buildOperationComments(node, { splitLines: true }));
+	const methodBody = [
+		body.mergeContentType ? "const { client: apiClient = this.client, contentType, ...config } = options" : "const { client: apiClient = this.client, ...config } = options",
+		"",
+		body.statement
+	].map((line) => line ? `    ${line}` : "").join("\n");
+	return `${jsdoc}  public ${name}${generics}(${body.paramsSignature}): ${body.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(...)`. It also takes an existing
+* client, which is how the root SDK shares one client across its tags. The client is public so callers
+* can add interceptors, and a per-call `client` option still overrides it for a one-off call.
+*/
+function SdkClient({ name, operations, returnType, throwOnErrorDefault }) {
+	const methods = operations.map(({ node, name: methodName, types, validatorHooks, security, baseURL }) => buildSdkMethod({
+		node,
+		name: methodName,
+		types,
+		validatorHooks,
+		security,
+		baseURL,
+		returnType,
+		throwOnErrorDefault
+	}));
+	const classCode = `export class ${name} {\n${[
+		"  readonly client: ClientInstance",
+		"",
+		"  constructor(config: ClientConfig | ClientInstance = {}) {",
+		"    this.client = typeof config === 'function' ? config : createClient(config)",
+		"  }"
+	].join("\n")}\n\n${methods.join("\n\n")}\n}`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: classCode
+	});
+}
+// src/components/SdkFacade.tsx
+/**
+* Renders a composed root SDK class that creates one client from the config and hands it to every tag
+* client, so `new PetStore({ baseURL }).pet.getPetById(...)` reaches an operation through a single entry
+* point bound to one environment. The shared client is the public `client` field, where interceptors
+* registered once apply to every tag. The per-tag clients are read-only fields built in the constructor.
+*/
+function SdkFacade({ name, members }) {
+	const fields = ["  readonly client: ClientInstance", ...members.map((member) => `  readonly ${member.propName}: ${member.className}`)];
+	const assignments = ["    this.client = createClient(config)", ...members.map((member) => `    this.${member.propName} = new ${member.className}(this.client)`)];
+	const classCode = `export class ${name} {\n${[
+		...fields,
+		"",
+		"  constructor(config: ClientConfig = {}) {",
+		...assignments,
+		"  }"
+	].join("\n")}\n}`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: classCode
+	});
+}
+// src/generators/sdkGenerator.tsx
+/**
+* Groups operations into one controller per tag. Operations without a tag fall back to a single
+* `Client`/`ApiClient` controller, matching the resolver's default naming.
+*/
+function buildControllers(nodes, ctx, types) {
+	const { resolver, root } = ctx;
+	const { output, group } = ctx.options;
+	return nodes.reduce((acc, operationNode) => {
+		if (!ast.http.isOperation(operationNode)) return acc;
+		const tag = operationNode.tags[0];
+		const name = tag ? ensureValidVarName(resolver.groupName(tag)) : resolver.className("ApiClient");
+		const fileName = tag && group ? ensureValidVarName(path.basename(resolver.groupDir(group, tag))) : name;
+		const file = resolver.file({
+			name: fileName,
+			extname: ".ts",
+			tag,
+			root,
+			output,
+			group: group ?? void 0
+		});
+		const operationData = resolveOperationData({
+			node: operationNode,
+			ctx,
+			types
+		});
+		const previous = acc.find((item) => item.file.path === file.path);
+		if (previous) previous.operations.push(operationData);
+		else acc.push({
+			name,
+			tag,
+			file,
+			operations: [operationData]
+		});
+		return acc;
+	}, []);
+}
+function collectImportsByFile(ops, pick) {
+	const namesByPath = /* @__PURE__ */ new Map();
+	const filesByPath = /* @__PURE__ */ new Map();
+	ops.forEach((op) => {
+		const { file, names } = pick(op);
+		if (!file || names.length === 0) return;
+		const set = memo(namesByPath, file.path, () => /* @__PURE__ */ new Set());
+		names.forEach((n) => set.add(n));
+		filesByPath.set(file.path, file);
+	});
+	return {
+		namesByPath,
+		filesByPath
+	};
+}
+/**
+* Builds the class-based SDK generator for a client plugin (`@kubb/plugin-fetch`,
+* `@kubb/plugin-axios`). Only registered when `sdk` is set; otherwise the plugin keeps its
+* standalone per-operation functions.
+*
+* Every tag client is an instance class whose constructor takes a client config and builds its own
+* client, or takes an existing client, so each environment is a separate instance. With `sdk.mode:
+* 'tag'` (the default) it emits one class per tag, named by `resolver.groupName`, and, when `sdk.name`
+* is set, a composed root that creates one client and shares it with every tag client. With
+* `sdk.mode: 'flat'` it emits one class named by `sdk.name`, with every operation as a direct method.
+*
+* `templates` is the folder the optional runtime is copied from: `sse.ts` only for a document that streams, and each
+* form media type only for a document with a body of that type.
+*/
+function createSdkGenerator({ templates } = {}) {
+	return defineGenerator({
+		name: "sdk",
+		renderer: jsxRenderer,
+		operations(nodes, ctx) {
+			const { config, resolver, root } = ctx;
+			const { output, group, validator, returnType, throwOnErrorDefault, sdk } = ctx.options;
+			if (!sdk) return null;
+			if (sdk.mode === "tag" && output.mode === "file") throw new Diagnostics.Error({
+				code: Diagnostics.code.invalidPluginOptions,
+				severity: "error",
+				message: `Plugin "${ctx.plugin.name}" resolves \`output.mode\` to 'file' but also configures \`sdk.mode: 'tag'\`.`,
+				help: "A single-file output has nothing to split tag classes into. Set `sdk.mode: 'flat'` to emit one class into that file, or give `output.path` an extensionless directory name (or set `output.mode: 'directory'` explicitly) so each tag gets its own file.",
+				location: { kind: "config" },
+				plugin: ctx.plugin.name
+			});
+			const types = resolveOperationTypes(ctx.driver, ctx.plugin.name);
+			const validatorEnabled = isValidatorEnabled(validator);
+			const controllers = buildControllers(nodes, ctx, types);
+			const clientPath = path.resolve(root, ".kubb/client.ts");
+			const standardSchemaPath = path.resolve(root, ".kubb/standardSchema.ts");
+			const banner = (file) => resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: file.path,
+					baseName: file.baseName
+				}
+			});
+			const footer = (file) => resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: file.path,
+					baseName: file.baseName
+				}
+			});
+			const renderClassFile = (className, file, ops) => {
+				const { namesByPath: typeNamesByPath, filesByPath: typeFilesByPath } = collectImportsByFile(ops, (op) => ({
+					file: op.typeFile,
+					names: [
+						op.types.response.options(op.node),
+						op.types.response.responses(op.node),
+						...op.headerTypeNames
+					]
+				}));
+				const { namesByPath: zodNamesByPath, filesByPath: zodFilesByPath } = validatorEnabled ? collectImportsByFile(ops, (op) => ({
+					file: op.zodFile,
+					names: op.validatorHooks.importedZodNames
+				})) : {
+					namesByPath: /* @__PURE__ */ new Map(),
+					filesByPath: /* @__PURE__ */ new Map()
+				};
+				const resultOps = ops.filter((op) => !isEventStream(op.node));
+				const typedHeaders = (op) => op.headerTypeNames.length > 0;
+				const resultName = returnType === "data" ? "UnwrappedResult" : "RequestResult";
+				return /* @__PURE__ */ jsxs(File, {
+					baseName: file.baseName,
+					path: file.path,
+					meta: file.meta,
+					banner: banner(file),
+					footer: footer(file),
+					children: [
+						/* @__PURE__ */ jsx(File.Import, {
+							name: [
+								"createClient",
+								returnType === "data" ? "unwrapResult" : "withUnwrap",
+								"resolveThrowOnError",
+								...ctx.options.importPath === void 0 && ops.some((op) => op.security) ? ["securitySchemes"] : []
+							],
+							root: file.path,
+							path: clientPath
+						}),
+						/* @__PURE__ */ jsx(File.Import, {
+							name: Array.from(/* @__PURE__ */ new Set([
+								"ClientConfig",
+								"ClientInstance",
+								"Options",
+								...returnType === "data" ? [] : ["Unwrappable"],
+								...resultOps.some((op) => !typedHeaders(op)) ? [resultName] : [],
+								...resultOps.some(typedHeaders) ? [resultTypeName(resultName, true)] : [],
+								...ops.filter((op) => isEventStream(op.node)).flatMap((op) => buildEventStreamImports({
+									node: op.node,
+									types: op.types,
+									returnType
+								}))
+							])),
+							root: file.path,
+							path: clientPath,
+							isTypeOnly: true
+						}),
+						validator === "zod" && ops.some((op) => ast.http.requestBody.getSchema(op.node) != null) && /* @__PURE__ */ jsx(File.Import, {
+							name: ["z"],
+							path: "zod",
+							isTypeOnly: true
+						}),
+						Array.from(typeNamesByPath.entries()).map(([filePath, set]) => /* @__PURE__ */ jsx(File.Import, {
+							name: Array.from(set),
+							root: file.path,
+							path: typeFilesByPath.get(filePath).path,
+							isTypeOnly: true
+						}, filePath)),
+						validatorEnabled && Array.from(zodNamesByPath.entries()).map(([filePath, set]) => /* @__PURE__ */ jsx(File.Import, {
+							name: Array.from(set),
+							root: file.path,
+							path: zodFilesByPath.get(filePath).path
+						}, filePath)),
+						ops.some((op) => op.validatorHooks.headers) && /* @__PURE__ */ jsx(File.Import, {
+							name: ["toHeadersStandardSchema"],
+							root: file.path,
+							path: standardSchemaPath
+						}),
+						/* @__PURE__ */ jsx(SdkClient, {
+							name: className,
+							operations: ops,
+							returnType,
+							throwOnErrorDefault
+						})
+					]
+				}, file.path);
+			};
+			const renderFacadeFile = (name) => {
+				const sdkFile = resolver.file({
+					name,
+					extname: ".ts",
+					root,
+					output,
+					group: group ?? void 0
+				});
+				const members = controllers.map(({ name, tag }) => ({
+					className: name,
+					propName: resolver.propertyName(tag ?? name)
+				}));
+				return /* @__PURE__ */ jsxs(File, {
+					baseName: sdkFile.baseName,
+					path: sdkFile.path,
+					meta: sdkFile.meta,
+					banner: banner(sdkFile),
+					footer: footer(sdkFile),
+					children: [
+						/* @__PURE__ */ jsx(File.Import, {
+							name: ["createClient"],
+							root: sdkFile.path,
+							path: clientPath
+						}),
+						/* @__PURE__ */ jsx(File.Import, {
+							name: ["ClientConfig", "ClientInstance"],
+							root: sdkFile.path,
+							path: clientPath,
+							isTypeOnly: true
+						}),
+						controllers.map(({ name, file }) => /* @__PURE__ */ jsx(File.Import, {
+							name: [name],
+							root: sdkFile.path,
+							path: file.path
+						}, name)),
+						/* @__PURE__ */ jsx(SdkFacade, {
+							name: resolver.className(name),
+							members
+						})
+					]
+				}, sdkFile.path);
+			};
+			const files = sdk.mode === "flat" ? renderClassFile(resolver.className(sdk.name ?? "sdk"), resolver.file({
+				name: sdk.name ?? "sdk",
+				extname: ".ts",
+				root,
+				output,
+				group: group ?? void 0
+			}), controllers.flatMap((controller) => controller.operations)) : [...controllers.map(({ name, file, operations: ops }) => renderClassFile(name, file, ops)), sdk.name && renderFacadeFile(sdk.name)];
+			return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(ClientRuntime, {
+				nodes,
+				root,
+				templates,
+				baseURL: ctx.options.baseURL,
+				servers: ctx.meta.servers,
+				auth: ctx.meta.auth
+			}), files] });
+		}
+	});
+}
+// src/setup.ts
+const templatePath = (name) => fileURLToPath(new URL(`../templates/${name}`, import.meta.url));
+/**
+* Applies the client option defaults and merges a user `resolver` over the built-in one.
+*/
+function resolveClientOptions(options) {
+	const { output = {
+		path: "clients",
+		barrel: { type: "named" }
+	}, exclude = [], include, override = [], baseURL, throwOnErrorDefault = true, validator = false, returnType = "full", group, sdk, resolver: userResolver } = options;
+	return {
+		output,
+		exclude,
+		include,
+		override,
+		group: group ?? null,
+		baseURL,
+		throwOnErrorDefault,
+		validator,
+		returnType,
+		sdk: sdk ? {
+			mode: sdk.mode ?? "tag",
+			name: sdk.name
+		} : void 0,
+		resolver: userResolver ? Resolver.merge(resolverClient, userResolver) : resolverClient
+	};
+}
+/**
+* Wires a client plugin in its `setup`: resolver, macros, client or SDK generator, and the `.kubb/` runtime with the plugin's own `client.ts`.
+*/
+function setupClient({ name, resolved, macros = [], client }) {
+	const config = useConfig();
+	setResolver(resolved.resolver);
+	setMacros([...defaultMacros, ...macros]);
+	const templates = templatePath("");
+	addGenerator(resolved.sdk ? createSdkGenerator({ templates }) : createClientGenerator(name, { templates }));
+	const root = path.resolve(config.root, config.output.path);
+	const files = [
+		["serializers.ts", templatePath("serializers.ts")],
+		["mediaTypes.ts", templatePath("mediaTypes.ts")],
+		["core.ts", templatePath("core.ts")],
+		["client.ts", client],
+		["standardSchema.ts", templatePath("standardSchema.ts")]
+	];
+	for (const [baseName, copy] of files) injectFile({
+		baseName,
+		path: path.resolve(root, ".kubb", baseName),
+		copy
+	});
+}
 /**
-* Built-in operation generator for `@kubb/plugin-client`. Emits one async function per OpenAPI
-* operation using the shared `Operation` component: a grouped `<Name>Request` type and a function
-* that forwards a single `options` object to the user-provided client module and returns the `RequestResult`.
+* Declares `plugin-ts` as optional and `plugin-zod` as required once `validator` enables a direction.
 */
-const clientGenerator = createClientGenerator("client");
+function clientDependencies(options) {
+	return {
+		[pluginTsName]: { optional: true },
+		[pluginZodName$1]: { optional: !isValidatorEnabled(options.validator) }
+	};
+}
 // src/plugin.ts
 /**
 * Canonical plugin name for `@kubb/plugin-client`.
@@ -1336,10 +1928,7 @@ const pluginClient = defineExtension({
 		version,
 		compatibility
 	},
-	dependencies: (options) => ({
-		[pluginTsName]: { optional: true },
-		[pluginZodName]: { optional: !isValidatorEnabled(options.validator) }
-	}),
+	dependencies: clientDependencies,
 	setup(options) {
 		const { output = {
 			path: "clients",
@@ -1348,13 +1937,13 @@ const pluginClient = defineExtension({
 		const resolver = userResolver ? Resolver.merge(resolverClient, userResolver) : resolverClient;
 		setResolver(resolver);
 		setMacros([...defaultMacros, ...options.macros ?? []]);
-		addGenerator(clientGenerator);
+		addGenerator(createClientGenerator("client"));
 		return {
 			output,
 			exclude,
 			include,
 			override,
-			group: createGroupConfig(group),
+			group: group ?? null,
 			importPath,
 			baseURL: void 0,
 			throwOnErrorDefault,
@@ -1365,6 +1954,6 @@ const pluginClient = defineExtension({
 		};
 	}
 });
-export { pluginClient as default, pluginClient, pluginClientName };
+export { clientDependencies, pluginClient as default, pluginClient, pluginClientName, resolveClientOptions, resolverClient, setupClient };
 
 //# sourceMappingURL=index.js.map