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

package/dist/index.d.ts

@@ -82,6 +82,15 @@ type ArrayKey<Type> = keyof PickArrayProperties<Type>;
 type NonArrayKey<Type> = string | number extends ArrayKey<Type> ? keyof Type : Exclude<keyof Type, ArrayKey<Type>>;
 type NonEmptyArray<Type> = [Type, ...Type[]];
 type ReplaceBy<Type, Source, Target> = Type extends Source ? Target : Type;
+declare const brand: unique symbol;
+/**
+ * A utility type to create a branded type. This is useful for creating types that are distinct from each other even if
+ * they have the same underlying structure. It also helps the TypeScript compiler to reference the type in the generated
+ * declaration files, rather than inlining it.
+ */
+type Branded<Type, Brand extends string> = Type & {
+    [brand]?: Brand;
+};
 
 /** A schema for strict HTTP form data. */
 interface HttpFormDataSchema {
@@ -127,31 +136,29 @@ declare namespace HttpFormDataSchemaName {
  *   // "title" | "content"
  */
 type HttpFormDataSchemaName<Schema extends HttpFormDataSchema> = IfNever<Schema, never, keyof Schema & string>;
-type PrimitiveHttpFormDataSerialized<Type> = Type extends HttpFormDataSchema[string] ? Type : Type extends (infer ArrayItem)[] ? ArrayItem extends (infer _InternalArrayItem)[] ? never : PrimitiveHttpFormDataSerialized<ArrayItem>[] : Type extends number ? `${number}` : Type extends boolean ? `${boolean}` : never;
+type PrimitiveHttpFormDataSerialized<Type> = [Type] extends [never] ? never : Type extends number ? `${number}` : Type extends boolean ? `${boolean}` : Type extends null ? 'null' : Type extends symbol ? never : Type extends HttpFormDataSchema[string] ? Type : Type extends (infer ArrayItem)[] ? ArrayItem extends (infer _InternalArrayItem)[] ? never : PrimitiveHttpFormDataSerialized<ArrayItem>[] : string;
 /**
  * Recursively converts a schema to its {@link https://developer.mozilla.org/docs/Web/API/FormData FormData}-serialized
- * version. Numbers and booleans are converted to `${number}` and `${boolean}` respectively, and not serializable values
- * are excluded, such as functions and dates.
+ * version. Numbers, booleans, and null are converted to `${number}`, `${boolean}`, and 'null' respectively, and other
+ * values become strings.
  *
  * @example
  *   import { type HttpFormDataSerialized } from '@zimic/http';
  *
  *   type Schema = HttpFormDataSerialized<{
- *     contentTitle: string | null;
- *     contentSize: number;
+ *     contentTitle: string;
+ *     contentSize: number | null;
  *     content: Blob;
  *     full?: boolean;
- *     date: Date;
- *     method: () => void;
  *   }>;
  *   // {
- *   //   contentTitle: string | null;
- *   //   contentSize? `${number}`;
+ *   //   contentTitle: string;
+ *   //   contentSize? `${number}` | 'null';
  *   //   content: Blob;
  *   //   full?: "false" | "true";
  *   // }
  */
-type HttpFormDataSerialized<Type> = Type extends HttpFormDataSchema ? 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 ? {
+type HttpFormDataSerialized<Type> = [Type] extends [never] ? never : Type extends HttpFormDataSchema ? Type : Type extends object ? {
     [Key in keyof Type as IfNever<PrimitiveHttpFormDataSerialized<Type[Key]>, never, Key>]: PrimitiveHttpFormDataSerialized<Type[Key]>;
 } : never;
 
@@ -181,13 +188,14 @@ type HttpFormDataSerialized<Type> = Type extends HttpFormDataSchema ? Type : Typ
  *
  * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http#httpformdata `HttpFormData` API reference}
  */
-declare class HttpFormData<Schema extends HttpFormDataSchema = HttpFormDataSchema> extends FormData {
+declare class HttpFormData<LooseSchema extends HttpFormDataSchema.Loose = HttpFormDataSchema.Loose> extends FormData {
+    readonly _schema: HttpFormDataSerialized<LooseSchema>;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/set MDN Reference} */
-    set<Name extends HttpFormDataSchemaName<Schema>>(name: Name, value: Exclude<ArrayItemIfArray<NonNullable<Schema[Name]>>, Blob>): void;
-    set<Name extends HttpFormDataSchemaName<Schema>>(name: Name, blob: Exclude<ArrayItemIfArray<NonNullable<Schema[Name]>>, string>, fileName?: string): void;
+    set<Name extends HttpFormDataSchemaName<this['_schema']>>(name: Name, value: Exclude<ArrayItemIfArray<NonNullable<LooseSchema[Name]>>, Blob>): void;
+    set<Name extends HttpFormDataSchemaName<this['_schema']>>(name: Name, blob: Exclude<ArrayItemIfArray<NonNullable<LooseSchema[Name]>>, string>, fileName?: string): void;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/append MDN Reference} */
-    append<Name extends HttpFormDataSchemaName<Schema>>(name: Name, value: Exclude<ArrayItemIfArray<NonNullable<Schema[Name]>>, Blob>): void;
-    append<Name extends HttpFormDataSchemaName<Schema>>(name: Name, blob: Exclude<ArrayItemIfArray<NonNullable<Schema[Name]>>, string>, fileName?: string): void;
+    append<Name extends HttpFormDataSchemaName<this['_schema']>>(name: Name, value: Exclude<ArrayItemIfArray<NonNullable<LooseSchema[Name]>>, Blob>): void;
+    append<Name extends HttpFormDataSchemaName<this['_schema']>>(name: Name, blob: Exclude<ArrayItemIfArray<NonNullable<LooseSchema[Name]>>, string>, fileName?: string): void;
     /**
      * Get the value of the entry associated to a key name.
      *
@@ -197,7 +205,7 @@ declare class HttpFormData<Schema extends HttpFormDataSchema = HttpFormDataSchem
      * @returns The value associated with the key name, or `null` if the key does not exist.
      * @see {@link https://developer.mozilla.org/docs/Web/API/FormData/get MDN Reference}
      */
-    get<Name extends HttpFormDataSchemaName.NonArray<Schema>>(name: Name): ReplaceBy<ReplaceBy<ArrayItemIfArray<Schema[Name]>, undefined, null>, Blob, File>;
+    get<Name extends HttpFormDataSchemaName.NonArray<this['_schema']>>(name: Name): ReplaceBy<ReplaceBy<ArrayItemIfArray<this['_schema'][Name]>, undefined, null>, Blob, File>;
     /**
      * Get all the values of the entry associated with a key name.
      *
@@ -207,24 +215,24 @@ declare class HttpFormData<Schema extends HttpFormDataSchema = HttpFormDataSchem
      * @returns An array of values associated with the key name, or an empty array if the key does not exist.
      * @see {@link https://developer.mozilla.org/docs/Web/API/FormData/getAll MDN Reference}
      */
-    getAll<Name extends HttpFormDataSchemaName.Array<Schema>>(name: Name): ReplaceBy<ArrayItemIfArray<NonNullable<Schema[Name]>>, Blob, File>[];
+    getAll<Name extends HttpFormDataSchemaName.Array<this['_schema']>>(name: Name): ReplaceBy<ArrayItemIfArray<NonNullable<this['_schema'][Name]>>, Blob, File>[];
     /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/has MDN Reference} */
-    has<Name extends HttpFormDataSchemaName<Schema>>(name: Name): boolean;
+    has<Name extends HttpFormDataSchemaName<this['_schema']>>(name: Name): boolean;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/delete MDN Reference} */
-    delete<Name extends HttpFormDataSchemaName<Schema>>(name: Name): void;
-    forEach<This extends HttpFormData<Schema>>(callback: <Key extends HttpFormDataSchemaName<Schema>>(value: ReplaceBy<ArrayItemIfArray<NonNullable<Schema[Key]>>, Blob, File>, key: Key, parent: HttpFormData<Schema>) => void, thisArg?: This): void;
+    delete<Name extends HttpFormDataSchemaName<this['_schema']>>(name: Name): void;
+    forEach<This extends HttpFormData<this['_schema']>>(callback: <Key extends HttpFormDataSchemaName<this['_schema']>>(value: ReplaceBy<ArrayItemIfArray<NonNullable<this['_schema'][Key]>>, Blob, File>, key: Key, parent: HttpFormData<this['_schema']>) => void, thisArg?: This): void;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/keys MDN Reference} */
-    keys(): FormDataIterator<HttpFormDataSchemaName<Schema>>;
+    keys(): FormDataIterator<HttpFormDataSchemaName<this['_schema']>>;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/values MDN Reference} */
-    values(): FormDataIterator<ReplaceBy<ArrayItemIfArray<NonNullable<Schema[HttpFormDataSchemaName<Schema>]>>, Blob, File>>;
+    values(): FormDataIterator<ReplaceBy<ArrayItemIfArray<NonNullable<this['_schema'][HttpFormDataSchemaName<this['_schema']>]>>, Blob, File>>;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/entries MDN Reference} */
     entries(): FormDataIterator<[
-        HttpFormDataSchemaName<Schema>,
-        ReplaceBy<ArrayItemIfArray<NonNullable<Schema[HttpFormDataSchemaName<Schema>]>>, Blob, File>
+        HttpFormDataSchemaName<this['_schema']>,
+        ReplaceBy<ArrayItemIfArray<NonNullable<this['_schema'][HttpFormDataSchemaName<this['_schema']>]>>, Blob, File>
     ]>;
     [Symbol.iterator](): FormDataIterator<[
-        HttpFormDataSchemaName<Schema>,
-        ReplaceBy<ArrayItemIfArray<NonNullable<Schema[HttpFormDataSchemaName<Schema>]>>, Blob, File>
+        HttpFormDataSchemaName<this['_schema']>,
+        ReplaceBy<ArrayItemIfArray<NonNullable<this['_schema'][HttpFormDataSchemaName<this['_schema']>]>>, Blob, File>
     ]>;
     /**
      * Checks if the data is equal to the other data. Equality is defined as having the same keys and values, regardless
@@ -234,7 +242,7 @@ declare class HttpFormData<Schema extends HttpFormDataSchema = HttpFormDataSchem
      * @returns A promise that resolves with `true` if the data is equal to the other data, or `false` otherwise.
      *   Important: both form data might be read while comparing.
      */
