@zimic/http 0.0.1-canary.2

package/dist/index.d.ts

@@ -0,0 +1,1306 @@
+type JSON = {
+    [key: string]: JSON;
+} | JSON[] | string | number | boolean | null | undefined;
+declare namespace JSON {
+    type Loose = Record<string, any> | Loose[] | string | number | boolean | null | undefined;
+}
+/**
+ * Represents or validates a type that is compatible with JSON.
+ *
+ * **IMPORTANT**: the input of `JSONValue` and all of its internal types must be declared inline or as a type aliases
+ * (`type`). They cannot be interfaces.
+ *
+ * @example
+ *   import { type JSONValue } from '@zimic/http';
+ *
+ *   // Can be used as a standalone type:
+ *   const value: JSONValue = {
+ *     name: 'example',
+ *     tags: ['one', 'two'],
+ *   };
+ *
+ * @example
+ *   import { type JSONValue } from '@zimic/http';
+ *
+ *   // Can be used with a type argument to validate a JSON value:
+ *   type ValidJSON = JSONValue<{
+ *     id: string;
+ *     email: string;
+ *     createdAt: string;
+ *   }>;
+ *
+ *   // This results in a type error:
+ *   type InvalidJSON = JSONValue<{
+ *     id: string;
+ *     email: string;
+ *     createdAt: Date; // `Date` is not a valid JSON value.
+ *     save: () => Promise<void>; // Functions are not valid JSON values.
+ *   }>;
+ */
+type JSONValue<Type extends JSON = JSON> = Type;
+declare namespace JSONValue {
+    /** A loose version of the JSON value type. JSON objects are not strictly typed. */
+    type Loose<Type extends JSON.Loose = JSON.Loose> = Type;
+}
+/**
+ * Recursively converts a type to its JSON-serialized version. Dates are converted to strings and keys with non-JSON
+ * values are excluded.
+ *
+ * @example
+ *   import { type JSONSerialized } from '@zimic/http';
+ *
+ *   type SerializedUser = JSONSerialized<{
+ *     id: string;
+ *     email: string;
+ *     createdAt: Date;
+ *     save: () => Promise<void>;
+ *   }>;
+ *   // {
+ *   //   id: string;
+ *   //   email: string;
+ *   //   createdAt: string;
+ *   // }
+ */
+type JSONSerialized<Type> = Type extends JSONValue ? Type : Type extends string | number | boolean | null | undefined ? Type : Type extends Date ? string : Type extends (...parameters: never[]) => unknown ? never : Type extends symbol ? never : Type extends Map<infer _Key, infer _Value> ? Record<string, never> : Type extends Set<infer _Value> ? Record<string, never> : Type extends (infer ArrayItem)[] ? JSONSerialized<ArrayItem>[] : Type extends object ? {
+    [Key in keyof Type as [JSONSerialized<Type[Key]>] extends [never] ? never : Key]: JSONSerialized<Type[Key]>;
+} : never;
+
+type Default<Type, IfEmpty = never> = [undefined | void] extends [Type] ? IfEmpty : Exclude<Type, undefined | void>;
+type IfAny<Type, Yes, No = Type> = 0 extends 1 & Type ? Yes : No;
+type IfNever<Type, Yes, No = Type> = [Type] extends [never] ? Yes : No;
+type UnionToIntersection<Union> = (Union extends unknown ? (union: Union) => void : never) extends (intersectedUnion: infer IntersectedUnion) => void ? IntersectedUnion : never;
+type UnionHasMoreThanOneType<Union> = [UnionToIntersection<Union>] extends [never] ? true : false;
+type Prettify<Type> = {
+    [Key in keyof Type]: Type[Key];
+};
+type ArrayItemIfArray<Type> = Type extends (infer Item)[] ? Item : Type;
+type PickArrayProperties<Type> = {
+    [Key in keyof Type as never[] extends Type[Key] ? Key : never]: Type[Key];
+};
+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;
+
+/** A schema for strict HTTP form data. */
+interface HttpFormDataSchema {
+    [fieldName: string]: string | string[] | Blob | Blob[] | null | undefined;
+}
+declare namespace HttpFormDataSchema {
+    /** A schema for loose HTTP form data. Field values are not strictly typed. */
+    type Loose = Record<string, any>;
+}
+declare namespace HttpFormDataSchemaName {
+    /** Extracts the names of the form data fields defined in a {@link HttpFormDataSchema} that are arrays. */
+    type Array<Schema extends HttpFormDataSchema> = IfNever<Schema, never, ArrayKey<Schema> & string>;
+    /** Extracts the names of the form data fields defined in a {@link HttpFormDataSchema} that are not arrays. */
+    type NonArray<Schema extends HttpFormDataSchema> = IfNever<Schema, never, NonArrayKey<Schema> & string>;
+}
+/**
+ * Extracts the names of the form data fields defined in a {@link HttpFormDataSchema}. Each key is considered a field
+ * name. `HttpFormDataSchemaName.Array` can be used to extract the names of array form data fields, whereas
+ * `HttpFormDataSchemaName.NonArray` extracts the names of non-array form data fields.
+ *
+ * @example
+ *   import { type HttpFormDataSchemaName } from '@zimic/http';
+ *
+ *   type FormDataName = HttpFormDataSchemaName<{
+ *     title: string;
+ *     descriptions: string[];
+ *     content: Blob;
+ *   }>;
+ *   // "title" | "descriptions" | "content"
+ *
+ *   type ArrayFormDataName = HttpFormDataSchemaName.Array<{
+ *     title: string;
+ *     descriptions: string[];
+ *     content: Blob;
+ *   }>;
+ *   // "descriptions"
+ *
+ *   type NonArrayFormDataName = HttpFormDataSchemaName.NonArray<{
+ *     title: string;
+ *     descriptions: string[];
+ *     content: Blob;
+ *   }>;
+ *   // "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;
+/**
+ * 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.
+ *
+ * @example
+ *   import { type HttpFormDataSerialized } from '@zimic/http';
+ *
+ *   type Schema = HttpFormDataSerialized<{
+ *     contentTitle: string | null;
+ *     contentSize: number;
+ *     content: Blob;
+ *     full?: boolean;
+ *     date: Date;
+ *     method: () => void;
+ *   }>;
+ *   // {
+ *   //   contentTitle: string | null;
+ *   //   contentSize? `${number}`;
+ *   //   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 ? {
+    [Key in keyof Type as IfNever<PrimitiveHttpFormDataSerialized<Type[Key]>, never, Key>]: PrimitiveHttpFormDataSerialized<Type[Key]>;
+} : never;
+
+/**
+ * An extended 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.
+ *
+ * **IMPORTANT**: the input of `HttpFormData` and all of its internal types must be declared inline or as a type aliases
+ * (`type`). They cannot be interfaces.
+ *
+ * @example
+ *   import { HttpFormData } from '@zimic/http';
+ *
+ *   const formData = new HttpFormData<{
+ *     files: File[];
+ *     description?: string;
+ *   }>();
+ *
+ *   formData.append('file', new File(['content'], 'file.txt', { type: 'text/plain' }));
+ *   formData.append('description', 'My file');
+ *
+ *   const files = formData.getAll('file');
+ *   console.log(files); // [File { name: 'file.txt', type: 'text/plain' }]
+ *
+ *   const description = formData.get('description');
+ *   console.log(description); // 'My file'
+ *
+ * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http#httpformdata `HttpFormData` API reference}
+ */
+declare class HttpFormData<Schema extends HttpFormDataSchema = HttpFormDataSchema> extends FormData {
+    /** @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;
+    /** @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;
+    /**
+     * Get the value of the entry associated to a key name.
+     *
+     * If the key might have multiple values, use {@link HttpFormData#getAll} instead.
+     *
+     * @param name The name of the key to get the value of.
+     * @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 all the values of the entry associated with a key name.
+     *
+     * If the key has at most a single value, use {@link HttpFormData#get} instead.
+     *
+     * @param name The name of the key to get the values of.
+     * @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>[];
+    /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/has MDN Reference} */
+    has<Name extends HttpFormDataSchemaName<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;
+    /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/keys MDN Reference} */
+    keys(): FormDataIterator<HttpFormDataSchemaName<Schema>>;
+    /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/values MDN Reference} */
+    values(): FormDataIterator<ReplaceBy<ArrayItemIfArray<NonNullable<Schema[HttpFormDataSchemaName<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>
+    ]>;
+    [Symbol.iterator](): FormDataIterator<[
+        HttpFormDataSchemaName<Schema>,
+        ReplaceBy<ArrayItemIfArray<NonNullable<Schema[HttpFormDataSchemaName<Schema>]>>, Blob, File>
+    ]>;
+    /**
+     * Checks if the data is equal to the other data. Equality is defined as having the same keys and values, regardless
+     * of the order of keys.
+     *
+     * @param otherData The other data to compare.
+     * @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>;
+    /**
+     * 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.
+     *
+     * @param otherData The other data to compare.
+     * @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>;
+    /**
+     * Converts this form data into a plain object. This method is useful for serialization and debugging purposes.
+     *
+     * **NOTE**: If a key has multiple values, the object will contain an array of values for that key. If the key has
+     * only one value, the object will contain its value directly, without an array, regardless of how the value was
+     * initialized when creating the form data.
+     *
+     * @example
+     *   const formData = new HttpFormData<{
+     *     title: string;
+     *     descriptions: string[];
+     *     content: Blob;
+     *   }>();
+     *
+     *   formData.set('title', 'My title');
+     *   formData.append('descriptions', 'Description 1');
+     *   formData.append('descriptions', 'Description 2');
+     *   formData.set('content', new Blob(['content'], { type: 'text/plain' }));
+     *
+     *   const object = formData.toObject();
+     *   console.log(object); // { title: 'My title', descriptions: ['Description 1', 'Description 2'], content: Blob { type: 'text/plain' } }
+     *
+     * @returns A plain object representation of this form data.
+     */
+    toObject(): Schema;
+}
+
+interface HttpPathParamsSchema {
+    [paramName: string]: string | undefined;
+}
+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;
+/**
+ * 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.
+ *
+ * @example
+ *   import { type HttpPathParamsSerialized } from '@zimic/http';
+ *
+ *   type Params = HttpPathParamsSerialized<{
+ *     userId: string;
+ *     notificationId: number | null;
+ *     full?: boolean;
+ *     from?: Date;
+ *     method: () => void;
+ *   }>;
+ *   // {
+ *   //   userId: string;
+ *   //   notificationId: `${number}` | undefined;
+ *   //   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 ? {
+    [Key in keyof Type as IfNever<PrimitiveHttpPathParamsSerialized<Type[Key]>, never, Key>]: PrimitiveHttpPathParamsSerialized<Type[Key]>;
+} : never;
+
+/** A schema for strict HTTP headers. */
+interface HttpHeadersSchema {
+    [headerName: string]: string | undefined;
+}
+declare namespace HttpHeadersSchema {
+    /** A schema for loose HTTP headers. Header values are not strictly typed. */
+    type Loose = Record<string, any>;
+}
+/** A strict tuple representation of a {@link HttpHeadersSchema}. */
+type HttpHeadersSchemaTuple<Schema extends HttpHeadersSchema = HttpHeadersSchema> = {
+    [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>[];
+/**
+ * Extracts the names of the headers defined in a {@link HttpHeadersSchema}. Each key is considered a header name.
+ *
+ * @example
+ *   import { type HttpHeadersSchemaName } from '@zimic/http';
+ *
+ *   type HeaderName = HttpHeadersSchemaName<{
+ *     'content-type': string;
+ *     'content-length'?: string;
+ *   }>;
+ *   // "content-type" | "content-length"
+ */
+type HttpHeadersSchemaName<Schema extends HttpHeadersSchema> = IfNever<Schema, never, keyof Schema & string>;
+/**
+ * Recursively converts a schema to its
+ * {@link https://developer.mozilla.org/docs/Web/API/Headers HTTP headers}-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.
+ *
+ * @example
+ *   import { type HttpHeadersSerialized } from '@zimic/http';
+ *
+ *   type Params = HttpHeadersSerialized<{
+ *     'content-type': string;
+ *     'x-remaining-tries': number;
+ *     'x-full'?: boolean;
+ *     'x-date': Date;
+ *     method: () => void;
+ *   }>;
+ *   // {
+ *   //   'content-type': string;
+ *   //   'x-remaining-tries': `${number}`;
+ *   //   'x-full'?: "false" | "true";
+ *   // }
+ */
+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';
+ *
+ *   const headers = new HttpHeaders<{
+ *     accept?: string;
+ *     'content-type'?: string;
+ *   }>({
+ *     accept: '*',
+ *     'content-type': 'application/json',
+ *   });
+ *
+ *   const contentType = headers.get('content-type');
+ *   console.log(contentType); // 'application/json'
+ *
+ * @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>);
+    /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/set MDN Reference} */
+    set<Name extends HttpHeadersSchemaName<Schema>>(name: Name, value: NonNullable<Schema[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]>): 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>;
+    /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/has MDN Reference} */
+    getSetCookie(): NonNullable<Default<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;
+    /** @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]>, 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>>;
+    /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/values MDN Reference} */
+    values(): HeadersIterator<NonNullable<Schema[HttpHeadersSchemaName<Schema>]>>;
+    /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/entries MDN Reference} */
+    entries(): HeadersIterator<[HttpHeadersSchemaName<Schema>, NonNullable<Schema[HttpHeadersSchemaName<Schema>]>]>;
+    [Symbol.iterator](): HeadersIterator<[
+        HttpHeadersSchemaName<Schema>,
+        NonNullable<Schema[HttpHeadersSchemaName<Schema>]>
+    ]>;
+    /**
+     * Checks if this headers object is equal to another set of headers. Equality is defined as having the same keys and
+     * values, regardless of the order of keys.
+     *
+     * @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;
+    /**
+     * 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
+     * headers.
+     *
+     * @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;
+    /**
+     * Converts these headers into a plain object. This method is useful for serialization and debugging purposes.
+     *
+     * @example
+     *   const headers = new HttpHeaders({
+     *     accept: 'application/json',
+     *     'content-type': 'application/json',
+     *   });
+     *   const object = headers.toObject();
+     *   console.log(object); // { accept: 'application/json', 'content-type': 'application/json' }
+     *
+     * @returns A plain object representation of these headers.
+     */
+    toObject(): Schema;
+    private splitHeaderValues;
+}
+
+/** A schema for strict HTTP URL search parameters. */
+interface HttpSearchParamsSchema {
+    [paramName: string]: string | string[] | undefined;
+}
+declare namespace HttpSearchParamsSchema {
+    /** A schema for loose HTTP URL search parameters. Parameter values are not strictly typed. */
+    type Loose = Record<string, any>;
+}
+/** A strict tuple representation of a {@link HttpSearchParamsSchema}. */
+type HttpSearchParamsSchemaTuple<Schema extends HttpSearchParamsSchema = HttpSearchParamsSchema> = {
+    [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>[];
+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>;
+    /** Extracts the names of the search params defined in a {@link HttpSearchParamsSchema} that are not arrays. */
+    type NonArray<Schema extends HttpSearchParamsSchema> = IfNever<Schema, never, NonArrayKey<Schema> & string>;
+}
+/**
+ * Extracts the names of the search params defined in a {@link HttpSearchParamsSchema}. Each key is considered a search
+ * param name. `HttpSearchParamsSchemaName.Array` can be used to extract the names of array search params, whereas
+ * `HttpSearchParamsSchemaName.NonArray` extracts the names of non-array search params.
+ *
+ * @example
+ *   import { type HttpSearchParamsSchemaName } from '@zimic/http';
+ *
+ *   type SearchParamsName = HttpSearchParamsSchemaName<{
+ *     query?: string[];
+ *     page?: `${number}`;
+ *     perPage?: `${number}`;
+ *   }>;
+ *   // "query" | "page" | "perPage"
+ *
+ *   type ArraySearchParamsName = HttpSearchParamsSchemaName.Array<{
+ *     query?: string[];
+ *     page?: `${number}`;
+ *     perPage?: `${number}`;
+ *   }>;
+ *   // "query"
+ *
+ *   type NonArraySearchParamsName = HttpSearchParamsSchemaName.NonArray<{
+ *     query?: string[];
+ *     page?: `${number}`;
+ *     perPage?: `${number}`;
+ *   }>;
+ *   // "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;
+/**
+ * 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.
+ *
+ * @example
+ *   import { type HttpSearchParamsSerialized } from '@zimic/http';
+ *
+ *   type Params = HttpSearchParamsSerialized<{
+ *     query: string | null;
+ *     page?: number;
+ *     full?: boolean;
+ *     date: Date;
+ *     method: () => void;
+ *   }>;
+ *   // {
+ *   //   query: string | undefined;
+ *   //   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 ? {
+    [Key in keyof Type as IfNever<PrimitiveHttpSearchParamsSerialized<Type[Key]>, never, Key>]: PrimitiveHttpSearchParamsSerialized<Type[Key]>;
+} : never;
+
+/**
+ * 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';
+ *
+ *   const searchParams = new HttpSearchParams<{
+ *     names?: string[];
+ *     page?: `${number}`;
+ *   }>({
+ *     names: ['user 1', 'user 2'],
+ *     page: '1',
+ *   });
+ *
+ *   const names = searchParams.getAll('names');
+ *   console.log(names); // ['user 1', 'user 2']
+ *
+ *   const page = searchParams.get('page');
+ *   console.log(page); // '1'
+ *
+ * @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>);
+    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;
+    /** @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;
+    /**
+     * Get the value of the entry associated to a key name.
+     *
+     * If the key might have multiple values, use {@link HttpSearchParams#getAll} instead.
+     *
+     * @param name The name of the key to get the value of.
+     * @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 all the values of the entry associated with a key name.
+     *
+     * If the key has at most one value, use {@link HttpSearchParams#get} instead.
+     *
+     * @param name The name of the key to get the values of.
+     * @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]>>[];
+    /** @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;
+    /** @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;
+    /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/keys MDN Reference} */
+    keys(): URLSearchParamsIterator<HttpSearchParamsSchemaName<Schema>>;
+    /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/values MDN Reference} */
+    values(): URLSearchParamsIterator<ArrayItemIfArray<NonNullable<Schema[HttpSearchParamsSchemaName<Schema>]>>>;
+    /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/entries MDN Reference} */
+    entries(): URLSearchParamsIterator<[
+        HttpSearchParamsSchemaName<Schema>,
+        ArrayItemIfArray<NonNullable<Schema[HttpSearchParamsSchemaName<Schema>]>>
+    ]>;
+    [Symbol.iterator](): URLSearchParamsIterator<[
+        HttpSearchParamsSchemaName<Schema>,
+        ArrayItemIfArray<NonNullable<Schema[HttpSearchParamsSchemaName<Schema>]>>
+    ]>;
+    /**
+     * Checks if these search params are equal to another set of search parameters. Equality is defined as having the same
+     * keys and values, regardless of the order of the keys.
+     *
+     * @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;
+    /**
+     * 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
+     * present in these search parameters.
+     *
+     * @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;
+    /**
+     * Converts these search params into a plain object. This method is useful for serialization and debugging purposes.
+     *
+     * **NOTE**: If a key has multiple values, the object will contain an array of values for that key. If the key has
+     * only one value, the object will contain its value directly, without an array, regardless of how the value was
+     * initialized when creating the search params object.
+     *
+     * @example
+     *   const searchParams = new HttpSearchParams({
+     *     names: ['user 1', 'user 2'],
+     *     name: ['user 3'],
+     *     page: '1',
+     *   });
+     *   const object = searchParams.toObject();
+     *   console.log(object); // { names: ['user 1', 'user 2'], name: 'user 3', page: '1' }
+     *
+     * @returns A plain object representation of these search params.
+     */
+    toObject(): Schema;
+}
+
+declare const HTTP_METHODS_WITH_REQUEST_BODY: readonly ["POST", "PUT", "PATCH", "DELETE"];
+type HttpMethodWithRequestBody = (typeof HTTP_METHODS_WITH_REQUEST_BODY)[number];
+declare const HTTP_METHODS_WITH_RESPONSE_BODY: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
+type HttpMethodWithResponseBody = (typeof HTTP_METHODS_WITH_RESPONSE_BODY)[number];
+declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+/**
+ * A type representing the currently supported
+ * {@link https://developer.mozilla.org/docs/Web/HTTP/Methods `HTTP methods`}.
+ */
+type HttpMethod = (typeof HTTP_METHODS)[number];
+/**
+ * A schema representing the structure of an HTTP request.
+ *
+ * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http‐schemas Declaring HTTP interceptor schemas}
+ */
+interface HttpRequestSchema {
+    headers?: HttpHeadersSchema.Loose;
+    searchParams?: HttpSearchParamsSchema.Loose;
+    body?: HttpBody.Loose;
+}
+type ConvertToStrictHttpRequestSchema<Schema> = {
+    [Key in keyof Schema]: Key extends 'headers' ? HttpHeadersSerialized<Schema[Key]> : Key extends 'searchParams' ? HttpSearchParamsSerialized<Schema[Key]> : Key extends 'body' ? HttpBody.ConvertToStrict<Schema[Key]> : Schema[Key];
+};
+/**
+ * A schema representing the structure of an HTTP response.
+ *
+ * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http‐schemas Declaring HTTP interceptor schemas}
+ */
+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;
+    }
+}
+type ConvertToStrictHttpResponseSchema<Schema> = ConvertToStrictHttpRequestSchema<Schema>;
+/**
+ * The status codes used in HTTP responses, as defined by
+ * {@link https://httpwg.org/specs/rfc9110.html#overview.of.status.codes RFC-9110}.
+ *
+ * - `HttpStatusCode.Information`: {@link https://developer.mozilla.org/docs/Web/HTTP/Status#information_responses `1XX`}
+ * - `HttpStatusCode.Success`: {@link https://developer.mozilla.org/docs/Web/HTTP/Status#successful_responses `2XX`}
+ * - `HttpStatusCode.Redirection`: {@link https://developer.mozilla.org/docs/Web/HTTP/Status#redirection_messages `3XX`}
+ * - `HttpStatusCode.ClientError`: {@link https://developer.mozilla.org/docs/Web/HTTP/Status#client_error_responses `4XX`}
+ * - `HttpStatusCode.ServerError`: {@link https://developer.mozilla.org/docs/Web/HTTP/Status#server_error_responses `5XX`}
+ */
+declare namespace HttpStatusCode {
+    /**
+     * An HTTP status code in the `1XX` range, representing an informational response.
+     *
+     * @see {@link https://developer.mozilla.org/docs/Web/HTTP/Status#information_responses `1XX`}
+     */
+    type Information = 100 | 101 | 102 | 103;
+    /**
+     * An HTTP status code in the `2XX` range, representing a successful response.
+     *
+     * @see {@link https://developer.mozilla.org/docs/Web/HTTP/Status#successful_responses `2XX`}
+     */
+    type Success = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+    /**
+     * An HTTP status code in the `3XX` range, representing a redirection response.
+     *
+     * @see {@link https://developer.mozilla.org/docs/Web/HTTP/Status#redirection_messages `3XX`}
+     */
+    type Redirection = 300 | 301 | 302 | 303 | 304 | 307 | 308;
+    /**
+     * An HTTP status code in the `4XX` range, representing a client error response.
+     *
+     * @see {@link https://developer.mozilla.org/docs/Web/HTTP/Status#client_error_responses `4XX`}
+     */
+    type ClientError = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
+    /**
+     * An HTTP status code in the `5XX` range, representing a server error response.
+     *
+     * @see {@link https://developer.mozilla.org/docs/Web/HTTP/Status#server_error_responses `5XX`}
+     */
+    type ServerError = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+}
+type HttpStatusCode = HttpStatusCode.Information | HttpStatusCode.Success | HttpStatusCode.Redirection | HttpStatusCode.ClientError | HttpStatusCode.ServerError;
+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 a possibly loose HTTP response schema by status code to be strictly typed. JSON values are serialized to
+     * their strict form.
+     */
+    type ConvertToStrict<Schema extends Loose> = {
+        [StatusCode in keyof Schema]: StatusCode extends 204 ? HttpResponseSchema.NoBody : Schema[StatusCode];
+    };
+    /** A schema representing the structure of HTTP responses by status code with no body. */
+    type NoBody = {
+        [StatusCode in HttpStatusCode]?: HttpResponseSchema.NoBody;
+    };
+}
+/**
+ * A schema representing the structure of HTTP responses by status code.
+ *
+ * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http‐schemas Declaring HTTP interceptor schemas}
+ */
+type HttpResponseSchemaByStatusCode = HttpResponseSchemaByStatusCode.ConvertToStrict<HttpResponseSchemaByStatusCode.Loose>;
+type ConvertToStrictHttpResponseSchemaByStatusCode<Schema> = {
+    [Key in keyof Schema]: ConvertToStrictHttpResponseSchema<Schema[Key]>;
+};
+/**
+ * Extracts the status codes used in a response schema by status code.
+ *
+ * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http‐schemas Declaring HTTP interceptor schemas}
+ */
+type HttpResponseSchemaStatusCode<ResponseSchemaByStatusCode extends HttpResponseSchemaByStatusCode> = keyof ResponseSchemaByStatusCode & HttpStatusCode;
+/**
+ * A schema representing the structure of an HTTP request and response for a given method.
+ *
+ * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http‐schemas Declaring HTTP interceptor schemas}
+ */
+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;
+    }
+}
+type ConvertToStrictMethod<Schema> = {
+    [Key in keyof Schema]: Key extends 'request' ? ConvertToStrictHttpRequestSchema<Schema[Key]> : Key extends 'response' ? ConvertToStrictHttpResponseSchemaByStatusCode<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‐interceptor‐http‐schemas Declaring HTTP interceptor schemas}
+ */
+interface HttpMethodsSchema {
+    GET?: HttpMethodSchema.NoRequestBody;
+    POST?: HttpMethodSchema;
+    PUT?: HttpMethodSchema;
+    PATCH?: HttpMethodSchema;
+    DELETE?: HttpMethodSchema;
+    HEAD?: HttpMethodSchema.NoBody;
+    OPTIONS?: HttpMethodSchema.NoRequestBody;
+}
+type ConvertToStrictHttpMethodsSchema<Schema> = {
+    [Method in keyof Schema]: ConvertToStrictMethod<Schema[Method]>;
+};
+interface BaseHttpSchema {
+    [path: string]: HttpMethodsSchema;
+}
+type ConvertToStrictHttpSchema<Schema extends HttpSchema> = {
+    [Path in keyof Schema]: ConvertToStrictHttpMethodsSchema<Schema[Path]>;
+};
+/**
+ * Declares an HTTP service schema.
+ *
+ * **IMPORTANT**: the input of `HttpSchema` and all of its internal types, except bodies, must be declared inline or as
+ * a type aliases (`type`). Types other than bodies cannot be interfaces.
+ *
+ * @example
+ *   import { type HttpSchema } from '@zimic/http';
+ *
+ *   interface UserListHeaders {
+ *     accept: string;
+ *   }
+ *
+ *   interface UserListSearchParams {
+ *     name?: string;
+ *     limit?: `${number}`;
+ *   }
+ *
+ *   type Schema = HttpSchema<{
+ *     '/users': {
+ *       GET: {
+ *         request: {
+ *           headers: UserListHeaders;
+ *           searchParams: UserListSearchParams;
+ *         };
+ *         response: {
+ *           200: {
+ *             // Inline headers declaration
+ *             headers: { 'content-type': string };
+ *             body: User[];
+ *           };
+ *         };
+ *       };
+ *     };
+ *   }>;
+ *
+ * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http‐schemas Declaring HTTP interceptor schemas}
+ */
+type HttpSchema<Schema extends BaseHttpSchema = BaseHttpSchema> = ConvertToStrictHttpSchema<Schema>;
+declare namespace HttpSchema {
+    /**
+     * Declares an HTTP service methods schema.
+     *
+     * **IMPORTANT**: the input of `HttpSchema.Methods` and all of its internal types, except bodies, must be declared
+     * inline or as a type aliases (`type`). Types other than bodies cannot be interfaces.
+     *
+     * @example
+     *   import { type HttpSchema } from '@zimic/http';
+     *
+     *   type UserMethods = HttpSchema.Methods<{
+     *     GET: {
+     *       response: {
+     *         200: { body: User[] };
+     *       };
+     *     };
+     *   }>;
+     *
+     *   type Schema = HttpSchema<{
+     *     '/users': UserMethods;
+     *   }>;
+     */
+    type Methods<Schema extends HttpMethodsSchema> = ConvertToStrictHttpMethodsSchema<Schema>;
+    /**
+     * Declares an HTTP service method schema.
+     *
+     * **IMPORTANT**: the input of `HttpSchema.Method` and all of its internal types, except bodies, must be declared
+     * inline or as a type aliases (`type`). Types other than bodies cannot be interfaces.
+     *
+     * @example
+     *   import { type HttpSchema } from '@zimic/http';
+     *
+     *   type UserListMethod = HttpSchema.Method<{
+     *     response: {
+     *       200: { body: User[] };
+     *     };
+     *   }>;
+     *
+     *   type Schema = HttpSchema<{
+     *     '/users': {
+     *       GET: UserListMethod;
+     *     };
+     *   }>;
+     */
+    type Method<Schema extends HttpMethodSchema> = ConvertToStrictMethod<Schema>;
+    /**
+     * Declares an HTTP service request schema.
+     *
+     * **IMPORTANT**: the input of `HttpSchema.Request` and all of its internal types, except bodies, must be declared
+     * inline or as a type aliases (`type`). Types other than bodies cannot be interfaces.
+     *
+     * @example
+     *   import { type HttpSchema } from '@zimic/http';
+     *
+     *   type UserCreationRequest = HttpSchema.Request<{
+     *     headers: { 'content-type': 'application/json' };
+     *     body: User;
+     *   }>;
+     *
+     *   type Schema = HttpSchema<{
+     *     '/users': {
+     *       POST: {
+     *         request: UserCreationRequest;
+     *         response: {
+     *           201: { body: User };
+     *         };
+     *       };
+     *     };
+     *   }>;
+     */
+    type Request<Schema extends HttpRequestSchema> = ConvertToStrictHttpRequestSchema<Schema>;
+    /**
+     * Declares an HTTP service response schema by status code.
+     *
+     * **IMPORTANT**: the input of `HttpSchema.ResponseByStatusCode` and all of its internal types, except bodies, must be
+     * declared inline or as a type aliases (`type`). Types other than bodies cannot be interfaces.
+     *
+     * @example
+     *   import { type HttpSchema } from '@zimic/http';
+     *
+     *   type UserListResponseByStatusCode = HttpSchema.ResponseByStatusCode<{
+     *     200: { body: User[] };
+     *     400: { body: { message: string } };
+     *   }>;
+     *
+     *   type Schema = HttpSchema<{
+     *     '/users': {
+     *       GET: {
+     *         response: UserListResponseByStatusCode;
+     *       };
+     *     };
+     *   }>;
+     */
+    type ResponseByStatusCode<Schema extends HttpResponseSchemaByStatusCode> = ConvertToStrictHttpResponseSchemaByStatusCode<Schema>;
+    /**
+     * Declares an HTTP service response schema.
+     *
+     * **IMPORTANT**: the input of `HttpSchema.Response` and all of its internal types, except bodies, must be declared
+     * inline or as a type aliases (`type`). Types other than bodies cannot be interfaces.
+     *
+     * @example
+     *   import { type HttpSchema } from '@zimic/http';
+     *
+     *   type UserListSuccessResponse = HttpSchema.Response<{
+     *     body: User[];
+     *   }>;
+     *
+     *   type Schema = HttpSchema<{
+     *     '/users': {
+     *       GET: {
+     *         response: {
+     *           200: UserListSuccessResponse;
+     *         };
+     *       };
+     *     };
+     *   }>;
+     */
+    type Response<Schema extends HttpResponseSchema> = ConvertToStrictHttpResponseSchema<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.
+     *
+     * @example
+     *   import { type HttpSchema } from '@zimic/http';
+     *
+     *   type UserListSuccessResponseBody = HttpSchema.Body<User[]>;
+     *
+     *   type Schema = HttpSchema<{
+     *     '/users': {
+     *       GET: {
+     *         response: {
+     *           200: { body: UserListSuccessResponseBody };
+     *         };
+     *       };
+     *     };
+     *   }>;
+     */
+    type Body<Schema extends HttpBody.Loose> = HttpBody.ConvertToStrict<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.
+     *
+     * @example
+     *   import { type HttpSchema } from '@zimic/http';
+     *
+     *   type UserListHeaders = HttpSchema.Headers<{
+     *     accept: 'application/json';
+     *   }>;
+     *
+     *   type Schema = HttpSchema<{
+     *     '/users': {
+     *       GET: {
+     *         request: {
+     *           headers: UserListHeaders;
+     *         };
+     *         response: {
+     *           200: { body: User[] };
+     *         };
+     *       };
+     *     };
+     *   }>;
+     */
+    type Headers<Schema extends HttpHeadersSchema.Loose> = HttpHeadersSerialized<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.
+     *
+     * @example
+     *   import { type HttpSchema } from '@zimic/http';
+     *
+     *   type UserListSearchParams = HttpSchema.SearchParams<{
+     *     limit: `${number}`;
+     *     offset: `${number}`;
+     *   }>;
+     *
+     *   type Schema = HttpSchema<{
+     *     '/users': {
+     *       GET: {
+     *         request: {
+     *           searchParams: UserListSearchParams;
+     *         };
+     *         response: {
+     *           200: { body: User[] };
+     *         };
+     *       };
+     *     };
+     *   }>;
+     */
+    type SearchParams<Schema extends HttpSearchParamsSchema.Loose> = HttpSearchParamsSerialized<Schema>;
+    /**
+     * Declares an HTTP path params schema. Path params are serialized to their strict form using
+     * {@link HttpPathParamsSerialized} if necessary.
+     *
+     * @example
+     *   import { type HttpSchema, InferPathParams } from '@zimic/http';
+     *
+     *   type Schema = HttpSchema<{
+     *     '/users/:userId': {
+     *       GET: {
+     *         response: {
+     *           200: { body: User };
+     *         };
+     *       };
+     *     };
+     *   }>;
+     *
+     *   type UserByIdPathParams = HttpSchema.PathParams<{
+     *     userId: string;
+     *   }>;
+     *
+     *   // Or infer from the path string
+     *   type UserByIdPathParams = InferPathParams<Schema, '/users/:userId'>;
+     */
+    type PathParams<Schema extends HttpPathParamsSchema.Loose> = HttpPathParamsSerialized<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.
+     *
+     * @example
+     *   import { HttpFormData, type HttpSchema } from '@zimic/http';
+     *
+     *   type UserCreationFormData = HttpFormData<
+     *     HttpSchema.FormData<{
+     *       name: string;
+     *       email: string;
+     *     }>
+     *   >;
+     *
+     *   type Schema = HttpSchema<{
+     *     '/users': {
+     *       POST: {
+     *         request: {
+     *           body: UserCreationFormData;
+     *         };
+     *         response: {
+     *           201: { body: User };
+     *         };
+     *       };
+     *     };
+     *   }>;
+     */
+    type FormData<Schema extends HttpFormDataSchema.Loose> = HttpFormDataSerialized<Schema>;
+}
+/**
+ * Extracts the methods from an HTTP service schema.
+ *
+ * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http‐schemas Declaring HTTP interceptor schemas}
+ */
+type HttpSchemaMethod<Schema extends HttpSchema> = IfAny<Schema, any, // eslint-disable-line @typescript-eslint/no-explicit-any
+// eslint-disable-line @typescript-eslint/no-explicit-any
+keyof UnionToIntersection<Schema[keyof Schema]> & HttpMethod>;
+type AllowAnyStringInPathParams<Path extends string> = Path extends `${infer Prefix}:${string}/${infer Suffix}` ? `${Prefix}${string}/${AllowAnyStringInPathParams<Suffix>}` : Path extends `${infer Prefix}:${string}` ? `${Prefix}${string}` : Path;
+/**
+ * Extracts the paths from an HTTP service schema. Optionally receives a second argument with one or more methods to
+ * filter the paths with. Only the methods defined in the schema are allowed.
+ *
+ * @example
+ *   import { type HttpSchema, type HttpSchemaPath } from '@zimic/http';
+ *
+ *   type Schema = HttpSchema<{
+ *     '/users': {
+ *       GET: {
+ *         response: { 200: { body: User[] } };
+ *       };
+ *     };
+ *     '/users/:userId': {
+ *       DELETE: {
+ *         response: { 200: { body: User } };
+ *       };
+ *     };
+ *   }>;
+ *
+ *   type Path = HttpSchemaPath<Schema>;
+ *   // "/users" | "/users/:userId" | "/users/${string}"
+ *
+ *   type GetPath = HttpSchemaPath<Schema, 'GET'>;
+ *   // "/users"
+ *
+ * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http‐schemas Declaring HTTP interceptor schemas}
+ */
+declare namespace HttpSchemaPath {
+    type LooseLiteral<Schema extends HttpSchema, Method extends HttpMethod = HttpMethod> = {
+        [Path in keyof Schema & string]: Method extends keyof Schema[Path] ? Path : never;
+    }[keyof Schema & string];
+    /**
+     * Extracts the literal paths from an HTTP service schema. Optionally receives a second argument with one or more
+     * methods to filter the paths with. Only the methods defined in the schema are allowed.
+     *
+     * @example
+     *   import { type HttpSchema, type HttpSchemaPath } from '@zimic/http';
+     *
+     *   type Schema = HttpSchema<{
+     *     '/users': {
+     *       GET: {
+     *         response: { 200: { body: User[] } };
+     *       };
+     *     };
+     *     '/users/:userId': {
+     *       DELETE: {
+     *         response: { 200: { body: User } };
+     *       };
+     *     };
+     *   }>;
+     *
+     *   type LiteralPath = HttpSchemaPath.Literal<Schema>;
+     *   // "/users" | "/users/:userId"
+     *
+     *   type LiteralGetPath = HttpSchemaPath.Literal<Schema, 'GET'>;
+     *   // "/users"
+     *
+     * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http‐schemas Declaring HTTP interceptor schemas}
+     */
+    export type Literal<Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema> = HttpSchemaMethod<Schema>> = LooseLiteral<Schema, Method>;
+    /**
+     * Extracts the non-literal paths from an HTTP service schema. Optionally receives a second argument with one or more
+     * methods to filter the paths with. Only the methods defined in the schema are allowed.
+     *
+     * @example
+     *   import { type HttpSchema, type HttpSchemaPath } from '@zimic/http';
+     *
+     *   type Schema = HttpSchema<{
+     *     '/users': {
+     *       GET: {
+     *         response: { 200: { body: User[] } };
+     *       };
+     *     };
+     *     '/users/:userId': {
+     *       DELETE: {
+     *         response: { 200: { body: User } };
+     *       };
+     *     };
+     *   }>;
+     *
+     *   type NonLiteralPath = HttpSchemaPath.NonLiteral<Schema>;
+     *   // "/users" | "/users/${string}"
+     *
+     *   type NonLiteralGetPath = HttpSchemaPath.NonLiteral<Schema, 'GET'>;
+     *   // "/users"
+     *
+     * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐interceptor‐http‐schemas Declaring HTTP interceptor schemas}
+     */
+    export type NonLiteral<Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema> = HttpSchemaMethod<Schema>> = AllowAnyStringInPathParams<Literal<Schema, Method>>;
+    export {  };
+}
+type HttpSchemaPath<Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema> = HttpSchemaMethod<Schema>> = HttpSchemaPath.Literal<Schema, Method> | HttpSchemaPath.NonLiteral<Schema, Method>;
+type LargestPathPrefix<Path extends string> = Path extends `${infer Prefix}/${infer Suffix}` ? `${Prefix}/${Suffix extends `${string}/${string}` ? LargestPathPrefix<Suffix> : ''}` : Path;
+type ExcludeNonLiteralPathsSupersededByLiteralPath<Path extends string> = Path extends `${LargestPathPrefix<Path>}:${string}` ? never : Path;
+type PreferMostStaticLiteralPath<Path extends string> = UnionHasMoreThanOneType<Path> extends true ? ExcludeNonLiteralPathsSupersededByLiteralPath<Path> : Path;
+type RecursiveInferHttpSchemaPath<Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, NonLiteralPath extends string, LiteralPath extends HttpSchemaPath.Literal<Schema, Method>> = NonLiteralPath extends AllowAnyStringInPathParams<LiteralPath> ? NonLiteralPath extends `${AllowAnyStringInPathParams<LiteralPath>}/${string}` ? never : LiteralPath : never;
+type LiteralHttpSchemaPathFromNonLiteral<Schema extends HttpSchema, Method extends HttpSchemaMethod<Schema>, NonLiteralPath extends string, LiteralPath extends HttpSchemaPath.Literal<Schema, Method> = HttpSchemaPath.Literal<Schema, Method>> = PreferMostStaticLiteralPath<LiteralPath extends LiteralPath ? RecursiveInferHttpSchemaPath<Schema, Method, NonLiteralPath, LiteralPath> : never>;
+type RecursiveInferPathParams<Path extends string> = Path extends `${infer _Prefix}:${infer ParamName}/${infer Suffix}` ? {
+    [Name in ParamName]: string;
+} & RecursiveInferPathParams<Suffix> : Path extends `${infer _Prefix}:${infer ParamName}` ? {
+    [Name in ParamName]: string;
+} : {};
+/**
+ * Infers the path parameters schema from a path string, optionally validating it against an {@link HttpSchema}.
+ *
+ * If the first argument is a {@link HttpSchema} (recommended), the second argument is checked to be a valid path in that
+ * schema.
+ *
+ * @example
+ *   import { HttpSchema, InferPathParams } from '@zimic/http';
+ *
+ *   type MySchema = HttpSchema<{
+ *     '/users/:userId': {
+ *       GET: {
+ *         response: { 200: { body: User } };
+ *       };
+ *     };
+ *   }>;
+ *
+ *   // Using a schema to validate the path (recommended):
+ *   type PathParams = InferPathParams<MySchema, '/users/:userId'>;
+ *   // { userId: string }
+ *
+ * @example
+ *   import { InferPathParams } from '@zimic/http';
+ *
+ *   // Without using a schema to validate the path (works as `PathParamsSchemaFromPath`):
+ *   type PathParams = InferPathParams<'/users/:userId'>;
+ *   // { 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;
+/**
+ * Merges multiple HTTP response schemas by status code into a single schema. When there are duplicate status codes, the
+ * first declaration takes precedence.
+ *
+ * @example
+ *   import { type HttpSchema, type HttpStatusCode, MergeHttpResponsesByStatusCode } from '@zimic/http';
+ *
+ *   // Overriding the 400 status code with a more specific schema
+ *   // and using a generic schema for all other client errors.
+ *   type MergedResponseByStatusCode = MergeHttpResponsesByStatusCode<
+ *     [
+ *       {
+ *         400: { body: { message: string; issues: string[] } };
+ *       },
+ *       {
+ *         [StatusCode in HttpStatusCode.ClientError]: { body: { message: string } };
+ *       },
+ *     ]
+ *   >;
+ *   // {
+ *   //   400: { body: { message: string; issues: string[] } };
+ *   //   401: { body: { message: string}; };
+ *   //   402: { body: { message: string}; };
+ *   //   403: { body: { message: string}; };
+ *   //   ...
+ *   // }
+ *
+ *   type Schema = HttpSchema<{
+ *     '/users': {
+ *       GET: { response: MergedResponseByStatusCode };
+ *     };
+ *   }>;
+ */
+type MergeHttpResponsesByStatusCode<Schemas extends HttpResponseSchemaByStatusCode.Loose[], PastSchemas extends HttpResponseSchemaByStatusCode.Loose[] = []> = HttpResponseSchemaByStatusCode.ConvertToStrict<RecursiveMergeHttpResponsesByStatusCode<Schemas, PastSchemas>>;
+
+/** 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 a possibly loose HTTP body to be strictly typed. JSON values are serialized to their strict form. */
+    type ConvertToStrict<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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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 {
+    headers: StrictHeaders<StrictHeadersSchema>;
+    text: () => Promise<StrictBody extends string ? StrictBody : string>;
+    json: () => Promise<StrictBody extends string | Exclude<HttpBody, JSONValue> ? never : StrictBody>;
+    formData: () => Promise<StrictBody extends HttpFormData<infer HttpFormDataSchema> ? StrictFormData<HttpFormDataSchema> : StrictBody extends HttpSearchParams<infer HttpSearchParamsSchema> ? StrictFormData<HttpSearchParamsSchema> : FormData>;
+    clone: () => this;
+}
+/**
+ * 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 {
+    ok: StatusCode extends HttpStatusCode.Information | HttpStatusCode.Success | HttpStatusCode.Redirection ? true : false;
+    status: StatusCode;
+    headers: StrictHeaders<StrictHeadersSchema>;
+    text: () => Promise<StrictBody extends string ? StrictBody : string>;
+    json: () => Promise<StrictBody extends string | Exclude<HttpBody, JSONValue> ? never : StrictBody>;
+    formData: () => Promise<StrictBody extends HttpFormData<infer HttpFormDataSchema> ? StrictFormData<HttpFormDataSchema> : StrictBody extends HttpSearchParams<infer HttpSearchParamsSchema> ? StrictFormData<HttpSearchParamsSchema> : FormData>;
+    clone: () => this;
+}
+
+export { type AllowAnyStringInPathParams, HTTP_METHODS, HTTP_METHODS_WITH_REQUEST_BODY, HTTP_METHODS_WITH_RESPONSE_BODY, HttpBody, HttpFormData, HttpFormDataSchema, HttpFormDataSchemaName, type HttpFormDataSerialized, HttpHeaders, type HttpHeadersInit, HttpHeadersSchema, type HttpHeadersSchemaName, type HttpHeadersSchemaTuple, type HttpHeadersSerialized, type HttpMethod, HttpMethodSchema, type HttpMethodWithRequestBody, type HttpMethodWithResponseBody, type HttpMethodsSchema, HttpPathParamsSchema, type HttpPathParamsSerialized, type HttpRequest, type HttpRequestSchema, type HttpResponse, 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 };