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

package/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 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
+
+- [#96](https://github.com/openapi-typesafe/openapi-typesafe/pull/96) [`171fa71`](https://github.com/openapi-typesafe/openapi-typesafe/commit/171fa71311107e4e26a9ae7a62b431662fb13de5) Thanks [@fedorello](https://github.com/fedorello)! - `SuccessResponseJSON`, `ErrorResponseJSON` and the `data` and `error` of a client made with
+  ``createClient<paths, `${string}/json`>()`` leave out a response that has no JSON media type. It
+  added its whole `content` map, so a `text/html` 500 typed the error as `{ "text/html": string }`,
+  a value the client never returns.
+
+- [#96](https://github.com/openapi-typesafe/openapi-typesafe/pull/96) [`171fa71`](https://github.com/openapi-typesafe/openapi-typesafe/commit/171fa71311107e4e26a9ae7a62b431662fb13de5) Thanks [@fedorello](https://github.com/fedorello)! - A nested array or object in a path parameter (`{ id: [[1]] }`) now fails with an error that names
+  `pathSerializer()`, the option that sends such values. It told you to write a `querySerializer()`,
+  which does not apply to the path.
+
+- [#96](https://github.com/openapi-typesafe/openapi-typesafe/pull/96) [`171fa71`](https://github.com/openapi-typesafe/openapi-typesafe/commit/171fa71311107e4e26a9ae7a62b431662fb13de5) Thanks [@fedorello](https://github.com/fedorello)! - A request's `querySerializer` option set to `undefined` (`{ array: { explode: undefined } }`, as a
+  wrapper passes its own optional option on) now takes the client's value, as an option left out
+  does. It replaced the client's value, so the default style was sent.
+
 ## 1.0.0-rc.6
 
 ### Patch Changes

package/dist/helpers.d.cts

@@ -199,25 +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 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> extends never ? T[K]["content"] : FilterKeys<T[K]["content"], Media> : K extends keyof T ? T[K]["content"] : never;
-}[ResponseCode] : 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;
 /**
  * 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`.
+ * 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 ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatusKey<T>> : 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;
+/**
+ * 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 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 */
@@ -234,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,25 +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 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> extends never ? T[K]["content"] : FilterKeys<T[K]["content"], Media> : K extends keyof T ? T[K]["content"] : never;
-}[ResponseCode] : 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;
 /**
  * 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`.
+ * 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 ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatusKey<T>> : 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;
+/**
+ * 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 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 */
@@ -234,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,25 +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 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> extends never ? T[K]["content"] : FilterKeys<T[K]["content"], Media> : K extends keyof T ? T[K]["content"] : never;
-}[ResponseCode] : 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;
 /**
  * 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`.
+ * 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 ErrorResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = T extends unknown ? GetResponseContent<T, Media, ErrorStatusKey<T>> : 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;
+/**
+ * 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 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 */
@@ -234,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

@@ -415,9 +415,7 @@ function headerParamValue(value) {
   if (value === null || typeof value !== "object" || isDate(value)) {
     return valueText(value);
   }
-  if (Object.values(value).some((member) => isNestedValue(member))) {
-    throw new Error(`${NESTED_VALUE_ERROR} in header parameters.`);
-  }
+  checkFlatMembers(value, HEADER_NESTED_VALUE_ERROR);
   const serialize = Array.isArray(value) ? serializeArrayParam : serializeObjectParam;
   return serialize("", value, HEADER_PARAM_STYLE) || void 0;
 }
@@ -429,14 +427,29 @@ function serializeHeaderParams(header) {
   return Object.fromEntries(entries);
 }
 const NESTED_VALUE_ERROR = "Deeply-nested arrays/objects aren\u2019t supported";
+const HEADER_NESTED_VALUE_ERROR = `${NESTED_VALUE_ERROR} in header parameters.`;
+const PATH_HOOK_HINT = "Provide your own `pathSerializer()` to handle these.";
+const PATH_NESTED_VALUE_ERROR = `${NESTED_VALUE_ERROR} in path parameters. ${PATH_HOOK_HINT}`;
+const QUERY_HOOK_HINT = "Provide your own `querySerializer()` to handle these.";
+const QUERY_NESTED_VALUE_ERROR = `${NESTED_VALUE_ERROR}. ${QUERY_HOOK_HINT}`;
 function isNestedValue(value) {
   return Boolean(value) && typeof value === "object" && !isDate(value);
 }
+function checkFlatMembers(value, message) {
+  if (Object.values(value).some((member) => isNestedValue(member))) {
+    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(
-      `${NESTED_VALUE_ERROR}. Provide your own \`querySerializer()\` to handle these.`
-    );
+    throw new Error(QUERY_NESTED_VALUE_ERROR);
   }
   const text = valueText(value);
   return allowReserved === true ? text : encodeURIComponent(text);
@@ -448,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;
 }
@@ -485,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);
   }
@@ -524,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);
   }
@@ -573,11 +588,15 @@ function mergeQueryOptions(clientOptions, requestOptions) {
   const base = typeof clientOptions === "function" ? {} : clientOptions ?? {};
   return {
     ...base,
-    ...requestOptions,
-    array: { ...base.array, ...requestOptions.array },
-    object: { ...base.object, ...requestOptions.object }
+    ...definedOptions(requestOptions),
+    array: { ...base.array, ...definedOptions(requestOptions.array) },
+    object: { ...base.object, ...definedOptions(requestOptions.object) }
   };
 }
+function definedOptions(options) {
+  const entries = Object.entries(options ?? {}).filter(([, value]) => value !== void 0);
+  return Object.fromEntries(entries);
+}
 function defaultPathSerializer(pathname, pathParams) {
   const matches = pathname.match(PATH_PARAM_RE);
   if (!matches) {
@@ -602,22 +621,24 @@ function defaultPathSerializer(pathname, pathParams) {
     if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) {
       continue;
     }
-    const value = pathParams[name];
-    let serialized;
-    if (Array.isArray(value)) {
-      serialized = serializeArrayParam(name, value, { style, explode });
-    } else if (typeof value === "object" && !isDate(value)) {
-      serialized = serializeObjectParam(name, value, { style, explode });
-    } else if (style === "matrix") {
-      serialized = `;${serializePrimitiveParam(name, value)}`;
-    } else {
-      serialized = style === "label" ? `.${encodeValue(value)}` : encodeValue(value);
-    }
+    const serialized = serializePathParam(name, pathParams[name], { style, explode });
     nextURL = nextURL.replace(match, () => serialized);
   }
   checkSerializedPath(pathname, nextURL);
   return nextURL;
 }
+function serializePathParam(name, value, options) {
+  if (Array.isArray(value)) {
+    return serializeArrayParam(name, value, options);
+  }
+  if (typeof value === "object" && !isDate(value)) {
+    return serializeObjectParam(name, value, options);
+  }
+  if (options.style === "matrix") {
+    return `;${serializePrimitiveParam(name, value)}`;
+  }
+  return options.style === "label" ? `.${encodeValue(value)}` : encodeValue(value);
+}
 function checkSerializedPath(template, url) {
   const fixed = template.slice(0, template.search(PATH_PARAM_RE));
   const path = url.split(QUERY_OR_FRAGMENT_RE, 1)[0];