-    equals<OtherSchema extends Schema>(otherData: HttpFormData<OtherSchema>): Promise<boolean>;
+    equals<OtherSchema extends LooseSchema>(otherData: HttpFormData<OtherSchema>): Promise<boolean>;
     /**
      * Checks if the data contains the other data. This method is less strict than {@link HttpFormData#equals} and only
      * requires that all keys and values in the other data are present in this data.
@@ -243,7 +251,7 @@ declare class HttpFormData<Schema extends HttpFormDataSchema = HttpFormDataSchem
      * @returns A promise that resolves with `true` if this data contains the other data, or `false` otherwise. Important:
      *   both form data might be read while comparing.
      */
-    contains<OtherSchema extends Schema>(otherData: HttpFormData<OtherSchema>): Promise<boolean>;
+    contains<OtherSchema extends LooseSchema>(otherData: HttpFormData<OtherSchema>): Promise<boolean>;
     /**
      * Converts this form data into a plain object. This method is useful for serialization and debugging purposes.
      *
@@ -268,7 +276,7 @@ declare class HttpFormData<Schema extends HttpFormDataSchema = HttpFormDataSchem
      *
      * @returns A plain object representation of this form data.
      */
-    toObject(): Schema;
+    toObject(): this["_schema"];
 }
 
 interface HttpPathParamsSchema {
@@ -278,11 +286,10 @@ declare namespace HttpPathParamsSchema {
     /** A schema for loose HTTP path parameters. Parameter values are not strictly typed. */
     type Loose = Record<string, any>;
 }
-type PrimitiveHttpPathParamsSerialized<Type> = Type extends HttpPathParamsSchema[string] ? Type : Type extends (infer _ArrayItem)[] ? never : Type extends number ? `${number}` : Type extends boolean ? `${boolean}` : Type extends null ? undefined : never;
+type PrimitiveHttpPathParamsSerialized<Type> = [Type] extends [never] ? never : Type extends number ? `${number}` : Type extends boolean ? `${boolean}` : Type extends null ? 'null' : Type extends symbol ? never : Type extends HttpPathParamsSchema[string] ? Type : string;
 /**
- * Recursively converts a schema to its path parameters-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.
+ * Recursively converts a schema to its path parameters-serialized version. Numbers, booleans, and null are converted to
+ * `${number}`, `${boolean}`, and 'null' respectively, and other values become strings.
  *
  * @example
  *   import { type HttpPathParamsSerialized } from '@zimic/http';
@@ -291,16 +298,14 @@ type PrimitiveHttpPathParamsSerialized<Type> = Type extends HttpPathParamsSchema
  *     userId: string;
  *     notificationId: number | null;
  *     full?: boolean;
- *     from?: Date;
- *     method: () => void;
  *   }>;
  *   // {
  *   //   userId: string;
- *   //   notificationId: `${number}` | undefined;
+ *   //   notificationId: `${number}` | 'null';
  *   //   full?: "false" | "true";
  *   // }
  */
-type HttpPathParamsSerialized<Type> = Type extends HttpPathParamsSchema ? 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 ? {
+type HttpPathParamsSerialized<Type> = [Type] extends [never] ? never : Type extends HttpPathParamsSchema ? Type : Type extends object ? {
     [Key in keyof Type as IfNever<PrimitiveHttpPathParamsSerialized<Type[Key]>, never, Key>]: PrimitiveHttpPathParamsSerialized<Type[Key]>;
 } : never;
 
@@ -313,11 +318,11 @@ declare namespace HttpHeadersSchema {
     type Loose = Record<string, any>;
 }
 /** A strict tuple representation of a {@link HttpHeadersSchema}. */
-type HttpHeadersSchemaTuple<Schema extends HttpHeadersSchema = HttpHeadersSchema> = {
+type HttpHeadersSchemaTuple<Schema extends HttpHeadersSchema.Loose = HttpHeadersSchema.Loose> = {
     [Key in keyof Schema & string]: [Key, NonNullable<Schema[Key]>];
 }[keyof Schema & string];
 /** An initialization value for {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http#httpheaders `HttpHeaders`}. */
-type HttpHeadersInit<Schema extends HttpHeadersSchema = HttpHeadersSchema> = Headers | Schema | HttpHeaders<Schema> | HttpHeadersSchemaTuple<Schema>[];
+type HttpHeadersInit<Schema extends HttpHeadersSchema.Loose = HttpHeadersSchema.Loose> = Headers | Schema | HttpHeaders<Schema> | HttpHeadersSchemaTuple<Schema>[];
 /**
  * Extracts the names of the headers defined in a {@link HttpHeadersSchema}. Each key is considered a header name.
  *
@@ -359,9 +364,6 @@ type HttpHeadersSerialized<Type> = HttpPathParamsSerialized<Type>;
  * An extended 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.
  *
- * **IMPORTANT**: the input of `HttpHeaders` and all of its internal types must be declared inline or as a type aliases
- * (`type`). They cannot be interfaces.
- *
  * @example
  *   import { HttpHeaders } from '@zimic/http';
  *
@@ -378,33 +380,34 @@ type HttpHeadersSerialized<Type> = HttpPathParamsSerialized<Type>;
  *
  * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http#httpheaders `HttpHeaders` API reference}
  */
-declare class HttpHeaders<Schema extends HttpHeadersSchema = HttpHeadersSchema> extends Headers {
-    constructor(init?: HttpHeadersInit<Schema>);
+declare class HttpHeaders<LooseSchema extends HttpHeadersSchema.Loose = HttpHeadersSchema.Loose> extends Headers {
+    readonly _schema: HttpHeadersSerialized<LooseSchema>;
+    constructor(init?: HttpHeadersInit<LooseSchema>);
     /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/set MDN Reference} */
-    set<Name extends HttpHeadersSchemaName<Schema>>(name: Name, value: NonNullable<Schema[Name]> & string): void;
+    set<Name extends HttpHeadersSchemaName<this['_schema']>>(name: Name, value: NonNullable<LooseSchema[Name]>): void;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/append MDN Reference} */
-    append<Name extends HttpHeadersSchemaName<Schema>>(name: Name, value: NonNullable<Schema[Name]> & string): void;
+    append<Name extends HttpHeadersSchemaName<this['_schema']>>(name: Name, value: NonNullable<LooseSchema[Name]>): void;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/get MDN Reference} */
-    get<Name extends HttpHeadersSchemaName<Schema>>(name: Name): ReplaceBy<Schema[Name], undefined, null>;
+    get<Name extends HttpHeadersSchemaName<this['_schema']>>(name: Name): ReplaceBy<this['_schema'][Name], undefined, null>;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/has MDN Reference} */
-    getSetCookie(): NonNullable<Default<Schema['Set-Cookie'], string>>[];
+    getSetCookie(): NonNullable<Default<this['_schema']['Set-Cookie'], string>>[];
     /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/has MDN Reference} */
