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

package/src/formData/types.ts

@@ -50,61 +50,55 @@ export namespace HttpFormDataSchemaName {
  */
 export type HttpFormDataSchemaName<Schema extends HttpFormDataSchema> = IfNever<Schema, never, keyof Schema & string>;
 
-type PrimitiveHttpFormDataSerialized<Type> = Type extends HttpFormDataSchema[string]
-  ? Type
-  : Type extends (infer ArrayItem)[]
-    ? ArrayItem extends (infer _InternalArrayItem)[]
-      ? never
-      : PrimitiveHttpFormDataSerialized<ArrayItem>[]
-    : Type extends number
-      ? `${number}`
-      : Type extends boolean
-        ? `${boolean}`
-        : never;
+type PrimitiveHttpFormDataSerialized<Type> = [Type] extends [never]
+  ? never
+  : Type extends number
+    ? `${number}`
+    : Type extends boolean
+      ? `${boolean}`
+      : Type extends null
+        ? 'null'
+        : Type extends symbol
+          ? never
+          : Type extends HttpFormDataSchema[string]
+            ? Type
+            : Type extends (infer ArrayItem)[]
+              ? ArrayItem extends (infer _InternalArrayItem)[]
+                ? never
+                : PrimitiveHttpFormDataSerialized<ArrayItem>[]
+              : string;
 
 /**
  * Recursively converts a schema to its {@link https://developer.mozilla.org/docs/Web/API/FormData FormData}-serialized
- * version. Numbers and booleans are converted to `${number}` and `${boolean}` respectively, and not serializable values
- * are excluded, such as functions and dates.
+ * version. Numbers, booleans, and null are converted to `${number}`, `${boolean}`, and 'null' respectively, and other
+ * values become strings.
  *
  * @example
  *   import { type HttpFormDataSerialized } from '@zimic/http';
  *
  *   type Schema = HttpFormDataSerialized<{
- *     contentTitle: string | null;
- *     contentSize: number;
+ *     contentTitle: string;
+ *     contentSize: number | null;
  *     content: Blob;
  *     full?: boolean;
- *     date: Date;
- *     method: () => void;
  *   }>;
  *   // {
- *   //   contentTitle: string | null;
- *   //   contentSize? `${number}`;
+ *   //   contentTitle: string;
+ *   //   contentSize? `${number}` | 'null';
  *   //   content: Blob;
  *   //   full?: "false" | "true";
  *   // }
  */
-export 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;
+export type HttpFormDataSerialized<Type> = [Type] extends [never]
+  ? never
+  : Type extends HttpFormDataSchema
+    ? Type
+    : Type extends object
+      ? {
+          [Key in keyof Type as IfNever<
+            PrimitiveHttpFormDataSerialized<Type[Key]>,
+            never,
+            Key
+          >]: PrimitiveHttpFormDataSerialized<Type[Key]>;
+        }
+      : never;

package/src/headers/HttpHeaders.ts

@@ -1,11 +1,11 @@
 import { Default, ReplaceBy } from '@zimic/utils/types';
 
-import { HttpHeadersSchema, HttpHeadersInit, HttpHeadersSchemaName } from './types';
+import { HttpHeadersSchema, HttpHeadersInit, HttpHeadersSchemaName, HttpHeadersSerialized } from './types';
 
-function pickPrimitiveProperties<Schema extends HttpHeadersSchema>(schema: Schema) {
+function pickPrimitiveProperties<LooseSchema extends HttpHeadersSchema.Loose>(schema: LooseSchema) {
   return Object.entries(schema).reduce<Record<string, string>>((accumulated, [key, value]) => {
     if (value !== undefined) {
-      accumulated[key] = value;
+      accumulated[key] = String(value);
     }
     return accumulated;
   }, {});
@@ -15,9 +15,6 @@ function pickPrimitiveProperties<Schema extends HttpHeadersSchema>(schema: Schem
  * 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';
  *
@@ -34,8 +31,10 @@ function pickPrimitiveProperties<Schema extends HttpHeadersSchema>(schema: Schem
  *
  * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http#httpheaders `HttpHeaders` API reference}
  */
-class HttpHeaders<Schema extends HttpHeadersSchema = HttpHeadersSchema> extends Headers {
-  constructor(init?: HttpHeadersInit<Schema>) {
+class HttpHeaders<LooseSchema extends HttpHeadersSchema.Loose = HttpHeadersSchema.Loose> extends Headers {
+  readonly _schema!: HttpHeadersSerialized<LooseSchema>;
+
+  constructor(init?: HttpHeadersInit<LooseSchema>) {
     if (init instanceof Headers || Array.isArray(init) || !init) {
       super(init);
     } else {
@@ -44,38 +43,40 @@ class HttpHeaders<Schema extends HttpHeadersSchema = HttpHeadersSchema> extends
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/set MDN Reference} */
-  set<Name extends HttpHeadersSchemaName<Schema>>(name: Name, value: NonNullable<Schema[Name]> & string): void {
+  set<Name extends HttpHeadersSchemaName<this['_schema']>>(name: Name, value: NonNullable<LooseSchema[Name]>): void {
     super.set(name, value);
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/append MDN Reference} */
-  append<Name extends HttpHeadersSchemaName<Schema>>(name: Name, value: NonNullable<Schema[Name]> & string): void {
+  append<Name extends HttpHeadersSchemaName<this['_schema']>>(name: Name, value: NonNullable<LooseSchema[Name]>): void {
     super.append(name, value);
   }
 
   /** @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> {
-    return super.get(name) as ReplaceBy<Schema[Name], undefined, null>;
+  get<Name extends HttpHeadersSchemaName<this['_schema']>>(
+    name: Name,
+  ): ReplaceBy<this['_schema'][Name], undefined, null> {
+    return super.get(name) as never;
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/has MDN Reference} */
-  getSetCookie(): NonNullable<Default<Schema['Set-Cookie'], string>>[] {
-    return super.getSetCookie() as NonNullable<Default<Schema['Set-Cookie'], string>>[];
+  getSetCookie(): NonNullable<Default<this['_schema']['Set-Cookie'], string>>[] {
+    return super.getSetCookie() as never;
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/has MDN Reference} */
-  has<Name extends HttpHeadersSchemaName<Schema>>(name: Name): boolean {
+  has<Name extends HttpHeadersSchemaName<this['_schema']>>(name: Name): boolean {
     return super.has(name);
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/delete MDN Reference} */
-  delete<Name extends HttpHeadersSchemaName<Schema>>(name: Name): void {
+  delete<Name extends HttpHeadersSchemaName<this['_schema']>>(name: Name): void {
     super.delete(name);
   }
 
-  forEach<This extends HttpHeaders<Schema>>(
-    callback: <Key extends HttpHeadersSchemaName<Schema>>(
-      value: NonNullable<Schema[Key]> & string,
+  forEach<This extends HttpHeaders<this['_schema']>>(
+    callback: <Key extends HttpHeadersSchemaName<this['_schema']>>(
+      value: NonNullable<this['_schema'][Key]> & string,
       key: Key,
       parent: Headers,
     ) => void,
@@ -85,30 +86,32 @@ class HttpHeaders<Schema extends HttpHeadersSchema = HttpHeadersSchema> extends
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/keys MDN Reference} */
-  keys(): HeadersIterator<HttpHeadersSchemaName<Schema>> {
-    return super.keys() as HeadersIterator<HttpHeadersSchemaName<Schema>>;
+  keys(): HeadersIterator<HttpHeadersSchemaName<this['_schema']>> {
+    return super.keys() as never;
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/values MDN Reference} */
-  values(): HeadersIterator<NonNullable<Schema[HttpHeadersSchemaName<Schema>]> & string> {
-    return super.values() as HeadersIterator<NonNullable<Schema[HttpHeadersSchemaName<Schema>]> & string>;
+  values(): HeadersIterator<NonNullable<this['_schema'][HttpHeadersSchemaName<this['_schema']>]> & string> {
+    return super.values() as never;
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/entries MDN Reference} */
   entries(): HeadersIterator<
-    [HttpHeadersSchemaName<Schema>, NonNullable<Schema[HttpHeadersSchemaName<Schema>]> & string]
+    [
+      HttpHeadersSchemaName<this['_schema']>,
+      NonNullable<this['_schema'][HttpHeadersSchemaName<this['_schema']>]> & string,
+    ]
   > {
-    return super.entries() as HeadersIterator<
-      [HttpHeadersSchemaName<Schema>, NonNullable<Schema[HttpHeadersSchemaName<Schema>]> & string]
-    >;
+    return super.entries() as never;
   }
 
   [Symbol.iterator](): HeadersIterator<
-    [HttpHeadersSchemaName<Schema>, NonNullable<Schema[HttpHeadersSchemaName<Schema>]> & string]
+    [
+      HttpHeadersSchemaName<this['_schema']>,
+      NonNullable<this['_schema'][HttpHeadersSchemaName<this['_schema']>]> & string,
+    ]
   > {
-    return super[Symbol.iterator]() as HeadersIterator<
-      [HttpHeadersSchemaName<Schema>, NonNullable<Schema[HttpHeadersSchemaName<Schema>]> & string]
-    >;
+    return super[Symbol.iterator]() as never;
   }
 
   /**
@@ -118,7 +121,7 @@ class HttpHeaders<Schema extends HttpHeadersSchema = HttpHeadersSchema> extends
    * @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 {
     if (!this.contains(otherHeaders)) {
       return false;
     }
@@ -141,7 +144,7 @@ class HttpHeaders<Schema extends HttpHeadersSchema = HttpHeadersSchema> extends
    * @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 {
     for (const [key, otherValue] of otherHeaders.entries()) {
       const value = super.get.call(this, key);
 
@@ -180,8 +183,8 @@ class HttpHeaders<Schema extends HttpHeadersSchema = HttpHeadersSchema> extends
    *
    * @returns A plain object representation of these headers.
    */
-  toObject(): Schema {
-    const object = {} as Schema;
+  toObject(): this['_schema'] {
+    const object = {} as this['_schema'];
 
     for (const [key, value] of this.entries()) {
       object[key] = value;

package/src/headers/types.ts

@@ -15,12 +15,12 @@ export namespace HttpHeadersSchema {
 }
 
 /** A strict tuple representation of a {@link HttpHeadersSchema}. */
-export type HttpHeadersSchemaTuple<Schema extends HttpHeadersSchema = HttpHeadersSchema> = {
+export 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`}. */
-export type HttpHeadersInit<Schema extends HttpHeadersSchema = HttpHeadersSchema> =
+export type HttpHeadersInit<Schema extends HttpHeadersSchema.Loose = HttpHeadersSchema.Loose> =
   | Headers
   | Schema
   | HttpHeaders<Schema>

package/src/pathParams/types.ts

@@ -10,21 +10,22 @@ export namespace HttpPathParamsSchema {
   export type Loose = Record<string, any>;
 }
 
-type PrimitiveHttpPathParamsSerialized<Type> = Type extends HttpPathParamsSchema[string]
-  ? Type
-  : Type extends (infer _ArrayItem)[]
-    ? never
-    : Type extends number
-      ? `${number}`
-      : Type extends boolean
-        ? `${boolean}`
-        : Type extends null
-          ? undefined
-          : never;
+type PrimitiveHttpPathParamsSerialized<Type> = [Type] extends [never]
+  ? never
+  : Type extends number
+    ? `${number}`
+    : Type extends boolean
+      ? `${boolean}`
+      : Type extends null
+        ? 'null'
+        : Type extends symbol
+          ? never
+          : Type extends HttpPathParamsSchema[string]
+            ? Type
+            : string;
 /**
- * Recursively converts a schema to its path parameters-serialized version. Numbers and booleans are converted to
- * `${number}` and `${boolean}` respectively, null becomes undefined and not serializable values are excluded, such as
- * functions and dates.
+ * Recursively converts a schema to its path parameters-serialized version. Numbers, booleans, and null are converted to
+ * `${number}`, `${boolean}`, and 'null' respectively, and other values become strings.
  *
  * @example
  *   import { type HttpPathParamsSerialized } from '@zimic/http';
@@ -33,35 +34,23 @@ type PrimitiveHttpPathParamsSerialized<Type> = Type extends HttpPathParamsSchema
  *     userId: string;
  *     notificationId: number | null;
  *     full?: boolean;
- *     from?: Date;
- *     method: () => void;
  *   }>;
  *   // {
  *   //   userId: string;
- *   //   notificationId: `${number}` | undefined;
+ *   //   notificationId: `${number}` | 'null';
  *   //   full?: "false" | "true";
  *   // }
  */
-export 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;
+export type HttpPathParamsSerialized<Type> = [Type] extends [never]
+  ? never
+  : Type extends HttpPathParamsSchema
+    ? Type
+    : Type extends object
+      ? {
+          [Key in keyof Type as IfNever<
+            PrimitiveHttpPathParamsSerialized<Type[Key]>,
+            never,
+            Key
+          >]: PrimitiveHttpPathParamsSerialized<Type[Key]>;
+        }
+      : never;

package/src/searchParams/HttpSearchParams.ts

@@ -1,12 +1,17 @@
 import { ReplaceBy, ArrayItemIfArray } from '@zimic/utils/types';
 
-import { HttpSearchParamsSchema, HttpSearchParamsInit, HttpSearchParamsSchemaName } from './types';
-
-function pickPrimitiveProperties<Schema extends HttpSearchParamsSchema>(schema: Schema) {
+import {
+  HttpSearchParamsSchema,
+  HttpSearchParamsInit,
+  HttpSearchParamsSchemaName,
+  HttpSearchParamsSerialized,
+} from './types';
+
+function pickPrimitiveProperties<Schema extends HttpSearchParamsSchema.Loose>(schema: Schema) {
   const schemaWithPrimitiveProperties = Object.entries(schema).reduce<Record<string, string>>(
     (accumulated, [key, value]) => {
       if (value !== undefined && !Array.isArray(value)) {
-        accumulated[key] = value;
+        accumulated[key] = String(value);
       }
       return accumulated;
     },
@@ -19,9 +24,6 @@ function pickPrimitiveProperties<Schema extends HttpSearchParamsSchema>(schema:
  * 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';
  *
@@ -41,8 +43,12 @@ function pickPrimitiveProperties<Schema extends HttpSearchParamsSchema>(schema:
  *
  * @see {@link https://github.com/zimicjs/zimic/wiki/api‐zimic‐http#httpsearchparams `HttpSearchParams` API reference}
  */
-class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsSchema> extends URLSearchParams {
-  constructor(init?: HttpSearchParamsInit<Schema>) {
+class HttpSearchParams<
+  LooseSchema extends HttpSearchParamsSchema.Loose = HttpSearchParamsSchema.Loose,
+> extends URLSearchParams {
+  readonly _schema!: HttpSearchParamsSerialized<LooseSchema>;
+
+  constructor(init?: HttpSearchParamsInit<LooseSchema>) {
     if (init instanceof URLSearchParams || Array.isArray(init) || typeof init === 'string' || !init) {
       super(init);
     } else {
@@ -51,28 +57,28 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
     }
   }
 
-  private populateInitArrayProperties(init: Schema) {
+  private populateInitArrayProperties(init: LooseSchema) {
     for (const [key, value] of Object.entries(init)) {
       if (Array.isArray(value)) {
-        for (const item of value) {
-          super.append(key, item);
+        for (const item of value as unknown[]) {
+          super.append(key, String(item));
         }
       }
     }
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/set MDN Reference} */
-  set<Name extends HttpSearchParamsSchemaName<Schema>>(
+  set<Name extends HttpSearchParamsSchemaName<this['_schema']>>(
     name: Name,
-    value: ArrayItemIfArray<NonNullable<Schema[Name]>>,
+    value: ArrayItemIfArray<NonNullable<LooseSchema[Name]>>,
   ): void {
     super.set(name, value);
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/append MDN Reference} */
-  append<Name extends HttpSearchParamsSchemaName<Schema>>(
+  append<Name extends HttpSearchParamsSchemaName<this['_schema']>>(
     name: Name,
-    value: ArrayItemIfArray<NonNullable<Schema[Name]>>,
+    value: ArrayItemIfArray<NonNullable<LooseSchema[Name]>>,
   ): void {
     super.append(name, value);
   }
@@ -86,10 +92,10 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
    * @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>>(
+  get<Name extends HttpSearchParamsSchemaName.NonArray<this['_schema']>>(
     name: Name,
-  ): ReplaceBy<ArrayItemIfArray<Schema[Name]>, undefined, null> {
-    return super.get(name) as ReplaceBy<ArrayItemIfArray<Schema[Name]>, undefined, null>;
+  ): ReplaceBy<ArrayItemIfArray<this['_schema'][Name]>, undefined, null> {
+    return super.get(name) as never;
   }
 
   /**
@@ -101,33 +107,33 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
    * @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>>(
+  getAll<Name extends HttpSearchParamsSchemaName.Array<this['_schema']>>(
     name: Name,
-  ): ArrayItemIfArray<NonNullable<Schema[Name]>>[] {
-    return super.getAll(name) as ArrayItemIfArray<NonNullable<Schema[Name]>>[];
+  ): ArrayItemIfArray<NonNullable<this['_schema'][Name]>>[] {
+    return super.getAll(name) as never;
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/has MDN Reference} */
-  has<Name extends HttpSearchParamsSchemaName<Schema>>(
+  has<Name extends HttpSearchParamsSchemaName<this['_schema']>>(
     name: Name,
-    value?: ArrayItemIfArray<NonNullable<Schema[Name]>>,
+    value?: ArrayItemIfArray<NonNullable<LooseSchema[Name]>>,
   ): boolean {
     return super.has(name, value);
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/delete MDN Reference} */
-  delete<Name extends HttpSearchParamsSchemaName<Schema>>(
+  delete<Name extends HttpSearchParamsSchemaName<this['_schema']>>(
     name: Name,
-    value?: ArrayItemIfArray<NonNullable<Schema[Name]>>,
+    value?: ArrayItemIfArray<NonNullable<LooseSchema[Name]>>,
   ): void {
     super.delete(name, value);
   }
 
-  forEach<This extends HttpSearchParams<Schema>>(
-    callback: <Key extends HttpSearchParamsSchemaName<Schema>>(
-      value: ArrayItemIfArray<NonNullable<Schema[Key]>>,
+  forEach<This extends HttpSearchParams<this['_schema']>>(
+    callback: <Key extends HttpSearchParamsSchemaName<this['_schema']>>(
+      value: ArrayItemIfArray<NonNullable<this['_schema'][Key]>>,
       key: Key,
-      parent: HttpSearchParams<Schema>,
+      parent: HttpSearchParams<this['_schema']>,
     ) => void,
     thisArg?: This,
   ): void {
@@ -135,32 +141,34 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/keys MDN Reference} */
-  keys(): URLSearchParamsIterator<HttpSearchParamsSchemaName<Schema>> {
-    return super.keys() as URLSearchParamsIterator<HttpSearchParamsSchemaName<Schema>>;
+  keys(): URLSearchParamsIterator<HttpSearchParamsSchemaName<this['_schema']>> {
+    return super.keys() as never;
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/values MDN Reference} */
-  values(): URLSearchParamsIterator<ArrayItemIfArray<NonNullable<Schema[HttpSearchParamsSchemaName<Schema>]>>> {
-    return super.values() as URLSearchParamsIterator<
-      ArrayItemIfArray<NonNullable<Schema[HttpSearchParamsSchemaName<Schema>]>>
-    >;
+  values(): URLSearchParamsIterator<
+    ArrayItemIfArray<NonNullable<this['_schema'][HttpSearchParamsSchemaName<this['_schema']>]>>
+  > {
+    return super.values() as never;
   }
 
   /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/entries MDN Reference} */
   entries(): URLSearchParamsIterator<
-    [HttpSearchParamsSchemaName<Schema>, ArrayItemIfArray<NonNullable<Schema[HttpSearchParamsSchemaName<Schema>]>>]
+    [
+      HttpSearchParamsSchemaName<this['_schema']>,
+      ArrayItemIfArray<NonNullable<this['_schema'][HttpSearchParamsSchemaName<this['_schema']>]>>,
+    ]
   > {
-    return super.entries() as URLSearchParamsIterator<
-      [HttpSearchParamsSchemaName<Schema>, ArrayItemIfArray<NonNullable<Schema[HttpSearchParamsSchemaName<Schema>]>>]
-    >;
+    return super.entries() as never;
   }
 
   [Symbol.iterator](): URLSearchParamsIterator<
-    [HttpSearchParamsSchemaName<Schema>, ArrayItemIfArray<NonNullable<Schema[HttpSearchParamsSchemaName<Schema>]>>]
+    [
+      HttpSearchParamsSchemaName<this['_schema']>,
+      ArrayItemIfArray<NonNullable<this['_schema'][HttpSearchParamsSchemaName<this['_schema']>]>>,
+    ]
   > {
-    return super[Symbol.iterator]() as URLSearchParamsIterator<
-      [HttpSearchParamsSchemaName<Schema>, ArrayItemIfArray<NonNullable<Schema[HttpSearchParamsSchemaName<Schema>]>>]
-    >;
+    return super[Symbol.iterator]() as never;
   }
 
   /**
@@ -170,7 +178,7 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
    * @param otherParams The other search parameters to compare against.
    * @returns `true` if the search parameters are equal, `false` otherwise.
    */
-  equals<OtherSchema extends Schema>(otherParams: HttpSearchParams<OtherSchema>): boolean {
+  equals<OtherSchema extends LooseSchema>(otherParams: HttpSearchParams<OtherSchema>): boolean {
     return this.contains(otherParams) && this.size === otherParams.size;
   }
 
@@ -182,7 +190,7 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
    * @param otherParams The other search parameters to check for containment.
    * @returns `true` if these search parameters contain the other search parameters, `false` otherwise.
    */
-  contains<OtherSchema extends Schema>(otherParams: HttpSearchParams<OtherSchema>): boolean {
+  contains<OtherSchema extends LooseSchema>(otherParams: HttpSearchParams<OtherSchema>): boolean {
     for (const [key, otherValue] of otherParams.entries()) {
       const values = super.getAll.call(this, key);
 
@@ -219,13 +227,13 @@ class HttpSearchParams<Schema extends HttpSearchParamsSchema = HttpSearchParamsS
    * @returns A plain object representation of these search params.
    */
   toObject() {
-    const object = {} as Schema;
+    const object = {} as this['_schema'];
 
-    type SchemaValue = Schema[HttpSearchParamsSchemaName<Schema>];
+    type SchemaValue = this['_schema'][HttpSearchParamsSchemaName<this['_schema']>];
 
     for (const [key, value] of this.entries()) {
       if (key in object) {
-        const existingValue = object[key];
+        const existingValue = object[key] as SchemaValue[];
 
         if (Array.isArray<SchemaValue>(existingValue)) {
           existingValue.push(value as SchemaValue);