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

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 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.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,61 @@ 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. */
+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 ? GetResponseContent<T, Media, SuccessStatus<T>> : never;
+type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = IsAny<T> extends true ? T : T extends unknown ? ResponseBodies<T, Media, SuccessStatus<T>, never> : 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`).
+ * 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 ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = IsAny<T> extends true ? T : T extends unknown ? ResponseBodies<T, Media, ErrorStatusKey<T>, string> : 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 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 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 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 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 ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatusKey<T>> : never;
+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 +270,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,61 @@ 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. */
+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 ? GetResponseContent<T, Media, SuccessStatus<T>> : never;
+type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = IsAny<T> extends true ? T : T extends unknown ? ResponseBodies<T, Media, SuccessStatus<T>, never> : 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`).
+ * 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 ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = IsAny<T> extends true ? T : T extends unknown ? ResponseBodies<T, Media, ErrorStatusKey<T>, string> : 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 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 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 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 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 ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatusKey<T>> : never;
+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 +270,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,61 @@ 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. */
+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 ? GetResponseContent<T, Media, SuccessStatus<T>> : never;
+type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = IsAny<T> extends true ? T : T extends unknown ? ResponseBodies<T, Media, SuccessStatus<T>, never> : 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`).
+ * 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 ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = IsAny<T> extends true ? T : T extends unknown ? ResponseBodies<T, Media, ErrorStatusKey<T>, string> : 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 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 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 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 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 ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatusKey<T>> : never;
+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 +270,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

@@ -440,6 +440,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 +461,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 +498,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 +538,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 +629,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") {