-    has<Name extends HttpHeadersSchemaName<Schema>>(name: Name): boolean;
+    has<Name extends HttpHeadersSchemaName<this['_schema']>>(name: Name): boolean;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/delete MDN Reference} */
-    delete<Name extends HttpHeadersSchemaName<Schema>>(name: Name): void;
-    forEach<This extends HttpHeaders<Schema>>(callback: <Key extends HttpHeadersSchemaName<Schema>>(value: NonNullable<Schema[Key]> & string, key: Key, parent: Headers) => void, thisArg?: This): void;
+    delete<Name extends HttpHeadersSchemaName<this['_schema']>>(name: Name): void;
+    forEach<This extends HttpHeaders<this['_schema']>>(callback: <Key extends HttpHeadersSchemaName<this['_schema']>>(value: NonNullable<this['_schema'][Key]> & string, key: Key, parent: Headers) => void, thisArg?: This): void;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/keys MDN Reference} */
-    keys(): HeadersIterator<HttpHeadersSchemaName<Schema>>;
+    keys(): HeadersIterator<HttpHeadersSchemaName<this['_schema']>>;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/values MDN Reference} */
-    values(): HeadersIterator<NonNullable<Schema[HttpHeadersSchemaName<Schema>]> & string>;
+    values(): HeadersIterator<NonNullable<this['_schema'][HttpHeadersSchemaName<this['_schema']>]> & string>;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/entries MDN Reference} */
     entries(): HeadersIterator<[
-        HttpHeadersSchemaName<Schema>,
-        NonNullable<Schema[HttpHeadersSchemaName<Schema>]> & string
+        HttpHeadersSchemaName<this['_schema']>,
+        NonNullable<this['_schema'][HttpHeadersSchemaName<this['_schema']>]> & string
     ]>;
     [Symbol.iterator](): HeadersIterator<[
-        HttpHeadersSchemaName<Schema>,
-        NonNullable<Schema[HttpHeadersSchemaName<Schema>]> & string
+        HttpHeadersSchemaName<this['_schema']>,
+        NonNullable<this['_schema'][HttpHeadersSchemaName<this['_schema']>]> & string
     ]>;
     /**
      * Checks if this headers object is equal to another set of headers. Equality is defined as having the same keys and
@@ -413,7 +416,7 @@ declare class HttpHeaders<Schema extends HttpHeadersSchema = HttpHeadersSchema>
      * @param otherHeaders The other headers object to compare against.
      * @returns `true` if the headers are equal, `false` otherwise.
      */
