@kubb/plugin-client 5.11.0-canary.20261106T171559 → 5.11.0

package/dist/{client-CiHb_Cfg.d.ts → client-BxO6Dygu.d.ts}

@@ -124,6 +124,11 @@ type DataShape = {
 };
 type RequestCredentials = 'omit' | 'same-origin' | 'include';
 type ResponseType = 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream' | 'formdata';
+/**
+ * Parser per response content type. Generated when one success response declares several content
+ * types that do not share a single parser. Keys are base media types, such as `audio/mpeg` or `audio/*`.
+ */
+type ResponseTypeMap = Record<string, ResponseType>;
 /**
  * Decodes a response body for a codec's media type.
  */
@@ -184,7 +189,7 @@ type RequestConfig<TBody = unknown, TRequest = NativeRequest, TResponse = Native
   credentials?: RequestCredentials;
   options?: Record<string, unknown>;
   contentType?: ContentType;
-  responseType?: ResponseType;
+  responseType?: ResponseType | ResponseTypeMap;
   throwOnError?: boolean;
   client?: ClientInstance<TRequest, TResponse>;
   transport?: Transport<TRequest, TResponse>;
@@ -237,7 +242,7 @@ type ResolvedRequest = {
   signal?: AbortSignal;
   credentials?: RequestCredentials;
   options?: Record<string, unknown>;
-  responseType?: ResponseType;
+  responseType?: ResponseType | ResponseTypeMap;
 };
 /**
  * What a transport returns: the parsed body plus the native request and response objects.
@@ -332,6 +337,11 @@ declare function resolveAuth(params: {
 }): Promise<void>;
 /** A body a transport left as a stream: a web `ReadableStream` or an async iterable such as a Node readable. */
 declare function isStreamed(data: unknown): data is ReadableStream<Uint8Array> | AsyncIterable<Uint8Array | string>;
+/**
+ * Picks the parser for a response. A string `responseType` wins. A map is matched against the media type: the exact
+ * type, then a wildcard such as `audio/*`, then a catch-all entry. Otherwise the parser is guessed from the media type.
+ */
+declare function resolveResponseType(responseType: ResponseType | ResponseTypeMap | undefined, contentType: string | null | undefined): ResponseType | undefined;
 /** The media type of the `Content-Type` response header, without its parameters. */
 declare function getResponseContentType(headers: Headers | Record<string, string> | undefined): string | undefined;
 /**
@@ -342,4 +352,4 @@ declare function createClientCore<TRequest = NativeRequest, TResponse = NativeRe
 } & ClientConfig<TRequest, TResponse>): ClientInstance<TRequest, TResponse>;
 type NativeRequest = unknown;
 type NativeResponse = unknown;
-export { SuccessResultUnion as A, createClientCore as B, ResolvedRequest as C, ResultByStatus as D, ResponseType as E, TransportResult as F, unwrapResult as G, getResponseContentType as H, Unwrappable as I, withUnwrap as K, UnwrappedResult as L, SuccessVariant as M, ToStatusNumber as N, ResultUnion as O, Transport as P, UrlConfig as R, RequestResult as S, ResponseErrorConfig as T, isStreamed as U, createInterceptorStack as V, resolveAuth as W, InterceptorStack as _, AuthToken as a, RequestConfig as b, ClientInstance as c, ContentType as d, DataOf as f, InterceptorFn as g, ErrorOf as h, AuthResolver as i, SuccessStatusCode as j, SuccessOf as k, Codec as l, Deserializer as m, NativeResponse as n, CallResult as o, DataShape as p, Auth as r, ClientConfig as s, NativeRequest as t, ContentBodySerializer as u, Interceptors as v, ResponseError as w, RequestCredentials as x, Options as y, Validator as z };
+export { SuccessOf as A, Validator as B, ResolvedRequest as C, ResponseTypeMap as D, ResponseType as E, Transport as F, resolveAuth as G, createInterceptorStack as H, TransportResult as I, withUnwrap as J, resolveResponseType as K, Unwrappable as L, SuccessStatusCode as M, SuccessVariant as N, ResultByStatus as O, ToStatusNumber as P, UnwrappedResult as R, RequestResult as S, ResponseErrorConfig as T, getResponseContentType as U, createClientCore as V, isStreamed as W, InterceptorStack as _, AuthToken as a, RequestConfig as b, ClientInstance as c, ContentType as d, DataOf as f, InterceptorFn as g, ErrorOf as h, AuthResolver as i, SuccessResultUnion as j, ResultUnion as k, Codec as l, Deserializer as m, NativeResponse as n, CallResult as o, DataShape as p, unwrapResult as q, Auth as r, ClientConfig as s, NativeRequest as t, ContentBodySerializer as u, Interceptors as v, ResponseError as w, RequestCredentials as x, Options as y, UrlConfig as z };

package/dist/index.cjs

@@ -131,22 +131,65 @@ 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";
+}
 /**
-* Derives the default `responseType` for an operation from its primary success response.
+* Parser for one response content entry.
 *
-* Returns a value only when that response declares a single non-JSON content type. `text/event-stream` maps to
-* `'stream'`, `application/octet-stream`, `application/pdf`, `image/*`, `audio/*` and `video/*` map to `'blob'`, and
-* other `text/*` to `'text'`. Otherwise `undefined`, leaving the runtime client's `Content-Type` auto-detection in charge.
+* 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 getResponseType(node) {
-	const baseType = getPrimarySuccessContentType(node);
+function responseTypeForContent(contentType, schema) {
+	const baseType = baseContentType(contentType);
 	if (!baseType) return void 0;
-	if (baseType === "application/json" || baseType.endsWith("+json") || baseType === "text/json") 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) {
@@ -220,17 +263,18 @@ function spreadQuerystring(param) {
 function getOperationParameters(node) {
 	const cached = operationParameterGroupsByNode.get(node);
 	if (cached) return cached;
-	const group = (location) => {
+	const dedupe = (params) => {
 		const seen = /* @__PURE__ */ new Set();
-		return node.parameters.filter((param) => {
-			if (param.in !== location || seen.has(param.name)) return false;
+		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: [...group("query"), ...group("querystring").flatMap(spreadQuerystring)],
+		query: dedupe([...group("query"), ...group("querystring").flatMap(spreadQuerystring)]),
 		header: group("header"),
 		cookie: group("cookie")
 	};
@@ -464,7 +508,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.11.0-canary.20261106T171559";
+var version = "5.11.0";
 // ../../internals/client/src/builders/validatorOptions.ts
 /**
 * Returns `true` when any direction of the validator uses zod (used for dependency checks).
@@ -823,6 +867,17 @@ function buildStyles({ node }) {
 }
 // ../../internals/client/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`.
+*/
+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(", ")} }`;
+}
+/**
 * 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.
 *
@@ -849,7 +904,6 @@ function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault,
 		"error"
 	]);
 	const { literal: contentTypeLiteral, merge: mergeContentType } = buildContentType({ node });
-	const responseType = getResponseType(node);
 	return {
 		callConfig: `{ ${[
 			`method: '${node.method.toUpperCase()}'`,
@@ -858,7 +912,7 @@ function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault,
 			stylesLiteral ? `styles: ${stylesLiteral}` : null,
 			validatorLiteral,
 			contentTypeLiteral,
-			responseType ? `responseType: '${responseType}'` : null,
+			buildResponseTypeLiteral(node),
 			"...config",
 			`throwOnError: config.throwOnError ?? ${throwOnErrorDefault}`
 		].filter(Boolean).join(", ")} }`,