From 06163a2030eaf8d0579f624d86481e1205aef396 Mon Sep 17 00:00:00 2001
From: Djordy Koert <djordy.koert@live.nl>
Date: Fri, 25 Oct 2024 19:33:36 +0200
Subject: [PATCH] fix(openapi-fetch): Return union of possible responses (data
 & error) (#1937)

* Get all possible responses as a union

* Add tests

* lint fix

* Add tests for standalone types

* lint fix

* changeset

* Fix passing more keys (OkStatus) returning unknown

* add test for non-existent media type

* Update invalid path test

* lint-fix

* better @ts-expect-error scoping
---
 .changeset/small-jokes-wait.md                |   6 +
 packages/openapi-fetch/src/index.d.ts         |   6 +-
 .../test/common/response.test.ts              |   6 +-
 .../never-response/never-response.test.ts     | 143 +++++++++
 .../schemas/never-response.d.ts               | 142 +++++++++
 .../schemas/never-response.yaml               |  78 +++++
 packages/openapi-fetch/test/types.test.ts     | 283 ++++++++++++++++++
 .../openapi-typescript-helpers/index.d.ts     |  46 ++-
 8 files changed, 692 insertions(+), 18 deletions(-)
 create mode 100644 .changeset/small-jokes-wait.md
 create mode 100644 packages/openapi-fetch/test/never-response/never-response.test.ts
 create mode 100644 packages/openapi-fetch/test/never-response/schemas/never-response.d.ts
 create mode 100644 packages/openapi-fetch/test/never-response/schemas/never-response.yaml
 create mode 100644 packages/openapi-fetch/test/types.test.ts

diff --git a/.changeset/small-jokes-wait.md b/.changeset/small-jokes-wait.md
new file mode 100644
index 00000000..cfcff9af
--- /dev/null
+++ b/.changeset/small-jokes-wait.md
@@ -0,0 +1,6 @@
+---
+"openapi-typescript-helpers": patch
+"openapi-fetch": patch
+---
+
+client data & error now return a union of possible types
diff --git a/packages/openapi-fetch/src/index.d.ts b/packages/openapi-fetch/src/index.d.ts
index 4941612f..a7b26a1b 100644
--- a/packages/openapi-fetch/src/index.d.ts
+++ b/packages/openapi-fetch/src/index.d.ts
@@ -98,7 +98,7 @@ export type RequestBodyOption<T> = OperationRequestBodyContent<T> extends never
 
 export type FetchOptions<T> = RequestOptions<T> & Omit<RequestInit, "body" | "headers">;
 
-export type FetchResponse<T, Options, Media extends MediaType> =
+export type FetchResponse<T extends Record<string | number, any>, Options, Media extends MediaType> =
   | {
       data: ParseAsResponse<SuccessResponse<ResponseObjectMap<T>, Media>, Options>;
       error?: never;
@@ -187,7 +187,7 @@ export type ClientMethod<
   ...init: InitParam<Init>
 ) => Promise<FetchResponse<Paths[Path][Method], Init, Media>>;
 
-export type ClientForPath<PathInfo, Media extends MediaType> = {
+export type ClientForPath<PathInfo extends Record<string | number, any>, Media extends MediaType> = {
   [Method in keyof PathInfo as Uppercase<string & Method>]: <Init extends MaybeOptionalInit<PathInfo, Method>>(
     ...init: InitParam<Init>
   ) => Promise<FetchResponse<PathInfo[Method], Init, Media>>;
@@ -234,7 +234,7 @@ export default function createClient<Paths extends {}, Media extends MediaType =
   clientOptions?: ClientOptions,
 ): Client<Paths, Media>;
 
-export type PathBasedClient<Paths, Media extends MediaType = MediaType> = {
+export type PathBasedClient<Paths extends Record<string | number, any>, Media extends MediaType = MediaType> = {
   [Path in keyof Paths]: ClientForPath<Paths[Path], Media>;
 };
 
diff --git a/packages/openapi-fetch/test/common/response.test.ts b/packages/openapi-fetch/test/common/response.test.ts
index 50b8e85a..7a3aacf3 100644
--- a/packages/openapi-fetch/test/common/response.test.ts
+++ b/packages/openapi-fetch/test/common/response.test.ts
@@ -49,8 +49,8 @@ describe("response", () => {
         {},
       );
 
-      assertType<undefined>(result.data);
-      // @ts-expect-error: FIXME when #1723 is resolved; this shouldn’t throw an error
+      //@ts-expect-error impossible to determine data type for invalid path
+      assertType<never>(result.data);
       assertType<undefined>(result.error);
     });
 
@@ -74,7 +74,7 @@ describe("response", () => {
       } else {
         expectTypeOf(result.data).toBeUndefined();
         expectTypeOf(result.error).extract<{ code: number }>().toEqualTypeOf<{ code: number; message: string }>();
-        expectTypeOf(result.error).exclude<{ code: number }>().toEqualTypeOf<never>();
+        expectTypeOf(result.error).exclude<{ code: number }>().toEqualTypeOf(undefined);
       }
     });
 
diff --git a/packages/openapi-fetch/test/never-response/never-response.test.ts b/packages/openapi-fetch/test/never-response/never-response.test.ts
new file mode 100644
index 00000000..bca47fae
--- /dev/null
+++ b/packages/openapi-fetch/test/never-response/never-response.test.ts
@@ -0,0 +1,143 @@
+import { assertType, describe, expect, test } from "vitest";
+import { createObservedClient } from "../helpers.js";
+import type { components, paths } from "./schemas/never-response.js";
+
+describe("GET", () => {
+  test("sends correct method", async () => {
+    let method = "";
+    const client = createObservedClient<paths>({}, async (req) => {
+      method = req.method;
+      return Response.json({});
+    });
+    await client.GET("/posts");
+    expect(method).toBe("GET");
+  });
+
+  test("sends correct options, returns success", async () => {
+    const mockData = {
+      id: 123,
+      title: "My Post",
+    };
+
+    let actualPathname = "";
+    const client = createObservedClient<paths>({}, async (req) => {
+      actualPathname = new URL(req.url).pathname;
+      return Response.json(mockData);
+    });
+
+    const { data, error, response } = await client.GET("/posts/{id}", {
+      params: { path: { id: 123 } },
+    });
+
+    assertType<typeof mockData | undefined>(data);
+
+    // assert correct URL was called
+    expect(actualPathname).toBe("/posts/123");
+
+    // assert correct data was returned
+    expect(data).toEqual(mockData);
+    expect(response.status).toBe(200);
+
+    // assert error is empty
+    expect(error).toBeUndefined();
+  });
+
+  test("sends correct options, returns undefined on 204", async () => {
+    let actualPathname = "";
+    const client = createObservedClient<paths>({}, async (req) => {
+      actualPathname = new URL(req.url).pathname;
+      return new Response(null, { status: 204 });
+    });
+
+    const { data, error, response } = await client.GET("/posts/{id}", {
+      params: { path: { id: 123 } },
+    });
+
+    assertType<components["schemas"]["Post"] | undefined>(data);
+
+    // assert correct URL was called
+    expect(actualPathname).toBe("/posts/123");
+
+    // assert 204 to be transformed to empty object
+    expect(data).toEqual({});
+    expect(response.status).toBe(204);
+
+    // assert error is empty
+    expect(error).toBeUndefined();
+  });
+
+  test("sends correct options, returns error", async () => {
+    const mockError = { code: 404, message: "Post not found" };
+
+    let method = "";
+    let actualPathname = "";
+    const client = createObservedClient<paths>({}, async (req) => {
+      method = req.method;
+      actualPathname = new URL(req.url).pathname;
+      return Response.json(mockError, { status: 404 });
+    });
+
+    const { data, error, response } = await client.GET("/posts/{id}", {
+      params: { path: { id: 123 } },
+    });
+
+    assertType<typeof mockError | undefined>(error);
+
+    // assert correct URL was called
+    expect(actualPathname).toBe("/posts/123");
+
+    // assert correct method was called
+    expect(method).toBe("GET");
+
+    // assert correct error was returned
+    expect(error).toEqual(mockError);
+    expect(response.status).toBe(404);
+
+    // assert data is empty
+    expect(data).toBeUndefined();
+  });
+
+  test("handles array-type responses", async () => {
+    const client = createObservedClient<paths>({}, async () => Response.json([]));
+
+    const { data } = await client.GET("/posts", { params: {} });
+    if (!data) {
+      throw new Error("data empty");
+    }
+
+    // assert array type (and only array type) was inferred
+    expect(data.length).toBe(0);
+  });
+
+  test("handles empty-array-type 204 response", async () => {
+    let method = "";
+    let actualPathname = "";
+    const client = createObservedClient<paths>({}, async (req) => {
+      method = req.method;
+      actualPathname = new URL(req.url).pathname;
+      return new Response(null, { status: 204 });
+    });
+
+    const { data } = await client.GET("/posts", { params: {} });
+
+    assertType<components["schemas"]["Post"][] | unknown[] | undefined>(data);
+
+    // assert correct URL was called
+    expect(actualPathname).toBe("/posts");
+
+    // assert correct method was called
+    expect(method).toBe("GET");
+
+    // assert 204 to be transformed to empty object
+    expect(data).toEqual({});
+  });
+
+  test("gracefully handles invalid JSON for errors", async () => {
+    const client = createObservedClient<paths>({}, async () => new Response("Unauthorized", { status: 401 }));
+
+    const { data, error } = await client.GET("/posts");
+
+    expect(data).toBeUndefined();
+    expect(error).toBe("Unauthorized");
+  });
+});
diff --git a/packages/openapi-fetch/test/never-response/schemas/never-response.d.ts b/packages/openapi-fetch/test/never-response/schemas/never-response.d.ts
new file mode 100644
index 00000000..d3d7f5b7
--- /dev/null
+++ b/packages/openapi-fetch/test/never-response/schemas/never-response.d.ts
@@ -0,0 +1,142 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+export interface paths {
+    "/posts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Post"][];
+                    };
+                };
+                /** @description No posts found, but it's OK */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": unknown[];
+                    };
+                };
+                /** @description Unexpected error */
+                default: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/posts/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: number;
+            };
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: number;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Post"];
+                    };
+                };
+                /** @description No post found, but it's OK */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description A weird error happened */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Unexpected error */
+                default: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Error"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        Error: {
+            code: number;
+            message: string;
+        };
+        Post: {
+            id: number;
+            title: string;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export type operations = Record<string, never>;
diff --git a/packages/openapi-fetch/test/never-response/schemas/never-response.yaml b/packages/openapi-fetch/test/never-response/schemas/never-response.yaml
new file mode 100644
index 00000000..45f4bce5
--- /dev/null
+++ b/packages/openapi-fetch/test/never-response/schemas/never-response.yaml
@@ -0,0 +1,78 @@
+openapi: 3.1.0
+info:
+  title: openapi-fetch
+  version: "1.0"
+paths:
+  /posts:
+    get:
+      responses:
+        200:
+          description: OK
+          operationId: getPosts
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: "#/components/schemas/Post"
+        204:
+          description: No posts found, but it's OK
+          content:
+            application/json:
+              schema:
+                type: array
+                items: {}
+        default:
+          description: Unexpected error
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
+  /posts/{id}:
+    parameters:
+      - name: id
+        in: path
+        required: true
+        schema:
+          type: integer
+    get:
+      responses:
+        200:
+          description: OK
+          operationId: getPost
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Post"
+        204:
+          description: No post found, but it's OK
+        500:
+          description: A weird error happened
+        default:
+          description: Unexpected error
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
+components:
+  schemas:
+    Error:
+      type: object
+      required:
+        - code
+        - message
+      properties:
+        code:
+          type: integer
+        message:
+          type: string
+    Post:
+      type: object
+      required:
+        - id
+        - title
+      properties:
+        id:
+          type: integer
+        title:
+          type: string
diff --git a/packages/openapi-fetch/test/types.test.ts b/packages/openapi-fetch/test/types.test.ts
new file mode 100644
index 00000000..a44e437e
--- /dev/null
+++ b/packages/openapi-fetch/test/types.test.ts
@@ -0,0 +1,283 @@
+import { assertType, describe, test } from "vitest";
+import type { ErrorResponse, GetResponseContent, OkStatus, SuccessResponse } from "openapi-typescript-helpers";
+
+describe("types", () => {
+  describe("GetResponseContent", () => {
+    describe("MixedResponses", () => {
+      interface MixedResponses {
+        200: {
+          content: {
+            "application/json": { data: `200 application/json` };
+            "text/plain": `200 text/plain`;
+          };
+        };
+        204: { content: never };
+        206: { content: { "text/plain": `206 text/plain` } };
+        404: { content: { "text/plain": `404 text/plain` } };
+        500: { content: { "application/json": { error: `500 application/json` } } };
+      }
+
+      test("returns all possible responses", () => {
+        type Response = GetResponseContent<MixedResponses>;
+        assertType<Response>({ data: "200 application/json" });
+        assertType<Response>({
+          // @ts-expect-error It picks literal over string
+          data: "200 but different string",
+        });
+        assertType<Response>("200 text/plain");
+        assertType<Response>("206 text/plain");
+        assertType<Response>("404 text/plain");
+        assertType<Response>({ error: "500 application/json" });
+        assertType<Response>(
+          // @ts-expect-error 204 never does not become undefined
+          undefined,
+        );
+      });
+
+      test("returns correct type for 200 with literal", () => {
+        type Response = GetResponseContent<MixedResponses, `${string}/${string}`, 200>;
+        assertType<Response>({ data: "200 application/json" });
+        assertType<Response>("200 text/plain");
+        assertType<Response>(
+          // @ts-expect-error
+          "206 text/plain",
+        );
+        assertType<Response>(
+          // @ts-expect-error
+          "404 text/plain",
+        );
+        assertType<Response>({
+          // @ts-expect-error
+          error: "500 application/json",
+        });
+      });
+
+      test("returns correct type for 200 with json-like literal", () => {
+        type Response = GetResponseContent<MixedResponses, `${string}/json`, 200>;
+        assertType<Response>({ data: "200 application/json" });
+        assertType<Response>(
+          // @ts-expect-error
+          "200 text/plain",
+        );
+        assertType<Response>(
+          // @ts-expect-error
+          "206 text/plain",
+        );
+        assertType<Response>(
+          // @ts-expect-error
+          "404 text/plain",
+        );
+        assertType<Response>({
+          // @ts-expect-error
+          error: "500 application/json",
+        });
+      });
+
+      test("returns correct type for 200 with application/json", () => {
+        type Response = GetResponseContent<MixedResponses, "application/json", 200>;
+        assertType<Response>({ data: "200 application/json" });
+        assertType<Response>(
+          // @ts-expect-error
+          "200 text/plain",
+        );
+        assertType<Response>(
+          // @ts-expect-error
+          "206 text/plain",
+        );
+        assertType<Response>(
+          // @ts-expect-error
+          "404 text/plain",
+        );
+        assertType<Response>({
+          // @ts-expect-error
+          error: "500 application/json",
+        });
+      });
+
+      test("returns 200 & 500 responses", () => {
+        type Response = GetResponseContent<MixedResponses, `${string}/${string}`, 200 | 500>;
+        assertType<Response>({ data: "200 application/json" });
+        assertType<Response>("200 text/plain");
+        assertType<Response>(
+          // @ts-expect-error
+          "206 text/plain",
+        );
+        assertType<Response>(
+          // @ts-expect-error
+          "404 text/plain",
+        );
+        assertType<Response>({ error: "500 application/json" });
+      });
+
+      test("returns all OK responses", () => {
+        type Response = GetResponseContent<
+          MixedResponses,
+          `${string}/${string}`,
+          // @ts-expect-error: Type 'OkStatus' does not satisfy the constraint 'keyof MixedResponses'. Can safely ignore this error.
+          OkStatus
+        >;
+        assertType<Response>({ data: "200 application/json" });
+        assertType<Response>("200 text/plain");
+        assertType<Response>("206 text/plain");
+        assertType<Response>(
+          // @ts-expect-error
+          "404 text/plain",
+        );
+        assertType<Response>({
+          // @ts-expect-error
+          error: "500 application/json",
+        });
+      });
+
+      test("non existent media type", () => {
+        type Response = GetResponseContent<MixedResponses, "I/DO NOT EXIST">;
+        assertType<Response>({
+          // @ts-expect-error
+          data: "200 application/json",
+        });
+        assertType<Response>({
+          // @ts-expect-error
+          data: "200 but different string",
+        });
+        assertType<Response>(
+          // @ts-expect-error
+          "200 text/plain",
+        );
+        assertType<Response>(
+          // @ts-expect-error
+          "206 text/plain",
+        );
+        assertType<Response>(
+          // @ts-expect-error
+          "404 text/plain",
+        );
+
+        assertType<Response>({
+          // @ts-expect-error
+          error: "500 application/json",
+        });
+        assertType<Response>(
+          // @ts-expect-error 204 never does not become undefined
+          undefined,
+        );
+      });
+    });
+
+    test("picks undefined over never", () => {
+      interface Responses {
+        200: { content: { "application/json": { data: `Yup` } } };
+        204: { content?: never };
+      }
+
+      type Response = GetResponseContent<Responses>;
+      assertType<Response>({ data: "Yup" });
+      assertType<Response>(undefined);
+    });
+  });
+
+  describe("SuccessResponse", () => {
+    interface Responses {
+      200: {
+        content: {
+          "application/json": { data: `200 application/json` };
+          "text/plain": `200 text/plain`;
+        };
+      };
+      204: { content: never };
+      206: { content: { "text/plain": `206 text/plain` } };
+      404: { content: { "text/plain": `404 text/plain` } };
+      500: { content: { "application/json": { error: `500 application/json` } } };
+    }
+
+    test("returns all 2XX responses", () => {
+      type Response = SuccessResponse<Responses>;
+      assertType<Response>({ data: "200 application/json" });
+      assertType<Response>("200 text/plain");
+      assertType<Response>("206 text/plain");
+      assertType<Response>(
+        // @ts-expect-error
+        "404 text/plain",
+      );
+      assertType<Response>({
+        // @ts-expect-error
+        error: "500 application/json",
+      });
+    });
+
+    test("returns all 2XX responses, only application/json", () => {
+      type Response = SuccessResponse<Responses, "application/json">;
+      assertType<Response>({ data: "200 application/json" });
+      assertType<Response>(
+        // @ts-expect-error
+        "200 text/plain",
+      );
+      assertType<Response>(
+        // @ts-expect-error
+        "206 text/plain",
+      );
+      assertType<Response>(
+        // @ts-expect-error
+        "404 text/plain",
+      );
+      // @ts-expect-error
+      assertType<Response>({ error: "500 application/json" });
+    });
+  });
+
+  describe("ErrorResponse", () => {
+    interface Responses {
+      200: {
+        content: {
+          "application/json": { data: `200 application/json` };
+          "text/plain": `200 text/plain`;
+        };
+      };
+      204: { content: never };
+      206: { content: { "text/plain": `206 text/plain` } };
+      404: { content: { "text/plain": `404 text/plain` } };
+      500: { content: { "application/json": { error: `500 application/json` } } };
+      default: { content: { "application/json": { error: `default application/json` } } };
+    }
+
+    test("returns all 5XX and 4xx responses", () => {
+      type Response = ErrorResponse<Responses>;
+      assertType<Response>({
+        // @ts-expect-error
+        data: "200 application/json",
+      });
+      assertType<Response>(
+        // @ts-expect-error
+        "200 text/plain",
+      );
+      assertType<Response>(
+        // @ts-expect-error
+        "206 text/plain",
+      );
+      assertType<Response>("404 text/plain");
+      assertType<Response>({ error: "500 application/json" });
+      assertType<Response>({ error: "default application/json" });
+    });
+
+    test("returns all 5XX and 4xx responses, only application/json", () => {
+      type Response = ErrorResponse<Responses, "application/json">;
+      assertType<Response>({
+        // @ts-expect-error
+        data: "200 application/json",
+      });
+      assertType<Response>(
+        // @ts-expect-error
+        "200 text/plain",
+      );
+      assertType<Response>(
+        // @ts-expect-error
+        "206 text/plain",
+      );
+      assertType<Response>(
+        // @ts-expect-error
+        "404 text/plain",
+      );
+      assertType<Response>({ error: "500 application/json" });
+      assertType<Response>({ error: "default application/json" });
+    });
+  });
+});
diff --git a/packages/openapi-typescript-helpers/index.d.ts b/packages/openapi-typescript-helpers/index.d.ts
index c6cf5cbd..1715c07c 100644
--- a/packages/openapi-typescript-helpers/index.d.ts
+++ b/packages/openapi-typescript-helpers/index.d.ts
@@ -116,25 +116,47 @@ export type OperationRequestBodyContent<T> = FilterKeys<OperationRequestBodyMedi
   ? FilterKeys<NonNullable<OperationRequestBodyMediaContent<T>>, MediaType> | undefined
   : FilterKeys<OperationRequestBodyMediaContent<T>, MediaType>;
 
-/** Return first 2XX response from a Response Object Map */
-export type SuccessResponse<T, Media extends MediaType = MediaType> = FilterKeys<
-  ResponseContent<FilterKeys<T, OkStatus>>,
-  Media
->;
+/** Return all 2XX responses from a Response Object Map */
+export type SuccessResponse<
+  T extends Record<string | number, any>,
+  Media extends MediaType = MediaType,
+> = GetResponseContent<T, Media, OkStatus>;
+
+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;
 
 /**
- * Return first 5XX or 4XX response (in that order) from a Response Object Map
+ * Return all 5XX and 4XX responses (in that order) from a Response Object Map
  */
-export type ErrorResponse<T, Media extends MediaType = MediaType> = FilterKeys<
-  ResponseContent<FirstErrorStatus<T>>,
-  Media
->;
+export type ErrorResponse<
+  T extends Record<string | number, any>,
+  Media extends MediaType = MediaType,
+> = GetResponseContent<T, Media, ErrorStatus>;
 
 /** Return first JSON-like 2XX response from a path + HTTP method */
-export type SuccessResponseJSON<PathMethod> = SuccessResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
+export type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<
+  ResponseObjectMap<PathMethod>,
+  `${string}/json`
+>;
 
 /** Return first JSON-like 5XX or 4XX response from a path + HTTP method */
-export type ErrorResponseJSON<PathMethod> = ErrorResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
+export type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<
+  ResponseObjectMap<PathMethod>,
+  `${string}/json`
+>;
 
 /** Return JSON-like request body from a path + HTTP method */
 export type RequestBodyJSON<PathMethod> = JSONLike<FilterKeys<OperationRequestBody<PathMethod>, "content">>;