-    equals<OtherSchema extends Schema>(otherHeaders: HttpHeaders<OtherSchema>): boolean;
+    equals<OtherSchema extends LooseSchema>(otherHeaders: HttpHeaders<OtherSchema>): boolean;
     /**
      * Checks if this headers object contains another set of headers. This method is less strict than
      * {@link HttpHeaders#equals} and only requires that all keys and values in the other headers are present in these
@@ -422,7 +425,7 @@ declare class HttpHeaders<Schema extends HttpHeadersSchema = HttpHeadersSchema>
      * @param otherHeaders The other headers object to compare against.
      * @returns `true` if these headers contain the other headers, `false` otherwise.
      */
-    contains<OtherSchema extends Schema>(otherHeaders: HttpHeaders<OtherSchema>): boolean;
+    contains<OtherSchema extends LooseSchema>(otherHeaders: HttpHeaders<OtherSchema>): boolean;
     /**
      * Converts these headers into a plain object. This method is useful for serialization and debugging purposes.
      *
@@ -436,7 +439,7 @@ declare class HttpHeaders<Schema extends HttpHeadersSchema = HttpHeadersSchema>
      *
      * @returns A plain object representation of these headers.
      */
-    toObject(): Schema;
+    toObject(): this['_schema'];
     private splitHeaderValues;
 }
 
@@ -449,14 +452,14 @@ declare namespace HttpSearchParamsSchema {
     type Loose = Record<string, any>;
 }
 /** A strict tuple representation of a {@link HttpSearchParamsSchema}. */
