@zimic/http 0.3.2 → 0.4.0-canary.1

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 {
@@ -181,13 +190,13 @@ 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, Schema extends HttpFormDataSchema = HttpFormDataSerialized<LooseSchema>> 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;
+    set<Name extends HttpFormDataSchemaName<Schema>>(name: Name, value: Exclude<ArrayItemIfArray<NonNullable<LooseSchema[Name]>>, Blob>): void;
+    set<Name extends HttpFormDataSchemaName<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<Schema>>(name: Name, value: Exclude<ArrayItemIfArray<NonNullable<LooseSchema[Name]>>, Blob>): void;
+    append<Name extends HttpFormDataSchemaName<Schema>>(name: Name, blob: Exclude<ArrayItemIfArray<NonNullable<LooseSchema[Name]>>, string>, fileName?: string): void;
     /**
      * Get the value of the entry associated to a key name.
      *
@@ -234,7 +243,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 +252,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.
      *
@@ -313,11 +322,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.
  *
@@ -378,12 +387,12 @@ 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, Schema extends HttpHeadersSchema = HttpHeadersSerialized<LooseSchema>> extends Headers {
+    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<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<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>;
     /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/has MDN Reference} */
@@ -413,7 +422,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 +431,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.
      *
@@ -449,14 +458,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>;
@@ -546,13 +555,13 @@ 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, Schema extends HttpSearchParamsSchema = HttpSearchParamsSerialized<LooseSchema>> extends URLSearchParams {
+    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<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<Schema>>(name: Name, value: ArrayItemIfArray<NonNullable<LooseSchema[Name]>>): void;
     /**
      * Get the value of the entry associated to a key name.
      *
@@ -574,9 +583,9 @@ declare class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearc
      */
     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;
+    has<Name extends HttpSearchParamsSchemaName<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;
+    delete<Name extends HttpSearchParamsSchemaName<Schema>>(name: Name, value?: ArrayItemIfArray<NonNullable<LooseSchema[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>>;
@@ -598,7 +607,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 +616,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.
      *
@@ -629,10 +638,6 @@ declare class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearc
     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
@@ -649,12 +654,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.
  *
@@ -664,14 +663,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}.
@@ -720,21 +711,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.
  *
@@ -750,44 +729,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;
@@ -804,7 +758,7 @@ interface BaseHttpSchema {
  *
  *   interface UserListSearchParams {
  *     name?: string;
- *     limit?: `${number}`;
+ *     limit?: number;
  *   }
  *
  *   type Schema = HttpSchema<{
@@ -827,12 +781,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.
      *
@@ -851,7 +801,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.
      *
@@ -870,7 +820,7 @@ declare namespace HttpSchema {
      *     };
      *   }>;
      */
-    type Method<Schema extends HttpMethodSchema> = HttpMethodSchema.AsStrict<Schema>;
+    type Method<Schema extends HttpMethodSchema> = Schema;
     /**
      * Declares an HTTP service request schema.
      *
@@ -893,7 +843,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.
      *
@@ -913,7 +863,7 @@ declare namespace HttpSchema {
      *     };
      *   }>;
      */
-    type ResponseByStatusCode<Schema extends HttpResponseSchemaByStatusCode> = HttpResponseSchemaByStatusCode.AsStrict<Schema>;
+    type ResponseByStatusCode<Schema extends HttpResponseSchemaByStatusCode> = Schema;
     /**
      * Declares an HTTP service response schema.
      *
@@ -934,10 +884,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';
@@ -954,11 +903,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';
@@ -980,11 +927,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';
@@ -1007,10 +952,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';
@@ -1032,11 +976,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';
@@ -1061,7 +1003,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.
@@ -1204,11 +1146,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.
@@ -1242,36 +1180,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>;
@@ -1282,7 +1221,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, StatusCode extends number = number, StrictHeadersSchema extends HttpHeadersSchema.Loose = HttpHeadersSchema.Loose> extends Response {
     ok: StatusCode extends HttpStatusCode.Information | HttpStatusCode.Success | HttpStatusCode.Redirection ? true : false;
     status: StatusCode;
     headers: StrictHeaders<StrictHeadersSchema>;
@@ -1291,10 +1230,10 @@ 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 HttpRequestHeadersSchema<MethodSchema extends HttpMethodSchema> = 'headers' extends keyof MethodSchema['request'] ? Default<MethodSchema['request']>['headers'] : 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 HttpResponseHeadersSchema<MethodSchema extends HttpMethodSchema, StatusCode extends HttpStatusCode> = 'headers' extends keyof Default<MethodSchema['response']>[StatusCode] ? Default<Default<MethodSchema['response']>[StatusCode]>['headers'] : 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, 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, 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 };

package/dist/index.js

@@ -228,7 +228,7 @@ var HttpFormData_default = HttpFormData;
 function pickPrimitiveProperties(schema) {
   return Object.entries(schema).reduce((accumulated, [key, value]) => {
     if (value !== void 0) {
-      accumulated[key] = value;
+      accumulated[key] = String(value);
     }
     return accumulated;
   }, {});
@@ -365,7 +365,7 @@ function pickPrimitiveProperties2(schema) {
   const schemaWithPrimitiveProperties = Object.entries(schema).reduce(
     (accumulated, [key, value]) => {
       if (value !== void 0 && !Array.isArray(value)) {
-        accumulated[key] = value;
+        accumulated[key] = String(value);
       }
       return accumulated;
     },
@@ -390,7 +390,7 @@ var HttpSearchParams = class extends URLSearchParams {
     for (const [key, value] of Object.entries(init)) {
       if (Array.isArray(value)) {
         for (const item of value) {
-          super.append(key, item);
+          super.append(key, String(item));
         }
       }
     }
@@ -523,20 +523,9 @@ var HttpSearchParams = class extends URLSearchParams {
 var HttpSearchParams_default = HttpSearchParams;
 
 // src/types/schema.ts
-var HTTP_METHODS_WITH_REQUEST_BODY = Object.freeze(["POST", "PUT", "PATCH", "DELETE"]);
-var HTTP_METHODS_WITH_RESPONSE_BODY = Object.freeze([
-  "GET",
-  "POST",
-  "PUT",
-  "PATCH",
-  "DELETE",
-  "OPTIONS"
-]);
 var HTTP_METHODS = Object.freeze(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 
 exports.HTTP_METHODS = HTTP_METHODS;
-exports.HTTP_METHODS_WITH_REQUEST_BODY = HTTP_METHODS_WITH_REQUEST_BODY;
-exports.HTTP_METHODS_WITH_RESPONSE_BODY = HTTP_METHODS_WITH_RESPONSE_BODY;
 exports.HttpFormData = HttpFormData_default;
 exports.HttpHeaders = HttpHeaders_default;
 exports.HttpSearchParams = HttpSearchParams_default;