openapi-typesafe-fetch 1.0.0-rc.7 → 1.0.0-rc.9

package/CHANGELOG.md

@@ -2,6 +2,51 @@
 
 This package is a fork of `openapi-fetch`. The entries above `0.17.0` are releases of openapi-typesafe-fetch; `0.17.0` and the entries below it are the upstream history up to the fork point (upstream commit `d46a319a`), with `openapi-fetch` versions.
 
+## 1.0.0-rc.9
+
+### Patch Changes
+
+- [#112](https://github.com/openapi-typesafe/openapi-typesafe/pull/112) [`05886b5`](https://github.com/openapi-typesafe/openapi-typesafe/commit/05886b5b8fdbb832f58abd12b9f8c741b0c73ad2) Thanks [@fedorello](https://github.com/fedorello)! - An error body is parsed as JSON only when its `Content-Type` is a JSON media type (`json` or a
+  `+json` suffix), or when the response has no `Content-Type` and the body is JSON. Any other error
+  body, such as `text/plain` or HTML, is returned as text, as its `string` type says. A `text/plain`
+  error body `429`, `true`, `0` or `null` came back as a number, a boolean or `null`, and with `0`
+  or `null` the check `if (error)` was skipped. openapi-fetch parses every error body, so this
+  differs from it.
+
+- [#112](https://github.com/openapi-typesafe/openapi-typesafe/pull/112) [`05886b5`](https://github.com/openapi-typesafe/openapi-typesafe/commit/05886b5b8fdbb832f58abd12b9f8c741b0c73ad2) Thanks [@fedorello](https://github.com/fedorello)! - Code that is generic in the path compiles again. `SuccessResponse`, `ErrorResponse`,
+  `ErrorResponseJSON` and the `data` and `error` of `FetchResponse` for `Paths[Path]` gave the whole
+  `responses` map next to the response bodies, so assigning them to the bodies failed with TS2322.
+  They give the bodies now. This also fixes the error type of hook wrappers generic in the path.
+
+- [#112](https://github.com/openapi-typesafe/openapi-typesafe/pull/112) [`05886b5`](https://github.com/openapi-typesafe/openapi-typesafe/commit/05886b5b8fdbb832f58abd12b9f8c741b0c73ad2) Thanks [@fedorello](https://github.com/fedorello)! - Every optional option of `createClient()` and of a request accepts `undefined` in its type, not
+  only the members of `querySerializer`: `baseUrl`, `fetch`, `Request`, `FormData`,
+  `querySerializer`, `bodySerializer`, `pathSerializer`, `headers`, `requestInitExt`, `parseAs`,
+  `middleware` and `params`. The client already counted `undefined` as left out, so a wrapper that
+  passes its own optional options on now compiles with `exactOptionalPropertyTypes`.
+
+## 1.0.0-rc.8
+
+### Patch Changes
+
+- [#103](https://github.com/openapi-typesafe/openapi-typesafe/pull/103) [`091b864`](https://github.com/openapi-typesafe/openapi-typesafe/commit/091b864cdb6dd9e1ff5810d4d44cebee8a01a721) Thanks [@fedorello](https://github.com/fedorello)! - `createClient<any>()` types `data` and `error` as `any` again; they were `never`, so
+  `if (error)` made the whole result `never`. `SuccessResponse<any>` and `ErrorResponse<any>` are
+  `any` too.
+
+- [#103](https://github.com/openapi-typesafe/openapi-typesafe/pull/103) [`091b864`](https://github.com/openapi-typesafe/openapi-typesafe/commit/091b864cdb6dd9e1ff5810d4d44cebee8a01a721) Thanks [@fedorello](https://github.com/fedorello)! - Response types follow what the client returns. `ErrorResponseJSON`, `SuccessResponseJSON` and the
+  `data` and `error` of a client made with ``createClient<paths, `${string}/json`>()`` keep a
+  JSON body of any JSON media type: an `application/problem+json` error, an
+  `application/vnd.api+json` success and `application/json; charset=utf-8` bodies were left out,
+  so the error could be `never` or miss a status. An error that is not JSON, such as the HTML page
+  of a proxy, is typed `string`, the text the client returns, instead of being left out.
+
+- [#103](https://github.com/openapi-typesafe/openapi-typesafe/pull/103) [`091b864`](https://github.com/openapi-typesafe/openapi-typesafe/commit/091b864cdb6dd9e1ff5810d4d44cebee8a01a721) Thanks [@fedorello](https://github.com/fedorello)! - Every `querySerializer` option accepts `undefined` in its type, so a wrapper that passes its own
+  optional option on (`{ array: { explode: options.explode } }`) compiles with
+  `exactOptionalPropertyTypes`.
+
+- [#103](https://github.com/openapi-typesafe/openapi-typesafe/pull/103) [`091b864`](https://github.com/openapi-typesafe/openapi-typesafe/commit/091b864cdb6dd9e1ff5810d4d44cebee8a01a721) Thanks [@fedorello](https://github.com/fedorello)! - `serializeArrayParam` and `serializeObjectParam` with a nested value in a path style (`simple`,
+  `label`, `matrix`) name `pathSerializer()` in their error, also inside your own `pathSerializer`,
+  instead of `querySerializer()`.
+
 ## 1.0.0-rc.7
 
 ### Patch Changes

package/dist/helpers.d.cts

@@ -199,31 +199,66 @@ type OperationRequestBodyContent<T> = FilterKeys<OperationRequestBodyMediaConten
  * `default` is left to the errors, as before.
  */
 type SuccessStatus<T> = [SuccessStatusKey<T>] extends [never] ? Extract<keyof T, "default"> : SuccessStatusKey<T>;
+/**
+ * `true` for `any`: a conditional type on `any` takes both branches, so `any` is checked first.
+ * The response types check it inside `T extends unknown`: TypeScript relates a conditional type
+ * on a type parameter through the one with the parameter's constraint put in, while one on
+ * `IsAny<T>` relates through both branches, which for a generic path added the whole map.
+ */
+type IsAny<T> = 0 extends 1 & T ? true : false;
 /**
  * Return all 2XX responses from a Response Object Map, or `default` if it declares no 2XX one. For
  * a union of maps (a call with a union of paths), the union of each map's responses: `keyof` of a
  * union is only the shared statuses, so one map of them lost the body of every path that did not
- * share its statuses, and a `default`-only path typed the data `undefined` (upstream).
+ * share its statuses, and a `default`-only path typed the data `undefined` (upstream). An `any`
+ * map (`createClient<any>()`) gives `any`: no key of `keyof any` is a status, which gave `never`.
+ */
+type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? IsAny<T> extends true ? T : ResponseBodies<T, Media, SuccessStatus<T>, never> : never;
+/**
+ * Return all 1XX, 3XX, 4XX, 5XX and `default` responses from a Response Object Map; for a union
+ * of maps, the union of each map's responses, as `SuccessResponse`. An `any` map gives `any`.
  */
-type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, SuccessStatus<T>> : never;
+type ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? IsAny<T> extends true ? T : ResponseBodies<T, Media, ErrorStatusKey<T>, string> : never;
 /**
- * The bodies of the responses `ResponseCode` in the media types `Media`. A response with a
- * `content` map but no media type in `Media` adds nothing: it gave its whole map, so the error of
- * `ErrorResponseJSON` for a `text/html` 500 was `{ "text/html": string }`, a body no response has.
- * A response without `content` keeps its `content` type (`undefined` for `content?: never`).
+ * The bodies of the responses `ResponseCode` as the client returns them (`ResponseBody`): each
+ * success one as `SuccessResponse` gives it, each other one as `ErrorResponse` does.
  */
-type GetResponseContent<T extends Record<string | number, any>, Media extends MediaType = MediaType, ResponseCode extends keyof T = keyof T> = ResponseCode extends keyof T ? {
-    [K in ResponseCode]: T[K]["content"] extends Record<string, any> ? FilterKeys<T[K]["content"], Media> : K extends keyof T ? T[K]["content"] : never;
+type GetResponseContent<T extends Record<string | number, any>, Media extends MediaType = MediaType, ResponseCode extends keyof T = keyof T> = ResponseCode extends SuccessStatus<T> ? ResponseBodies<T, Media, ResponseCode, never> : ResponseBodies<T, Media, ResponseCode, string>;
+/**
+ * The bodies of the responses `ResponseCode`. A response without `content` keeps its `content`
+ * type (`undefined` for `content?: never`). `OtherBody` is the class's body that is not JSON: it
+ * is passed in, not read from the status, so the result for a generic map stays a type that
+ * TypeScript relates to the one of another client (ADR-030).
+ */
+type ResponseBodies<T extends Record<string | number, any>, Media, ResponseCode extends keyof T, OtherBody> = ResponseCode extends keyof T ? {
+    [K in ResponseCode]: T[K]["content"] extends Record<string, any> ? ResponseBody<T[K]["content"], Media, OtherBody> : K extends keyof T ? T[K]["content"] : never;
 }[ResponseCode] : never;
 /**
- * Return all 1XX, 3XX, 4XX, 5XX and `default` responses from a Response Object Map; for a union
- * of maps, the union of each map's responses, as `SuccessResponse`.
+ * The body of one response with the content map `Content`, as the client returns it. `Media`
+ * picks among its media types, as an `Accept` header does, and each one picked gives its schema.
+ * A response with none of them can still arrive (a proxy's HTML 500), so it gives what the client
+ * makes of its bodies: a JSON body gives its schema, any other body `OtherBody`, a `string` for an
+ * error (the client returns the text) and nothing for a success (the default `parseAs: "json"`
+ * rejects it; another `parseAs` types the data by itself). `Media` is read only in
+ * `keyof Content & Media`, as in `FilterKeys`, so TypeScript still relates the results of two
+ * clients with different `Media` in generic code (ADR-030).
  */
-type ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatusKey<T>> : never;
+type ResponseBody<Content, Media, OtherBody> = ([keyof Content & Media] extends [never] ? JSONLike<Content> : Content[keyof Content & Media]) | ([keyof Content & Media] extends [never] ? false extends {
+    [Key in keyof Content]: IsJSONMediaType<Key>;
+}[keyof Content] ? OtherBody : never : never);
+/**
+ * The media types that the client parses as JSON, as a content map writes them: `json` or a
+ * `+json` suffix (RFC 6838), with or without parameters, as the client's `JSON_MEDIA_TYPE_RE`, and
+ * the wildcards for any type and any `application` type, which may hold JSON. Not `x-ndjson` or
+ * `json-seq`, whose bodies are lines of JSON.
+ */
+type JSONMediaType = `${string}/${"" | `${string}+`}json` | `${string}/${"" | `${string}+`}json${";" | " " | "\t"}${string}` | "*/*" | "application/*";
+/** Whether the client parses a body of the media type `Key` as JSON, in any letter case. */
+type IsJSONMediaType<Key> = Key extends string ? Lowercase<Key> extends JSONMediaType ? true : false : false;
 /** Return first JSON-like 2XX response from a path + HTTP method */
-type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
+type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaType>;
 /** Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method */
-type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
+type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaType>;
 /** Return JSON-like request body from a path + HTTP method */
 type RequestBodyJSON<PathMethod> = JSONLike<FilterKeys<OperationRequestBody<PathMethod>, "content">>;
 /** Find first match of multiple keys */
@@ -240,10 +275,13 @@ type GetValueWithDefault<Obj, KeyPattern, Default> = Obj extends unknown ? Filte
  */
 type MediaType = `${string}/${string}`;
 /**
- * Return any media type containing "json" (works for "application/json",
- * "application/vnd.api+json", "application/vnd.oai.openapi+json")
+ * The values of the JSON media types of a content map, as the client parses them: `json` or a
+ * `+json` suffix, with or without parameters ("application/json", "application/vnd.api+json",
+ * "application/json; charset=utf-8").
  */
-type JSONLike<T> = FilterKeys<T, `${string}/json`>;
+type JSONLike<T> = {
+    [Key in keyof T]: IsJSONMediaType<Key> extends true ? T[Key] : never;
+}[keyof T];
 /**
  * Filter objects that have required keys
  * @deprecated Use `RequiredKeysOf` instead

package/dist/helpers.d.mts

@@ -199,31 +199,66 @@ type OperationRequestBodyContent<T> = FilterKeys<OperationRequestBodyMediaConten
  * `default` is left to the errors, as before.
  */
 type SuccessStatus<T> = [SuccessStatusKey<T>] extends [never] ? Extract<keyof T, "default"> : SuccessStatusKey<T>;
+/**
+ * `true` for `any`: a conditional type on `any` takes both branches, so `any` is checked first.
+ * The response types check it inside `T extends unknown`: TypeScript relates a conditional type
+ * on a type parameter through the one with the parameter's constraint put in, while one on
+ * `IsAny<T>` relates through both branches, which for a generic path added the whole map.
+ */
+type IsAny<T> = 0 extends 1 & T ? true : false;
 /**
  * Return all 2XX responses from a Response Object Map, or `default` if it declares no 2XX one. For
  * a union of maps (a call with a union of paths), the union of each map's responses: `keyof` of a
  * union is only the shared statuses, so one map of them lost the body of every path that did not
- * share its statuses, and a `default`-only path typed the data `undefined` (upstream).
+ * share its statuses, and a `default`-only path typed the data `undefined` (upstream). An `any`
+ * map (`createClient<any>()`) gives `any`: no key of `keyof any` is a status, which gave `never`.
+ */
+type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? IsAny<T> extends true ? T : ResponseBodies<T, Media, SuccessStatus<T>, never> : never;
+/**
+ * Return all 1XX, 3XX, 4XX, 5XX and `default` responses from a Response Object Map; for a union
+ * of maps, the union of each map's responses, as `SuccessResponse`. An `any` map gives `any`.
  */
-type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, SuccessStatus<T>> : never;
+type ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? IsAny<T> extends true ? T : ResponseBodies<T, Media, ErrorStatusKey<T>, string> : never;
 /**
- * The bodies of the responses `ResponseCode` in the media types `Media`. A response with a
- * `content` map but no media type in `Media` adds nothing: it gave its whole map, so the error of
- * `ErrorResponseJSON` for a `text/html` 500 was `{ "text/html": string }`, a body no response has.
- * A response without `content` keeps its `content` type (`undefined` for `content?: never`).
+ * The bodies of the responses `ResponseCode` as the client returns them (`ResponseBody`): each
+ * success one as `SuccessResponse` gives it, each other one as `ErrorResponse` does.
  */
-type GetResponseContent<T extends Record<string | number, any>, Media extends MediaType = MediaType, ResponseCode extends keyof T = keyof T> = ResponseCode extends keyof T ? {
-    [K in ResponseCode]: T[K]["content"] extends Record<string, any> ? FilterKeys<T[K]["content"], Media> : K extends keyof T ? T[K]["content"] : never;
+type GetResponseContent<T extends Record<string | number, any>, Media extends MediaType = MediaType, ResponseCode extends keyof T = keyof T> = ResponseCode extends SuccessStatus<T> ? ResponseBodies<T, Media, ResponseCode, never> : ResponseBodies<T, Media, ResponseCode, string>;
+/**
+ * The bodies of the responses `ResponseCode`. A response without `content` keeps its `content`
+ * type (`undefined` for `content?: never`). `OtherBody` is the class's body that is not JSON: it
+ * is passed in, not read from the status, so the result for a generic map stays a type that
+ * TypeScript relates to the one of another client (ADR-030).
+ */
+type ResponseBodies<T extends Record<string | number, any>, Media, ResponseCode extends keyof T, OtherBody> = ResponseCode extends keyof T ? {
+    [K in ResponseCode]: T[K]["content"] extends Record<string, any> ? ResponseBody<T[K]["content"], Media, OtherBody> : K extends keyof T ? T[K]["content"] : never;
 }[ResponseCode] : never;
 /**
- * Return all 1XX, 3XX, 4XX, 5XX and `default` responses from a Response Object Map; for a union
- * of maps, the union of each map's responses, as `SuccessResponse`.
+ * The body of one response with the content map `Content`, as the client returns it. `Media`
+ * picks among its media types, as an `Accept` header does, and each one picked gives its schema.
+ * A response with none of them can still arrive (a proxy's HTML 500), so it gives what the client
+ * makes of its bodies: a JSON body gives its schema, any other body `OtherBody`, a `string` for an
+ * error (the client returns the text) and nothing for a success (the default `parseAs: "json"`
+ * rejects it; another `parseAs` types the data by itself). `Media` is read only in
+ * `keyof Content & Media`, as in `FilterKeys`, so TypeScript still relates the results of two
+ * clients with different `Media` in generic code (ADR-030).
  */
-type ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatusKey<T>> : never;
+type ResponseBody<Content, Media, OtherBody> = ([keyof Content & Media] extends [never] ? JSONLike<Content> : Content[keyof Content & Media]) | ([keyof Content & Media] extends [never] ? false extends {
+    [Key in keyof Content]: IsJSONMediaType<Key>;
+}[keyof Content] ? OtherBody : never : never);
+/**
+ * The media types that the client parses as JSON, as a content map writes them: `json` or a
+ * `+json` suffix (RFC 6838), with or without parameters, as the client's `JSON_MEDIA_TYPE_RE`, and
+ * the wildcards for any type and any `application` type, which may hold JSON. Not `x-ndjson` or
+ * `json-seq`, whose bodies are lines of JSON.
+ */
+type JSONMediaType = `${string}/${"" | `${string}+`}json` | `${string}/${"" | `${string}+`}json${";" | " " | "\t"}${string}` | "*/*" | "application/*";
+/** Whether the client parses a body of the media type `Key` as JSON, in any letter case. */
+type IsJSONMediaType<Key> = Key extends string ? Lowercase<Key> extends JSONMediaType ? true : false : false;
 /** Return first JSON-like 2XX response from a path + HTTP method */
-type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
+type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaType>;
 /** Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method */
-type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
+type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaType>;
 /** Return JSON-like request body from a path + HTTP method */
 type RequestBodyJSON<PathMethod> = JSONLike<FilterKeys<OperationRequestBody<PathMethod>, "content">>;
 /** Find first match of multiple keys */
@@ -240,10 +275,13 @@ type GetValueWithDefault<Obj, KeyPattern, Default> = Obj extends unknown ? Filte
  */
 type MediaType = `${string}/${string}`;
 /**
- * Return any media type containing "json" (works for "application/json",
- * "application/vnd.api+json", "application/vnd.oai.openapi+json")
+ * The values of the JSON media types of a content map, as the client parses them: `json` or a
+ * `+json` suffix, with or without parameters ("application/json", "application/vnd.api+json",
+ * "application/json; charset=utf-8").
  */
-type JSONLike<T> = FilterKeys<T, `${string}/json`>;
+type JSONLike<T> = {
+    [Key in keyof T]: IsJSONMediaType<Key> extends true ? T[Key] : never;
+}[keyof T];
 /**
  * Filter objects that have required keys
  * @deprecated Use `RequiredKeysOf` instead

package/dist/helpers.d.ts

@@ -199,31 +199,66 @@ type OperationRequestBodyContent<T> = FilterKeys<OperationRequestBodyMediaConten
  * `default` is left to the errors, as before.
  */
 type SuccessStatus<T> = [SuccessStatusKey<T>] extends [never] ? Extract<keyof T, "default"> : SuccessStatusKey<T>;
+/**
+ * `true` for `any`: a conditional type on `any` takes both branches, so `any` is checked first.
+ * The response types check it inside `T extends unknown`: TypeScript relates a conditional type
+ * on a type parameter through the one with the parameter's constraint put in, while one on
+ * `IsAny<T>` relates through both branches, which for a generic path added the whole map.
+ */
+type IsAny<T> = 0 extends 1 & T ? true : false;
 /**
  * Return all 2XX responses from a Response Object Map, or `default` if it declares no 2XX one. For
  * a union of maps (a call with a union of paths), the union of each map's responses: `keyof` of a
  * union is only the shared statuses, so one map of them lost the body of every path that did not
- * share its statuses, and a `default`-only path typed the data `undefined` (upstream).
+ * share its statuses, and a `default`-only path typed the data `undefined` (upstream). An `any`
+ * map (`createClient<any>()`) gives `any`: no key of `keyof any` is a status, which gave `never`.
+ */
+type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? IsAny<T> extends true ? T : ResponseBodies<T, Media, SuccessStatus<T>, never> : never;
+/**
+ * Return all 1XX, 3XX, 4XX, 5XX and `default` responses from a Response Object Map; for a union
+ * of maps, the union of each map's responses, as `SuccessResponse`. An `any` map gives `any`.
  */
-type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, SuccessStatus<T>> : never;
+type ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? IsAny<T> extends true ? T : ResponseBodies<T, Media, ErrorStatusKey<T>, string> : never;
 /**
- * The bodies of the responses `ResponseCode` in the media types `Media`. A response with a
- * `content` map but no media type in `Media` adds nothing: it gave its whole map, so the error of
- * `ErrorResponseJSON` for a `text/html` 500 was `{ "text/html": string }`, a body no response has.
- * A response without `content` keeps its `content` type (`undefined` for `content?: never`).
+ * The bodies of the responses `ResponseCode` as the client returns them (`ResponseBody`): each
+ * success one as `SuccessResponse` gives it, each other one as `ErrorResponse` does.
  */
-type GetResponseContent<T extends Record<string | number, any>, Media extends MediaType = MediaType, ResponseCode extends keyof T = keyof T> = ResponseCode extends keyof T ? {
-    [K in ResponseCode]: T[K]["content"] extends Record<string, any> ? FilterKeys<T[K]["content"], Media> : K extends keyof T ? T[K]["content"] : never;
+type GetResponseContent<T extends Record<string | number, any>, Media extends MediaType = MediaType, ResponseCode extends keyof T = keyof T> = ResponseCode extends SuccessStatus<T> ? ResponseBodies<T, Media, ResponseCode, never> : ResponseBodies<T, Media, ResponseCode, string>;
+/**
+ * The bodies of the responses `ResponseCode`. A response without `content` keeps its `content`
+ * type (`undefined` for `content?: never`). `OtherBody` is the class's body that is not JSON: it
+ * is passed in, not read from the status, so the result for a generic map stays a type that
+ * TypeScript relates to the one of another client (ADR-030).
+ */
+type ResponseBodies<T extends Record<string | number, any>, Media, ResponseCode extends keyof T, OtherBody> = ResponseCode extends keyof T ? {
+    [K in ResponseCode]: T[K]["content"] extends Record<string, any> ? ResponseBody<T[K]["content"], Media, OtherBody> : K extends keyof T ? T[K]["content"] : never;
 }[ResponseCode] : never;
 /**
- * Return all 1XX, 3XX, 4XX, 5XX and `default` responses from a Response Object Map; for a union
- * of maps, the union of each map's responses, as `SuccessResponse`.
+ * The body of one response with the content map `Content`, as the client returns it. `Media`
+ * picks among its media types, as an `Accept` header does, and each one picked gives its schema.
+ * A response with none of them can still arrive (a proxy's HTML 500), so it gives what the client
+ * makes of its bodies: a JSON body gives its schema, any other body `OtherBody`, a `string` for an
+ * error (the client returns the text) and nothing for a success (the default `parseAs: "json"`
+ * rejects it; another `parseAs` types the data by itself). `Media` is read only in
+ * `keyof Content & Media`, as in `FilterKeys`, so TypeScript still relates the results of two
+ * clients with different `Media` in generic code (ADR-030).
  */
-type ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatusKey<T>> : never;
+type ResponseBody<Content, Media, OtherBody> = ([keyof Content & Media] extends [never] ? JSONLike<Content> : Content[keyof Content & Media]) | ([keyof Content & Media] extends [never] ? false extends {
+    [Key in keyof Content]: IsJSONMediaType<Key>;
+}[keyof Content] ? OtherBody : never : never);
+/**
+ * The media types that the client parses as JSON, as a content map writes them: `json` or a
+ * `+json` suffix (RFC 6838), with or without parameters, as the client's `JSON_MEDIA_TYPE_RE`, and
+ * the wildcards for any type and any `application` type, which may hold JSON. Not `x-ndjson` or
+ * `json-seq`, whose bodies are lines of JSON.
+ */
+type JSONMediaType = `${string}/${"" | `${string}+`}json` | `${string}/${"" | `${string}+`}json${";" | " " | "\t"}${string}` | "*/*" | "application/*";
+/** Whether the client parses a body of the media type `Key` as JSON, in any letter case. */
+type IsJSONMediaType<Key> = Key extends string ? Lowercase<Key> extends JSONMediaType ? true : false : false;
 /** Return first JSON-like 2XX response from a path + HTTP method */
-type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
+type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaType>;
 /** Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method */
-type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
+type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaType>;
 /** Return JSON-like request body from a path + HTTP method */
 type RequestBodyJSON<PathMethod> = JSONLike<FilterKeys<OperationRequestBody<PathMethod>, "content">>;
 /** Find first match of multiple keys */
@@ -240,10 +275,13 @@ type GetValueWithDefault<Obj, KeyPattern, Default> = Obj extends unknown ? Filte
  */
 type MediaType = `${string}/${string}`;
 /**
- * Return any media type containing "json" (works for "application/json",
- * "application/vnd.api+json", "application/vnd.oai.openapi+json")
+ * The values of the JSON media types of a content map, as the client parses them: `json` or a
+ * `+json` suffix, with or without parameters ("application/json", "application/vnd.api+json",
+ * "application/json; charset=utf-8").
  */
-type JSONLike<T> = FilterKeys<T, `${string}/json`>;
+type JSONLike<T> = {
+    [Key in keyof T]: IsJSONMediaType<Key> extends true ? T[Key] : never;
+}[keyof T];
 /**
  * Filter objects that have required keys
  * @deprecated Use `RequiredKeysOf` instead

package/dist/index.cjs

@@ -2,6 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+const CONTENT_TYPE = "Content-Type";
 const PATH_PARAM_RE = /\{[^{}]+\}/g;
 const DOT_SEGMENT_RE = /^\.\.?$/;
 const QUERY_OR_FRAGMENT_RE = /[?#]/;
@@ -83,7 +84,7 @@ function createClient(clientOptions) {
       // with no body, we should not to set Content-Type
       requestBody === void 0 || // a raw body (FormData, Blob, ...) gets its Content-Type from the platform, or none
       isRawBody(requestBody) ? {} : {
-        "Content-Type": "application/json"
+        [CONTENT_TYPE]: "application/json"
       },
       baseHeaders,
       headers,
@@ -342,8 +343,8 @@ function createPathBasedClient(clientOptions) {
   return wrapAsPathBasedClient(createClient(clientOptions));
 }
 function dropFormContentType(headers, isClientBuilt) {
-  if (isClientBuilt || !BOUNDARY_PARAMETER_RE.test(headers.get("Content-Type"))) {
-    headers.delete("Content-Type");
+  if (isClientBuilt || !BOUNDARY_PARAMETER_RE.test(headers.get(CONTENT_TYPE))) {
+    headers.delete(CONTENT_TYPE);
   }
 }
 function isHeaders(value) {
@@ -359,7 +360,7 @@ function parseJSON(raw, response) {
   try {
     return JSON.parse(raw);
   } catch {
-    const contentType = response.headers.get("Content-Type");
+    const contentType = response.headers.get(CONTENT_TYPE);
     const hint = TEXT_MEDIA_TYPE_RE.test(contentType) ? 'set `parseAs: "text"`' : "set `parseAs`";
     const subject = `Response ${response.status} (${contentType ?? "no Content-Type"})`;
     throw new SyntaxError(`${subject} is not JSON (${raw.length} characters); ${hint}`);
@@ -394,6 +395,10 @@ async function readErrorBody(response) {
   if (!raw) {
     return void 0;
   }
+  const contentType = response.headers.get(CONTENT_TYPE);
+  if (contentType !== null && !JSON_MEDIA_TYPE_RE.test(contentType)) {
+    return raw;
+  }
   try {
     return JSON.parse(raw);
   } catch {
@@ -440,6 +445,13 @@ function checkFlatMembers(value, message) {
     throw new Error(message);
   }
 }
+const PATH_STYLE_JOINERS = { simple: ",", label: ".", matrix: ";" };
+function checkFlatParam(value, style) {
+  checkFlatMembers(
+    value,
+    PATH_STYLE_JOINERS[style] ? PATH_NESTED_VALUE_ERROR : QUERY_NESTED_VALUE_ERROR
+  );
+}
 function encodeValue(value, allowReserved) {
   if (isNestedValue(value)) {
     throw new Error(QUERY_NESTED_VALUE_ERROR);
@@ -454,7 +466,7 @@ function serializePrimitiveParam(name, value, options) {
   return `${name}=${encodeValue(value, options?.allowReserved)}`;
 }
 function joinExploded(values, style) {
-  const joiner = { simple: ",", label: ".", matrix: ";" }[style] || "&";
+  const joiner = PATH_STYLE_JOINERS[style] || "&";
   const final = values.join(joiner);
   return style === "label" || style === "matrix" ? `${joiner}${final}` : final;
 }
@@ -491,6 +503,7 @@ function serializeObjectParam(name, value, options) {
   if (!value || typeof value !== "object" || !Object.keys(value).length) {
     return "";
   }
+  checkFlatParam(value, options.style);
   if (options.style !== "deepObject" && options.explode === false) {
     return serializeUnexplodedObject(name, value, options);
   }
@@ -530,6 +543,7 @@ function serializeArrayParam(name, value, options) {
   if (!Array.isArray(value) || !value.length) {
     return "";
   }
+  checkFlatParam(value, options.style);
   if (options.explode === false) {
     return serializeUnexplodedArray(name, value, options);
   }
@@ -620,11 +634,9 @@ function defaultPathSerializer(pathname, pathParams) {
 }
 function serializePathParam(name, value, options) {
   if (Array.isArray(value)) {
-    checkFlatMembers(value, PATH_NESTED_VALUE_ERROR);
     return serializeArrayParam(name, value, options);
   }
   if (typeof value === "object" && !isDate(value)) {
-    checkFlatMembers(value, PATH_NESTED_VALUE_ERROR);
     return serializeObjectParam(name, value, options);
   }
   if (options.style === "matrix") {
@@ -724,7 +736,7 @@ function defaultBodySerializer(body, headers) {
   if (isRawBody(body)) {
     return body;
   }
-  const contentType = headers && (isHeaders(headers) ? headers : mergeHeaders(headers)).get("Content-Type");
+  const contentType = headers && (isHeaders(headers) ? headers : mergeHeaders(headers)).get(CONTENT_TYPE);
   if (FORM_MEDIA_TYPE_RE.test(contentType)) {
     return formBody(body);
   }