-type HttpSearchParamsSchemaTuple<Schema extends HttpSearchParamsSchema = HttpSearchParamsSchema> = {
+type HttpSearchParamsSchemaTuple<Schema extends HttpSearchParamsSchema.Loose = HttpSearchParamsSchema.Loose> = {
     [Key in keyof Schema & string]: [Key, ArrayItemIfArray<NonNullable<Schema[Key]>>];
 }[keyof Schema & string];
 /**
  * An initialization value for
  * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http#httpsearchparams `HttpSearchParams`}.
  */
-type HttpSearchParamsInit<Schema extends HttpSearchParamsSchema = HttpSearchParamsSchema> = string | URLSearchParams | Schema | HttpSearchParams<Schema> | HttpSearchParamsSchemaTuple<Schema>[];
+type HttpSearchParamsInit<Schema extends HttpSearchParamsSchema.Loose = HttpSearchParamsSchema.Loose> = string | URLSearchParams | Schema | HttpSearchParams<Schema> | HttpSearchParamsSchemaTuple<Schema>[];
 declare namespace HttpSearchParamsSchemaName {
     /** Extracts the names of the search params defined in a {@link HttpSearchParamsSchema} that are arrays. */
     type Array<Schema extends HttpSearchParamsSchema> = IfNever<Schema, never, ArrayKey<Schema> & string>;
@@ -493,30 +496,30 @@ declare namespace HttpSearchParamsSchemaName {
  *   // "page" | "perPage"
  */
 type HttpSearchParamsSchemaName<Schema extends HttpSearchParamsSchema> = IfNever<Schema, never, 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";
  *   // }
  */
-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 ? {
+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;
 
@@ -524,9 +527,6 @@ type HttpSearchParamsSerialized<Type> = Type extends HttpSearchParamsSchema ? Ty
  * An extended 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.
  *
- * **IMPORTANT**: the input of `HttpSearchParams` and all of its internal types must be declared inline or as a type
- * aliases (`type`). They cannot be interfaces.
- *
  * @example
  *   import { HttpSearchParams } from '@zimic/http';
  *
@@ -546,13 +546,14 @@ type HttpSearchParamsSerialized<Type> = Type extends HttpSearchParamsSchema ? Ty
  *
  * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http#httpsearchparams `HttpSearchParams` API reference}
  */
-declare class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsSchema> extends URLSearchParams {
-    constructor(init?: HttpSearchParamsInit<Schema>);
+declare class HttpSearchParams<LooseSchema extends HttpSearchParamsSchema.Loose = HttpSearchParamsSchema.Loose> extends URLSearchParams {
+    readonly _schema: HttpSearchParamsSerialized<LooseSchema>;
+    constructor(init?: HttpSearchParamsInit<LooseSchema>);
     private populateInitArrayProperties;
     /** @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]>>): void;
+    set<Name extends HttpSearchParamsSchemaName<this['_schema']>>(name: Name, value: ArrayItemIfArray<NonNullable<LooseSchema[Name]>>): void;
     /** @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]>>): void;
+    append<Name extends HttpSearchParamsSchemaName<this['_schema']>>(name: Name, value: ArrayItemIfArray<NonNullable<LooseSchema[Name]>>): void;
     /**
      * Get the value of the entry associated to a key name.
      *
@@ -562,7 +563,7 @@ declare class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearc
      * @returns The value associated with the key name, or `null` if the key does not exist.
      * @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/get MDN Reference}
      */
-    get<Name extends HttpSearchParamsSchemaName.NonArray<Schema>>(name: Name): ReplaceBy<ArrayItemIfArray<Schema[Name]>, undefined, null>;
+    get<Name extends HttpSearchParamsSchemaName.NonArray<this['_schema']>>(name: Name): ReplaceBy<ArrayItemIfArray<this['_schema'][Name]>, undefined, null>;
     /**
      * Get all the values of the entry associated with a key name.
      *
@@ -572,24 +573,24 @@ declare class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearc
      * @returns An array of values associated with the key name, or an empty array if the key does not exist.
      * @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/getAll MDN Reference}
      */
-    getAll<Name extends HttpSearchParamsSchemaName.Array<Schema>>(name: Name): ArrayItemIfArray<NonNullable<Schema[Name]>>[];
+    getAll<Name extends HttpSearchParamsSchemaName.Array<this['_schema']>>(name: Name): ArrayItemIfArray<NonNullable<this['_schema'][Name]>>[];
     /** @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]>>): boolean;
+    has<Name extends HttpSearchParamsSchemaName<this['_schema']>>(name: Name, value?: ArrayItemIfArray<NonNullable<LooseSchema[Name]>>): boolean;
     /** @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]>>): void;
-    forEach<This extends HttpSearchParams<Schema>>(callback: <Key extends HttpSearchParamsSchemaName<Schema>>(value: ArrayItemIfArray<NonNullable<Schema[Key]>>, key: Key, parent: HttpSearchParams<Schema>) => void, thisArg?: This): void;
+    delete<Name extends HttpSearchParamsSchemaName<this['_schema']>>(name: Name, value?: ArrayItemIfArray<NonNullable<LooseSchema[Name]>>): void;
+    forEach<This extends HttpSearchParams<this['_schema']>>(callback: <Key extends HttpSearchParamsSchemaName<this['_schema']>>(value: ArrayItemIfArray<NonNullable<this['_schema'][Key]>>, key: Key, parent: HttpSearchParams<this['_schema']>) => void, thisArg?: This): void;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/keys MDN Reference} */
-    keys(): URLSearchParamsIterator<HttpSearchParamsSchemaName<Schema>>;
+    keys(): URLSearchParamsIterator<HttpSearchParamsSchemaName<this['_schema']>>;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/values MDN Reference} */
-    values(): URLSearchParamsIterator<ArrayItemIfArray<NonNullable<Schema[HttpSearchParamsSchemaName<Schema>]>>>;
+    values(): URLSearchParamsIterator<ArrayItemIfArray<NonNullable<this['_schema'][HttpSearchParamsSchemaName<this['_schema']>]>>>;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/entries MDN Reference} */
     entries(): URLSearchParamsIterator<[
-        HttpSearchParamsSchemaName<Schema>,
-        ArrayItemIfArray<NonNullable<Schema[HttpSearchParamsSchemaName<Schema>]>>
+        HttpSearchParamsSchemaName<this['_schema']>,
+        ArrayItemIfArray<NonNullable<this['_schema'][HttpSearchParamsSchemaName<this['_schema']>]>>
     ]>;
     [Symbol.iterator](): URLSearchParamsIterator<[
-        HttpSearchParamsSchemaName<Schema>,
-        ArrayItemIfArray<NonNullable<Schema[HttpSearchParamsSchemaName<Schema>]>>
+        HttpSearchParamsSchemaName<this['_schema']>,
+        ArrayItemIfArray<NonNullable<this['_schema'][HttpSearchParamsSchemaName<this['_schema']>]>>
     ]>;
     /**
      * Checks if these search params are equal to another set of search parameters. Equality is defined as having the same
@@ -598,7 +599,7 @@ declare class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearc
      * @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;
     /**
      * Checks if these search params contain another set of search parameters. This method is less strict than
      * {@link HttpSearchParams#equals} and only requires that all keys and values in the other search parameters are
@@ -607,7 +608,7 @@ declare class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearc
      * @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;
     /**
      * Converts these search params into a plain object. This method is useful for serialization and debugging purposes.
      *
@@ -626,7 +627,7 @@ declare class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearc
      *
      * @returns A plain object representation of these search params.
      */
-    toObject(): Schema;
+    toObject(): this["_schema"];
 }
 
 declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
@@ -645,12 +646,6 @@ interface HttpRequestSchema {
     searchParams?: HttpSearchParamsSchema.Loose;
     body?: HttpBody.Loose;
 }
-declare namespace HttpRequestSchema {
-    /** Convert an HTTP request schema to be strictly typed. */
-    type AsStrict<Schema> = {
-        [Key in keyof Schema]: Key extends 'headers' ? HttpHeadersSerialized<Schema[Key]> : Key extends 'searchParams' ? HttpSearchParamsSerialized<Schema[Key]> : Key extends 'body' ? HttpBody.AsStrict<Schema[Key]> : Schema[Key];
-    };
-}
 /**
  * A schema representing the structure of an HTTP response.
  *
@@ -660,14 +655,6 @@ interface HttpResponseSchema {
     headers?: HttpHeadersSchema.Loose;
     body?: HttpBody.Loose;
 }
-declare namespace HttpResponseSchema {
-    /** A schema representing the structure of an HTTP response with no body. */
-    interface NoBody extends Omit<HttpResponseSchema, 'body'> {
-        body?: null;
-    }
-    /** Convert an HTTP response schema to be strictly typed. */
-    type AsStrict<Schema> = HttpRequestSchema.AsStrict<Schema>;
-}
 /**
  * The status codes used in HTTP responses, as defined by
  * {@link https://httpwg.org/specs/rfc9110.html#overview.of.status.codes RFC-9110}.
@@ -716,21 +703,9 @@ declare namespace HttpStatusCode {
  *
  * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http‐schemas Declaring HTTP interceptor schemas}
  */
-type HttpResponseSchemaByStatusCode = HttpResponseSchemaByStatusCode.AsStrict<HttpResponseSchemaByStatusCode.Loose>;
-declare namespace HttpResponseSchemaByStatusCode {
-    /** A loose version of HTTP responses by status code. JSON values are not strictly typed. */
-    type Loose = {
-        [StatusCode in HttpStatusCode]?: HttpResponseSchema;
-    };
-    /** Converts an HTTP response schema by status code to be strictly typed. */
-    type AsStrict<Schema> = {
-        [StatusCode in keyof Schema]: StatusCode extends 204 ? HttpResponseSchema.NoBody : HttpResponseSchema.AsStrict<Schema[StatusCode]>;
-    };
-    /** A schema representing the structure of HTTP responses by status code with no body. */
-    type NoBody = {
-        [StatusCode in HttpStatusCode]?: HttpResponseSchema.NoBody;
-    };
-}
+type HttpResponseSchemaByStatusCode = {
+    [StatusCode in HttpStatusCode]?: HttpResponseSchema;
+};
 /**
  * Extracts the status codes used in a response schema by status code.
  *
@@ -746,44 +721,19 @@ interface HttpMethodSchema {
     request?: HttpRequestSchema;
     response?: HttpResponseSchemaByStatusCode;
 }
-declare namespace HttpMethodSchema {
-    /** A schema representing the structure of an HTTP request and response for a given method, having no request body. */
-    interface NoRequestBody extends Omit<HttpMethodSchema, 'request'> {
-        request?: Omit<HttpRequestSchema, 'body'> & {
-            body?: null;
-        };
-    }
-    /**
-     * A schema representing the structure of an HTTP request and response for a given method, having no request and
-     * response bodies.
-     */
-    interface NoBody extends Omit<NoRequestBody, 'response'> {
-        response?: HttpResponseSchemaByStatusCode.NoBody;
-    }
-    /** Converts an HTTP method schema to be strictly typed. */
-    type AsStrict<Schema> = {
-        [Key in keyof Schema]: Key extends 'request' ? HttpRequestSchema.AsStrict<Schema[Key]> : Key extends 'response' ? HttpResponseSchemaByStatusCode.AsStrict<Schema[Key]> : Schema[Key];
-    };
-}
 /**
  * A schema representing the structure of HTTP request and response by method.
  *
  * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http‐schemas Declaring HTTP interceptor schemas}
  */
 interface HttpMethodsSchema {
-    GET?: HttpMethodSchema.NoRequestBody;
+    GET?: HttpMethodSchema;
     POST?: HttpMethodSchema;
     PUT?: HttpMethodSchema;
     PATCH?: HttpMethodSchema;
     DELETE?: HttpMethodSchema;
-    HEAD?: HttpMethodSchema.NoBody;
-    OPTIONS?: HttpMethodSchema.NoRequestBody;
-}
-declare namespace HttpMethodsSchema {
-    /** Converts an HTTP methods schema to be strictly typed. */
-    type AsStrict<Schema> = {
-        [Method in keyof Schema]: HttpMethodSchema.AsStrict<Schema[Method]>;
-    };
+    HEAD?: HttpMethodSchema;
+    OPTIONS?: HttpMethodSchema;
 }
 interface BaseHttpSchema {
     [path: string]: HttpMethodsSchema;
@@ -800,7 +750,7 @@ interface BaseHttpSchema {
  *
  *   interface UserListSearchParams {
  *     name?: string;
- *     limit?: `${number}`;
+ *     limit?: number;
  *   }
  *
  *   type Schema = HttpSchema<{
@@ -823,12 +773,8 @@ interface BaseHttpSchema {
  *
  * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http‐schemas Declaring HTTP interceptor schemas}
  */
-type HttpSchema<Schema extends BaseHttpSchema = BaseHttpSchema> = HttpSchema.AsStrict<Schema>;
+type HttpSchema<Schema extends BaseHttpSchema = BaseHttpSchema> = Branded<Schema, 'HttpSchema'>;
 declare namespace HttpSchema {
-    /** Converts an HTTP service schema to be strictly typed. */
-    type AsStrict<Schema extends BaseHttpSchema> = {
-        [Path in keyof Schema]: HttpMethodsSchema.AsStrict<Schema[Path]>;
-    };
     /**
      * Declares an HTTP service methods schema.
      *
@@ -847,7 +793,7 @@ declare namespace HttpSchema {
      *     '/users': UserMethods;
      *   }>;
      */
-    type Methods<Schema extends HttpMethodsSchema> = HttpMethodsSchema.AsStrict<Schema>;
+    type Methods<Schema extends HttpMethodsSchema> = Schema;
     /**
      * Declares an HTTP service method schema.
      *
@@ -866,7 +812,7 @@ declare namespace HttpSchema {
      *     };
      *   }>;
      */
-    type Method<Schema extends HttpMethodSchema> = HttpMethodSchema.AsStrict<Schema>;
+    type Method<Schema extends HttpMethodSchema> = Schema;
     /**
      * Declares an HTTP service request schema.
      *
@@ -889,7 +835,7 @@ declare namespace HttpSchema {
      *     };
      *   }>;
      */
-    type Request<Schema extends HttpRequestSchema> = HttpRequestSchema.AsStrict<Schema>;
+    type Request<Schema extends HttpRequestSchema> = Schema;
     /**
      * Declares an HTTP service response schema by status code.
      *
@@ -909,7 +855,7 @@ declare namespace HttpSchema {
      *     };
      *   }>;
      */
-    type ResponseByStatusCode<Schema extends HttpResponseSchemaByStatusCode> = HttpResponseSchemaByStatusCode.AsStrict<Schema>;
+    type ResponseByStatusCode<Schema extends HttpResponseSchemaByStatusCode> = Schema;
     /**
      * Declares an HTTP service response schema.
      *
@@ -930,10 +876,9 @@ declare namespace HttpSchema {
      *     };
      *   }>;
      */
-    type Response<Schema extends HttpResponseSchema> = HttpResponseSchema.AsStrict<Schema>;
+    type Response<Schema extends HttpResponseSchema> = Schema;
     /**
-     * Declares an HTTP body schema. JSON values are serialized to their strict form using
-     * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic#jsonserialized `JSONSerialized`} if necessary.
+     * Declares an HTTP body schema.
      *
      * @example
      *   import { type HttpSchema } from '@zimic/http';
@@ -950,11 +895,9 @@ declare namespace HttpSchema {
      *     };
      *   }>;
      */
-    type Body<Schema extends HttpBody.Loose> = HttpBody.AsStrict<Schema>;
+    type Body<Schema extends HttpBody.Loose> = Schema;
     /**
-     * Declares an HTTP headers schema. Headers are serialized to their strict form using
-     * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http#httpheadersserialized `HttpHeadersSerialized`} if
-     * necessary.
+     * Declares an HTTP headers schema.
      *
      * @example
      *   import { type HttpSchema } from '@zimic/http';
@@ -976,11 +919,9 @@ declare namespace HttpSchema {
      *     };
      *   }>;
      */
-    type Headers<Schema extends HttpHeadersSchema.Loose> = HttpHeadersSerialized<Schema>;
+    type Headers<Schema extends HttpHeadersSchema.Loose> = Schema;
     /**
-     * Declares an HTTP search params schema. Search params are serialized to their strict form using
-     * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http#httpsearchparamsserialized `HttpSearchParamsSerialized`}
-     * if necessary.
+     * Declares an HTTP search params schema.
      *
      * @example
      *   import { type HttpSchema } from '@zimic/http';
@@ -1003,10 +944,9 @@ declare namespace HttpSchema {
      *     };
      *   }>;
      */
-    type SearchParams<Schema extends HttpSearchParamsSchema.Loose> = HttpSearchParamsSerialized<Schema>;
+    type SearchParams<Schema extends HttpSearchParamsSchema.Loose> = Schema;
     /**
-     * Declares an HTTP path params schema. Path params are serialized to their strict form using
-     * {@link HttpPathParamsSerialized} if necessary.
+     * Declares an HTTP path params schema.
      *
      * @example
      *   import { type HttpSchema, InferPathParams } from '@zimic/http';
@@ -1028,11 +968,9 @@ declare namespace HttpSchema {
      *   // Or infer from the path string
      *   type UserByIdPathParams = InferPathParams<Schema, '/users/:userId'>;
      */
-    type PathParams<Schema extends HttpPathParamsSchema.Loose> = HttpPathParamsSerialized<Schema>;
+    type PathParams<Schema extends HttpPathParamsSchema.Loose> = Schema;
     /**
-     * Declares an HTTP form data schema. Form data is serialized to their strict form using
-     * {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http#httpformdataserialized `HttpFormDataSerialized`} if
-     * necessary.
+     * Declares an HTTP form data schema.
      *
      * @example
      *   import { HttpFormData, type HttpSchema } from '@zimic/http';
@@ -1057,7 +995,7 @@ declare namespace HttpSchema {
      *     };
      *   }>;
      */
-    type FormData<Schema extends HttpFormDataSchema.Loose> = HttpFormDataSerialized<Schema>;
+    type FormData<Schema extends HttpFormDataSchema.Loose> = Schema;
 }
 /**
  * Extracts the methods from an HTTP service schema.
@@ -1200,11 +1138,7 @@ type RecursiveInferPathParams<Path extends string> = Path extends `${infer _Pref
  *   // { userId: string }
  */
 type InferPathParams<PathOrSchema extends string | HttpSchema, OptionalPath extends PathOrSchema extends HttpSchema ? HttpSchemaPath.Literal<PathOrSchema> : never = never> = Prettify<RecursiveInferPathParams<PathOrSchema extends HttpSchema ? OptionalPath : PathOrSchema extends string ? PathOrSchema : never>>;
-type OmitPastHttpStatusCodes<Schema extends HttpResponseSchemaByStatusCode.Loose, PastSchemas extends HttpResponseSchemaByStatusCode.Loose[]> = PastSchemas extends NonEmptyArray<HttpResponseSchemaByStatusCode.Loose> ? Omit<Schema, keyof UnionToIntersection<PastSchemas[number]>> : Schema;
-type RecursiveMergeHttpResponsesByStatusCode<Schemas extends HttpResponseSchemaByStatusCode.Loose[], PastSchemas extends HttpResponseSchemaByStatusCode.Loose[] = []> = Schemas extends [
-    infer FirstSchema extends HttpResponseSchemaByStatusCode.Loose,
-    ...infer RestSchemas extends HttpResponseSchemaByStatusCode.Loose[]
-] ? RestSchemas extends NonEmptyArray<HttpResponseSchemaByStatusCode.Loose> ? OmitPastHttpStatusCodes<FirstSchema, PastSchemas> & RecursiveMergeHttpResponsesByStatusCode<RestSchemas, [...PastSchemas, FirstSchema]> : OmitPastHttpStatusCodes<FirstSchema, PastSchemas> : never;
+type OmitPastHttpStatusCodes<Schema extends HttpResponseSchemaByStatusCode, PastSchemas extends HttpResponseSchemaByStatusCode[]> = PastSchemas extends NonEmptyArray<HttpResponseSchemaByStatusCode> ? Omit<Schema, keyof UnionToIntersection<PastSchemas[number]>> : Schema;
 /**
  * Merges multiple HTTP response schemas by status code into a single schema. When there are duplicate status codes, the
  * first declaration takes precedence.
@@ -1238,36 +1172,37 @@ type RecursiveMergeHttpResponsesByStatusCode<Schemas extends HttpResponseSchemaB
  *     };
  *   }>;
  */
-type MergeHttpResponsesByStatusCode<Schemas extends HttpResponseSchemaByStatusCode.Loose[], PastSchemas extends HttpResponseSchemaByStatusCode.Loose[] = []> = HttpResponseSchemaByStatusCode.AsStrict<RecursiveMergeHttpResponsesByStatusCode<Schemas, PastSchemas>>;
+type MergeHttpResponsesByStatusCode<Schemas extends HttpResponseSchemaByStatusCode[], PastSchemas extends HttpResponseSchemaByStatusCode[] = []> = Schemas extends [
+    infer FirstSchema extends HttpResponseSchemaByStatusCode,
+    ...infer RestSchemas extends HttpResponseSchemaByStatusCode[]
+] ? RestSchemas extends NonEmptyArray<HttpResponseSchemaByStatusCode> ? OmitPastHttpStatusCodes<FirstSchema, PastSchemas> & MergeHttpResponsesByStatusCode<RestSchemas, [...PastSchemas, FirstSchema]> : OmitPastHttpStatusCodes<FirstSchema, PastSchemas> : never;
 
 /** The body type for HTTP requests and responses. */
 type HttpBody = JSONValue | HttpFormData<any> | HttpSearchParams<any> | Blob | ArrayBuffer;
 declare namespace HttpBody {
     /** A loose version of the HTTP body type. JSON values are not strictly typed. */
     type Loose = ReplaceBy<HttpBody, JSONValue, JSONValue.Loose>;
-    /** Convert an HTTP body to be strictly typed. JSON values are serialized to their strict form. */
-    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.
  */
-type StrictHeaders<Schema extends HttpHeadersSchema = HttpHeadersSchema> = Pick<HttpHeaders<Schema>, keyof Headers>;
+type StrictHeaders<Schema extends HttpHeadersSchema.Loose = HttpHeadersSchema.Loose> = Pick<HttpHeaders<Schema>, keyof Headers>;
 /**
  * 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.
  */
-type StrictURLSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsSchema> = Pick<HttpSearchParams<Schema>, keyof URLSearchParams>;
+type StrictURLSearchParams<Schema extends HttpSearchParamsSchema.Loose = HttpSearchParamsSchema.Loose> = Pick<HttpSearchParams<Schema>, keyof URLSearchParams>;
 /**
  * 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.
  */
-type StrictFormData<Schema extends HttpFormDataSchema = HttpFormDataSchema> = Pick<HttpFormData<Schema>, keyof FormData>;
+type StrictFormData<Schema extends HttpFormDataSchema.Loose = HttpFormDataSchema.Loose> = Pick<HttpFormData<Schema>, keyof FormData>;
 /**
  * An HTTP request with a strictly-typed JSON body. Fully compatible with the built-in
  * {@link https://developer.mozilla.org/docs/Web/API/Request `Request`} class.
  */
-interface HttpRequest<StrictBody extends HttpBody.Loose = HttpBody, StrictHeadersSchema extends HttpHeadersSchema = HttpHeadersSchema> extends Request {
+interface HttpRequest<StrictBody extends HttpBody.Loose = HttpBody.Loose, StrictHeadersSchema extends HttpHeadersSchema.Loose = HttpHeadersSchema.Loose> extends Request {
     headers: StrictHeaders<StrictHeadersSchema>;
     text: () => Promise<StrictBody extends string ? StrictBody : string>;
     json: () => Promise<StrictBody extends string | Exclude<HttpBody, JSONValue> ? never : StrictBody>;
@@ -1278,7 +1213,7 @@ interface HttpRequest<StrictBody extends HttpBody.Loose = HttpBody, StrictHeader
  * An HTTP response with a strictly-typed JSON body and status code. Fully compatible with the built-in
  * {@link https://developer.mozilla.org/docs/Web/API/Response `Response`} class.
  */
-interface HttpResponse<StrictBody extends HttpBody.Loose = HttpBody, StatusCode extends number = number, StrictHeadersSchema extends HttpHeadersSchema = HttpHeadersSchema> extends Response {
+interface HttpResponse<StrictBody extends HttpBody.Loose = HttpBody.Loose, StrictHeadersSchema extends HttpHeadersSchema.Loose = HttpHeadersSchema.Loose, StatusCode extends number = number> extends Response {
     ok: StatusCode extends HttpStatusCode.Information | HttpStatusCode.Success | HttpStatusCode.Redirection ? true : false;
     status: StatusCode;
     headers: StrictHeaders<StrictHeadersSchema>;
@@ -1287,10 +1222,20 @@ interface HttpResponse<StrictBody extends HttpBody.Loose = HttpBody, StatusCode
     formData: () => Promise<StrictBody extends HttpFormData<infer HttpFormDataSchema> ? StrictFormData<HttpFormDataSchema> : StrictBody extends HttpSearchParams<infer HttpSearchParamsSchema> ? StrictFormData<HttpSearchParamsSchema> : FormData>;
     clone: () => this;
 }
-type HttpRequestHeadersSchema<MethodSchema extends HttpMethodSchema> = Default<Default<MethodSchema['request']>['headers']>;
-type HttpRequestSearchParamsSchema<MethodSchema extends HttpMethodSchema> = Default<Default<MethodSchema['request']>['searchParams']>;
+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;
+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>;
+type HttpRequestSearchParamsSchema<MethodSchema extends HttpMethodSchema> = 'searchParams' extends keyof MethodSchema['request'] ? Default<MethodSchema['request']>['searchParams'] : never;
 type HttpRequestBodySchema<MethodSchema extends HttpMethodSchema> = ReplaceBy<ReplaceBy<IfNever<DefaultNoExclude<Default<MethodSchema['request']>['body']>, null>, undefined, null>, ArrayBuffer, Blob>;
-type HttpResponseHeadersSchema<MethodSchema extends HttpMethodSchema, StatusCode extends HttpStatusCode> = Default<DefaultNoExclude<Default<Default<MethodSchema['response']>[StatusCode]>['headers']>>;
+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;
+type HttpResponseHeadersSchema<MethodSchema extends HttpMethodSchema, StatusCode extends HttpStatusCode> = '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>;
 type HttpResponseBodySchema<MethodSchema extends HttpMethodSchema, StatusCode extends HttpStatusCode> = ReplaceBy<ReplaceBy<IfNever<DefaultNoExclude<Default<Default<MethodSchema['response']>[StatusCode]>['body']>, null>, undefined, null>, ArrayBuffer, Blob>;
 
-export { type AllowAnyStringInPathParams, HTTP_METHODS, HttpBody, HttpFormData, HttpFormDataSchema, HttpFormDataSchemaName, type HttpFormDataSerialized, HttpHeaders, type HttpHeadersInit, HttpHeadersSchema, type HttpHeadersSchemaName, type HttpHeadersSchemaTuple, type HttpHeadersSerialized, type HttpMethod, HttpMethodSchema, HttpMethodsSchema, HttpPathParamsSchema, type HttpPathParamsSerialized, type HttpRequest, type HttpRequestBodySchema, type HttpRequestHeadersSchema, HttpRequestSchema, type HttpRequestSearchParamsSchema, type HttpResponse, type HttpResponseBodySchema, type HttpResponseHeadersSchema, HttpResponseSchema, HttpResponseSchemaByStatusCode, type HttpResponseSchemaStatusCode, HttpSchema, type HttpSchemaMethod, HttpSchemaPath, HttpSearchParams, type HttpSearchParamsInit, HttpSearchParamsSchema, HttpSearchParamsSchemaName, type HttpSearchParamsSchemaTuple, type HttpSearchParamsSerialized, HttpStatusCode, type InferPathParams, type JSONSerialized, JSONValue, type LiteralHttpSchemaPathFromNonLiteral, type MergeHttpResponsesByStatusCode, type StrictFormData, type StrictHeaders, type StrictURLSearchParams };
+export { type AllowAnyStringInPathParams, HTTP_METHODS, HttpBody, HttpFormData, HttpFormDataSchema, HttpFormDataSchemaName, type HttpFormDataSerialized, HttpHeaders, type HttpHeadersInit, HttpHeadersSchema, type HttpHeadersSchemaName, type HttpHeadersSchemaTuple, type HttpHeadersSerialized, type HttpMethod, type HttpMethodSchema, type HttpMethodsSchema, HttpPathParamsSchema, type HttpPathParamsSerialized, type HttpRequest, type HttpRequestBodySchema, type HttpRequestHeadersSchema, type HttpRequestSchema, type HttpRequestSearchParamsSchema, type HttpResponse, type HttpResponseBodySchema, type HttpResponseHeadersSchema, type HttpResponseSchema, type HttpResponseSchemaByStatusCode, type HttpResponseSchemaStatusCode, HttpSchema, type HttpSchemaMethod, HttpSchemaPath, HttpSearchParams, type HttpSearchParamsInit, HttpSearchParamsSchema, HttpSearchParamsSchemaName, type HttpSearchParamsSchemaTuple, type HttpSearchParamsSerialized, HttpStatusCode, type InferPathParams, type JSONSerialized, JSONValue, type LiteralHttpSchemaPathFromNonLiteral, type MergeHttpResponsesByStatusCode, type StrictFormData, type StrictHeaders, type StrictURLSearchParams };