openapi-typesafe-fetch 1.0.0-rc.10 → 1.0.0-rc.12

package/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 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.12
+
+### Patch Changes
+
+- [#136](https://github.com/openapi-typesafe/openapi-typesafe/pull/136) [`68ce29a`](https://github.com/openapi-typesafe/openapi-typesafe/commit/68ce29ad4b8f8490d38990af62bbc830b54df015) Thanks [@fedorello](https://github.com/fedorello)! - A wrapper generic in the path that sets `parseAs`, such as
+  `client.GET(path, { ...init, parseAs: "text" })` or an `init` typed
+  `FetchOptions<…> & { parseAs: "text" }`, types `data` as the body of that `parseAs` again
+  (`string` for `"text"`), as openapi-fetch does. Before, it was the text or any JSON body of the
+  paths, so assigning it to `string | undefined` failed. Each member of a union of options now
+  types its own data: `{ parseAs: ParseAs } | undefined` gives every body, as in openapi-fetch.
+
+- [#136](https://github.com/openapi-typesafe/openapi-typesafe/pull/136) [`68ce29a`](https://github.com/openapi-typesafe/openapi-typesafe/commit/68ce29ad4b8f8490d38990af62bbc830b54df015) Thanks [@fedorello](https://github.com/fedorello)! - `SuccessResponseJSON` and `ErrorResponseJSON` of a union of operations are the union of each
+  operation's JSON bodies again. Before, only the status codes the operations share counted, so
+  `ErrorResponseJSON<OpA | OpB>` could gain a `string` that neither operation has alone.
+
+## 1.0.0-rc.11
+
+### Patch Changes
+
+- [#128](https://github.com/openapi-typesafe/openapi-typesafe/pull/128) [`fad3163`](https://github.com/openapi-typesafe/openapi-typesafe/commit/fad31635ed28508082d59c2e0a3ba6e881b20d02) Thanks [@fedorello](https://github.com/fedorello)! - A `json` inside the parameters of a media type no longer makes it a JSON media type in the types,
+  as at runtime: an error declared as `text/plain; profile=urn:a+json` or
+  `message/http; msgtype=application/json` is typed as the text (`string`) the client returns, and
+  `JSONLike`, `RequestBodyJSON`, `SuccessResponseJSON` and `ErrorResponseJSON` leave such media
+  types out. Only the media type before the `;` counts, for media ranges (`text/*`) too.
+
+- [#128](https://github.com/openapi-typesafe/openapi-typesafe/pull/128) [`fad3163`](https://github.com/openapi-typesafe/openapi-typesafe/commit/fad31635ed28508082d59c2e0a3ba6e881b20d02) Thanks [@fedorello](https://github.com/fedorello)! - An optional `parseAs` with only some values, such as a wrapper's `options: { parseAs?: "text" }`
+  passed to `client.GET()`, types `data` as the body of each value or the JSON body (`string | T`),
+  as the client returns it. Before, it was typed as the JSON body only. Options whose `parseAs` may
+  be any value, or that have none, still type `data` as the JSON body. With and without
+  `exactOptionalPropertyTypes`.
+
+- [#128](https://github.com/openapi-typesafe/openapi-typesafe/pull/128) [`fad3163`](https://github.com/openapi-typesafe/openapi-typesafe/commit/fad31635ed28508082d59c2e0a3ba6e881b20d02) Thanks [@fedorello](https://github.com/fedorello)! - `client.request(method, path, { parseAs })` types `data` by `parseAs`, as `client.GET()` and the
+  other method calls do: `{ parseAs: "text" }` gives a `string`, `"stream"` the body stream. Before,
+  `data` was always the JSON body. A literal in `params` or `body` next to `parseAs`, such as an
+  enum value, no longer loses the `parseAs` type either.
+
 ## 1.0.0-rc.10
 
 ### Patch Changes

package/dist/helpers.d.cts

@@ -272,12 +272,26 @@ type JSONErrorMediaTypes<Content> = {
 type TextErrorMediaTypes<Content> = {
     [Key in keyof Content]: IsJSONMediaPattern<Key> extends true ? never : Key;
 }[keyof Content];
-/** Whether the client parses every body of the media type `Key` as JSON, in any letter case. */
-type IsJSONMediaPattern<Key> = Key extends string ? Lowercase<Key> extends JSONMediaPattern ? true : false : false;
+/**
+ * Whether the client parses every body of the media type `Key` as JSON, in any letter case: its
+ * subtype is `json` or ends in `+json`, as `JSON_MEDIA_TYPE_RE` reads it. A `json` in a parameter
+ * (`text/plain; profile=urn:a+json`) does not count; `JSONMediaPattern` alone matched it.
+ */
+type IsJSONMediaPattern<Key> = Key extends string ? MediaSubtype<Lowercase<Key>> extends "json" | `${string}+json` ? true : false : false;
+/**
+ * The subtype of a media type: the text after the first `/` and before the parameters (the first
+ * `;`), without the spaces and tabs at its end. Empty without a type before a `/`, as
+ * `JSON_MEDIA_TYPE_RE` wants one. A subtype may hold a `/`, as the regular expression allows.
+ */
+type MediaSubtype<Text extends string> = Text extends `${infer Type}/${infer Rest}` ? Type extends "" ? "" : TrimmedEnd<Rest extends `${infer Subtype};${string}` ? Subtype : Rest> : "";
+/** The text without the spaces and tabs at its end (OWS before parameters, RFC 9110). */
+type TrimmedEnd<Text extends string> = Text extends `${infer Rest} ` | `${infer Rest}\t` ? TrimmedEnd<Rest> : Text;
 /**
  * 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`.
- * Not `x-ndjson` or `json-seq`, whose bodies are lines of JSON.
+ * Not `x-ndjson` or `json-seq`, whose bodies are lines of JSON. A template cannot keep its
+ * `${string}` out of the parameters, so it only picks the schema of an index signature
+ * (`JSONMediaKey`); whether a media type is JSON is `IsJSONMediaPattern`'s answer.
  */
 type JSONMediaPattern = `${string}/${"" | `${string}+`}json` | `${string}/${"" | `${string}+`}json${";" | " " | "\t"}${string}`;
 /**
@@ -287,12 +301,39 @@ type JSONMediaPattern = `${string}/${"" | `${string}+`}json` | `${string}/${"" |
 type JSONMediaRange = `${string}/*` | `${string}/*${";" | " " | "\t"}${string}`;
 /** The media types that may hold JSON, in lower case. */
 type JSONMediaType = JSONMediaPattern | JSONMediaRange;
-/** 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>, 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>, JSONMediaType>;
+/**
+ * Whether a body of the media type `Key` may be one the client parses as JSON, in any letter
+ * case: a JSON media type (`IsJSONMediaPattern`) or a media range (subtype `*`), with or without
+ * parameters, which do not count.
+ */
+type IsJSONMediaType<Key> = Key extends string ? IsJSONMediaPattern<Key> extends true ? true : MediaSubtype<Lowercase<Key>> extends "*" ? true : false : false;
+/**
+ * Return first JSON-like 2XX response from a path + HTTP method; for a union of operations, the
+ * union of each one's.
+ */
+type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = PathMethod extends unknown ? SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>> : never;
+/**
+ * Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method; for a
+ * union of operations, the union of each one's.
+ */
+type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = PathMethod extends unknown ? ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>> : never;
+/**
+ * The media types of the responses `T` (of one operation) that may hold JSON (`IsJSONMediaType`),
+ * for the JSON helpers to pick by: their keys, as `JSONMediaType` cannot leave out a `json` in
+ * parameters. A content map with an index signature has no such key, so it gives
+ * `JSONMediaType`, which picks the schema of its signature. The helpers pick per operation: the
+ * keys of a union of response maps are only the status codes they share, so the media types of
+ * the other statuses were lost, and the media types of one operation could pick in another.
+ */
+type JSONMediaKeys<T> = {
+    [Status in keyof T]: T[Status] extends {
+        content: infer Content;
+    } ? {
+        [Key in keyof Content]: JSONMediaKey<Key>;
+    }[keyof Content] : never;
+}[keyof T];
+/** `Key` when it may hold JSON; `JSONMediaType` for the wide key of an index signature. */
+type JSONMediaKey<Key> = string extends Key ? JSONMediaType : IsJSONMediaType<Key> extends true ? Key : never;
 /** Return JSON-like request body from a path + HTTP method */
 type RequestBodyJSON<PathMethod> = JSONLike<FilterKeys<OperationRequestBody<PathMethod>, "content">>;
 /** Find first match of multiple keys */

package/dist/helpers.d.mts

@@ -272,12 +272,26 @@ type JSONErrorMediaTypes<Content> = {
 type TextErrorMediaTypes<Content> = {
     [Key in keyof Content]: IsJSONMediaPattern<Key> extends true ? never : Key;
 }[keyof Content];
-/** Whether the client parses every body of the media type `Key` as JSON, in any letter case. */
-type IsJSONMediaPattern<Key> = Key extends string ? Lowercase<Key> extends JSONMediaPattern ? true : false : false;
+/**
+ * Whether the client parses every body of the media type `Key` as JSON, in any letter case: its
+ * subtype is `json` or ends in `+json`, as `JSON_MEDIA_TYPE_RE` reads it. A `json` in a parameter
+ * (`text/plain; profile=urn:a+json`) does not count; `JSONMediaPattern` alone matched it.
+ */
+type IsJSONMediaPattern<Key> = Key extends string ? MediaSubtype<Lowercase<Key>> extends "json" | `${string}+json` ? true : false : false;
+/**
+ * The subtype of a media type: the text after the first `/` and before the parameters (the first
+ * `;`), without the spaces and tabs at its end. Empty without a type before a `/`, as
+ * `JSON_MEDIA_TYPE_RE` wants one. A subtype may hold a `/`, as the regular expression allows.
+ */
+type MediaSubtype<Text extends string> = Text extends `${infer Type}/${infer Rest}` ? Type extends "" ? "" : TrimmedEnd<Rest extends `${infer Subtype};${string}` ? Subtype : Rest> : "";
+/** The text without the spaces and tabs at its end (OWS before parameters, RFC 9110). */
+type TrimmedEnd<Text extends string> = Text extends `${infer Rest} ` | `${infer Rest}\t` ? TrimmedEnd<Rest> : Text;
 /**
  * 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`.
- * Not `x-ndjson` or `json-seq`, whose bodies are lines of JSON.
+ * Not `x-ndjson` or `json-seq`, whose bodies are lines of JSON. A template cannot keep its
+ * `${string}` out of the parameters, so it only picks the schema of an index signature
+ * (`JSONMediaKey`); whether a media type is JSON is `IsJSONMediaPattern`'s answer.
  */
 type JSONMediaPattern = `${string}/${"" | `${string}+`}json` | `${string}/${"" | `${string}+`}json${";" | " " | "\t"}${string}`;
 /**
@@ -287,12 +301,39 @@ type JSONMediaPattern = `${string}/${"" | `${string}+`}json` | `${string}/${"" |
 type JSONMediaRange = `${string}/*` | `${string}/*${";" | " " | "\t"}${string}`;
 /** The media types that may hold JSON, in lower case. */
 type JSONMediaType = JSONMediaPattern | JSONMediaRange;
-/** 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>, 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>, JSONMediaType>;
+/**
+ * Whether a body of the media type `Key` may be one the client parses as JSON, in any letter
+ * case: a JSON media type (`IsJSONMediaPattern`) or a media range (subtype `*`), with or without
+ * parameters, which do not count.
+ */
+type IsJSONMediaType<Key> = Key extends string ? IsJSONMediaPattern<Key> extends true ? true : MediaSubtype<Lowercase<Key>> extends "*" ? true : false : false;
+/**
+ * Return first JSON-like 2XX response from a path + HTTP method; for a union of operations, the
+ * union of each one's.
+ */
+type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = PathMethod extends unknown ? SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>> : never;
+/**
+ * Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method; for a
+ * union of operations, the union of each one's.
+ */
+type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = PathMethod extends unknown ? ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>> : never;
+/**
+ * The media types of the responses `T` (of one operation) that may hold JSON (`IsJSONMediaType`),
+ * for the JSON helpers to pick by: their keys, as `JSONMediaType` cannot leave out a `json` in
+ * parameters. A content map with an index signature has no such key, so it gives
+ * `JSONMediaType`, which picks the schema of its signature. The helpers pick per operation: the
+ * keys of a union of response maps are only the status codes they share, so the media types of
+ * the other statuses were lost, and the media types of one operation could pick in another.
+ */
+type JSONMediaKeys<T> = {
+    [Status in keyof T]: T[Status] extends {
+        content: infer Content;
+    } ? {
+        [Key in keyof Content]: JSONMediaKey<Key>;
+    }[keyof Content] : never;
+}[keyof T];
+/** `Key` when it may hold JSON; `JSONMediaType` for the wide key of an index signature. */
+type JSONMediaKey<Key> = string extends Key ? JSONMediaType : IsJSONMediaType<Key> extends true ? Key : never;
 /** Return JSON-like request body from a path + HTTP method */
 type RequestBodyJSON<PathMethod> = JSONLike<FilterKeys<OperationRequestBody<PathMethod>, "content">>;
 /** Find first match of multiple keys */

package/dist/helpers.d.ts

@@ -272,12 +272,26 @@ type JSONErrorMediaTypes<Content> = {
 type TextErrorMediaTypes<Content> = {
     [Key in keyof Content]: IsJSONMediaPattern<Key> extends true ? never : Key;
 }[keyof Content];
-/** Whether the client parses every body of the media type `Key` as JSON, in any letter case. */
-type IsJSONMediaPattern<Key> = Key extends string ? Lowercase<Key> extends JSONMediaPattern ? true : false : false;
+/**
+ * Whether the client parses every body of the media type `Key` as JSON, in any letter case: its
+ * subtype is `json` or ends in `+json`, as `JSON_MEDIA_TYPE_RE` reads it. A `json` in a parameter
+ * (`text/plain; profile=urn:a+json`) does not count; `JSONMediaPattern` alone matched it.
+ */
+type IsJSONMediaPattern<Key> = Key extends string ? MediaSubtype<Lowercase<Key>> extends "json" | `${string}+json` ? true : false : false;
+/**
+ * The subtype of a media type: the text after the first `/` and before the parameters (the first
+ * `;`), without the spaces and tabs at its end. Empty without a type before a `/`, as
+ * `JSON_MEDIA_TYPE_RE` wants one. A subtype may hold a `/`, as the regular expression allows.
+ */
+type MediaSubtype<Text extends string> = Text extends `${infer Type}/${infer Rest}` ? Type extends "" ? "" : TrimmedEnd<Rest extends `${infer Subtype};${string}` ? Subtype : Rest> : "";
+/** The text without the spaces and tabs at its end (OWS before parameters, RFC 9110). */
+type TrimmedEnd<Text extends string> = Text extends `${infer Rest} ` | `${infer Rest}\t` ? TrimmedEnd<Rest> : Text;
 /**
  * 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`.
- * Not `x-ndjson` or `json-seq`, whose bodies are lines of JSON.
+ * Not `x-ndjson` or `json-seq`, whose bodies are lines of JSON. A template cannot keep its
+ * `${string}` out of the parameters, so it only picks the schema of an index signature
+ * (`JSONMediaKey`); whether a media type is JSON is `IsJSONMediaPattern`'s answer.
  */
 type JSONMediaPattern = `${string}/${"" | `${string}+`}json` | `${string}/${"" | `${string}+`}json${";" | " " | "\t"}${string}`;
 /**
@@ -287,12 +301,39 @@ type JSONMediaPattern = `${string}/${"" | `${string}+`}json` | `${string}/${"" |
 type JSONMediaRange = `${string}/*` | `${string}/*${";" | " " | "\t"}${string}`;
 /** The media types that may hold JSON, in lower case. */
 type JSONMediaType = JSONMediaPattern | JSONMediaRange;
-/** 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>, 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>, JSONMediaType>;
+/**
+ * Whether a body of the media type `Key` may be one the client parses as JSON, in any letter
+ * case: a JSON media type (`IsJSONMediaPattern`) or a media range (subtype `*`), with or without
+ * parameters, which do not count.
+ */
+type IsJSONMediaType<Key> = Key extends string ? IsJSONMediaPattern<Key> extends true ? true : MediaSubtype<Lowercase<Key>> extends "*" ? true : false : false;
+/**
+ * Return first JSON-like 2XX response from a path + HTTP method; for a union of operations, the
+ * union of each one's.
+ */
+type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = PathMethod extends unknown ? SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>> : never;
+/**
+ * Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method; for a
+ * union of operations, the union of each one's.
+ */
+type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = PathMethod extends unknown ? ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>> : never;
+/**
+ * The media types of the responses `T` (of one operation) that may hold JSON (`IsJSONMediaType`),
+ * for the JSON helpers to pick by: their keys, as `JSONMediaType` cannot leave out a `json` in
+ * parameters. A content map with an index signature has no such key, so it gives
+ * `JSONMediaType`, which picks the schema of its signature. The helpers pick per operation: the
+ * keys of a union of response maps are only the status codes they share, so the media types of
+ * the other statuses were lost, and the media types of one operation could pick in another.
+ */
+type JSONMediaKeys<T> = {
+    [Status in keyof T]: T[Status] extends {
+        content: infer Content;
+    } ? {
+        [Key in keyof Content]: JSONMediaKey<Key>;
+    }[keyof Content] : never;
+}[keyof T];
+/** `Key` when it may hold JSON; `JSONMediaType` for the wide key of an index signature. */
+type JSONMediaKey<Key> = string extends Key ? JSONMediaType : IsJSONMediaType<Key> extends true ? Key : never;
 /** Return JSON-like request body from a path + HTTP method */
 type RequestBodyJSON<PathMethod> = JSONLike<FilterKeys<OperationRequestBody<PathMethod>, "content">>;
 /** Find first match of multiple keys */

package/dist/index.d.cts

@@ -129,16 +129,71 @@ type BodyType<T = unknown> = {
 };
 type ParseAs = keyof BodyType;
 /**
- * The data of a success body `T` read with the `parseAs` of `Options`. Each value of a union gives
- * its body, and `undefined` is the default `"json"`, as at runtime: a wrapper that passes on
- * `parseAs: "text" | undefined` gets `string | T`, not `T` only. An optional `parseAs` (the
- * declared init type, as for a call without options) gives `T`, as in openapi-fetch. No `infer`:
- * TypeScript relates a type to a deferred conditional type through both of its branches only
- * when it infers nothing, and generic hooks return the data of a call as this type.
+ * The data of a success body `T` read with the `parseAs` of `Options`. Each value it may have gives
+ * its body, and `undefined` or a left-out `parseAs` is the default `"json"`, as at runtime: a
+ * wrapper that passes on `parseAs?: "text"` gets `string | T`, not `T` only. Options without
+ * `parseAs`, or whose `parseAs` may be any value (the declared init type, as for a call without
+ * options), give `T`, as in openapi-fetch; each member of a union of options gives its own data.
+ * No `infer`: TypeScript relates a type to a deferred conditional type through both of its
+ * branches only when it infers nothing, and generic hooks return the data of a call as this type.
+ * It distributes over `Options`, as openapi-fetch's does, so the options of a generic call (a
+ * wrapper's `FetchOptions` of a generic path with `parseAs: "text"`) give the data of their
+ * constraint: TypeScript reads a deferred distributive type through its check type's constraint.
  */
-type ParseAsResponse<T, Options> = Options extends { parseAs: ParseAs | undefined }
-  ? BodyType<T>[ParseAsValue<Options["parseAs"]>]
-  : T;
+type ParseAsResponse<T, Options> = Options extends unknown
+  ? BodyType<T>[ParseAsKey<Options>]
+  : never;
+
+/**
+ * The key of `BodyType` that the options `Options` read the body with. A conditional type of its
+ * own, inside the index: one in the branch of `ParseAsResponse` that picked `T` would be read
+ * through both of its branches while TypeScript reads the constraint above, as `never` fits any
+ * check type, so a generic `parseAs: "text"` gave the JSON body too.
+ */
+type ParseAsKey<Options> = [MissingParseAsValues<Options>] extends [never]
+  ? "json"
+  : ParseAsValue<ParseAsValues<Options>>;
+
+/**
+ * The `parseAs` values that `Options` may have; `undefined` when it may be left out. One
+ * conditional type, not a union: `BodyType<T>` indexed by a union of generic keys is read as the
+ * intersection of their bodies when another type is checked against it. `any` options give `any`,
+ * so their data is `any`, as in openapi-fetch: a caller that passes an `any` init (as the generic
+ * hooks of openapi-typesafe-react-query do) returns it as the data type it declares. The branch
+ * is `any` itself, not `Options`: a type parameter there stops TypeScript relating the data of a
+ * generic call to a wrapper's (ADR-030).
+ */
+type ParseAsValues<Options> = Options extends unknown
+  ? IsAny<Options> extends true
+    ? // biome-ignore lint/suspicious/noExplicitAny: any options give any data, as in openapi-fetch
+      any
+    :
+        | (Options extends RequiredParseAs ? never : undefined)
+        | { [Value in ParseAs]: Options extends WithoutParseAs<Value> ? never : Value }[ParseAs]
+  : never;
+
+/**
+ * The `parseAs` values that the options `Options` (one member of a union) cannot have, as
+ * `ParseAsValues` reads them.
+ */
+type MissingParseAsValues<Options> =
+  | ([Options] extends [RequiredParseAs] ? undefined : never)
+  | { [Value in ParseAs]: [Options] extends [WithoutParseAs<Value>] ? Value : never }[ParseAs];
+
+/** Options that always have a `parseAs`. */
+type RequiredParseAs = { parseAs: ParseAs };
+
+/**
+ * Options that cannot have the `parseAs` value `Value`: `undefined` options, or options whose
+ * `parseAs` (if any) leaves it out. Each
+ * check takes `Options` as its checked type and a fixed type here, so TypeScript relates the
+ * data of a generic call to a wrapper's (ADR-030); one union of these types instead would let
+ * TypeScript split `parseAs?: ParseAs` into its values and match each one. The `object` keeps
+ * options without `parseAs` (`{ headers }`) from failing as a weak type.
+ */
+type WithoutParseAs<Value extends ParseAs> =
+  | undefined
+  | (object & { parseAs?: Exclude<ParseAs, Value> | undefined });
 
 /** How a `parseAs` value reads the body, for each member of a union; `undefined` reads JSON. */
 type ParseAsValue<Value> = Value extends ParseAs ? Value : "json";
@@ -178,10 +233,16 @@ type RequestBodyOption<T> =
  * gave a conditional type no `FetchOptions` argument was assignable to (TS2345). The operations
  * of a union are not merged into one deep init type, which gave TS2589 on hundreds of paths
  * (upstream #1882).
+ * Only the options that depend on the operation distribute; the others stay outside the
+ * conditional type. While `request()` has not fixed its method, TypeScript reads the init's
+ * contextual type through the constraints of the method and the path, and stops after ten nested
+ * instantiations of one conditional type: with every option inside it, `parseAs: "text"` had no
+ * contextual type, widened to `string`, and the init fell back to its constraint (`data` the JSON
+ * body). `FetchOptions<never>` is still `never`.
  */
-type FetchOptions<T> = T extends unknown
-  ? RequestOptions<T> & Omit<RequestInit, "body" | "headers">
-  : never;
+type FetchOptions<T> = (T extends unknown ? OperationRequestOptions<T> : never) &
+  SharedRequestOptions &
+  Omit<RequestInit, "body" | "headers">;
 
 // Readable<T> strips $Write markers (writeOnly properties excluded from response)
 type FetchResponse<
@@ -201,18 +262,25 @@ type FetchResponse<
       response: Response;
     };
 
-type RequestOptions<T> = ParamsOption<T> &
+type RequestOptions<T> = OperationRequestOptions<T> & SharedRequestOptions;
+
+/** The options of a call that depend on its operation `T`. */
+type OperationRequestOptions<T> = ParamsOption<T> &
   RequestBodyOption<T> & {
-    baseUrl?: string | undefined;
     querySerializer?: QuerySerializer<T> | QuerySerializerOptions | undefined;
     bodySerializer?: BodySerializer<T> | undefined;
-    pathSerializer?: PathSerializer | undefined;
-    parseAs?: ParseAs | undefined;
-    fetch?: ClientOptions["fetch"];
-    headers?: HeadersOptions | undefined;
-    middleware?: Middleware[] | undefined;
   };
 
+/** The options of a call that are the same for every operation. */
+type SharedRequestOptions = {
+  baseUrl?: string | undefined;
+  pathSerializer?: PathSerializer | undefined;
+  parseAs?: ParseAs | undefined;
+  fetch?: ClientOptions["fetch"];
+  headers?: HeadersOptions | undefined;
+  middleware?: Middleware[] | undefined;
+};
+
 type MergedOptions<T = unknown> = {
   baseUrl: string;
   parseAs: ParseAs;

package/dist/index.d.mts

@@ -129,16 +129,71 @@ type BodyType<T = unknown> = {
 };
 type ParseAs = keyof BodyType;
 /**
- * The data of a success body `T` read with the `parseAs` of `Options`. Each value of a union gives
- * its body, and `undefined` is the default `"json"`, as at runtime: a wrapper that passes on
- * `parseAs: "text" | undefined` gets `string | T`, not `T` only. An optional `parseAs` (the
- * declared init type, as for a call without options) gives `T`, as in openapi-fetch. No `infer`:
- * TypeScript relates a type to a deferred conditional type through both of its branches only
- * when it infers nothing, and generic hooks return the data of a call as this type.
+ * The data of a success body `T` read with the `parseAs` of `Options`. Each value it may have gives
+ * its body, and `undefined` or a left-out `parseAs` is the default `"json"`, as at runtime: a
+ * wrapper that passes on `parseAs?: "text"` gets `string | T`, not `T` only. Options without
+ * `parseAs`, or whose `parseAs` may be any value (the declared init type, as for a call without
+ * options), give `T`, as in openapi-fetch; each member of a union of options gives its own data.
+ * No `infer`: TypeScript relates a type to a deferred conditional type through both of its
+ * branches only when it infers nothing, and generic hooks return the data of a call as this type.
+ * It distributes over `Options`, as openapi-fetch's does, so the options of a generic call (a
+ * wrapper's `FetchOptions` of a generic path with `parseAs: "text"`) give the data of their
+ * constraint: TypeScript reads a deferred distributive type through its check type's constraint.
  */
-type ParseAsResponse<T, Options> = Options extends { parseAs: ParseAs | undefined }
-  ? BodyType<T>[ParseAsValue<Options["parseAs"]>]
-  : T;
+type ParseAsResponse<T, Options> = Options extends unknown
+  ? BodyType<T>[ParseAsKey<Options>]
+  : never;
+
+/**
+ * The key of `BodyType` that the options `Options` read the body with. A conditional type of its
+ * own, inside the index: one in the branch of `ParseAsResponse` that picked `T` would be read
+ * through both of its branches while TypeScript reads the constraint above, as `never` fits any
+ * check type, so a generic `parseAs: "text"` gave the JSON body too.
+ */
+type ParseAsKey<Options> = [MissingParseAsValues<Options>] extends [never]
+  ? "json"
+  : ParseAsValue<ParseAsValues<Options>>;
+
+/**
+ * The `parseAs` values that `Options` may have; `undefined` when it may be left out. One
+ * conditional type, not a union: `BodyType<T>` indexed by a union of generic keys is read as the
+ * intersection of their bodies when another type is checked against it. `any` options give `any`,
+ * so their data is `any`, as in openapi-fetch: a caller that passes an `any` init (as the generic
+ * hooks of openapi-typesafe-react-query do) returns it as the data type it declares. The branch
+ * is `any` itself, not `Options`: a type parameter there stops TypeScript relating the data of a
+ * generic call to a wrapper's (ADR-030).
+ */
+type ParseAsValues<Options> = Options extends unknown
+  ? IsAny<Options> extends true
+    ? // biome-ignore lint/suspicious/noExplicitAny: any options give any data, as in openapi-fetch
+      any
+    :
+        | (Options extends RequiredParseAs ? never : undefined)
+        | { [Value in ParseAs]: Options extends WithoutParseAs<Value> ? never : Value }[ParseAs]
+  : never;
+
+/**
+ * The `parseAs` values that the options `Options` (one member of a union) cannot have, as
+ * `ParseAsValues` reads them.
+ */
+type MissingParseAsValues<Options> =
+  | ([Options] extends [RequiredParseAs] ? undefined : never)
+  | { [Value in ParseAs]: [Options] extends [WithoutParseAs<Value>] ? Value : never }[ParseAs];
+
+/** Options that always have a `parseAs`. */
+type RequiredParseAs = { parseAs: ParseAs };
+
+/**
+ * Options that cannot have the `parseAs` value `Value`: `undefined` options, or options whose
+ * `parseAs` (if any) leaves it out. Each
+ * check takes `Options` as its checked type and a fixed type here, so TypeScript relates the
+ * data of a generic call to a wrapper's (ADR-030); one union of these types instead would let
+ * TypeScript split `parseAs?: ParseAs` into its values and match each one. The `object` keeps
+ * options without `parseAs` (`{ headers }`) from failing as a weak type.
+ */
+type WithoutParseAs<Value extends ParseAs> =
+  | undefined
+  | (object & { parseAs?: Exclude<ParseAs, Value> | undefined });
 
 /** How a `parseAs` value reads the body, for each member of a union; `undefined` reads JSON. */
 type ParseAsValue<Value> = Value extends ParseAs ? Value : "json";
@@ -178,10 +233,16 @@ type RequestBodyOption<T> =
  * gave a conditional type no `FetchOptions` argument was assignable to (TS2345). The operations
  * of a union are not merged into one deep init type, which gave TS2589 on hundreds of paths
  * (upstream #1882).
+ * Only the options that depend on the operation distribute; the others stay outside the
+ * conditional type. While `request()` has not fixed its method, TypeScript reads the init's
+ * contextual type through the constraints of the method and the path, and stops after ten nested
+ * instantiations of one conditional type: with every option inside it, `parseAs: "text"` had no
+ * contextual type, widened to `string`, and the init fell back to its constraint (`data` the JSON
+ * body). `FetchOptions<never>` is still `never`.
  */
-type FetchOptions<T> = T extends unknown
-  ? RequestOptions<T> & Omit<RequestInit, "body" | "headers">
-  : never;
+type FetchOptions<T> = (T extends unknown ? OperationRequestOptions<T> : never) &
+  SharedRequestOptions &
+  Omit<RequestInit, "body" | "headers">;
 
 // Readable<T> strips $Write markers (writeOnly properties excluded from response)
 type FetchResponse<
@@ -201,18 +262,25 @@ type FetchResponse<
       response: Response;
     };
 
-type RequestOptions<T> = ParamsOption<T> &
+type RequestOptions<T> = OperationRequestOptions<T> & SharedRequestOptions;
+
+/** The options of a call that depend on its operation `T`. */
+type OperationRequestOptions<T> = ParamsOption<T> &
   RequestBodyOption<T> & {
-    baseUrl?: string | undefined;
     querySerializer?: QuerySerializer<T> | QuerySerializerOptions | undefined;
     bodySerializer?: BodySerializer<T> | undefined;
-    pathSerializer?: PathSerializer | undefined;
-    parseAs?: ParseAs | undefined;
-    fetch?: ClientOptions["fetch"];
-    headers?: HeadersOptions | undefined;
-    middleware?: Middleware[] | undefined;
   };
 
+/** The options of a call that are the same for every operation. */
+type SharedRequestOptions = {
+  baseUrl?: string | undefined;
+  pathSerializer?: PathSerializer | undefined;
+  parseAs?: ParseAs | undefined;
+  fetch?: ClientOptions["fetch"];
+  headers?: HeadersOptions | undefined;
+  middleware?: Middleware[] | undefined;
+};
+
 type MergedOptions<T = unknown> = {
   baseUrl: string;
   parseAs: ParseAs;

package/dist/index.d.ts

@@ -129,16 +129,71 @@ type BodyType<T = unknown> = {
 };
 type ParseAs = keyof BodyType;
 /**
- * The data of a success body `T` read with the `parseAs` of `Options`. Each value of a union gives
- * its body, and `undefined` is the default `"json"`, as at runtime: a wrapper that passes on
- * `parseAs: "text" | undefined` gets `string | T`, not `T` only. An optional `parseAs` (the
- * declared init type, as for a call without options) gives `T`, as in openapi-fetch. No `infer`:
- * TypeScript relates a type to a deferred conditional type through both of its branches only
- * when it infers nothing, and generic hooks return the data of a call as this type.
+ * The data of a success body `T` read with the `parseAs` of `Options`. Each value it may have gives
+ * its body, and `undefined` or a left-out `parseAs` is the default `"json"`, as at runtime: a
+ * wrapper that passes on `parseAs?: "text"` gets `string | T`, not `T` only. Options without
+ * `parseAs`, or whose `parseAs` may be any value (the declared init type, as for a call without
+ * options), give `T`, as in openapi-fetch; each member of a union of options gives its own data.
+ * No `infer`: TypeScript relates a type to a deferred conditional type through both of its
+ * branches only when it infers nothing, and generic hooks return the data of a call as this type.
+ * It distributes over `Options`, as openapi-fetch's does, so the options of a generic call (a
+ * wrapper's `FetchOptions` of a generic path with `parseAs: "text"`) give the data of their
+ * constraint: TypeScript reads a deferred distributive type through its check type's constraint.
  */
-type ParseAsResponse<T, Options> = Options extends { parseAs: ParseAs | undefined }
-  ? BodyType<T>[ParseAsValue<Options["parseAs"]>]
-  : T;
+type ParseAsResponse<T, Options> = Options extends unknown
+  ? BodyType<T>[ParseAsKey<Options>]
+  : never;
+
+/**
+ * The key of `BodyType` that the options `Options` read the body with. A conditional type of its
+ * own, inside the index: one in the branch of `ParseAsResponse` that picked `T` would be read
+ * through both of its branches while TypeScript reads the constraint above, as `never` fits any
+ * check type, so a generic `parseAs: "text"` gave the JSON body too.
+ */
+type ParseAsKey<Options> = [MissingParseAsValues<Options>] extends [never]
+  ? "json"
+  : ParseAsValue<ParseAsValues<Options>>;
+
+/**
+ * The `parseAs` values that `Options` may have; `undefined` when it may be left out. One
+ * conditional type, not a union: `BodyType<T>` indexed by a union of generic keys is read as the
+ * intersection of their bodies when another type is checked against it. `any` options give `any`,
+ * so their data is `any`, as in openapi-fetch: a caller that passes an `any` init (as the generic
+ * hooks of openapi-typesafe-react-query do) returns it as the data type it declares. The branch
+ * is `any` itself, not `Options`: a type parameter there stops TypeScript relating the data of a
+ * generic call to a wrapper's (ADR-030).
+ */
+type ParseAsValues<Options> = Options extends unknown
+  ? IsAny<Options> extends true
+    ? // biome-ignore lint/suspicious/noExplicitAny: any options give any data, as in openapi-fetch
+      any
+    :
+        | (Options extends RequiredParseAs ? never : undefined)
+        | { [Value in ParseAs]: Options extends WithoutParseAs<Value> ? never : Value }[ParseAs]
+  : never;
+
+/**
+ * The `parseAs` values that the options `Options` (one member of a union) cannot have, as
+ * `ParseAsValues` reads them.
+ */
+type MissingParseAsValues<Options> =
+  | ([Options] extends [RequiredParseAs] ? undefined : never)
+  | { [Value in ParseAs]: [Options] extends [WithoutParseAs<Value>] ? Value : never }[ParseAs];
+
+/** Options that always have a `parseAs`. */
+type RequiredParseAs = { parseAs: ParseAs };
+
+/**
+ * Options that cannot have the `parseAs` value `Value`: `undefined` options, or options whose
+ * `parseAs` (if any) leaves it out. Each
+ * check takes `Options` as its checked type and a fixed type here, so TypeScript relates the
+ * data of a generic call to a wrapper's (ADR-030); one union of these types instead would let
+ * TypeScript split `parseAs?: ParseAs` into its values and match each one. The `object` keeps
+ * options without `parseAs` (`{ headers }`) from failing as a weak type.
+ */
+type WithoutParseAs<Value extends ParseAs> =
+  | undefined
+  | (object & { parseAs?: Exclude<ParseAs, Value> | undefined });
 
 /** How a `parseAs` value reads the body, for each member of a union; `undefined` reads JSON. */
 type ParseAsValue<Value> = Value extends ParseAs ? Value : "json";
@@ -178,10 +233,16 @@ type RequestBodyOption<T> =
  * gave a conditional type no `FetchOptions` argument was assignable to (TS2345). The operations
  * of a union are not merged into one deep init type, which gave TS2589 on hundreds of paths
  * (upstream #1882).
+ * Only the options that depend on the operation distribute; the others stay outside the
+ * conditional type. While `request()` has not fixed its method, TypeScript reads the init's
+ * contextual type through the constraints of the method and the path, and stops after ten nested
+ * instantiations of one conditional type: with every option inside it, `parseAs: "text"` had no
+ * contextual type, widened to `string`, and the init fell back to its constraint (`data` the JSON
+ * body). `FetchOptions<never>` is still `never`.
  */
-type FetchOptions<T> = T extends unknown
-  ? RequestOptions<T> & Omit<RequestInit, "body" | "headers">
-  : never;
+type FetchOptions<T> = (T extends unknown ? OperationRequestOptions<T> : never) &
+  SharedRequestOptions &
+  Omit<RequestInit, "body" | "headers">;
 
 // Readable<T> strips $Write markers (writeOnly properties excluded from response)
 type FetchResponse<
@@ -201,18 +262,25 @@ type FetchResponse<
       response: Response;
     };
 
-type RequestOptions<T> = ParamsOption<T> &
+type RequestOptions<T> = OperationRequestOptions<T> & SharedRequestOptions;
+
+/** The options of a call that depend on its operation `T`. */
+type OperationRequestOptions<T> = ParamsOption<T> &
   RequestBodyOption<T> & {
-    baseUrl?: string | undefined;
     querySerializer?: QuerySerializer<T> | QuerySerializerOptions | undefined;
     bodySerializer?: BodySerializer<T> | undefined;
-    pathSerializer?: PathSerializer | undefined;
-    parseAs?: ParseAs | undefined;
-    fetch?: ClientOptions["fetch"];
-    headers?: HeadersOptions | undefined;
-    middleware?: Middleware[] | undefined;
   };
 
+/** The options of a call that are the same for every operation. */
+type SharedRequestOptions = {
+  baseUrl?: string | undefined;
+  pathSerializer?: PathSerializer | undefined;
+  parseAs?: ParseAs | undefined;
+  fetch?: ClientOptions["fetch"];
+  headers?: HeadersOptions | undefined;
+  middleware?: Middleware[] | undefined;
+};
+
 type MergedOptions<T = unknown> = {
   baseUrl: string;
   parseAs: ParseAs;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openapi-typesafe-fetch",
   "description": "Fast, type-safe fetch client for your OpenAPI schema. About 10.5 kB minified, 4 kB gzipped. Works with React, Vue, Svelte, or vanilla JS.",
-  "version": "1.0.0-rc.10",
+  "version": "1.0.0-rc.12",
   "author": {
     "name": "Fedor Chishchin",
     "url": "https://github.com/fedorello"
@@ -67,7 +67,7 @@
     "express": "5.3.0",
     "feature-fetch": "0.1.2",
     "node-forge": "1.4.3",
-    "openapi-typesafe": "^1.0.0-rc.10",
+    "openapi-typesafe": "^1.0.0-rc.12",
     "openapi-typescript-fetch": "2.2.1",
     "typescript": "^6.0.3",
     "undici": "7.30.2",

package/src/helpers.ts

@@ -394,17 +394,39 @@ type TextErrorMediaTypes<Content> = {
   [Key in keyof Content]: IsJSONMediaPattern<Key> extends true ? never : Key;
 }[keyof Content];
 
-/** Whether the client parses every body of the media type `Key` as JSON, in any letter case. */
+/**
+ * Whether the client parses every body of the media type `Key` as JSON, in any letter case: its
+ * subtype is `json` or ends in `+json`, as `JSON_MEDIA_TYPE_RE` reads it. A `json` in a parameter
+ * (`text/plain; profile=urn:a+json`) does not count; `JSONMediaPattern` alone matched it.
+ */
 type IsJSONMediaPattern<Key> = Key extends string
-  ? Lowercase<Key> extends JSONMediaPattern
+  ? MediaSubtype<Lowercase<Key>> extends "json" | `${string}+json`
     ? true
     : false
   : false;
 
+/**
+ * The subtype of a media type: the text after the first `/` and before the parameters (the first
+ * `;`), without the spaces and tabs at its end. Empty without a type before a `/`, as
+ * `JSON_MEDIA_TYPE_RE` wants one. A subtype may hold a `/`, as the regular expression allows.
+ */
+type MediaSubtype<Text extends string> = Text extends `${infer Type}/${infer Rest}`
+  ? Type extends ""
+    ? ""
+    : TrimmedEnd<Rest extends `${infer Subtype};${string}` ? Subtype : Rest>
+  : "";
+
+/** The text without the spaces and tabs at its end (OWS before parameters, RFC 9110). */
+type TrimmedEnd<Text extends string> = Text extends `${infer Rest} ` | `${infer Rest}\t`
+  ? TrimmedEnd<Rest>
+  : Text;
+
 /**
  * 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`.
- * Not `x-ndjson` or `json-seq`, whose bodies are lines of JSON.
+ * Not `x-ndjson` or `json-seq`, whose bodies are lines of JSON. A template cannot keep its
+ * `${string}` out of the parameters, so it only picks the schema of an index signature
+ * (`JSONMediaKey`); whether a media type is JSON is `IsJSONMediaPattern`'s answer.
  */
 type JSONMediaPattern =
   | `${string}/${"" | `${string}+`}json`
@@ -419,26 +441,59 @@ type JSONMediaRange = `${string}/*` | `${string}/*${";" | " " | "\t"}${string}`;
 /** The media types that may hold JSON, in lower case. */
 type JSONMediaType = JSONMediaPattern | JSONMediaRange;
 
-/** Whether the client parses a body of the media type `Key` as JSON, in any letter case. */
+/**
+ * Whether a body of the media type `Key` may be one the client parses as JSON, in any letter
+ * case: a JSON media type (`IsJSONMediaPattern`) or a media range (subtype `*`), with or without
+ * parameters, which do not count.
+ */
 type IsJSONMediaType<Key> = Key extends string
-  ? Lowercase<Key> extends JSONMediaType
+  ? IsJSONMediaPattern<Key> extends true
     ? true
-    : false
+    : MediaSubtype<Lowercase<Key>> extends "*"
+      ? true
+      : false
   : false;
 
-/** Return first JSON-like 2XX response from a path + HTTP method */
+/**
+ * Return first JSON-like 2XX response from a path + HTTP method; for a union of operations, the
+ * union of each one's.
+ */
 // biome-ignore lint/suspicious/noExplicitAny: unknown rejects the generated interfaces
-export type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<
-  ResponseObjectMap<PathMethod>,
-  JSONMediaType
->;
+export type SuccessResponseJSON<PathMethod extends Record<string | number, any>> =
+  PathMethod extends unknown
+    ? SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>>
+    : never;
 
-/** Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method */
+/**
+ * Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method; for a
+ * union of operations, the union of each one's.
+ */
 // biome-ignore lint/suspicious/noExplicitAny: unknown rejects the generated interfaces
-export type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<
-  ResponseObjectMap<PathMethod>,
-  JSONMediaType
->;
+export type ErrorResponseJSON<PathMethod extends Record<string | number, any>> =
+  PathMethod extends unknown
+    ? ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>>
+    : never;
+
+/**
+ * The media types of the responses `T` (of one operation) that may hold JSON (`IsJSONMediaType`),
+ * for the JSON helpers to pick by: their keys, as `JSONMediaType` cannot leave out a `json` in
+ * parameters. A content map with an index signature has no such key, so it gives
+ * `JSONMediaType`, which picks the schema of its signature. The helpers pick per operation: the
+ * keys of a union of response maps are only the status codes they share, so the media types of
+ * the other statuses were lost, and the media types of one operation could pick in another.
+ */
+type JSONMediaKeys<T> = {
+  [Status in keyof T]: T[Status] extends { content: infer Content }
+    ? { [Key in keyof Content]: JSONMediaKey<Key> }[keyof Content]
+    : never;
+}[keyof T];
+
+/** `Key` when it may hold JSON; `JSONMediaType` for the wide key of an index signature. */
+type JSONMediaKey<Key> = string extends Key
+  ? JSONMediaType
+  : IsJSONMediaType<Key> extends true
+    ? Key
+    : never;
 
 /** Return JSON-like request body from a path + HTTP method */
 export type RequestBodyJSON<PathMethod> = JSONLike<

package/src/index.d.ts

@@ -139,16 +139,71 @@ type BodyType<T = unknown> = {
 };
 export type ParseAs = keyof BodyType;
 /**
- * The data of a success body `T` read with the `parseAs` of `Options`. Each value of a union gives
- * its body, and `undefined` is the default `"json"`, as at runtime: a wrapper that passes on
- * `parseAs: "text" | undefined` gets `string | T`, not `T` only. An optional `parseAs` (the
- * declared init type, as for a call without options) gives `T`, as in openapi-fetch. No `infer`:
- * TypeScript relates a type to a deferred conditional type through both of its branches only
- * when it infers nothing, and generic hooks return the data of a call as this type.
+ * The data of a success body `T` read with the `parseAs` of `Options`. Each value it may have gives
+ * its body, and `undefined` or a left-out `parseAs` is the default `"json"`, as at runtime: a
+ * wrapper that passes on `parseAs?: "text"` gets `string | T`, not `T` only. Options without
+ * `parseAs`, or whose `parseAs` may be any value (the declared init type, as for a call without
+ * options), give `T`, as in openapi-fetch; each member of a union of options gives its own data.
+ * No `infer`: TypeScript relates a type to a deferred conditional type through both of its
+ * branches only when it infers nothing, and generic hooks return the data of a call as this type.
+ * It distributes over `Options`, as openapi-fetch's does, so the options of a generic call (a
+ * wrapper's `FetchOptions` of a generic path with `parseAs: "text"`) give the data of their
+ * constraint: TypeScript reads a deferred distributive type through its check type's constraint.
  */
-export type ParseAsResponse<T, Options> = Options extends { parseAs: ParseAs | undefined }
-  ? BodyType<T>[ParseAsValue<Options["parseAs"]>]
-  : T;
+export type ParseAsResponse<T, Options> = Options extends unknown
+  ? BodyType<T>[ParseAsKey<Options>]
+  : never;
+
+/**
+ * The key of `BodyType` that the options `Options` read the body with. A conditional type of its
+ * own, inside the index: one in the branch of `ParseAsResponse` that picked `T` would be read
+ * through both of its branches while TypeScript reads the constraint above, as `never` fits any
+ * check type, so a generic `parseAs: "text"` gave the JSON body too.
+ */
+type ParseAsKey<Options> = [MissingParseAsValues<Options>] extends [never]
+  ? "json"
+  : ParseAsValue<ParseAsValues<Options>>;
+
+/**
+ * The `parseAs` values that `Options` may have; `undefined` when it may be left out. One
+ * conditional type, not a union: `BodyType<T>` indexed by a union of generic keys is read as the
+ * intersection of their bodies when another type is checked against it. `any` options give `any`,
+ * so their data is `any`, as in openapi-fetch: a caller that passes an `any` init (as the generic
+ * hooks of openapi-typesafe-react-query do) returns it as the data type it declares. The branch
+ * is `any` itself, not `Options`: a type parameter there stops TypeScript relating the data of a
+ * generic call to a wrapper's (ADR-030).
+ */
+type ParseAsValues<Options> = Options extends unknown
+  ? IsAny<Options> extends true
+    ? // biome-ignore lint/suspicious/noExplicitAny: any options give any data, as in openapi-fetch
+      any
+    :
+        | (Options extends RequiredParseAs ? never : undefined)
+        | { [Value in ParseAs]: Options extends WithoutParseAs<Value> ? never : Value }[ParseAs]
+  : never;
+
+/**
+ * The `parseAs` values that the options `Options` (one member of a union) cannot have, as
+ * `ParseAsValues` reads them.
+ */
+type MissingParseAsValues<Options> =
+  | ([Options] extends [RequiredParseAs] ? undefined : never)
+  | { [Value in ParseAs]: [Options] extends [WithoutParseAs<Value>] ? Value : never }[ParseAs];
+
+/** Options that always have a `parseAs`. */
+type RequiredParseAs = { parseAs: ParseAs };
+
+/**
+ * Options that cannot have the `parseAs` value `Value`: `undefined` options, or options whose
+ * `parseAs` (if any) leaves it out. Each
+ * check takes `Options` as its checked type and a fixed type here, so TypeScript relates the
+ * data of a generic call to a wrapper's (ADR-030); one union of these types instead would let
+ * TypeScript split `parseAs?: ParseAs` into its values and match each one. The `object` keeps
+ * options without `parseAs` (`{ headers }`) from failing as a weak type.
+ */
+type WithoutParseAs<Value extends ParseAs> =
+  | undefined
+  | (object & { parseAs?: Exclude<ParseAs, Value> | undefined });
 
 /** How a `parseAs` value reads the body, for each member of a union; `undefined` reads JSON. */
 type ParseAsValue<Value> = Value extends ParseAs ? Value : "json";
@@ -188,10 +243,16 @@ export type RequestBodyOption<T> =
  * gave a conditional type no `FetchOptions` argument was assignable to (TS2345). The operations
  * of a union are not merged into one deep init type, which gave TS2589 on hundreds of paths
  * (upstream #1882).
+ * Only the options that depend on the operation distribute; the others stay outside the
+ * conditional type. While `request()` has not fixed its method, TypeScript reads the init's
+ * contextual type through the constraints of the method and the path, and stops after ten nested
+ * instantiations of one conditional type: with every option inside it, `parseAs: "text"` had no
+ * contextual type, widened to `string`, and the init fell back to its constraint (`data` the JSON
+ * body). `FetchOptions<never>` is still `never`.
  */
-export type FetchOptions<T> = T extends unknown
-  ? RequestOptions<T> & Omit<RequestInit, "body" | "headers">
-  : never;
+export type FetchOptions<T> = (T extends unknown ? OperationRequestOptions<T> : never) &
+  SharedRequestOptions &
+  Omit<RequestInit, "body" | "headers">;
 
 // Readable<T> strips $Write markers (writeOnly properties excluded from response)
 export type FetchResponse<
@@ -211,18 +272,25 @@ export type FetchResponse<
       response: Response;
     };
 
-export type RequestOptions<T> = ParamsOption<T> &
+export type RequestOptions<T> = OperationRequestOptions<T> & SharedRequestOptions;
+
+/** The options of a call that depend on its operation `T`. */
+type OperationRequestOptions<T> = ParamsOption<T> &
   RequestBodyOption<T> & {
-    baseUrl?: string | undefined;
     querySerializer?: QuerySerializer<T> | QuerySerializerOptions | undefined;
     bodySerializer?: BodySerializer<T> | undefined;
-    pathSerializer?: PathSerializer | undefined;
-    parseAs?: ParseAs | undefined;
-    fetch?: ClientOptions["fetch"];
-    headers?: HeadersOptions | undefined;
-    middleware?: Middleware[] | undefined;
   };
 
+/** The options of a call that are the same for every operation. */
+type SharedRequestOptions = {
+  baseUrl?: string | undefined;
+  pathSerializer?: PathSerializer | undefined;
+  parseAs?: ParseAs | undefined;
+  fetch?: ClientOptions["fetch"];
+  headers?: HeadersOptions | undefined;
+  middleware?: Middleware[] | undefined;
+};
+
 export type MergedOptions<T = unknown> = {
   baseUrl: string;
   parseAs: ParseAs;