@zimic/http 0.4.0-canary.0 → 0.4.0-canary.2

package/src/searchParams/types.ts

@@ -14,7 +14,7 @@ export namespace HttpSearchParamsSchema {
 }
 
 /** A strict tuple representation of a {@link HttpSearchParamsSchema}. */
-export type HttpSearchParamsSchemaTuple<Schema extends HttpSearchParamsSchema = HttpSearchParamsSchema> = {
+export type HttpSearchParamsSchemaTuple<Schema extends HttpSearchParamsSchema.Loose = HttpSearchParamsSchema.Loose> = {
   [Key in keyof Schema & string]: [Key, ArrayItemIfArray<NonNullable<Schema[Key]>>];
 }[keyof Schema & string];
 
@@ -22,7 +22,7 @@ export type HttpSearchParamsSchemaTuple<Schema extends HttpSearchParamsSchema =
  * An initialization value for
  * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http#httpsearchparams `HttpSearchParams`}.
  */
-export type HttpSearchParamsInit<Schema extends HttpSearchParamsSchema = HttpSearchParamsSchema> =
+export type HttpSearchParamsInit<Schema extends HttpSearchParamsSchema.Loose = HttpSearchParamsSchema.Loose> =
   | string
   | URLSearchParams
   | Schema
@@ -72,62 +72,56 @@ export type HttpSearchParamsSchemaName<Schema extends HttpSearchParamsSchema> =
   keyof Schema & string
 >;
 
-type PrimitiveHttpSearchParamsSerialized<Type> = Type extends HttpSearchParamsSchema[string]
-  ? Type
-  : Type extends (infer ArrayItem)[]
-    ? ArrayItem extends (infer _InternalArrayItem)[]
-      ? never
-      : PrimitiveHttpSearchParamsSerialized<ArrayItem>[]
-    : Type extends number
-      ? `${number}`
-      : Type extends boolean
-        ? `${boolean}`
-        : Type extends null
-          ? undefined
-          : never;
+type PrimitiveHttpSearchParamsSerialized<Type> = [Type] extends [never]
+  ? never
+  : Type extends number
+    ? `${number}`
+    : Type extends boolean
+      ? `${boolean}`
+      : Type extends null
+        ? 'null'
+        : Type extends symbol
+          ? never
+          : Type extends HttpSearchParamsSchema[string]
+            ? Type
+            : Type extends (infer ArrayItem)[]
+              ? ArrayItem extends (infer _InternalArrayItem)[]
+                ? string
+                : PrimitiveHttpSearchParamsSerialized<ArrayItem>[]
+              : string;
 
 /**
  * Recursively converts a schema to its
- * {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams URLSearchParams}-serialized version. Numbers and
- * booleans are converted to `${number}` and `${boolean}` respectively, null becomes undefined and not serializable
- * values are excluded, such as functions and dates.
+ * {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams URLSearchParams}-serialized version. Numbers,
+ * booleans, and null are converted to `${number}`, `${boolean}`, and 'null' respectively, and other values become
+ * strings.
  *
  * @example
  *   import { type HttpSearchParamsSerialized } from '@zimic/http';
  *
  *   type Params = HttpSearchParamsSerialized<{
- *     query: string | null;
+ *     query?: string;
+ *     order: 'asc' | 'desc' | null;
  *     page?: number;
  *     full?: boolean;
- *     date: Date;
- *     method: () => void;
  *   }>;
  *   // {
- *   //   query: string | undefined;
+ *   //   query?: string;
+ *   //   order: 'asc' | 'desc' | 'null';
  *   //   page?: `${number}`;
  *   //   full?: "false" | "true";
  *   // }
  */
-export type HttpSearchParamsSerialized<Type> = Type extends HttpSearchParamsSchema
-  ? Type
-  : Type extends (infer _ArrayItem)[]
-    ? never
-    : Type extends Date
-      ? never
-      : Type extends (...parameters: never[]) => unknown
-        ? never
-        : Type extends symbol
-          ? never
-          : Type extends Map<infer _Key, infer _Value>
-            ? never
-            : Type extends Set<infer _Value>
-              ? never
-              : Type extends object
-                ? {
-                    [Key in keyof Type as IfNever<
-                      PrimitiveHttpSearchParamsSerialized<Type[Key]>,
-                      never,
-                      Key
-                    >]: PrimitiveHttpSearchParamsSerialized<Type[Key]>;
-                  }
-                : never;
+export type HttpSearchParamsSerialized<Type> = [Type] extends [never]
+  ? never
+  : Type extends HttpSearchParamsSchema
+    ? Type
+    : Type extends object
+      ? {
+          [Key in keyof Type as IfNever<
+            PrimitiveHttpSearchParamsSerialized<Type[Key]>,
+            never,
+            Key
+          >]: PrimitiveHttpSearchParamsSerialized<Type[Key]>;
+        }
+      : never;

package/src/typegen/openapi/transform/components.ts

@@ -264,16 +264,6 @@ function processPendingRequestComponentActions(component: RequestComponent, cont
   return { bodyQuestionToken };
 }
 
-function wrapRequestComponentType(type: ts.TypeNode, context: TypeTransformContext) {
-  context.typeImports.http.add('HttpSchema');
-
-  const httpSchemaRequestWrapper = ts.factory.createQualifiedName(
-    ts.factory.createIdentifier('HttpSchema'),
-    ts.factory.createIdentifier('Request'),
-  );
-  return ts.factory.createTypeReferenceNode(httpSchemaRequestWrapper, [type]);
-}
-
 function normalizeRequestComponent(component: Component, context: TypeTransformContext) {
   /* istanbul ignore if -- @preserve
    * Component group members in `requests` are always expected the be request components. */
@@ -289,7 +279,7 @@ function normalizeRequestComponent(component: Component, context: TypeTransformC
     component.modifiers,
     component.name,
     component.questionToken,
-    wrapRequestComponentType(newType, context),
+    newType,
   );
 }
 

package/src/typegen/openapi/transform/context.ts

@@ -10,10 +10,7 @@ export interface TypePathFilters {
 type HttpTypeImportName =
   | 'HttpSchema'
   | 'HttpFormData'
-  | 'HttpFormDataSerialized'
   | 'HttpSearchParams'
-  | 'HttpSearchParamsSerialized'
-  | 'HttpHeadersSerialized'
   | 'HttpStatusCode'
   | 'MergeHttpResponsesByStatusCode';
 

package/src/typegen/openapi/transform/methods.ts

@@ -65,22 +65,10 @@ function isRequestHeaders(node: ts.Node): node is RequestHeaders {
   return isRequestMember(node) && node.name.text === 'headers' && ts.isTypeLiteralNode(node.type);
 }
 
-type NormalizedRequestHeaders = Override<
-  RequestHeaders,
-  {
-    type: Override<ts.TypeReferenceNode, { typeArguments: ts.NodeArray<ts.TypeLiteralNode> }>;
-  }
->;
+type NormalizedRequestHeaders = Override<RequestHeaders, { type: ts.TypeLiteralNode }>;
 
 function isNormalizedRequestHeaders(node: ts.Node): node is NormalizedRequestHeaders {
-  return (
-    isRequestMember(node) &&
-    node.name.text === 'headers' &&
-    ts.isTypeReferenceNode(node.type) &&
-    node.type.typeArguments !== undefined &&
-    node.type.typeArguments.length === 1 &&
-    ts.isTypeLiteralNode(node.type.typeArguments[0])
-  );
+  return isRequestMember(node) && node.name.text === 'headers' && ts.isTypeLiteralNode(node.type);
 }
 
 type RequestParameters = Override<RequestMember, { type: ts.TypeLiteralNode }>;
@@ -170,23 +158,17 @@ function removeRedundantNullUnionIfNecessary(type: ts.TypeNode) {
 
 function wrapFormDataContentType(type: ts.TypeNode, context: TypeTransformContext) {
   context.typeImports.http.add('HttpFormData');
-  context.typeImports.http.add('HttpFormDataSerialized');
 
   return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('HttpFormData'), [
-    ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('HttpFormDataSerialized'), [
-      renameComponentReferences(type, context),
-    ]),
+    renameComponentReferences(type, context),
   ]);
 }
 
 function wrapURLEncodedContentType(type: ts.TypeNode, context: TypeTransformContext) {
   context.typeImports.http.add('HttpSearchParams');
-  context.typeImports.http.add('HttpSearchParamsSerialized');
 
   return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('HttpSearchParams'), [
-    ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('HttpSearchParamsSerialized'), [
-      renameComponentReferences(type, context),
-    ]),
+    renameComponentReferences(type, context),
   ]);
 }
 
