@sapporta/rest-core 3.52.1 → 3.52.2

package/src/lib/infer-types.spec.ts

@@ -1,935 +0,0 @@
-import { z } from 'zod';
-import {
-  UnknownOrUndefinedObjectValuesToOptionalKeys,
-  initContract,
-} from './dsl';
-import { Equal, Expect } from './test-helpers';
-import {
-  ClientInferRequest,
-  ServerInferRequest,
-  ClientInferResponseBody,
-  ServerInferResponseBody,
-  ClientInferResponses,
-  ServerInferResponses,
-  InferResponseDefinedStatusCodes,
-  InferResponseUndefinedStatusCodes,
-} from './infer-types';
-import {
-  ErrorHttpStatusCode,
-  HTTPStatusCode,
-  SuccessfulHttpStatusCode,
-} from './status-codes';
-import { FetchOptions, OverridableClientArgs, initClient } from './client';
-import { Prettify } from './type-utils';
-import * as v from 'valibot';
-
-const c = initContract();
-
-const contract = c.router(
-  {
-    getPost: {
-      method: 'GET',
-      path: '/posts/:id',
-      pathParams: z.object({
-        id: z.string().transform((id) => Number(id)),
-      }),
-      query: z.object({
-        includeComments: z.boolean().default(false),
-      }),
-      responses: {
-        200: z.object({
-          id: z.number(),
-          title: z.string().default('Untitled'),
-          content: z.string(),
-        }),
-        404: z.object({
-          message: z.string(),
-        }),
-      },
-    },
-    createPost: {
-      method: 'POST',
-      path: '/posts',
-      body: z.object({
-        title: z.string(),
-        content: z.string(),
-      }),
-      responses: {
-        201: z.object({
-          id: z.number(),
-          title: z.string(),
-          content: z.string(),
-        }),
-      },
-    },
-    uploadImage: {
-      method: 'POST',
-      path: '/images',
-      contentType: 'multipart/form-data',
-      body: c.type<{ image: File; images: File[] }>(),
-      responses: {
-        201: c.otherResponse({
-          contentType: 'text/plain',
-          body: c.type<'Image uploaded successfully'>(),
-        }),
-        500: c.otherResponse({
-          contentType: 'text/plain',
-          body: z.literal('Image upload failed'),
-        }),
-      },
-    },
-    nested: {
-      getComments: {
-        method: 'GET',
-        path: '/posts/:id/comments',
-        pathParams: z.object({
-          id: z.string().transform((id) => Number(id)),
-        }),
-        headers: {
-          'pagination-page': z.string().transform(Number),
-        },
-        responses: {
-          200: z.object({
-            comments: z.array(
-              z.object({
-                id: z.number(),
-                content: z.string(),
-              }),
-            ),
-          }),
-          404: c.type<null>(),
-        },
-      },
-    },
-  },
-  {
-    baseHeaders: {
-      Authorization: z.string(),
-      age: z.coerce.number().optional(),
-    },
-  },
-);
-
-const contractStrict = c.router(contract, {
-  strictStatusCodes: true,
-});
-
-const headerlessContract = c.router({
-  getPost: {
-    method: 'GET',
-    path: '/posts/:id',
-    pathParams: z.object({
-      id: z.string().transform((id) => Number(id)),
-    }),
-    query: z.object({
-      includeComments: z.boolean().default(false),
-    }),
-    responses: {
-      200: z.object({
-        id: z.number(),
-        title: z.string().default('Untitled'),
-        content: z.string(),
-      }),
-      404: z.object({
-        message: z.string(),
-      }),
-    },
-  },
-});
-
-it('type inference helpers', () => {
-  /**
-   * @name ServerInferResponsesWithUnknownStatusCodes
-   * Expect ServerInferResponses to include all defined status codes plus unknown status codes
-   * for endpoints that don't have strict status codes enabled
-   */
-  type ServerInferResponsesWithUnknownStatusCodes = ServerInferResponses<
-    typeof contract
-  >;
-  type TestServerInferResponsesWithUnknownStatusCodes = Expect<
-    Equal<
-      ServerInferResponsesWithUnknownStatusCodes,
-      {
-        getPost:
-          | {
-              status: 200;
-              body: { title?: string | undefined; id: number; content: string };
-            }
-          | { status: 404; body: { message: string } }
-          | { status: Exclude<HTTPStatusCode, 200 | 404>; body: unknown };
-        createPost:
-          | {
-              status: 201;
-              body: { id: number; title: string; content: string };
-            }
-          | { status: Exclude<HTTPStatusCode, 201>; body: unknown };
-        uploadImage:
-          | {
-              status: 201;
-              body: 'Image uploaded successfully';
-            }
-          | {
-              status: 500;
-              body: 'Image upload failed';
-            }
-          | { status: Exclude<HTTPStatusCode, 201 | 500>; body: unknown };
-        nested: {
-          getComments:
-            | {
-                status: 200;
-                body: { comments: { id: number; content: string }[] };
-              }
-            | { status: 404; body: null }
-            | { status: Exclude<HTTPStatusCode, 200 | 404>; body: unknown };
-        };
-      }
-    >
-  >;
-
-  /**
-   * @name ServerInferResponsesWithStrictStatusCodes
-   * Expect ServerInferResponses to only include explicitly defined status codes
-   * when strict status codes are enabled, excluding unknown status codes
-   */
-  type ServerInferResponsesWithStrictStatusCodes = ServerInferResponses<
-    typeof contractStrict
-  >;
-  type TestServerInferResponsesWithStrictStatusCodes = Expect<
-    Equal<
-      ServerInferResponsesWithStrictStatusCodes,
-      {
-        getPost:
-          | {
-              status: 200;
-              body: { title?: string | undefined; id: number; content: string };
-            }
-          | { status: 404; body: { message: string } };
-        createPost: {
-          status: 201;
-          body: { id: number; title: string; content: string };
-        };
-        uploadImage:
-          | {
-              status: 201;
-              body: 'Image uploaded successfully';
-            }
-          | {
-              status: 500;
-              body: 'Image upload failed';
-            };
-        nested: {
-          getComments:
-            | {
-                status: 200;
-                body: { comments: { id: number; content: string }[] };
-              }
-            | { status: 404; body: null };
-        };
-      }
-    >
-  >;
-
-  /**
-   * @name ServerInferResponsesIgnoreStrictMode
-   * Expect ServerInferResponses to include unknown status codes even when strict mode is enabled
-   * but explicitly ignored via the 'ignore' parameter
-   */
-  type ServerInferResponsesIgnoreStrictMode = ServerInferResponses<
-    typeof contractStrict,
-    HTTPStatusCode,
-    'ignore'
-  >;
-  type TestServerInferResponsesIgnoreStrictMode = Expect<
-    Equal<
-      ServerInferResponsesIgnoreStrictMode,
-      {
-        getPost:
-          | {
-              status: 200;
-              body: { title?: string | undefined; id: number; content: string };
-            }
-          | { status: 404; body: { message: string } }
-          | { status: Exclude<HTTPStatusCode, 200 | 404>; body: unknown };
-        createPost:
-          | {
-              status: 201;
-              body: { id: number; title: string; content: string };
-            }
-          | { status: Exclude<HTTPStatusCode, 201>; body: unknown };
-        uploadImage:
-          | {
-              status: 201;
-              body: 'Image uploaded successfully';
-            }
-          | {
-              status: 500;
-              body: 'Image upload failed';
-            }
-          | { status: Exclude<HTTPStatusCode, 201 | 500>; body: unknown };
-        nested: {
-          getComments:
-            | {
-                status: 200;
-                body: { comments: { id: number; content: string }[] };
-              }
-            | { status: 404; body: null }
-            | { status: Exclude<HTTPStatusCode, 200 | 404>; body: unknown };
-        };
-      }
-    >
-  >;
-
-  /**
-   * @name ServerInferResponsesSpecificStatusCode
-   * Expect ServerInferResponses to filter responses to only include the specified status code (200),
-   * returning unknown body for endpoints that don't define that status code
-   */
-  type ServerInferResponsesSpecificStatusCode = ServerInferResponses<
-    typeof contract,
-    200
-  >;
-  type TestServerInferResponsesSpecificStatusCode = Expect<
-    Equal<
-      ServerInferResponsesSpecificStatusCode,
-      {
-        getPost: {
-          status: 200;
-          body: { title?: string | undefined; id: number; content: string };
-        };
-        createPost: {
-          status: 200;
-          body: unknown;
-        };
-        uploadImage: {
-          status: 200;
-          body: unknown;
-        };
-        nested: {
-          getComments: {
-            status: 200;
-            body: { comments: { id: number; content: string }[] };
-          };
-        };
-      }
-    >
-  >;
-
-  /**
-   * @name ServerInferResponsesUndefinedStatusCode
-   * Expect ServerInferResponses to return unknown body for all endpoints
-   * when filtering by a status code (401) that is not defined in any endpoint
-   */
-  type ServerInferResponsesUndefinedStatusCode = ServerInferResponses<
-    typeof contract,
-    401
-  >;
-  type TestServerInferResponsesUndefinedStatusCode = Expect<
-    Equal<
-      ServerInferResponsesUndefinedStatusCode,
-      {
-        getPost: {
-          status: 401;
-          body: unknown;
-        };
-        createPost: {
-          status: 401;
-          body: unknown;
-        };
-        uploadImage: {
-          status: 401;
-          body: unknown;
-        };
-        nested: {
-          getComments: {
-            status: 401;
-            body: unknown;
-          };
-        };
-      }
-    >
-  >;
-
-  /**
-   * @name ServerInferResponsesErrorStatusCodes
-   * Expect ServerInferResponses to filter responses to only include error status codes,
-   * showing defined error responses and unknown for undefined error codes
-   */
-  type ServerInferResponsesErrorStatusCodes = ServerInferResponses<
-    typeof contractStrict,
-    ErrorHttpStatusCode,
-    'ignore'
-  >;
-  type TestServerInferResponsesErrorStatusCodes = Expect<
-    Equal<
-      ServerInferResponsesErrorStatusCodes,
-      {
-        getPost:
-          | { status: 404; body: { message: string } }
-          | { status: Exclude<ErrorHttpStatusCode, 404>; body: unknown };
-        createPost: { status: ErrorHttpStatusCode; body: unknown };
-        uploadImage:
-          | {
-              status: 500;
-              body: 'Image upload failed';
-            }
-          | { status: Exclude<ErrorHttpStatusCode, 500>; body: unknown };
-        nested: {
-          getComments:
-            | { status: 404; body: null }
-            | { status: Exclude<ErrorHttpStatusCode, 404>; body: unknown };
-        };
-      }
-    >
-  >;
-
-  /**
-   * @name ServerInferResponsesSuccessStatusCodesForced
-   * Expect ServerInferResponses to only include successful status codes when forced,
-   * filtering out error responses and unknown status codes
-   */
-  type ServerInferResponsesSuccessStatusCodesForced = ServerInferResponses<
-    typeof contract,
-    SuccessfulHttpStatusCode,
-    'force'
-  >;
-  type TestServerInferResponsesSuccessStatusCodesForced = Expect<
-    Equal<
-      ServerInferResponsesSuccessStatusCodesForced,
-      {
-        getPost: {
-          status: 200;
-          body: { title?: string | undefined; id: number; content: string };
-        };
-        createPost: {
-          status: 201;
-          body: { id: number; title: string; content: string };
-        };
-        uploadImage: {
-          status: 201;
-          body: 'Image uploaded successfully';
-        };
-        nested: {
-          getComments: {
-            status: 200;
-            body: { comments: { id: number; content: string }[] };
-          };
-        };
-      }
-    >
-  >;
-
-  /**
-   * @name ClientInferResponsesWithHeaders
-   * Expect ClientInferResponses to include Headers object in all response types,
-   * distinguishing client-side responses from server-side responses
-   */
-  type ClientInferResponsesWithHeaders = ClientInferResponses<typeof contract>;
-  type TestClientInferResponsesWithHeaders = Expect<
-    Equal<
-      ClientInferResponsesWithHeaders,
-      {
-        getPost:
-          | {
-              status: 200;
-              body: { title: string; id: number; content: string };
-              headers: Headers;
-            }
-          | {
-              status: 404;
-              body: { message: string };
-              headers: Headers;
-            }
-          | {
-              status: Exclude<HTTPStatusCode, 200 | 404>;
-              body: unknown;
-              headers: Headers;
-            };
-        createPost:
-          | {
-              status: 201;
-              body: { id: number; title: string; content: string };
-              headers: Headers;
-            }
-          | {
-              status: Exclude<HTTPStatusCode, 201>;
-              body: unknown;
-              headers: Headers;
-            };
-        uploadImage:
-          | {
-              status: 201;
-              body: 'Image uploaded successfully';
-              headers: Headers;
-            }
-          | {
-              status: 500;
-              body: 'Image upload failed';
-              headers: Headers;
-            }
-          | {
-              status: Exclude<HTTPStatusCode, 201 | 500>;
-              body: unknown;
-              headers: Headers;
-            };
-        nested: {
-          getComments:
-            | {
-                status: 200;
-                body: { comments: { id: number; content: string }[] };
-                headers: Headers;
-              }
-            | {
-                status: 404;
-                body: null;
-                headers: Headers;
-              }
-            | {
-                status: Exclude<HTTPStatusCode, 200 | 404>;
-                body: unknown;
-                headers: Headers;
-              };
-        };
-      }
-    >
-  >;
-
-  /**
-   * @name ServerInferResponseBodySpecificEndpoint
-   * Expect ServerInferResponseBody to extract the response body type for a specific endpoint and status code,
-   * including optional properties from Zod defaults
-   */
-  type ServerInferResponseBodySpecificEndpoint = ServerInferResponseBody<
-    typeof contract.getPost,
-    200
-  >;
-  type TestServerInferResponseBodySpecificEndpoint = Expect<
-    Equal<
-      ServerInferResponseBodySpecificEndpoint,
-      { title?: string | undefined; id: number; content: string }
-    >
-  >;
-
-  /**
-   * @name ClientInferResponseBodySpecificEndpoint
-   * Expect ClientInferResponseBody to extract the response body type for a specific endpoint and status code,
-   * with required properties (no optional from Zod defaults on client side)
-   */
-  type ClientInferResponseBodySpecificEndpoint = ClientInferResponseBody<
-    typeof contract.getPost,
-    200
-  >;
-  type TestClientInferResponseBodySpecificEndpoint = Expect<
-    Equal<
-      ClientInferResponseBodySpecificEndpoint,
-      { title: string; id: number; content: string }
-    >
-  >;
-
-  const commonErrors = c.responses({
-    400: c.type<{ message: string }>(),
-  });
-
-  const contractWithCommonErrors = c.router({
-    get: {
-      method: 'GET',
-      path: '/',
-      responses: {
-        ...commonErrors,
-      },
-    },
-  });
-
-  /**
-   * @name ClientInferResponseBodyWithCommonResponses
-   * Expect ClientInferResponseBody to work with common response definitions,
-   * extracting the correct body type from shared response schemas
-   */
-  type ClientInferResponseBodyWithCommonResponses = ClientInferResponseBody<
-    typeof contractWithCommonErrors.get,
-    400
-  >;
-  type TestClientInferResponseBodyWithCommonResponses = Expect<
-    Equal<ClientInferResponseBodyWithCommonResponses, { message: string }>
-  >;
-
-  /**
-   * @name ServerInferRequestWithTransforms
-   * Expect ServerInferRequest to include transformed types for path params and headers,
-   * showing how Zod transforms affect the inferred server-side types
-   */
-  type ServerInferRequestWithTransforms = ServerInferRequest<typeof contract>;
-  type TestServerInferRequestWithTransforms = Expect<
-    Equal<
-      ServerInferRequestWithTransforms,
-      {
-        getPost: {
-          query: { includeComments: boolean };
-          params: { id: number };
-          headers: {
-            Authorization: string;
-            age: number | undefined;
-          };
-        };
-        createPost: {
-          body: { title: string; content: string };
-          headers: {
-            Authorization: string;
-            age: number | undefined;
-          };
-        };
-        uploadImage: {
-          body: {};
-          headers: {
-            Authorization: string;
-            age: number | undefined;
-          };
-        };
-        nested: {
-          getComments: {
-            params: { id: number };
-            headers: {
-              'pagination-page': number;
-              Authorization: string;
-              age: number | undefined;
-            };
-          };
-        };
-      }
-    >
-  >;
-
-  /**
-   * @name ServerInferRequestWithOverriddenHeaders
-   * Expect ServerInferRequest to merge contract headers with overridden server headers,
-   * allowing server-specific header types to be injected
-   */
-  type ServerInferRequestWithOverriddenHeaders = ServerInferRequest<
-    typeof contract,
-    {
-      authorization: string | undefined;
-      age: string | undefined;
-      'content-type': string | undefined;
-    }
-  >;
-  type TestServerInferRequestWithOverriddenHeaders = Expect<
-    Equal<
-      ServerInferRequestWithOverriddenHeaders,
-      {
-        getPost: {
-          query: { includeComments: boolean };
-          params: { id: number };
-          headers: {
-            Authorization: string;
-            age: number | undefined;
-            'content-type': string | undefined;
-          };
-        };
-        createPost: {
-          body: { title: string; content: string };
-          headers: {
-            Authorization: string;
-            age: number | undefined;
-            'content-type': string | undefined;
-          };
-        };
-        uploadImage: {
-          body: {};
-          headers: {
-            Authorization: string;
-            age: number | undefined;
-            'content-type': string | undefined;
-          };
-        };
-        nested: {
-          getComments: {
-            params: { id: number };
-            headers: {
-              'pagination-page': number;
-              Authorization: string;
-              age: number | undefined;
-              'content-type': string | undefined;
-            };
-          };
-        };
-      }
-    >
-  >;
-
-  /**
-   * @name ClientInferRequestWithClientOptions
-   * Expect ClientInferRequest to include client-specific options like fetchOptions and extraHeaders,
-   * showing the difference between client and server request inference
-   */
-  type ClientInferRequestWithClientOptions = ClientInferRequest<
-    typeof contract
-  >;
-  type TestClientInferRequestWithClientOptions = Expect<
-    Equal<
-      ClientInferRequestWithClientOptions,
-      {
-        getPost: {
-          query: { includeComments?: boolean | undefined };
-          params: { id: string };
-          headers: {
-            age?: unknown;
-            authorization: string;
-          };
-          extraHeaders?: {
-            authorization?: undefined;
-            age?: undefined;
-          } & Record<string, string>;
-          fetchOptions?: FetchOptions;
-          overrideClientOptions?: Partial<OverridableClientArgs>;
-          cache?: FetchOptions['cache'];
-        };
-        createPost: {
-          body: { title: string; content: string };
-          headers: {
-            age?: unknown;
-            authorization: string;
-          };
-          extraHeaders?: {
-            authorization?: undefined;
-            age?: undefined;
-          } & Record<string, string>;
-          fetchOptions?: FetchOptions;
-          overrideClientOptions?: Partial<OverridableClientArgs>;
-          cache?: FetchOptions['cache'];
-        };
-        uploadImage: {
-          body:
-            | {
-                image: File;
-                images: File[];
-              }
-            | FormData;
-          headers: {
-            age?: unknown;
-            authorization: string;
-          };
-          extraHeaders?: {
-            authorization?: undefined;
-            age?: undefined;
-          } & Record<string, string>;
-          fetchOptions?: FetchOptions;
-          overrideClientOptions?: Partial<OverridableClientArgs>;
-          cache?: FetchOptions['cache'];
-        };
-        nested: {
-          getComments: {
-            params: { id: string };
-            headers: {
-              authorization: string;
-              'pagination-page': string;
-              age?: unknown;
-            };
-            extraHeaders?: {
-              authorization?: undefined;
-              'pagination-page'?: undefined;
-              age?: undefined;
-            } & Record<string, string>;
-            fetchOptions?: FetchOptions;
-            overrideClientOptions?: Partial<OverridableClientArgs>;
-            cache?: FetchOptions['cache'];
-          };
-        };
-      }
-    >
-  >;
-
-  /**
-   * @name ClientInferRequestWithoutBaseHeaders
-   * Expect ClientInferRequest to only include extraHeaders when no base headers are defined,
-   * demonstrating how base headers affect the client request interface
-   */
-  type ClientInferRequestWithoutBaseHeaders = Omit<
-    ClientInferRequest<typeof headerlessContract>['getPost'],
-    'next'
-  >;
-  type TestClientInferRequestWithoutBaseHeaders = Expect<
-    Equal<
-      ClientInferRequestWithoutBaseHeaders,
-      {
-        query: { includeComments?: boolean | undefined };
-        params: { id: string };
-        extraHeaders?: Record<string, string>;
-        fetchOptions?: FetchOptions;
-        overrideClientOptions?: Partial<OverridableClientArgs>;
-        cache?: FetchOptions['cache'];
-      }
-    >
-  >;
-
-  /**
-   * @name InferResponseDefinedStatusCodesBasic
-   * Expect InferResponseDefinedStatusCodes to extract all explicitly defined status codes
-   * from an endpoint's response definitions
-   */
-  type InferResponseDefinedStatusCodesBasic = InferResponseDefinedStatusCodes<
-    typeof contract.getPost
-  >;
-  type TestInferResponseDefinedStatusCodesBasic = Expect<
-    Equal<InferResponseDefinedStatusCodesBasic, 200 | 404>
-  >;
-
-  /**
-   * @name InferResponseDefinedStatusCodesFiltered
-   * Expect InferResponseDefinedStatusCodes to filter defined status codes by a specific type,
-   * only returning successful status codes that are explicitly defined
-   */
-  type InferResponseDefinedStatusCodesFiltered =
-    InferResponseDefinedStatusCodes<
-      typeof contract.getPost,
-      SuccessfulHttpStatusCode
-    >;
-  type TestInferResponseDefinedStatusCodesFiltered = Expect<
-    Equal<InferResponseDefinedStatusCodesFiltered, 200>
-  >;
-
-  /**
-   * @name InferResponseDefinedStatusCodesErrorsOnly
-   * Expect InferResponseDefinedStatusCodes to filter defined status codes by error type,
-   * only returning error status codes that are explicitly defined
-   */
-  type InferResponseDefinedStatusCodesErrorsOnly =
-    InferResponseDefinedStatusCodes<
-      typeof contract.getPost,
-      ErrorHttpStatusCode
-    >;
-  type TestInferResponseDefinedStatusCodesErrorsOnly = Expect<
-    Equal<InferResponseDefinedStatusCodesErrorsOnly, 404>
-  >;
-
-  /**
-   * @name InferResponseUndefinedStatusCodesBasic
-   * Expect InferResponseUndefinedStatusCodes to extract all status codes that are NOT explicitly defined,
-   * representing the complement of defined status codes
-   */
-  type InferResponseUndefinedStatusCodesBasic =
-    InferResponseUndefinedStatusCodes<typeof contract.getPost>;
-  type TestInferResponseUndefinedStatusCodesBasic = Expect<
-    Equal<
-      InferResponseUndefinedStatusCodesBasic,
-      Exclude<HTTPStatusCode, 200 | 404>
-    >
-  >;
-
-  /**
-   * @name InferResponseUndefinedStatusCodesSuccessFiltered
-   * Expect InferResponseUndefinedStatusCodes to extract undefined successful status codes,
-   * showing which successful codes are not explicitly defined in the endpoint
-   */
-  type InferResponseUndefinedStatusCodesSuccessFiltered =
-    InferResponseUndefinedStatusCodes<
-      typeof contract.getPost,
-      SuccessfulHttpStatusCode
-    >;
-  type TestInferResponseUndefinedStatusCodesSuccessFiltered = Expect<
-    Equal<
-      InferResponseUndefinedStatusCodesSuccessFiltered,
-      Exclude<SuccessfulHttpStatusCode, 200>
-    >
-  >;
-
-  /**
-   * @name InferResponseUndefinedStatusCodesErrorFiltered
-   * Expect InferResponseUndefinedStatusCodes to extract undefined error status codes,
-   * showing which error codes are not explicitly defined in the endpoint
-   */
-  type InferResponseUndefinedStatusCodesErrorFiltered =
-    InferResponseUndefinedStatusCodes<
-      typeof contract.getPost,
-      ErrorHttpStatusCode
-    >;
-  type TestInferResponseUndefinedStatusCodesErrorFiltered = Expect<
-    Equal<
-      InferResponseUndefinedStatusCodesErrorFiltered,
-      Exclude<ErrorHttpStatusCode, 404>
-    >
-  >;
-});
-
-describe('ClientInferRequest', () => {
-  it('standard schema - optional headers', () => {
-    const contract = c.router({
-      getPost: {
-        method: 'GET',
-        path: '/post',
-        headers: {
-          'x-foo': v.optional(v.string()),
-        },
-        responses: {
-          200: c.noBody(),
-        },
-      },
-    });
-
-    const client = initClient(contract, { baseUrl: '' });
-    const testUsage = () => client.getPost({ headers: { 'x-foo': 'string' } });
-
-    type Actual = ClientInferRequest<typeof contract.getPost>['headers'];
-    type TestResult = Expect<
-      Equal<
-        Actual,
-        {
-          'x-foo'?: string | undefined;
-        }
-      >
-    >;
-  });
-
-  it('headers zod coerce', () => {
-    const contract = c.router({
-      getPost: {
-        method: 'GET',
-        path: '/post',
-        headers: {
-          'x-foo': z.coerce.number().optional(),
-        },
-        responses: {
-          200: c.noBody(),
-        },
-      },
-    });
-
-    const client = initClient(contract, { baseUrl: '' });
-    const testUsage = () => client.getPost({ headers: { 'x-foo': 1 } });
-
-    type Actual = ClientInferRequest<typeof contract.getPost>['headers'];
-    type TestResult = Expect<Equal<Actual, { 'x-foo'?: unknown }>>;
-  });
-});
-
-describe('UnknownOrUndefinedObjectValuesToOptionalKeys', () => {
-  it('should make undefined key optional', () => {
-    type Actual = Prettify<
-      UnknownOrUndefinedObjectValuesToOptionalKeys<{
-        foo: string | undefined;
-      }>
-    >;
-    type Assert = Expect<Equal<Actual, { foo?: string | undefined }>>;
-  });
-
-  it('should make unknown key optional', () => {
-    type Actual = Prettify<
-      UnknownOrUndefinedObjectValuesToOptionalKeys<{
-        foo: unknown;
-      }>
-    >;
-    type Assert = Expect<Equal<Actual, { foo?: unknown }>>;
-  });
-
-  it('should not affect a non-empty object', () => {
-    type Actual = Prettify<
-      UnknownOrUndefinedObjectValuesToOptionalKeys<{
-        foo: string;
-      }>
-    >;
-    type Assert = Expect<Equal<Actual, { foo: string }>>;
-  });
-
-  it('should not affect an empty object', () => {
-    type Actual = Prettify<UnknownOrUndefinedObjectValuesToOptionalKeys<{}>>;
-    type Assert = Expect<Equal<Actual, {}>>;
-  });
-});