openapi-typesafe-helpers 1.0.0-rc.0 → 1.0.0-rc.2

package/README.md

@@ -6,6 +6,15 @@ Type helpers shared by `openapi-typesafe-fetch` and `openapi-typesafe-react-quer
 A maintained successor to `openapi-typescript-helpers` (see the [repository README](../../README.md)).
 Most projects do not need to install it directly.
 
+> **Release candidate.** The current version is a 1.0.0 release candidate (`1.0.0-rc.N`);
+> names and output can still change before 1.0.0.
+
+## Versioning
+
+Semantic versioning from 1.0.0, with one version for all openapi-typesafe packages. What the
+version promises, and what may grow in a minor release, is listed under
+[Versioning](https://github.com/openapi-typesafe/openapi-typesafe/blob/main/docs/compatibility.md#versioning).
+
 ## License
 
 [MIT](./LICENSE)

package/dist/index.d.cts

@@ -1,172 +1,286 @@
-type HttpMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace" | "query";
+type HttpMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace"
+/** OpenAPI 3.2: a safe, idempotent request with a body. */
+ | "query";
+/** 2XX statuses */
 type OkStatus = 200 | 201 | 202 | 203 | 204 | 206 | 207 | "2XX";
+/** 4XX and 5XX statuses */
 type ErrorStatus = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | "5XX" | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 420 | 421 | 422 | 423 | 424 | 425 | 426 | 427 | 428 | 429 | 430 | 431 | 444 | 450 | 451 | 497 | 498 | 499 | "4XX" | "default";
+/** Get a union of OK Statuses */
 type OKStatusUnion<T> = FilterKeys<T, OkStatus>;
+/** Get first error status, in order */
 type FirstErrorStatus<T> = T extends {
-    500: any;
+    500: unknown;
 } ? T[500] : T extends {
-    501: any;
+    501: unknown;
 } ? T[501] : T extends {
-    502: any;
+    502: unknown;
 } ? T[502] : T extends {
-    503: any;
+    503: unknown;
 } ? T[503] : T extends {
-    504: any;
+    504: unknown;
 } ? T[504] : T extends {
-    505: any;
+    505: unknown;
 } ? T[505] : T extends {
-    506: any;
+    506: unknown;
 } ? T[506] : T extends {
-    507: any;
+    507: unknown;
 } ? T[507] : T extends {
-    508: any;
+    508: unknown;
 } ? T[508] : T extends {
-    510: any;
+    510: unknown;
 } ? T[510] : T extends {
-    511: any;
+    511: unknown;
 } ? T[511] : T extends {
-    "5XX": any;
+    "5XX": unknown;
 } ? T["5XX"] : T extends {
-    400: any;
+    400: unknown;
 } ? T[400] : T extends {
-    401: any;
+    401: unknown;
 } ? T[401] : T extends {
-    402: any;
+    402: unknown;
 } ? T[402] : T extends {
-    403: any;
+    403: unknown;
 } ? T[403] : T extends {
-    404: any;
+    404: unknown;
 } ? T[404] : T extends {
-    405: any;
+    405: unknown;
 } ? T[405] : T extends {
-    406: any;
+    406: unknown;
 } ? T[406] : T extends {
-    407: any;
+    407: unknown;
 } ? T[407] : T extends {
-    408: any;
+    408: unknown;
 } ? T[408] : T extends {
-    409: any;
+    409: unknown;
 } ? T[409] : T extends {
-    410: any;
+    410: unknown;
 } ? T[410] : T extends {
-    411: any;
+    411: unknown;
 } ? T[411] : T extends {
-    412: any;
+    412: unknown;
 } ? T[412] : T extends {
-    413: any;
+    413: unknown;
 } ? T[413] : T extends {
-    414: any;
+    414: unknown;
 } ? T[414] : T extends {
-    415: any;
+    415: unknown;
 } ? T[415] : T extends {
-    416: any;
+    416: unknown;
 } ? T[416] : T extends {
-    417: any;
+    417: unknown;
 } ? T[417] : T extends {
-    418: any;
+    418: unknown;
 } ? T[418] : T extends {
-    420: any;
+    420: unknown;
 } ? T[420] : T extends {
-    421: any;
+    421: unknown;
 } ? T[421] : T extends {
-    422: any;
+    422: unknown;
 } ? T[422] : T extends {
-    423: any;
+    423: unknown;
 } ? T[423] : T extends {
-    424: any;
+    424: unknown;
 } ? T[424] : T extends {
-    425: any;
+    425: unknown;
 } ? T[425] : T extends {
-    426: any;
+    426: unknown;
 } ? T[426] : T extends {
-    427: any;
+    427: unknown;
 } ? T[427] : T extends {
-    428: any;
+    428: unknown;
 } ? T[428] : T extends {
-    429: any;
+    429: unknown;
 } ? T[429] : T extends {
-    430: any;
+    430: unknown;
 } ? T[430] : T extends {
-    431: any;
+    431: unknown;
 } ? T[431] : T extends {
-    444: any;
+    444: unknown;
 } ? T[444] : T extends {
-    450: any;
+    450: unknown;
 } ? T[450] : T extends {
-    451: any;
+    451: unknown;
 } ? T[451] : T extends {
-    497: any;
+    497: unknown;
 } ? T[497] : T extends {
-    498: any;
+    498: unknown;
 } ? T[498] : T extends {
-    499: any;
+    499: unknown;
 } ? T[499] : T extends {
-    "4XX": any;
+    "4XX": unknown;
 } ? T["4XX"] : T extends {
-    default: any;
+    default: unknown;
 } ? T["default"] : never;
-type PathsWithMethod<Paths extends {}, PathnameMethod extends HttpMethod> = {
+/** The paths that have each of the methods: upstream's `PathsWithMethod`. */
+type PathsWithEveryMethod<Paths extends {}, PathnameMethod extends HttpMethod> = {
     [Pathname in keyof Paths]: Paths[Pathname] extends {
-        [K in PathnameMethod]: any;
+        [K in PathnameMethod]: unknown;
     } ? Pathname : never;
 }[keyof Paths];
+/** The paths that have at least one method. */
+type PathsWithAnyMethod<Paths extends {}> = {
+    [Pathname in keyof Paths]: {
+        [Method in HttpMethod]: Paths[Pathname] extends {
+            [K in Method]: unknown;
+        } ? Pathname : never;
+    }[HttpMethod];
+}[keyof Paths];
+/**
+ * Given an OpenAPI **Paths Object**, find all paths that have the given method. For a union of
+ * methods, the paths that have each of them, so a call with either method finds its operation.
+ * For `HttpMethod` itself, a method not known yet, the paths that have any method too: TypeScript
+ * uses it where a hook's `Method` is not inferred, as in `Parameters<typeof $api.queryOptions>`,
+ * and the paths with every method were none (upstream #2178).
+ *
+ * A union with upstream's type, not a conditional type over the method: code that is generic in
+ * the method (`Path extends PathsWithMethod<Paths, Method>`, as swr-openapi has) must still
+ * relate one `PathsWithMethod` to another, and TypeScript cannot relate a type to a conditional
+ * type that waits for its method (TS2344). For a known method the second member is `never`.
+ */
+type PathsWithMethod<Paths extends {}, PathnameMethod extends HttpMethod> = PathsWithEveryMethod<Paths, PathnameMethod> | (HttpMethod extends PathnameMethod ? PathsWithAnyMethod<Paths> : never);
+/**
+ * DO NOT USE!
+ * Only used only for OperationObject type inference
+ */
 interface OperationObject {
     parameters: any;
     requestBody: any;
     responses: any;
 }
+/** Internal helper used in PathsWithMethod */
 type PathItemObject = {
     [M in HttpMethod]: OperationObject;
 } & {
     parameters?: any;
 };
+/** Return `responses` for an Operation Object */
 type ResponseObjectMap<T> = T extends {
     responses: any;
 } ? T["responses"] : unknown;
+/** Return `content` for a Response Object */
 type ResponseContent<T> = T extends {
     content: any;
 } ? T["content"] : unknown;
+/** Return type of `requestBody` for an Operation Object */
 type OperationRequestBody<T> = "requestBody" extends keyof T ? T["requestBody"] : never;
+/** Internal helper to get object type with only the `requestBody` property */
 type PickRequestBody<T> = "requestBody" extends keyof T ? Pick<T, "requestBody"> : never;
+/** Resolve to `true` if request body is optional, else `false` */
 type IsOperationRequestBodyOptional<T> = RequiredKeysOf<PickRequestBody<T>> extends never ? true : false;
+/** Internal helper used in OperationRequestBodyContent */
 type OperationRequestBodyMediaContent<T> = IsOperationRequestBodyOptional<T> extends true ? ResponseContent<NonNullable<OperationRequestBody<T>>> | undefined : ResponseContent<OperationRequestBody<T>>;
+/** Return first `content` from a Request Object Mapping, allowing any media type */
 type OperationRequestBodyContent<T> = FilterKeys<OperationRequestBodyMediaContent<T>, MediaType> extends never ? FilterKeys<NonNullable<OperationRequestBodyMediaContent<T>>, MediaType> | undefined : FilterKeys<OperationRequestBodyMediaContent<T>, MediaType>;
-type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = GetResponseContent<T, Media, OkStatus>;
+/**
+ * The statuses of success responses in a Response Object Map: the 2XX statuses, or `default` when
+ * no 2XX status is declared. `default` covers every status the operation does not declare (OpenAPI
+ * Responses Object), so then it covers every success (upstream #1862). With a 2XX status declared,
+ * `default` is left to the errors, as before.
+ */
+type SuccessStatus<T> = [Extract<keyof T, OkStatus>] extends [never] ? "default" : OkStatus;
+/** Return all 2XX responses from a Response Object Map, or `default` if it declares no 2XX one */
+type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = GetResponseContent<T, Media, SuccessStatus<T>>;
 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 all 5XX and 4XX responses (in that order) from a Response Object Map
+ */
 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 */
 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 */
 type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
+/** Return JSON-like request body from a path + HTTP method */
 type RequestBodyJSON<PathMethod> = JSONLike<FilterKeys<OperationRequestBody<PathMethod>, "content">>;
+/** Find first match of multiple keys */
 type FilterKeys<Obj, Matchers> = Obj[keyof Obj & Matchers];
-type GetValueWithDefault<Obj, KeyPattern, Default> = Obj extends any ? FilterKeys<Obj, KeyPattern> extends never ? Default : FilterKeys<Obj, KeyPattern> : never;
+/**
+ * @deprecated Use `FilterKeys` instead
+ * Get the type of a value of an input object with a given key. If the key is
+ * not found, return a default type. Works with unions of objects too.
+ */
+type GetValueWithDefault<Obj, KeyPattern, Default> = Obj extends unknown ? FilterKeys<Obj, KeyPattern> extends never ? Default : FilterKeys<Obj, KeyPattern> : never;
+/**
+ * Return any `[string]/[string]` media type (important because openapi-typesafe-fetch allows any
+ * content response, not just JSON-like)
+ */
 type MediaType = `${string}/${string}`;
+/**
+ * Return any media type containing "json" (works for "application/json",
+ * "application/vnd.api+json", "application/vnd.oai.openapi+json")
+ */
 type JSONLike<T> = FilterKeys<T, `${string}/json`>;
+/**
+ * Filter objects that have required keys
+ * @deprecated Use `RequiredKeysOf` instead
+ */
 type FindRequiredKeys<T, K extends keyof T> = K extends unknown ? undefined extends T[K] ? never : K : K;
+/**
+ * Does this object contain required keys?
+ * @deprecated Use `RequiredKeysOf` instead
+ */
 type HasRequiredKeys<T> = FindRequiredKeys<T, keyof T>;
+/**
+ * Helper to get the required keys of an object. If no keys are required, will be `undefined` with
+ * strictNullChecks enabled, else `never`
+ */
 type RequiredKeysOfHelper<T> = {
     [K in keyof T]: {} extends Pick<T, K> ? never : K;
 }[keyof T];
+/** Get the required keys of an object, or `never` if no keys are required */
 type RequiredKeysOf<T> = RequiredKeysOfHelper<T> extends undefined ? never : RequiredKeysOfHelper<T>;
+/** Marker type for readOnly properties (excluded from request bodies) */
 type $Read<T> = {
     readonly $read: T;
 };
+/** Marker type for writeOnly properties (excluded from response bodies) */
 type $Write<T> = {
     readonly $write: T;
 };
+/** Primitives, also branded ones (`string & { __brand: "Id" }`), which stay unmapped (#2765). */
 type ReadWritePrimitive = string | number | boolean | bigint | symbol | null | undefined;
+/**
+ * Types that stay unmapped. Mapping a function type drops its call signatures, so a `Blob` from
+ * `--binary-as-blob` lost its methods (`arrayBuffer()`, `text()`, ...) in response data.
+ */
 type ReadWriteLeaf = ReadWritePrimitive | ((...args: never) => unknown);
+/**
+ * Keys of `T` whose value is a `Marker`. A key whose value is only `null` or `undefined` is not
+ * marked: `NonNullable` of it is `never`, and `never` extends every marker (upstream #2717). The
+ * checks are not distributive (`NonNullable<T[K]>` is not a type parameter), so `never` is seen.
+ */
 type ReadWriteMarkedKeys<T, Marker> = {
     [K in keyof T]-?: NonNullable<T[K]> extends never ? never : NonNullable<T[K]> extends Marker ? K : never;
 }[keyof T];
+/**
+ * Resolve an array or a tuple element by element. An array uses `T[number]`, not `infer E`: for an
+ * intersection of arrays (`allOf`) inference keeps one member and narrowing breaks (upstream
+ * #2620). `T` is a plain array when an array of its elements is assignable to it; otherwise it is a
+ * tuple (also `[A, ...B[]]`), mapped homomorphically to stay a tuple (upstream #2632). Both keep
+ * `readonly` (upstream #2615).
+ */
 type ReadWriteResolveArray<T extends readonly unknown[], Resolved extends "read" | "write"> = T[number][] extends T ? T extends unknown[] ? ReadWriteResolve<T[number], Resolved>[] : readonly ReadWriteResolve<T[number], Resolved>[] : {
     [K in keyof T]: ReadWriteResolve<T[K], Resolved>;
 };
 type ReadWriteResolve<T, Resolved extends "read" | "write"> = Resolved extends "read" ? Readable<T> : Writable<T>;
+/**
+ * Resolve type for reading (responses): strips $Write properties, unwraps $Read
+ * - $Read<T> → T (readable), continues recursion
+ * - $Write<T> → never (excluded from response)
+ * - primitives (also branded), functions, arrays and tuples keep their shape; objects resolve
+ *   recursively
+ */
 type Readable<T> = T extends $Write<any> ? never : T extends $Read<infer U> ? Readable<U> : T extends ReadWriteLeaf ? T : T extends readonly unknown[] ? ReadWriteResolveArray<T, "read"> : T extends object ? {
     [K in keyof T as K extends ReadWriteMarkedKeys<T, $Write<any>> ? never : K]: Readable<T[K]>;
 } : T;
+/**
+ * Resolve type for writing (requests): strips $Read properties, unwraps $Write
+ * - $Write<T> → T (writable), continues recursion
+ * - $Read<T> → never (excluded from request)
+ * - primitives (also branded), functions, arrays and tuples keep their shape; objects resolve
+ *   recursively
+ */
 type Writable<T> = T extends $Read<any> ? never : T extends $Write<infer U> ? Writable<U> : T extends ReadWriteLeaf ? T : T extends readonly unknown[] ? ReadWriteResolveArray<T, "write"> : T extends object ? {
     [K in keyof T as K extends ReadWriteMarkedKeys<T, $Read<any>> ? never : K]: Writable<T[K]>;
 } & {

package/dist/index.d.mts

@@ -1,172 +1,286 @@
-type HttpMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace" | "query";
+type HttpMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace"
+/** OpenAPI 3.2: a safe, idempotent request with a body. */
+ | "query";
+/** 2XX statuses */
 type OkStatus = 200 | 201 | 202 | 203 | 204 | 206 | 207 | "2XX";
+/** 4XX and 5XX statuses */
 type ErrorStatus = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | "5XX" | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 420 | 421 | 422 | 423 | 424 | 425 | 426 | 427 | 428 | 429 | 430 | 431 | 444 | 450 | 451 | 497 | 498 | 499 | "4XX" | "default";
+/** Get a union of OK Statuses */
 type OKStatusUnion<T> = FilterKeys<T, OkStatus>;
+/** Get first error status, in order */
 type FirstErrorStatus<T> = T extends {
-    500: any;
+    500: unknown;
 } ? T[500] : T extends {
-    501: any;
+    501: unknown;
 } ? T[501] : T extends {
-    502: any;
+    502: unknown;
 } ? T[502] : T extends {
-    503: any;
+    503: unknown;
 } ? T[503] : T extends {
-    504: any;
+    504: unknown;
 } ? T[504] : T extends {
-    505: any;
+    505: unknown;
 } ? T[505] : T extends {
-    506: any;
+    506: unknown;
 } ? T[506] : T extends {
-    507: any;
+    507: unknown;
 } ? T[507] : T extends {
-    508: any;
+    508: unknown;
 } ? T[508] : T extends {
-    510: any;
+    510: unknown;
 } ? T[510] : T extends {
-    511: any;
+    511: unknown;
 } ? T[511] : T extends {
-    "5XX": any;
+    "5XX": unknown;
 } ? T["5XX"] : T extends {
-    400: any;
+    400: unknown;
 } ? T[400] : T extends {
-    401: any;
+    401: unknown;
 } ? T[401] : T extends {
-    402: any;
+    402: unknown;
 } ? T[402] : T extends {
-    403: any;
+    403: unknown;
 } ? T[403] : T extends {
-    404: any;
+    404: unknown;
 } ? T[404] : T extends {
-    405: any;
+    405: unknown;
 } ? T[405] : T extends {
-    406: any;
+    406: unknown;
 } ? T[406] : T extends {
-    407: any;
+    407: unknown;
 } ? T[407] : T extends {
-    408: any;
+    408: unknown;
 } ? T[408] : T extends {
-    409: any;
+    409: unknown;
 } ? T[409] : T extends {
-    410: any;
+    410: unknown;
 } ? T[410] : T extends {
-    411: any;
+    411: unknown;
 } ? T[411] : T extends {
-    412: any;
+    412: unknown;
 } ? T[412] : T extends {
-    413: any;
+    413: unknown;
 } ? T[413] : T extends {
-    414: any;
+    414: unknown;
 } ? T[414] : T extends {
-    415: any;
+    415: unknown;
 } ? T[415] : T extends {
-    416: any;
+    416: unknown;
 } ? T[416] : T extends {
-    417: any;
+    417: unknown;
 } ? T[417] : T extends {
-    418: any;
+    418: unknown;
 } ? T[418] : T extends {
-    420: any;
+    420: unknown;
 } ? T[420] : T extends {
-    421: any;
+    421: unknown;
 } ? T[421] : T extends {
-    422: any;
+    422: unknown;
 } ? T[422] : T extends {
-    423: any;
+    423: unknown;
 } ? T[423] : T extends {
-    424: any;
+    424: unknown;
 } ? T[424] : T extends {
-    425: any;
+    425: unknown;
 } ? T[425] : T extends {
-    426: any;
+    426: unknown;
 } ? T[426] : T extends {
-    427: any;
+    427: unknown;
 } ? T[427] : T extends {
-    428: any;
+    428: unknown;
 } ? T[428] : T extends {
-    429: any;
+    429: unknown;
 } ? T[429] : T extends {
-    430: any;
+    430: unknown;
 } ? T[430] : T extends {
-    431: any;
+    431: unknown;
 } ? T[431] : T extends {
-    444: any;
+    444: unknown;
 } ? T[444] : T extends {
-    450: any;
+    450: unknown;
 } ? T[450] : T extends {
-    451: any;
+    451: unknown;
 } ? T[451] : T extends {
-    497: any;
+    497: unknown;
 } ? T[497] : T extends {
-    498: any;
+    498: unknown;
 } ? T[498] : T extends {
-    499: any;
+    499: unknown;
 } ? T[499] : T extends {
-    "4XX": any;
+    "4XX": unknown;
 } ? T["4XX"] : T extends {
-    default: any;
+    default: unknown;
 } ? T["default"] : never;
-type PathsWithMethod<Paths extends {}, PathnameMethod extends HttpMethod> = {
+/** The paths that have each of the methods: upstream's `PathsWithMethod`. */
+type PathsWithEveryMethod<Paths extends {}, PathnameMethod extends HttpMethod> = {
     [Pathname in keyof Paths]: Paths[Pathname] extends {
-        [K in PathnameMethod]: any;
+        [K in PathnameMethod]: unknown;
     } ? Pathname : never;
 }[keyof Paths];
+/** The paths that have at least one method. */
+type PathsWithAnyMethod<Paths extends {}> = {
+    [Pathname in keyof Paths]: {
+        [Method in HttpMethod]: Paths[Pathname] extends {
+            [K in Method]: unknown;
+        } ? Pathname : never;
+    }[HttpMethod];
+}[keyof Paths];
+/**
+ * Given an OpenAPI **Paths Object**, find all paths that have the given method. For a union of
+ * methods, the paths that have each of them, so a call with either method finds its operation.
+ * For `HttpMethod` itself, a method not known yet, the paths that have any method too: TypeScript
+ * uses it where a hook's `Method` is not inferred, as in `Parameters<typeof $api.queryOptions>`,
+ * and the paths with every method were none (upstream #2178).
+ *
+ * A union with upstream's type, not a conditional type over the method: code that is generic in
+ * the method (`Path extends PathsWithMethod<Paths, Method>`, as swr-openapi has) must still
+ * relate one `PathsWithMethod` to another, and TypeScript cannot relate a type to a conditional
+ * type that waits for its method (TS2344). For a known method the second member is `never`.
+ */
+type PathsWithMethod<Paths extends {}, PathnameMethod extends HttpMethod> = PathsWithEveryMethod<Paths, PathnameMethod> | (HttpMethod extends PathnameMethod ? PathsWithAnyMethod<Paths> : never);
+/**
+ * DO NOT USE!
+ * Only used only for OperationObject type inference
+ */
 interface OperationObject {
     parameters: any;
     requestBody: any;
     responses: any;
 }
+/** Internal helper used in PathsWithMethod */
 type PathItemObject = {
     [M in HttpMethod]: OperationObject;
 } & {
     parameters?: any;
 };
+/** Return `responses` for an Operation Object */
 type ResponseObjectMap<T> = T extends {
     responses: any;
 } ? T["responses"] : unknown;
+/** Return `content` for a Response Object */
 type ResponseContent<T> = T extends {
     content: any;
 } ? T["content"] : unknown;
+/** Return type of `requestBody` for an Operation Object */
 type OperationRequestBody<T> = "requestBody" extends keyof T ? T["requestBody"] : never;
+/** Internal helper to get object type with only the `requestBody` property */
 type PickRequestBody<T> = "requestBody" extends keyof T ? Pick<T, "requestBody"> : never;
+/** Resolve to `true` if request body is optional, else `false` */
 type IsOperationRequestBodyOptional<T> = RequiredKeysOf<PickRequestBody<T>> extends never ? true : false;
+/** Internal helper used in OperationRequestBodyContent */
 type OperationRequestBodyMediaContent<T> = IsOperationRequestBodyOptional<T> extends true ? ResponseContent<NonNullable<OperationRequestBody<T>>> | undefined : ResponseContent<OperationRequestBody<T>>;
+/** Return first `content` from a Request Object Mapping, allowing any media type */
 type OperationRequestBodyContent<T> = FilterKeys<OperationRequestBodyMediaContent<T>, MediaType> extends never ? FilterKeys<NonNullable<OperationRequestBodyMediaContent<T>>, MediaType> | undefined : FilterKeys<OperationRequestBodyMediaContent<T>, MediaType>;
-type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = GetResponseContent<T, Media, OkStatus>;
+/**
+ * The statuses of success responses in a Response Object Map: the 2XX statuses, or `default` when
+ * no 2XX status is declared. `default` covers every status the operation does not declare (OpenAPI
+ * Responses Object), so then it covers every success (upstream #1862). With a 2XX status declared,
+ * `default` is left to the errors, as before.
+ */
+type SuccessStatus<T> = [Extract<keyof T, OkStatus>] extends [never] ? "default" : OkStatus;
+/** Return all 2XX responses from a Response Object Map, or `default` if it declares no 2XX one */
+type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = GetResponseContent<T, Media, SuccessStatus<T>>;
 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 all 5XX and 4XX responses (in that order) from a Response Object Map
+ */
 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 */
 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 */
 type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
+/** Return JSON-like request body from a path + HTTP method */
 type RequestBodyJSON<PathMethod> = JSONLike<FilterKeys<OperationRequestBody<PathMethod>, "content">>;
+/** Find first match of multiple keys */
 type FilterKeys<Obj, Matchers> = Obj[keyof Obj & Matchers];
-type GetValueWithDefault<Obj, KeyPattern, Default> = Obj extends any ? FilterKeys<Obj, KeyPattern> extends never ? Default : FilterKeys<Obj, KeyPattern> : never;
+/**
+ * @deprecated Use `FilterKeys` instead
+ * Get the type of a value of an input object with a given key. If the key is
+ * not found, return a default type. Works with unions of objects too.
+ */
+type GetValueWithDefault<Obj, KeyPattern, Default> = Obj extends unknown ? FilterKeys<Obj, KeyPattern> extends never ? Default : FilterKeys<Obj, KeyPattern> : never;
+/**
+ * Return any `[string]/[string]` media type (important because openapi-typesafe-fetch allows any
+ * content response, not just JSON-like)
+ */
 type MediaType = `${string}/${string}`;
+/**
+ * Return any media type containing "json" (works for "application/json",
+ * "application/vnd.api+json", "application/vnd.oai.openapi+json")
+ */
 type JSONLike<T> = FilterKeys<T, `${string}/json`>;
+/**
+ * Filter objects that have required keys
+ * @deprecated Use `RequiredKeysOf` instead
+ */
 type FindRequiredKeys<T, K extends keyof T> = K extends unknown ? undefined extends T[K] ? never : K : K;
+/**
+ * Does this object contain required keys?
+ * @deprecated Use `RequiredKeysOf` instead
+ */
 type HasRequiredKeys<T> = FindRequiredKeys<T, keyof T>;
+/**
+ * Helper to get the required keys of an object. If no keys are required, will be `undefined` with
+ * strictNullChecks enabled, else `never`
+ */
 type RequiredKeysOfHelper<T> = {
     [K in keyof T]: {} extends Pick<T, K> ? never : K;
 }[keyof T];
+/** Get the required keys of an object, or `never` if no keys are required */
 type RequiredKeysOf<T> = RequiredKeysOfHelper<T> extends undefined ? never : RequiredKeysOfHelper<T>;
+/** Marker type for readOnly properties (excluded from request bodies) */
 type $Read<T> = {
     readonly $read: T;
 };
+/** Marker type for writeOnly properties (excluded from response bodies) */
 type $Write<T> = {
     readonly $write: T;
 };
+/** Primitives, also branded ones (`string & { __brand: "Id" }`), which stay unmapped (#2765). */
 type ReadWritePrimitive = string | number | boolean | bigint | symbol | null | undefined;
+/**
+ * Types that stay unmapped. Mapping a function type drops its call signatures, so a `Blob` from
+ * `--binary-as-blob` lost its methods (`arrayBuffer()`, `text()`, ...) in response data.
+ */
 type ReadWriteLeaf = ReadWritePrimitive | ((...args: never) => unknown);
+/**
+ * Keys of `T` whose value is a `Marker`. A key whose value is only `null` or `undefined` is not
+ * marked: `NonNullable` of it is `never`, and `never` extends every marker (upstream #2717). The
+ * checks are not distributive (`NonNullable<T[K]>` is not a type parameter), so `never` is seen.
+ */
 type ReadWriteMarkedKeys<T, Marker> = {
     [K in keyof T]-?: NonNullable<T[K]> extends never ? never : NonNullable<T[K]> extends Marker ? K : never;
 }[keyof T];
+/**
+ * Resolve an array or a tuple element by element. An array uses `T[number]`, not `infer E`: for an
+ * intersection of arrays (`allOf`) inference keeps one member and narrowing breaks (upstream
+ * #2620). `T` is a plain array when an array of its elements is assignable to it; otherwise it is a
+ * tuple (also `[A, ...B[]]`), mapped homomorphically to stay a tuple (upstream #2632). Both keep
+ * `readonly` (upstream #2615).
+ */
 type ReadWriteResolveArray<T extends readonly unknown[], Resolved extends "read" | "write"> = T[number][] extends T ? T extends unknown[] ? ReadWriteResolve<T[number], Resolved>[] : readonly ReadWriteResolve<T[number], Resolved>[] : {
     [K in keyof T]: ReadWriteResolve<T[K], Resolved>;
 };
 type ReadWriteResolve<T, Resolved extends "read" | "write"> = Resolved extends "read" ? Readable<T> : Writable<T>;
+/**
+ * Resolve type for reading (responses): strips $Write properties, unwraps $Read
+ * - $Read<T> → T (readable), continues recursion
+ * - $Write<T> → never (excluded from response)
+ * - primitives (also branded), functions, arrays and tuples keep their shape; objects resolve
+ *   recursively
+ */
 type Readable<T> = T extends $Write<any> ? never : T extends $Read<infer U> ? Readable<U> : T extends ReadWriteLeaf ? T : T extends readonly unknown[] ? ReadWriteResolveArray<T, "read"> : T extends object ? {
     [K in keyof T as K extends ReadWriteMarkedKeys<T, $Write<any>> ? never : K]: Readable<T[K]>;
 } : T;
+/**
+ * Resolve type for writing (requests): strips $Read properties, unwraps $Write
+ * - $Write<T> → T (writable), continues recursion
+ * - $Read<T> → never (excluded from request)
+ * - primitives (also branded), functions, arrays and tuples keep their shape; objects resolve
+ *   recursively
+ */
 type Writable<T> = T extends $Read<any> ? never : T extends $Write<infer U> ? Writable<U> : T extends ReadWriteLeaf ? T : T extends readonly unknown[] ? ReadWriteResolveArray<T, "write"> : T extends object ? {
     [K in keyof T as K extends ReadWriteMarkedKeys<T, $Read<any>> ? never : K]: Writable<T[K]>;
 } & {

package/dist/index.d.ts

@@ -1,172 +1,286 @@
-type HttpMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace" | "query";
+type HttpMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace"
+/** OpenAPI 3.2: a safe, idempotent request with a body. */
+ | "query";
+/** 2XX statuses */
 type OkStatus = 200 | 201 | 202 | 203 | 204 | 206 | 207 | "2XX";
+/** 4XX and 5XX statuses */
 type ErrorStatus = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | "5XX" | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 420 | 421 | 422 | 423 | 424 | 425 | 426 | 427 | 428 | 429 | 430 | 431 | 444 | 450 | 451 | 497 | 498 | 499 | "4XX" | "default";
+/** Get a union of OK Statuses */
 type OKStatusUnion<T> = FilterKeys<T, OkStatus>;
+/** Get first error status, in order */
 type FirstErrorStatus<T> = T extends {
-    500: any;
+    500: unknown;
 } ? T[500] : T extends {
-    501: any;
+    501: unknown;
 } ? T[501] : T extends {
-    502: any;
+    502: unknown;
 } ? T[502] : T extends {
-    503: any;
+    503: unknown;
 } ? T[503] : T extends {
-    504: any;
+    504: unknown;
 } ? T[504] : T extends {
-    505: any;
+    505: unknown;
 } ? T[505] : T extends {
-    506: any;
+    506: unknown;
 } ? T[506] : T extends {
-    507: any;
+    507: unknown;
 } ? T[507] : T extends {
-    508: any;
+    508: unknown;
 } ? T[508] : T extends {
-    510: any;
+    510: unknown;
 } ? T[510] : T extends {
-    511: any;
+    511: unknown;
 } ? T[511] : T extends {
-    "5XX": any;
+    "5XX": unknown;
 } ? T["5XX"] : T extends {
-    400: any;
+    400: unknown;
 } ? T[400] : T extends {
-    401: any;
+    401: unknown;
 } ? T[401] : T extends {
-    402: any;
+    402: unknown;
 } ? T[402] : T extends {
-    403: any;
+    403: unknown;
 } ? T[403] : T extends {
-    404: any;
+    404: unknown;
 } ? T[404] : T extends {
-    405: any;
+    405: unknown;
 } ? T[405] : T extends {
-    406: any;
+    406: unknown;
 } ? T[406] : T extends {
-    407: any;
+    407: unknown;
 } ? T[407] : T extends {
-    408: any;
+    408: unknown;
 } ? T[408] : T extends {
-    409: any;
+    409: unknown;
 } ? T[409] : T extends {
-    410: any;
+    410: unknown;
 } ? T[410] : T extends {
-    411: any;
+    411: unknown;
 } ? T[411] : T extends {
-    412: any;
+    412: unknown;
 } ? T[412] : T extends {
-    413: any;
+    413: unknown;
 } ? T[413] : T extends {
-    414: any;
+    414: unknown;
 } ? T[414] : T extends {
-    415: any;
+    415: unknown;
 } ? T[415] : T extends {
-    416: any;
+    416: unknown;
 } ? T[416] : T extends {
-    417: any;
+    417: unknown;
 } ? T[417] : T extends {
-    418: any;
+    418: unknown;
 } ? T[418] : T extends {
-    420: any;
+    420: unknown;
 } ? T[420] : T extends {
-    421: any;
+    421: unknown;
 } ? T[421] : T extends {
-    422: any;
+    422: unknown;
 } ? T[422] : T extends {
-    423: any;
+    423: unknown;
 } ? T[423] : T extends {
-    424: any;
+    424: unknown;
 } ? T[424] : T extends {
-    425: any;
+    425: unknown;
 } ? T[425] : T extends {
-    426: any;
+    426: unknown;
 } ? T[426] : T extends {
-    427: any;
+    427: unknown;
 } ? T[427] : T extends {
-    428: any;
+    428: unknown;
 } ? T[428] : T extends {
-    429: any;
+    429: unknown;
 } ? T[429] : T extends {
-    430: any;
+    430: unknown;
 } ? T[430] : T extends {
-    431: any;
+    431: unknown;
 } ? T[431] : T extends {
-    444: any;
+    444: unknown;
 } ? T[444] : T extends {
-    450: any;
+    450: unknown;
 } ? T[450] : T extends {
-    451: any;
+    451: unknown;
 } ? T[451] : T extends {
-    497: any;
+    497: unknown;
 } ? T[497] : T extends {
-    498: any;
+    498: unknown;
 } ? T[498] : T extends {
-    499: any;
+    499: unknown;
 } ? T[499] : T extends {
-    "4XX": any;
+    "4XX": unknown;
 } ? T["4XX"] : T extends {
-    default: any;
+    default: unknown;
 } ? T["default"] : never;
-type PathsWithMethod<Paths extends {}, PathnameMethod extends HttpMethod> = {
+/** The paths that have each of the methods: upstream's `PathsWithMethod`. */
+type PathsWithEveryMethod<Paths extends {}, PathnameMethod extends HttpMethod> = {
     [Pathname in keyof Paths]: Paths[Pathname] extends {
-        [K in PathnameMethod]: any;
+        [K in PathnameMethod]: unknown;
     } ? Pathname : never;
 }[keyof Paths];
+/** The paths that have at least one method. */
+type PathsWithAnyMethod<Paths extends {}> = {
+    [Pathname in keyof Paths]: {
+        [Method in HttpMethod]: Paths[Pathname] extends {
+            [K in Method]: unknown;
+        } ? Pathname : never;
+    }[HttpMethod];
+}[keyof Paths];
+/**
+ * Given an OpenAPI **Paths Object**, find all paths that have the given method. For a union of
+ * methods, the paths that have each of them, so a call with either method finds its operation.
+ * For `HttpMethod` itself, a method not known yet, the paths that have any method too: TypeScript
+ * uses it where a hook's `Method` is not inferred, as in `Parameters<typeof $api.queryOptions>`,
+ * and the paths with every method were none (upstream #2178).
+ *
+ * A union with upstream's type, not a conditional type over the method: code that is generic in
+ * the method (`Path extends PathsWithMethod<Paths, Method>`, as swr-openapi has) must still
+ * relate one `PathsWithMethod` to another, and TypeScript cannot relate a type to a conditional
+ * type that waits for its method (TS2344). For a known method the second member is `never`.
+ */
+type PathsWithMethod<Paths extends {}, PathnameMethod extends HttpMethod> = PathsWithEveryMethod<Paths, PathnameMethod> | (HttpMethod extends PathnameMethod ? PathsWithAnyMethod<Paths> : never);
+/**
+ * DO NOT USE!
+ * Only used only for OperationObject type inference
+ */
 interface OperationObject {
     parameters: any;
     requestBody: any;
     responses: any;
 }
+/** Internal helper used in PathsWithMethod */
 type PathItemObject = {
     [M in HttpMethod]: OperationObject;
 } & {
     parameters?: any;
 };
+/** Return `responses` for an Operation Object */
 type ResponseObjectMap<T> = T extends {
     responses: any;
 } ? T["responses"] : unknown;
+/** Return `content` for a Response Object */
 type ResponseContent<T> = T extends {
     content: any;
 } ? T["content"] : unknown;
+/** Return type of `requestBody` for an Operation Object */
 type OperationRequestBody<T> = "requestBody" extends keyof T ? T["requestBody"] : never;
+/** Internal helper to get object type with only the `requestBody` property */
 type PickRequestBody<T> = "requestBody" extends keyof T ? Pick<T, "requestBody"> : never;
+/** Resolve to `true` if request body is optional, else `false` */
 type IsOperationRequestBodyOptional<T> = RequiredKeysOf<PickRequestBody<T>> extends never ? true : false;
+/** Internal helper used in OperationRequestBodyContent */
 type OperationRequestBodyMediaContent<T> = IsOperationRequestBodyOptional<T> extends true ? ResponseContent<NonNullable<OperationRequestBody<T>>> | undefined : ResponseContent<OperationRequestBody<T>>;
+/** Return first `content` from a Request Object Mapping, allowing any media type */
 type OperationRequestBodyContent<T> = FilterKeys<OperationRequestBodyMediaContent<T>, MediaType> extends never ? FilterKeys<NonNullable<OperationRequestBodyMediaContent<T>>, MediaType> | undefined : FilterKeys<OperationRequestBodyMediaContent<T>, MediaType>;
-type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = GetResponseContent<T, Media, OkStatus>;
+/**
+ * The statuses of success responses in a Response Object Map: the 2XX statuses, or `default` when
+ * no 2XX status is declared. `default` covers every status the operation does not declare (OpenAPI
+ * Responses Object), so then it covers every success (upstream #1862). With a 2XX status declared,
+ * `default` is left to the errors, as before.
+ */
+type SuccessStatus<T> = [Extract<keyof T, OkStatus>] extends [never] ? "default" : OkStatus;
+/** Return all 2XX responses from a Response Object Map, or `default` if it declares no 2XX one */
+type SuccessResponse<T extends Record<string | number, any>, Media extends MediaType = MediaType> = GetResponseContent<T, Media, SuccessStatus<T>>;
 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 all 5XX and 4XX responses (in that order) from a Response Object Map
+ */
 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 */
 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 */
 type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<ResponseObjectMap<PathMethod>, `${string}/json`>;
+/** Return JSON-like request body from a path + HTTP method */
 type RequestBodyJSON<PathMethod> = JSONLike<FilterKeys<OperationRequestBody<PathMethod>, "content">>;
+/** Find first match of multiple keys */
 type FilterKeys<Obj, Matchers> = Obj[keyof Obj & Matchers];
-type GetValueWithDefault<Obj, KeyPattern, Default> = Obj extends any ? FilterKeys<Obj, KeyPattern> extends never ? Default : FilterKeys<Obj, KeyPattern> : never;
+/**
+ * @deprecated Use `FilterKeys` instead
+ * Get the type of a value of an input object with a given key. If the key is
+ * not found, return a default type. Works with unions of objects too.
+ */
+type GetValueWithDefault<Obj, KeyPattern, Default> = Obj extends unknown ? FilterKeys<Obj, KeyPattern> extends never ? Default : FilterKeys<Obj, KeyPattern> : never;
+/**
+ * Return any `[string]/[string]` media type (important because openapi-typesafe-fetch allows any
+ * content response, not just JSON-like)
+ */
 type MediaType = `${string}/${string}`;
+/**
+ * Return any media type containing "json" (works for "application/json",
+ * "application/vnd.api+json", "application/vnd.oai.openapi+json")
+ */
 type JSONLike<T> = FilterKeys<T, `${string}/json`>;
+/**
+ * Filter objects that have required keys
+ * @deprecated Use `RequiredKeysOf` instead
+ */
 type FindRequiredKeys<T, K extends keyof T> = K extends unknown ? undefined extends T[K] ? never : K : K;
+/**
+ * Does this object contain required keys?
+ * @deprecated Use `RequiredKeysOf` instead
+ */
 type HasRequiredKeys<T> = FindRequiredKeys<T, keyof T>;
+/**
+ * Helper to get the required keys of an object. If no keys are required, will be `undefined` with
+ * strictNullChecks enabled, else `never`
+ */
 type RequiredKeysOfHelper<T> = {
     [K in keyof T]: {} extends Pick<T, K> ? never : K;
 }[keyof T];
+/** Get the required keys of an object, or `never` if no keys are required */
 type RequiredKeysOf<T> = RequiredKeysOfHelper<T> extends undefined ? never : RequiredKeysOfHelper<T>;
+/** Marker type for readOnly properties (excluded from request bodies) */
 type $Read<T> = {
     readonly $read: T;
 };
+/** Marker type for writeOnly properties (excluded from response bodies) */
 type $Write<T> = {
     readonly $write: T;
 };
+/** Primitives, also branded ones (`string & { __brand: "Id" }`), which stay unmapped (#2765). */
 type ReadWritePrimitive = string | number | boolean | bigint | symbol | null | undefined;
+/**
+ * Types that stay unmapped. Mapping a function type drops its call signatures, so a `Blob` from
+ * `--binary-as-blob` lost its methods (`arrayBuffer()`, `text()`, ...) in response data.
+ */
 type ReadWriteLeaf = ReadWritePrimitive | ((...args: never) => unknown);
+/**
+ * Keys of `T` whose value is a `Marker`. A key whose value is only `null` or `undefined` is not
+ * marked: `NonNullable` of it is `never`, and `never` extends every marker (upstream #2717). The
+ * checks are not distributive (`NonNullable<T[K]>` is not a type parameter), so `never` is seen.
+ */
 type ReadWriteMarkedKeys<T, Marker> = {
     [K in keyof T]-?: NonNullable<T[K]> extends never ? never : NonNullable<T[K]> extends Marker ? K : never;
 }[keyof T];
+/**
+ * Resolve an array or a tuple element by element. An array uses `T[number]`, not `infer E`: for an
+ * intersection of arrays (`allOf`) inference keeps one member and narrowing breaks (upstream
+ * #2620). `T` is a plain array when an array of its elements is assignable to it; otherwise it is a
+ * tuple (also `[A, ...B[]]`), mapped homomorphically to stay a tuple (upstream #2632). Both keep
+ * `readonly` (upstream #2615).
+ */
 type ReadWriteResolveArray<T extends readonly unknown[], Resolved extends "read" | "write"> = T[number][] extends T ? T extends unknown[] ? ReadWriteResolve<T[number], Resolved>[] : readonly ReadWriteResolve<T[number], Resolved>[] : {
     [K in keyof T]: ReadWriteResolve<T[K], Resolved>;
 };
 type ReadWriteResolve<T, Resolved extends "read" | "write"> = Resolved extends "read" ? Readable<T> : Writable<T>;
+/**
+ * Resolve type for reading (responses): strips $Write properties, unwraps $Read
+ * - $Read<T> → T (readable), continues recursion
+ * - $Write<T> → never (excluded from response)
+ * - primitives (also branded), functions, arrays and tuples keep their shape; objects resolve
+ *   recursively
+ */
 type Readable<T> = T extends $Write<any> ? never : T extends $Read<infer U> ? Readable<U> : T extends ReadWriteLeaf ? T : T extends readonly unknown[] ? ReadWriteResolveArray<T, "read"> : T extends object ? {
     [K in keyof T as K extends ReadWriteMarkedKeys<T, $Write<any>> ? never : K]: Readable<T[K]>;
 } : T;
+/**
+ * Resolve type for writing (requests): strips $Read properties, unwraps $Write
+ * - $Write<T> → T (writable), continues recursion
+ * - $Read<T> → never (excluded from request)
+ * - primitives (also branded), functions, arrays and tuples keep their shape; objects resolve
+ *   recursively
+ */
 type Writable<T> = T extends $Read<any> ? never : T extends $Write<infer U> ? Writable<U> : T extends ReadWriteLeaf ? T : T extends readonly unknown[] ? ReadWriteResolveArray<T, "write"> : T extends object ? {
     [K in keyof T as K extends ReadWriteMarkedKeys<T, $Read<any>> ? never : K]: Writable<T[K]>;
 } & {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openapi-typesafe-helpers",
   "description": "TypeScript helpers for consuming openapi-typesafe types",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0-rc.2",
   "author": {
     "name": "Fedor Chishchin",
     "url": "https://github.com/fedorello"
@@ -36,7 +36,8 @@
     "url": "https://github.com/openapi-typesafe/openapi-typesafe/issues"
   },
   "devDependencies": {
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "vite-node": "6.0.0"
   },
   "engines": {
     "node": ">=22"
@@ -44,9 +45,10 @@
   "scripts": {
     "build": "unbuild",
     "format": "biome format src --write",
-    "lint": "pnpm run lint:js && pnpm run lint:ts",
+    "lint": "pnpm run lint:js && pnpm run lint:ts && pnpm run lint:sizes",
     "lint:js": "biome check src",
     "lint:ts": "tsc --noEmit",
+    "lint:sizes": "vite-node ../openapi-typesafe/scripts/size-rules/check-sizes.ts src",
     "test": "pnpm run test:exports",
     "test:exports": "pnpm run build && ../../scripts/check-exports.sh"
   }