@@ -224,18 +206,7 @@ function normalizeRequestBodyMember(
   };
 }
 
-function wrapHeadersType(type: ts.TypeLiteralNode, context: TypeTransformContext): NormalizedRequestHeaders['type'] {
-  context.typeImports.http.add('HttpHeadersSerialized');
-
-  const serializedWrapper = ts.factory.createIdentifier('HttpHeadersSerialized');
-
-  return ts.factory.createTypeReferenceNode(
-    serializedWrapper,
-    ts.factory.createNodeArray([type]) satisfies NormalizedRequestHeaders['type']['typeArguments'],
-  ) as NormalizedRequestHeaders['type'];
-}
-
-function normalizeHeaders(headers: ts.TypeLiteralNode, context: TypeTransformContext) {
+function normalizeHeaders(headers: ts.TypeLiteralNode) {
   const newHeaderMembers = headers.members.filter((header) => {
     if (ts.isIndexSignatureDeclaration(header)) {
       return false;
@@ -253,19 +224,15 @@ function normalizeHeaders(headers: ts.TypeLiteralNode, context: TypeTransformCon
     return undefined;
   }
 
-  const newHeaders = ts.factory.updateTypeLiteralNode(headers, ts.factory.createNodeArray(newHeaderMembers));
-  return wrapHeadersType(newHeaders, context);
+  return ts.factory.updateTypeLiteralNode(headers, ts.factory.createNodeArray(newHeaderMembers));
 }
 
-function normalizeRequestHeaders(
-  requestHeader: ts.TypeElement,
-  context: TypeTransformContext,
-): NormalizedRequestHeaders | undefined {
+function normalizeRequestHeaders(requestHeader: ts.TypeElement): NormalizedRequestHeaders | undefined {
   if (!isRequestHeaders(requestHeader)) {
     return undefined;
   }
 
-  const newType = normalizeHeaders(requestHeader.type, context);
+  const newType = normalizeHeaders(requestHeader.type);
 
   if (!newType) {
     return undefined;
@@ -283,20 +250,16 @@ function normalizeRequestHeaders(
 function createHeaderForUnionByContentType(
   existingHeader: NormalizedRequestHeaders | undefined,
   contentTypeName: string,
-  context: TypeTransformContext,
 ) {
-  const existingHeaderMembers = existingHeader ? existingHeader.type.typeArguments[0].members : [];
+  const existingHeaderMembers = existingHeader?.type.members ?? [];
 
   const contentTypeIdentifier = ts.factory.createIdentifier('"content-type"');
   const contentTypeValue = ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(contentTypeName));
 
-  const newHeaderType = wrapHeadersType(
-    ts.factory.createTypeLiteralNode([
-      ts.factory.createPropertySignature(undefined, contentTypeIdentifier, undefined, contentTypeValue),
-      ...existingHeaderMembers,
-    ]),
-    context,
-  );
+  const newHeaderType = ts.factory.createTypeLiteralNode([
+    ts.factory.createPropertySignature(undefined, contentTypeIdentifier, undefined, contentTypeValue),
+    ...existingHeaderMembers,
+  ]);
 
   return ts.factory.createPropertySignature(
     existingHeader?.modifiers,
@@ -321,7 +284,7 @@ export function normalizeContentType(
     return contentType;
   }
 
-  const newHeader = contentType.members.map((member) => normalizeRequestHeaders(member, context)).find(isDefined);
+  const newHeader = contentType.members.map(normalizeRequestHeaders).find(isDefined);
 
   const newBodyMembers = contentType.members.flatMap((body) => {
     if (isContentPropertySignature(body)) {
@@ -338,7 +301,7 @@ export function normalizeContentType(
     return ts.factory.updateTypeLiteralNode(contentType, ts.factory.createNodeArray(newMembers));
   } else {
     const bodyMemberUnionTypes = newBodyMembers.map((bodyMember) => {
-      const headerMember = createHeaderForUnionByContentType(newHeader, bodyMember.contentTypeName, context);
+      const headerMember = createHeaderForUnionByContentType(newHeader, bodyMember.contentTypeName);
       return ts.factory.createTypeLiteralNode([headerMember, bodyMember.propertySignature]);
     });
 
@@ -366,29 +329,18 @@ function normalizeRequest(request: MethodMember, context: TypeTransformContext)
   return ts.factory.updatePropertySignature(request, request.modifiers, newIdentifier, undefined, newType);
 }
 
-function wrapResponseType(type: ts.TypeNode, context: TypeTransformContext) {
-  context.typeImports.http.add('HttpSchema');
-
-  const httpSchemaResponseWrapper = ts.factory.createQualifiedName(
-    ts.factory.createIdentifier('HttpSchema'),
-    ts.factory.createIdentifier('Response'),
-  );
-  return ts.factory.createTypeReferenceNode(httpSchemaResponseWrapper, [type]);
-}
-
 function normalizeResponseType(
   responseType: ts.TypeNode,
   context: TypeTransformContext,
-  options: { isComponent: boolean; questionToken?: ts.QuestionToken },
+  options: { questionToken?: ts.QuestionToken },
 ) {
-  const { isComponent, questionToken } = options;
+  const { questionToken } = options;
 
   if (!ts.isTypeLiteralNode(responseType)) {
     return responseType;
   }
 
-  const newType = normalizeContentType(responseType, context, { bodyQuestionToken: questionToken });
-  return isComponent ? wrapResponseType(newType, context) : newType;
+  return normalizeContentType(responseType, context, { bodyQuestionToken: questionToken });
 }
 
 const NON_NUMERIC_RESPONSE_STATUS_TO_MAPPED_TYPE: Record<string, string | undefined> = {
@@ -414,7 +366,6 @@ export function normalizeResponse(
   }
 
   const newType = normalizeResponseType(response.type, context, {
-    isComponent,
     questionToken: response.questionToken,
   });
 
@@ -552,17 +503,12 @@ function normalizeRequestQueryWithParameters(requestMember: RequestMember, conte
 
   const newType = renameComponentReferences(requestMember.type, context);
 
-  context.typeImports.http.add('HttpSearchParamsSerialized');
-
-  const serializedWrapper = ts.factory.createIdentifier('HttpSearchParamsSerialized');
-  const wrappedNewType = ts.factory.createTypeReferenceNode(serializedWrapper, [newType]);
-
   return ts.factory.updatePropertySignature(
     requestMember,
     requestMember.modifiers,
     newIdentifier,
     newQuestionToken,
-    wrappedNewType,
+    newType,
   );
 }
 
@@ -572,17 +518,12 @@ function normalizeRequestHeadersWithParameters(requestMember: RequestMember, con
 
   const newType = renameComponentReferences(requestMember.type, context);
 
-  context.typeImports.http.add('HttpHeadersSerialized');
-
-  const serializedWrapper = ts.factory.createIdentifier('HttpHeadersSerialized');
-  const wrappedNewType = ts.factory.createTypeReferenceNode(serializedWrapper, [newType]);
-
   return ts.factory.updatePropertySignature(
     requestMember,
     requestMember.modifiers,
     newIdentifier,
     newQuestionToken,
-    wrappedNewType,
+    newType,
   );
 }
 
@@ -602,16 +543,10 @@ function normalizeRequestMemberWithParameters(requestMember: ts.TypeElement, con
 }
 
 function mergeRequestHeadersMember(headers: NormalizedRequestHeaders, otherHeaders: NormalizedRequestHeaders) {
-  const headersTypeLiteral = headers.type.typeArguments[0];
-  const otherHeadersTypeLiteral = otherHeaders.type.typeArguments[0];
-
-  const newType = ts.factory.updateTypeReferenceNode(
+  const newType = ts.factory.updateTypeLiteralNode(
     headers.type,
-    headers.type.typeName,
-    ts.factory.createNodeArray([
-      ts.factory.createTypeLiteralNode([...otherHeadersTypeLiteral.members, ...headersTypeLiteral.members]),
-    ]) satisfies NormalizedRequestHeaders['type']['typeArguments'],
-  ) as NormalizedRequestHeaders['type'];
+    ts.factory.createNodeArray([...otherHeaders.type.members, ...headers.type.members]),
+  );
 
   return ts.factory.updatePropertySignature(
     headers,

package/src/typegen/openapi/transform/operations.ts

@@ -36,16 +36,6 @@ function isOperation(node: ts.Node): node is Operation {
   );
 }
 
-function wrapOperationType(type: ts.TypeLiteralNode, context: TypeTransformContext) {
-  context.typeImports.http.add('HttpSchema');
-
-  const httpSchemaMethodWrapper = ts.factory.createQualifiedName(
-    ts.factory.createIdentifier('HttpSchema'),
-    ts.factory.createIdentifier('Method'),
-  );
-  return ts.factory.createTypeReferenceNode(httpSchemaMethodWrapper, [type]);
-}
-
 function normalizeOperation(operation: ts.TypeElement, context: TypeTransformContext) {
   /* istanbul ignore if -- @preserve
    * Operation members are always expected to be an operation. */
@@ -60,7 +50,7 @@ function normalizeOperation(operation: ts.TypeElement, context: TypeTransformCon
     operation.modifiers,
     operation.name,
     operation.questionToken,
-    wrapOperationType(newType, context),
+    newType,
   );
 }
 

package/src/typegen/openapi/transform/paths.ts

@@ -41,16 +41,6 @@ function normalizePathNameWithParameters(pathName: string) {
   return pathName.replace(/{([^}]+)}/g, ':$1');
 }
 
-function wrapComponentPathType(type: ts.TypeNode, context: TypeTransformContext) {
-  context.typeImports.http.add('HttpSchema');
-
-  const httpSchemaMethodsWrapper = ts.factory.createQualifiedName(
-    ts.factory.createIdentifier('HttpSchema'),
-    ts.factory.createIdentifier('Methods'),
-  );
-  return ts.factory.createTypeReferenceNode(httpSchemaMethodsWrapper, [type]);
-}
-
 export function normalizePath(
   path: ts.TypeElement,
   context: TypeTransformContext,
@@ -83,13 +73,7 @@ export function normalizePath(
     newType = renameComponentReferences(path.type, context);
   }
 
-  return ts.factory.updatePropertySignature(
-    path,
-    path.modifiers,
-    newIdentifier,
-    path.questionToken,
-    isComponent ? wrapComponentPathType(newType, context) : newType,
-  );
+  return ts.factory.updatePropertySignature(path, path.modifiers, newIdentifier, path.questionToken, newType);
 }
 
 function wrapPathsType(type: ts.TypeLiteralNode, context: TypeTransformContext) {

package/src/types/requests.ts

@@ -1,7 +1,7 @@
 import { Default, DefaultNoExclude, IfNever, ReplaceBy } from '@zimic/utils/types';
-import { JSONSerialized, JSONValue } from '@zimic/utils/types/json';
+import { JSONValue } from '@zimic/utils/types/json';
 
-import { HttpMethodSchema, HttpStatusCode } from '@/types/schema';
+import { HttpMethodSchema, HttpRequestSchema, HttpResponseSchema, HttpStatusCode } from '@/types/schema';
 
 import HttpFormData from '../formData/HttpFormData';
 import { HttpFormDataSchema } from '../formData/types';
@@ -17,16 +17,13 @@ export type HttpBody = JSONValue | HttpFormData<any> | HttpSearchParams<any> | B
 export namespace HttpBody {
   /** A loose version of the HTTP body type. JSON values are not strictly typed. */
   export type Loose = ReplaceBy<HttpBody, JSONValue, JSONValue.Loose>;
-
-  /** Convert an HTTP body to be strictly typed. JSON values are serialized to their strict form. */
-  export type AsStrict<Type> = Type extends Exclude<HttpBody, JSONValue> ? Type : JSONSerialized<Type>;
 }
 
 /**
  * An HTTP headers object with a strictly-typed schema. Fully compatible with the built-in
  * {@link https://developer.mozilla.org/docs/Web/API/Headers `Headers`} class.
  */
-export type StrictHeaders<Schema extends HttpHeadersSchema = HttpHeadersSchema> = Pick<
+export type StrictHeaders<Schema extends HttpHeadersSchema.Loose = HttpHeadersSchema.Loose> = Pick<
   HttpHeaders<Schema>,
   keyof Headers
 >;
@@ -35,7 +32,7 @@ export type StrictHeaders<Schema extends HttpHeadersSchema = HttpHeadersSchema>
  * An HTTP search params object with a strictly-typed schema. Fully compatible with the built-in
  * {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams `URLSearchParams`} class.
  */
-export type StrictURLSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsSchema> = Pick<
+export type StrictURLSearchParams<Schema extends HttpSearchParamsSchema.Loose = HttpSearchParamsSchema.Loose> = Pick<
   HttpSearchParams<Schema>,
   keyof URLSearchParams
 >;
@@ -44,7 +41,7 @@ export type StrictURLSearchParams<Schema extends HttpSearchParamsSchema = HttpSe
  * An HTTP form data object with a strictly-typed schema. Fully compatible with the built-in
  * {@link https://developer.mozilla.org/docs/Web/API/FormData `FormData`} class.
  */
-export type StrictFormData<Schema extends HttpFormDataSchema = HttpFormDataSchema> = Pick<
+export type StrictFormData<Schema extends HttpFormDataSchema.Loose = HttpFormDataSchema.Loose> = Pick<
   HttpFormData<Schema>,
   keyof FormData
 >;
@@ -54,8 +51,8 @@ export type StrictFormData<Schema extends HttpFormDataSchema = HttpFormDataSchem
  * {@link https://developer.mozilla.org/docs/Web/API/Request `Request`} class.
  */
 export interface HttpRequest<
-  StrictBody extends HttpBody.Loose = HttpBody,
-  StrictHeadersSchema extends HttpHeadersSchema = HttpHeadersSchema,
+  StrictBody extends HttpBody.Loose = HttpBody.Loose,
+  StrictHeadersSchema extends HttpHeadersSchema.Loose = HttpHeadersSchema.Loose,
 > extends Request {
   headers: StrictHeaders<StrictHeadersSchema>;
   text: () => Promise<StrictBody extends string ? StrictBody : string>;
@@ -75,9 +72,9 @@ export interface HttpRequest<
  * {@link https://developer.mozilla.org/docs/Web/API/Response `Response`} class.
  */
 export interface HttpResponse<
-  StrictBody extends HttpBody.Loose = HttpBody,
+  StrictBody extends HttpBody.Loose = HttpBody.Loose,
+  StrictHeadersSchema extends HttpHeadersSchema.Loose = HttpHeadersSchema.Loose,
   StatusCode extends number = number,
-  StrictHeadersSchema extends HttpHeadersSchema = HttpHeadersSchema,
 > extends Response {
   ok: StatusCode extends HttpStatusCode.Information | HttpStatusCode.Success | HttpStatusCode.Redirection
     ? true
@@ -96,13 +93,35 @@ export interface HttpResponse<
   clone: () => this;
 }
 
-export type HttpRequestHeadersSchema<MethodSchema extends HttpMethodSchema> = Default<
-  Default<MethodSchema['request']>['headers']
->;
+type HttpRequestHeadersSchemaFromBody<
+  RequestSchema extends HttpRequestSchema,
+  DefaultHeadersSchema,
+> = 'body' extends keyof RequestSchema
+  ? [RequestSchema['body']] extends [never]
+    ? DefaultHeadersSchema
+    : [Extract<RequestSchema['body'], BodyInit | HttpFormData | HttpSearchParams>] extends [never]
+      ? 'headers' extends keyof RequestSchema
+        ? [RequestSchema['headers']] extends [never]
+          ? DefaultHeadersSchema
+          : 'content-type' extends keyof Default<RequestSchema['headers']>
+            ? DefaultHeadersSchema
+            : { 'content-type': 'application/json' }
+        : { 'content-type': 'application/json' }
+      : DefaultHeadersSchema
+  : DefaultHeadersSchema;
 
-export type HttpRequestSearchParamsSchema<MethodSchema extends HttpMethodSchema> = Default<
-  Default<MethodSchema['request']>['searchParams']
->;
+export type HttpRequestHeadersSchema<MethodSchema extends HttpMethodSchema> =
+  'headers' extends keyof MethodSchema['request']
+    ? [MethodSchema['request']['headers']] extends [never]
+      ? HttpRequestHeadersSchemaFromBody<Default<MethodSchema['request']>, never>
+      :
+          | (MethodSchema['request']['headers'] &
+              HttpRequestHeadersSchemaFromBody<Default<MethodSchema['request']>, {}>)
+          | (MethodSchema['request']['headers'] & undefined)
+    : HttpRequestHeadersSchemaFromBody<Default<MethodSchema['request']>, never>;
+
+export type HttpRequestSearchParamsSchema<MethodSchema extends HttpMethodSchema> =
+  'searchParams' extends keyof MethodSchema['request'] ? Default<MethodSchema['request']>['searchParams'] : never;
 
 export type HttpRequestBodySchema<MethodSchema extends HttpMethodSchema> = ReplaceBy<
   ReplaceBy<IfNever<DefaultNoExclude<Default<MethodSchema['request']>['body']>, null>, undefined, null>,
@@ -110,10 +129,32 @@ export type HttpRequestBodySchema<MethodSchema extends HttpMethodSchema> = Repla
   Blob
 >;
 
+type HttpResponseHeadersSchemaFromBody<
+  ResponseSchema extends HttpResponseSchema,
+  DefaultHeadersSchema,
+> = 'body' extends keyof ResponseSchema
+  ? [ResponseSchema['body']] extends [never]
+    ? DefaultHeadersSchema
+    : [Extract<ResponseSchema['body'], BodyInit | HttpSearchParams | HttpFormData>] extends [never]
+      ? 'headers' extends keyof ResponseSchema
+        ? [ResponseSchema['headers']] extends [never]
+          ? DefaultHeadersSchema
+          : 'content-type' extends keyof Default<ResponseSchema['headers']>
+            ? DefaultHeadersSchema
+            : { 'content-type': 'application/json' }
+        : { 'content-type': 'application/json' }
+      : DefaultHeadersSchema
+  : DefaultHeadersSchema;
+
 export type HttpResponseHeadersSchema<
   MethodSchema extends HttpMethodSchema,
   StatusCode extends HttpStatusCode,
-> = Default<DefaultNoExclude<Default<Default<MethodSchema['response']>[StatusCode]>['headers']>>;
+> = 'headers' extends keyof Default<MethodSchema['response']>[StatusCode]
+  ? [Default<MethodSchema['response']>[StatusCode]] extends [never]
+    ? HttpResponseHeadersSchemaFromBody<Default<Default<MethodSchema['response']>[StatusCode]>, never>
+    : Default<Default<MethodSchema['response']>[StatusCode]>['headers'] &
+        HttpResponseHeadersSchemaFromBody<Default<Default<MethodSchema['response']>[StatusCode]>, {}>
+  : HttpResponseHeadersSchemaFromBody<Default<Default<MethodSchema['response']>[StatusCode]>, never>;
 
 export type HttpResponseBodySchema<
   MethodSchema extends HttpMethodSchema,