@zimic/http 0.3.2 → 0.4.0-canary.1

package/src/searchParams/HttpSearchParams.ts

@@ -1,12 +1,17 @@
 import { ReplaceBy, ArrayItemIfArray } from '@zimic/utils/types';
 
-import { HttpSearchParamsSchema, HttpSearchParamsInit, HttpSearchParamsSchemaName } from './types';
-
-function pickPrimitiveProperties<Schema extends HttpSearchParamsSchema>(schema: Schema) {
+import {
+  HttpSearchParamsSchema,
+  HttpSearchParamsInit,
+  HttpSearchParamsSchemaName,
+  HttpSearchParamsSerialized,
+} from './types';
+
+function pickPrimitiveProperties<Schema extends HttpSearchParamsSchema.Loose>(schema: Schema) {
   const schemaWithPrimitiveProperties = Object.entries(schema).reduce<Record<string, string>>(
     (accumulated, [key, value]) => {
       if (value !== undefined && !Array.isArray(value)) {
-        accumulated[key] = value;
+        accumulated[key] = String(value);
       }
       return accumulated;
     },
@@ -41,8 +46,11 @@ function pickPrimitiveProperties<Schema extends HttpSearchParamsSchema>(schema:
  *
  * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http#httpsearchparams `HttpSearchParams` API reference}
  */
-class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsSchema> extends URLSearchParams {
-  constructor(init?: HttpSearchParamsInit<Schema>) {
+class HttpSearchParams<
+  LooseSchema extends HttpSearchParamsSchema.Loose = HttpSearchParamsSchema.Loose,
+  Schema extends HttpSearchParamsSchema = HttpSearchParamsSerialized<LooseSchema>,
+> extends URLSearchParams {
+  constructor(init?: HttpSearchParamsInit<LooseSchema>) {
     if (init instanceof URLSearchParams || Array.isArray(init) || typeof init === 'string' || !init) {
       super(init);
     } else {
@@ -51,11 +59,11 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
     }
   }
 
-  private populateInitArrayProperties(init: Schema) {
+  private populateInitArrayProperties(init: LooseSchema) {
     for (const [key, value] of Object.entries(init)) {
       if (Array.isArray(value)) {
-        for (const item of value) {
-          super.append(key, item);
+        for (const item of value as unknown[]) {
+          super.append(key, String(item));
         }
       }
     }
@@ -64,7 +72,7 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
   /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/set MDN Reference} */
   set<Name extends HttpSearchParamsSchemaName<Schema>>(
     name: Name,
-    value: ArrayItemIfArray<NonNullable<Schema[Name]>>,
+    value: ArrayItemIfArray<NonNullable<LooseSchema[Name]>>,
   ): void {
     super.set(name, value);
   }
@@ -72,7 +80,7 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
   /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/append MDN Reference} */
   append<Name extends HttpSearchParamsSchemaName<Schema>>(
     name: Name,
-    value: ArrayItemIfArray<NonNullable<Schema[Name]>>,
+    value: ArrayItemIfArray<NonNullable<LooseSchema[Name]>>,
   ): void {
     super.append(name, value);
   }
@@ -110,7 +118,7 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
   /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/has MDN Reference} */
   has<Name extends HttpSearchParamsSchemaName<Schema>>(
     name: Name,
-    value?: ArrayItemIfArray<NonNullable<Schema[Name]>>,
+    value?: ArrayItemIfArray<NonNullable<LooseSchema[Name]>>,
   ): boolean {
     return super.has(name, value);
   }
@@ -118,7 +126,7 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
   /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/delete MDN Reference} */
   delete<Name extends HttpSearchParamsSchemaName<Schema>>(
     name: Name,
-    value?: ArrayItemIfArray<NonNullable<Schema[Name]>>,
+    value?: ArrayItemIfArray<NonNullable<LooseSchema[Name]>>,
   ): void {
     super.delete(name, value);
   }
@@ -170,7 +178,7 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
    * @param otherParams The other search parameters to compare against.
    * @returns `true` if the search parameters are equal, `false` otherwise.
    */
-  equals<OtherSchema extends Schema>(otherParams: HttpSearchParams<OtherSchema>): boolean {
+  equals<OtherSchema extends LooseSchema>(otherParams: HttpSearchParams<OtherSchema>): boolean {
     return this.contains(otherParams) && this.size === otherParams.size;
   }
 
@@ -182,7 +190,7 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
    * @param otherParams The other search parameters to check for containment.
    * @returns `true` if these search parameters contain the other search parameters, `false` otherwise.
    */
-  contains<OtherSchema extends Schema>(otherParams: HttpSearchParams<OtherSchema>): boolean {
+  contains<OtherSchema extends LooseSchema>(otherParams: HttpSearchParams<OtherSchema>): boolean {
     for (const [key, otherValue] of otherParams.entries()) {
       const values = super.getAll.call(this, key);
 

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

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,5 +1,5 @@
 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';
 
@@ -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,
   StatusCode extends number = number,
-  StrictHeadersSchema extends HttpHeadersSchema = HttpHeadersSchema,
+  StrictHeadersSchema extends HttpHeadersSchema.Loose = HttpHeadersSchema.Loose,
 > extends Response {
   ok: StatusCode extends HttpStatusCode.Information | HttpStatusCode.Success | HttpStatusCode.Redirection
     ? true
@@ -96,13 +93,11 @@ export interface HttpResponse<
   clone: () => this;
 }
 
-export type HttpRequestHeadersSchema<MethodSchema extends HttpMethodSchema> = Default<
-  Default<MethodSchema['request']>['headers']
->;
+export type HttpRequestHeadersSchema<MethodSchema extends HttpMethodSchema> =
+  'headers' extends keyof MethodSchema['request'] ? Default<MethodSchema['request']>['headers'] : never;
 
-export type HttpRequestSearchParamsSchema<MethodSchema extends HttpMethodSchema> = Default<
-  Default<MethodSchema['request']>['searchParams']
->;
+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>,
@@ -113,7 +108,9 @@ export type HttpRequestBodySchema<MethodSchema extends HttpMethodSchema> = Repla
 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<Default<MethodSchema['response']>[StatusCode]>['headers']
+  : never;
 
 export type HttpResponseBodySchema<
   MethodSchema extends HttpMethodSchema,