bupkis 0.1.2 → 0.2.0

package/dist/commonjs/bootstrap.d.ts

@@ -1,108 +1,113 @@
 /**
  * Factory function for creating the main assertion functions.
  *
- * This module provides the `bootstrap()` function that creates both synchronous
- * and asynchronous assertion engines. It contains the core implementation
- * previously split between `expect.ts` and `expect-async.ts`.
+ * This module provides the {@link bootstrap} function that creates both
+ * synchronous and asynchronous assertion engines.
  *
  * @packageDocumentation
  */
-import { type Expect, type ExpectAsync } from './api.js';
-/** {@inheritDoc Expect} */
-declare const expect: Expect<readonly [import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodMap<import("zod").ZodAny, import("zod").ZodAny>, readonly ["to contain", "to include"], import("zod").ZodAny], (subject: Map<any, any>, key: any) => boolean, readonly [import("zod").ZodMap<import("zod").ZodAny, import("zod").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodAny]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", import("zod").ZodNumber], (subject: Map<unknown, unknown>, expectedSize: number) => boolean, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], (subject: Map<unknown, unknown>) => boolean, readonly [import("zod").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodSet<import("zod").ZodAny>, readonly ["to contain", "to include"], import("zod").ZodAny], (subject: Set<any>, value: any) => boolean, readonly [import("zod").ZodSet<import("zod").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodAny]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to have size", import("zod").ZodNumber], (subject: Set<unknown>, expectedSize: number) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], (subject: Set<unknown>) => boolean, readonly [import("zod").ZodCustom<Set<unknown>, Set<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, readonly ["to contain", "to include"], import("zod").ZodAny], (subject: WeakMap<WeakKey, unknown>, key: any) => boolean, readonly [import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodAny]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, readonly ["to contain", "to include"], import("zod").ZodAny], (subject: WeakSet<WeakKey>, value: any) => boolean, readonly [import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodAny]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodAny>, readonly ["to contain", "to include"], import("zod").ZodAny], (subject: any[], value: any) => boolean, readonly [import("zod").ZodArray<import("zod").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodAny]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodAny>, "to have size", import("zod").ZodNumber], (subject: any[], expectedSize: number) => boolean, readonly [import("zod").ZodArray<import("zod").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodAny>, "to have length", import("zod").ZodNumber], (subject: any[], expectedLength: number) => boolean, readonly [import("zod").ZodArray<import("zod").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have length">, import("zod").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodAny>, "to be non-empty"], (subject: any[]) => {
+import { type Expect, type ExpectAsync } from './types.js';
+declare const 
+/**
+ * The main synchronous assertion function which can execute only built-in
+ * assertions.
+ *
+ * @function
+ */
+expect: Expect<readonly [import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodMap<import("zod/v4").ZodAny, import("zod/v4").ZodAny>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: Map<any, any>, key: any) => boolean, readonly [import("zod/v4").ZodMap<import("zod/v4").ZodAny, import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", import("zod/v4").ZodNumber], (subject: Map<unknown, unknown>, expectedSize: number) => boolean, readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], (subject: Map<unknown, unknown>) => boolean, readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodSet<import("zod/v4").ZodAny>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: Set<any>, value: any) => boolean, readonly [import("zod/v4").ZodSet<import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to have size", import("zod/v4").ZodNumber], (subject: Set<unknown>, expectedSize: number) => boolean, readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], (subject: Set<unknown>) => boolean, readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: WeakMap<WeakKey, unknown>, key: any) => boolean, readonly [import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: WeakSet<WeakKey>, value: any) => boolean, readonly [import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, readonly ["to contain", "to include"], import("zod/v4").ZodAny], (subject: any[], value: any) => boolean, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to have size", import("zod/v4").ZodNumber], (subject: any[], expectedSize: number) => boolean, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to have length", import("zod/v4").ZodNumber], (subject: any[], expectedLength: number) => boolean, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralSlot<"to have length">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to be non-empty"], (subject: any[]) => {
     actual: number;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod").ZodArray<import("zod").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodObject<{}, import("zod/v4/core").$loose>, readonly ["to have keys", "to have properties", "to have props"], import("zod").ZodTuple<[import("zod").ZodString], import("zod").ZodString>], (_: {
+} | undefined, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, readonly ["to have keys", "to have properties", "to have props"], import("zod/v4").ZodTuple<[import("zod/v4").ZodString], import("zod/v4").ZodString>], (_: {
     [x: string]: unknown;
-}, keys: [string, ...string[]]) => import("zod").ZodObject<{
-    [k: string]: import("zod").ZodNonOptional<import("zod").ZodUnknown>;
-}, import("zod/v4/core").$loose>, readonly [import("zod").ZodObject<{}, import("zod/v4/core").$loose>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props"]>, import("zod").ZodTuple<[import("zod").ZodString], import("zod").ZodString>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodObject<{}, import("zod/v4/core").$loose>, "to have size", import("zod").ZodNumber], (subject: {
+}, keys: [string, ...string[]]) => import("zod/v4").ZodObject<{
+    [k: string]: import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>;
+}, import("zod/v4/core").$loose>, readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props"]>, import("zod/v4").ZodTuple<[import("zod/v4").ZodString], import("zod/v4").ZodString>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, "to have size", import("zod/v4").ZodNumber], (subject: {
     [x: string]: unknown;
 }, expectedSize: number) => {
     actual: number;
     expected: number;
     message: string;
-} | undefined, readonly [import("zod").ZodObject<{}, import("zod/v4/core").$loose>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodNumber]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be a string"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be a string"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a number", "to be finite"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a number", "to be finite"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be infinite"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be infinite"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be Infinity"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be Infinity"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be -Infinity"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be -Infinity"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be true"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be true"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be false"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be false"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be a function"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be a function"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be an async function"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be an async function"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be NaN"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be NaN"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be null"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be null"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be undefined"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be undefined"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be an array", "to be array"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be an array", "to be array"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a date", "to be a Date"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a class", "to be a constructor"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a class", "to be a constructor"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be a primitive"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be a primitive"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be falsy"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be falsy"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be an object"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be an object"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [import("zod").ZodArray<import("zod").ZodAny>, "to be empty"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [import("zod").ZodArray<import("zod").ZodAny>, "to be empty"]>, readonly [import("zod").ZodArray<import("zod").ZodAny>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodUnknown>, "to be empty"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodUnknown>, "to be empty"]>, readonly [import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodUnknown>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be an Error"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be an Error"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [import("zod").ZodString, "to be empty"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [import("zod").ZodString, "to be empty"]>, readonly [import("zod").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [import("zod").ZodString, "to be non-empty"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [import("zod").ZodString, "to be non-empty"]>, readonly [import("zod").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be defined"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be defined"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be a Set"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be a Set"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be a WeakMap"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be a WeakMap"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be a WeakSet"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be a WeakSet"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to have a null prototype"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to have a null prototype"]>, never>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, "to be an enumerable property of", import("zod").ZodObject<{}, import("zod/v4/core").$loose>], (subject: string | number | symbol, obj: {
+} | undefined, readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, import("./types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionSchemaSync<readonly ["to be a string"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a string"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a number", "to be finite"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a number", "to be finite"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be infinite"], import("./types.js").AssertionImplSchemaSync<readonly ["to be infinite"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be Infinity"], import("./types.js").AssertionImplSchemaSync<readonly ["to be Infinity"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be -Infinity"], import("./types.js").AssertionImplSchemaSync<readonly ["to be -Infinity"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be true"], import("./types.js").AssertionImplSchemaSync<readonly ["to be true"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be false"], import("./types.js").AssertionImplSchemaSync<readonly ["to be false"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a function"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a function"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be an async function"], import("./types.js").AssertionImplSchemaSync<readonly ["to be an async function"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be NaN"], import("./types.js").AssertionImplSchemaSync<readonly ["to be NaN"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be null"], import("./types.js").AssertionImplSchemaSync<readonly ["to be null"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be undefined"], import("./types.js").AssertionImplSchemaSync<readonly ["to be undefined"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be an array", "to be array"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be an array", "to be array"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a date", "to be a Date"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a class", "to be a constructor"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a class", "to be a constructor"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a primitive"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a primitive"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be falsy"], import("./types.js").AssertionImplSchemaSync<readonly ["to be falsy"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be an object"], import("./types.js").AssertionImplSchemaSync<readonly ["to be an object"]>, never>, import("./types.js").AssertionSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], import("./types.js").AssertionImplSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]]>, never>, import("./types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to be empty"]>, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodAny, import("zod/v4").ZodUnknown>, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodAny, import("zod/v4").ZodUnknown>, "to be empty"]>, readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodAny, import("zod/v4").ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionSchemaSync<readonly ["to be an Error"], import("./types.js").AssertionImplSchemaSync<readonly ["to be an Error"]>, never>, import("./types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodString, "to be empty"], import("./types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodString, "to be empty"]>, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodString, "to be non-empty"], import("./types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodString, "to be non-empty"]>, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionSchemaSync<readonly ["to be defined"], import("./types.js").AssertionImplSchemaSync<readonly ["to be defined"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a Set"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a Set"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a WeakMap"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a WeakMap"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be a WeakSet"], import("./types.js").AssertionImplSchemaSync<readonly ["to be a WeakSet"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to have a null prototype"], import("./types.js").AssertionImplSchemaSync<readonly ["to have a null prototype"]>, never>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, "to be an enumerable property of", import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>], (subject: string | number | symbol, obj: {
     [x: string]: unknown;
-}) => boolean, readonly [import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodSymbol]>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be an enumerable property of">, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be sealed"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be frozen"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be frozen"]>, never>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly ["to be extensible"], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a"], import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (_: unknown, ctor: import("./types.js").Constructor) => import("zod").ZodCustom<any, any>, readonly [import("zod").ZodUnknown, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be an instance of", "to be a"]>, import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodAny, readonly ["to be a", "to be an"], import("zod").ZodEnum<{
+}) => boolean, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("./types.js").PhraseLiteralSlot<"to be an enumerable property of">, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>, import("./types.js").AssertionSchemaSync<readonly ["to be sealed"], import("./types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be frozen"], import("./types.js").AssertionImplSchemaSync<readonly ["to be frozen"]>, never>, import("./types.js").AssertionSchemaSync<readonly ["to be extensible"], import("./types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (_: unknown, ctor: import("./types.js").Constructor) => import("zod/v4").ZodCustom<any, any>, readonly [import("zod/v4").ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be an instance of", "to be a"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodAny, readonly ["to be a", "to be an"], import("zod/v4").ZodEnum<{
     [x: string]: string;
-}>], (_: any, type: string) => import("zod").ZodString | import("zod").ZodNumber | import("zod").ZodSymbol | import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | import("zod").ZodBoolean | import("zod").ZodBigInt | import("zod").ZodNull | import("zod").ZodUndefined | import("zod").ZodArray<import("zod").ZodAny> | import("zod").ZodCustom<RegExp, RegExp> | import("zod").ZodDate | import("zod").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | import("zod").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | import("zod").ZodCustom<Error, Error> | import("zod").ZodFunction<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut> | import("zod").ZodObject<{}, import("zod/v4/core").$loose> | import("zod").ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>, readonly [import("zod").ZodAny, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an"]>, import("zod").ZodEnum<{
+}>], (_: any, type: string) => import("zod/v4").ZodString | import("zod/v4").ZodNumber | import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | import("zod/v4").ZodArray<import("zod/v4").ZodAny> | import("zod/v4").ZodBoolean | import("zod/v4").ZodBigInt | import("zod/v4").ZodSymbol | import("zod/v4").ZodNull | import("zod/v4").ZodUndefined | import("zod/v4").ZodDate | import("zod/v4").ZodCustom<RegExp, RegExp> | import("zod/v4").ZodCustom<Error, Error> | import("zod/v4").ZodFunction<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut> | import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose> | import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | import("zod/v4").ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>, readonly [import("zod/v4").ZodAny, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an"]>, import("zod/v4").ZodEnum<{
     [x: string]: string;
-}>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, "to be greater than", import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be greater than">, import("zod").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, "to be less than", import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be less than">, import("zod").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be greater than or equal to", "to be at least"], import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be greater than or equal to", "to be at least"]>, import("zod").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, readonly ["to be less than or equal to", "to be at most"], import("zod").ZodNumber], (_: number, other: number) => import("zod").ZodNumber, readonly [import("zod").ZodNumber, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be less than or equal to", "to be at most"]>, import("zod").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, "to be within", import("zod").ZodNumber, import("zod").ZodNumber], (subject: number, min: number, max: number) => {
+}>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNumber, "to be greater than", import("zod/v4").ZodNumber], (_: number, other: number) => import("zod/v4").ZodNumber, readonly [import("zod/v4").ZodNumber, import("./types.js").PhraseLiteralSlot<"to be greater than">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNumber, "to be less than", import("zod/v4").ZodNumber], (_: number, other: number) => import("zod/v4").ZodNumber, readonly [import("zod/v4").ZodNumber, import("./types.js").PhraseLiteralSlot<"to be less than">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNumber, readonly ["to be greater than or equal to", "to be at least"], import("zod/v4").ZodNumber], (_: number, other: number) => import("zod/v4").ZodNumber, readonly [import("zod/v4").ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be greater than or equal to", "to be at least"]>, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNumber, readonly ["to be less than or equal to", "to be at most"], import("zod/v4").ZodNumber], (_: number, other: number) => import("zod/v4").ZodNumber, readonly [import("zod/v4").ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be less than or equal to", "to be at most"]>, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNumber, readonly ["to be within", "to be between"], import("zod/v4").ZodNumber, import("zod/v4").ZodNumber], (subject: number, min: number, max: number) => {
     actual: number;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod").ZodNumber, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be within">, import("zod").ZodNumber, import("zod").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, "to be close to", import("zod").ZodNumber, import("zod").ZodOptional<import("zod").ZodNumber>], (subject: number, expected: number, tolerance?: number | undefined) => {
+} | undefined, readonly [import("zod/v4").ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>, import("zod/v4").ZodNumber, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNumber, "to be close to", import("zod/v4").ZodNumber, import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>], (subject: number, expected: number, tolerance?: number | undefined) => {
     actual: number;
     expected: number;
     message: string;
-} | undefined, readonly [import("zod").ZodNumber, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be close to">, import("zod").ZodNumber, import("zod").ZodOptional<import("zod").ZodNumber>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to be greater than", import("zod").ZodString], (subject: string, other: string) => {
+} | undefined, readonly [import("zod/v4").ZodNumber, import("./types.js").PhraseLiteralSlot<"to be close to">, import("zod/v4").ZodNumber, import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to be greater than", import("zod/v4").ZodString], (subject: string, other: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be greater than">, import("zod").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to be less than", import("zod").ZodString], (subject: string, other: string) => {
+} | undefined, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralSlot<"to be greater than">, import("zod/v4").ZodString]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to be less than", import("zod/v4").ZodString], (subject: string, other: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be less than">, import("zod").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to be greater than or equal to", import("zod").ZodString], (subject: string, other: string) => {
+} | undefined, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralSlot<"to be less than">, import("zod/v4").ZodString]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to be greater than or equal to", import("zod/v4").ZodString], (subject: string, other: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be greater than or equal to">, import("zod").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to be less than or equal to", import("zod").ZodString], (subject: string, other: string) => {
+} | undefined, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralSlot<"to be greater than or equal to">, import("zod/v4").ZodString]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to be less than or equal to", import("zod/v4").ZodString], (subject: string, other: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be less than or equal to">, import("zod").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, readonly ["to begin with", "to start with"], import("zod").ZodString], (subject: string, prefix: string) => {
+} | undefined, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralSlot<"to be less than or equal to">, import("zod/v4").ZodString]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, readonly ["to begin with", "to start with"], import("zod/v4").ZodString], (subject: string, prefix: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod").ZodString, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>, import("zod").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to end with", import("zod").ZodString], (subject: string, suffix: string) => {
+} | undefined, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>, import("zod/v4").ZodString]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to end with", import("zod/v4").ZodString], (subject: string, suffix: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to end with">, import("zod").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodAny, "to be one of", import("zod").ZodArray<import("zod").ZodAny>], (subject: any, values: any[]) => {
+} | undefined, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralSlot<"to end with">, import("zod/v4").ZodString]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodAny, "to be one of", import("zod/v4").ZodArray<import("zod/v4").ZodAny>], (subject: any, values: any[]) => {
     actual: unknown;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod").ZodAny, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to be one of">, import("zod").ZodArray<import("zod").ZodAny>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, "to have arity", import("zod").ZodNumber], (subject: (...args: any[]) => any, expectedArity: number) => {
+} | undefined, readonly [import("zod/v4").ZodAny, import("./types.js").PhraseLiteralSlot<"to be one of">, import("zod/v4").ZodArray<import("zod/v4").ZodAny>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", import("zod/v4").ZodNumber], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
     actual: number;
     expected: number;
     message: string;
-} | undefined, readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have arity">, import("zod").ZodNumber]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Error, Error>, "to have message", import("zod").ZodString], (subject: Error, expectedMessage: string) => {
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to have arity">, import("zod/v4").ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Error, Error>, "to have message", import("zod/v4").ZodString], (subject: Error, expectedMessage: string) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod").ZodCustom<Error, Error>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have message">, import("zod").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<Error, Error>, "to have message matching", import("zod").ZodCustom<RegExp, RegExp>], (subject: Error, pattern: RegExp) => {
+} | undefined, readonly [import("zod/v4").ZodCustom<Error, Error>, import("./types.js").PhraseLiteralSlot<"to have message">, import("zod/v4").ZodString]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Error, Error>, "to have message matching", import("zod/v4").ZodCustom<RegExp, RegExp>], (subject: Error, pattern: RegExp) => {
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod").ZodCustom<Error, Error>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have message matching">, import("zod").ZodCustom<RegExp, RegExp>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal"], import("zod").ZodUnknown], (subject: unknown, value: unknown) => {
+} | undefined, readonly [import("zod/v4").ZodCustom<Error, Error>, import("./types.js").PhraseLiteralSlot<"to have message matching">, import("zod/v4").ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal"], import("zod/v4").ZodUnknown], (subject: unknown, value: unknown) => {
     actual: unknown;
     expected: unknown;
     message: string;
-} | undefined, readonly [import("zod").ZodUnknown, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal"]>, import("zod").ZodUnknown]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [import("zod").ZodObject<{}, import("zod/v4/core").$loose>, readonly ["to deep equal", "to deeply equal"], import("zod").ZodObject<{}, import("zod/v4/core").$loose>], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [import("zod").ZodObject<{}, import("zod/v4/core").$loose>, readonly ["to deep equal", "to deeply equal"], import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>, readonly [import("zod").ZodObject<{}, import("zod/v4/core").$loose>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>, import("./assertion/assertion-types.js").AssertionSchemaSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodAny>, import("zod").ZodObject<{
-    length: import("zod").ZodNumber;
-}, import("zod/v4/core").$loose>]>, readonly ["to deep equal", "to deeply equal"], import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodAny>, import("zod").ZodObject<{
-    length: import("zod").ZodNumber;
-}, import("zod/v4/core").$loose>]>], import("./assertion/assertion-types.js").AssertionImplSchemaSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodAny>, import("zod").ZodObject<{
-    length: import("zod").ZodNumber;
-}, import("zod/v4/core").$loose>]>, readonly ["to deep equal", "to deeply equal"], import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodAny>, import("zod").ZodObject<{
-    length: import("zod").ZodNumber;
-}, import("zod/v4/core").$loose>]>]>, readonly [import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodAny>, import("zod").ZodObject<{
-    length: import("zod").ZodNumber;
-}, import("zod/v4/core").$loose>]>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodAny>, import("zod").ZodObject<{
-    length: import("zod").ZodNumber;
-}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, "to throw"], (subject: (...args: any[]) => any) => {
+} | undefined, readonly [import("zod/v4").ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal"]>, import("zod/v4").ZodUnknown]>, import("./types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, readonly ["to deep equal", "to deeply equal"], import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>], import("./types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, readonly ["to deep equal", "to deeply equal"], import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>, readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>, import("./types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
+    length: import("zod/v4").ZodNumber;
+}, import("zod/v4/core").$loose>]>, readonly ["to deep equal", "to deeply equal"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
+    length: import("zod/v4").ZodNumber;
+}, import("zod/v4/core").$loose>]>], import("./types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
+    length: import("zod/v4").ZodNumber;
+}, import("zod/v4/core").$loose>]>, readonly ["to deep equal", "to deeply equal"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
+    length: import("zod/v4").ZodNumber;
+}, import("zod/v4/core").$loose>]>]>, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
+    length: import("zod/v4").ZodNumber;
+}, import("zod/v4/core").$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
+    length: import("zod/v4").ZodNumber;
+}, import("zod/v4/core").$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to throw"], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => {
     actual: unknown;
     message: string;
-} | undefined, readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to throw">]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to throw a", "to thrown an"], import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: any[]) => any, ctor: import("./types.js").Constructor) => false | {
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to throw">]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to thrown an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => false | {
     actual: {};
     expected: import("./types.js").Constructor;
     message: string;
-} | undefined, readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to throw"], import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<RegExp, RegExp>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: (...args: any[]) => any, param: string | RegExp | {
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
     [x: string]: unknown;
-}) => boolean, readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw"]>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<RegExp, RegExp>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to throw a", "to thrown an"], import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, "satisfying", import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<RegExp, RegExp>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: (...args: any[]) => any, ctor: import("./types.js").Constructor, param: string | RegExp | {
+}) => boolean, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to thrown an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, "satisfying", import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor, param: string | RegExp | {
     [x: string]: unknown;
 }) => {
     actual: string;
@@ -114,35 +119,40 @@ declare const expect: Expect<readonly [import("./assertion/assertion-types.js").
         [x: string]: unknown;
     };
     message: string;
-} | undefined, readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"satisfying">, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<RegExp, RegExp>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, readonly ["includes", "contains", "to include", "to contain"], import("zod").ZodString], (subject: string, expected: string) => boolean, readonly [import("zod").ZodString, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, import("zod").ZodString]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodString, "to match", import("zod").ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [import("zod").ZodString, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to match">, import("zod").ZodCustom<RegExp, RegExp>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNonOptional<import("zod").ZodObject<{}, import("zod/v4/core").$loose>>, readonly ["to satisfy", "to be like"], import("zod").ZodObject<{}, import("zod/v4/core").$loose>], (_subject: {
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, import("./types.js").PhraseLiteralSlot<"satisfying">, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, readonly ["includes", "contains", "to include", "to contain"], import("zod/v4").ZodString], (subject: string, expected: string) => boolean, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, import("zod/v4").ZodString]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, "to match", import("zod/v4").ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [import("zod/v4").ZodString, import("./types.js").PhraseLiteralSlot<"to match">, import("zod/v4").ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>>, readonly ["to satisfy", "to be like"], import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>], (subject: {
     [x: string]: unknown;
 }, shape: {
     [x: string]: unknown;
-}) => import("zod").ZodType<{}, import("zod/v4/core").$loose>, readonly [import("zod").ZodNonOptional<import("zod").ZodObject<{}, import("zod/v4/core").$loose>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodAny>, import("zod").ZodObject<{
-    length: import("zod").ZodNumber;
-}, import("zod/v4/core").$loose>]>, readonly ["to satisfy", "to be like"], import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodAny>, import("zod").ZodObject<{
-    length: import("zod").ZodNumber;
-}, import("zod/v4/core").$loose>]>], (_subject: any[] | [any, ...any[]] | {
+}) => import("zod/v4").ZodType<{}, import("zod/v4/core").$loose>, readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
+    length: import("zod/v4").ZodNumber;
+}, import("zod/v4/core").$loose>]>, readonly ["to satisfy", "to be like"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
+    length: import("zod/v4").ZodNumber;
+}, import("zod/v4/core").$loose>]>], (subject: unknown[] | [unknown, ...unknown[]] | {
     [x: string]: unknown;
     length: number;
-}, shape: any[] | [any, ...any[]] | {
+}, shape: unknown[] | [unknown, ...unknown[]] | {
     [x: string]: unknown;
     length: number;
-}) => typeof import("./schema.js").ArrayLikeSchema, readonly [import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodAny>, import("zod").ZodObject<{
-    length: import("zod").ZodNumber;
-}, import("zod/v4/core").$loose>]>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodAny>, import("zod").ZodTuple<[import("zod").ZodAny], import("zod").ZodAny>, import("zod").ZodObject<{
-    length: import("zod").ZodNumber;
-}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, "to have arity", import("zod").ZodNumber], (subject: (...args: any[]) => any, expectedArity: number) => {
+}) => typeof import("./schema.js").ArrayLikeSchema, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
+    length: import("zod/v4").ZodNumber;
+}, import("zod/v4/core").$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("zod/v4").ZodTuple<[import("zod/v4").ZodUnknown], import("zod/v4").ZodUnknown>, import("zod/v4").ZodObject<{
+    length: import("zod/v4").ZodNumber;
+}, import("zod/v4/core").$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", import("zod/v4").ZodNumber], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
     actual: number;
     expected: number;
     message: string;
-} | undefined, readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to have arity">, import("zod").ZodNumber]>]>;
-/** {@inheritDoc ExpectAsync} */
-declare const expectAsync: ExpectAsync<readonly [import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to resolve", "to fulfill"]], (subject: (...args: any[]) => any) => Promise<boolean>, readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<boolean>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, "to reject"], (subject: (...args: any[]) => any) => Promise<boolean>, readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to reject">]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, "to reject"], (subject: PromiseLike<unknown>) => Promise<boolean>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralSlot<"to reject">]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to reject with a", "to reject with an"], import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: any[]) => any, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an"], import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, import("zod").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to reject with"], import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<RegExp, RegExp>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: (...args: any[]) => any, param: string | RegExp | {
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to have arity">, import("zod/v4").ZodNumber]>]>, 
+/**
+ * The main asynchronous assertion function which can execute only built-in
+ * assertions.
+ *
+ * @function
+ */
+expectAsync: ExpectAsync<readonly [import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to resolve", "to fulfill"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to reject"], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, "to reject"], (subject: PromiseLike<unknown>) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an"], import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, import("zod/v4").ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
     [x: string]: unknown;
-}) => Promise<boolean>, readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with"]>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<RegExp, RegExp>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with"], import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<RegExp, RegExp>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: PromiseLike<unknown>, param: string | RegExp | {
+}) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: PromiseLike<unknown>, param: string | RegExp | {
     [x: string]: unknown;
-}) => Promise<boolean>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to reject with"]>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<RegExp, RegExp>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve to value satisfying"], import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<RegExp, RegExp>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>], (promise: PromiseLike<unknown>, param: string | RegExp | {
+}) => Promise<boolean>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>], (promise: PromiseLike<unknown>, param: string | RegExp | {
     [x: string]: unknown;
 }) => Promise<boolean | {
     actual: unknown;
@@ -156,7 +166,7 @@ declare const expectAsync: ExpectAsync<readonly [import("./assertion/assertion-t
     };
     message: string;
     expect?: never;
-}>, readonly [import("zod").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve to value satisfying"]>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<RegExp, RegExp>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./assertion/assertion-types.js").AssertionFunctionAsync<readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, readonly ["to fulfill with value satisfying", "to resolve to value satisfying"], import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<RegExp, RegExp>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: (...args: any[]) => any, param: string | RegExp | {
+}>, readonly [import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
     [x: string]: unknown;
 }) => Promise<boolean | {
     actual: unknown;
@@ -170,6 +180,6 @@ declare const expectAsync: ExpectAsync<readonly [import("./assertion/assertion-t
     };
     message: string;
     expect?: never;
-}>, readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("./assertion/assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve to value satisfying"]>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<RegExp, RegExp>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>]>]>;
+}>, readonly [import("zod/v4").ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodCustom<RegExp, RegExp>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>]>]>;
 export { expect, expectAsync };
 //# sourceMappingURL=bootstrap.d.ts.map

package/dist/commonjs/bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AA0BzD,2BAA2B;AAC3B,QAAA,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4MAAQ,CAAC;AACvB,gCAAgC;AAChC,QAAA,MAAQ,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8YAAQ,CAAC;AAE5B,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAwB3D,QAAA;AACE;;;;;GAKG;AACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACN;;;;;GAKG;AACH,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2eACN,CAAC;AAER,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC"}

package/dist/commonjs/bootstrap.js

@@ -2,33 +2,43 @@
 /**
  * Factory function for creating the main assertion functions.
  *
- * This module provides the `bootstrap()` function that creates both synchronous
- * and asynchronous assertion engines. It contains the core implementation
- * previously split between `expect.ts` and `expect-async.ts`.
+ * This module provides the {@link bootstrap} function that creates both
+ * synchronous and asynchronous assertion engines.
  *
  * @packageDocumentation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectAsync = exports.expect = void 0;
+const async_js_1 = require("./assertion/impl/async.js");
 const sync_js_1 = require("./assertion/impl/sync.js");
-const index_js_1 = require("./assertion/index.js");
 const use_js_1 = require("./use.js");
 /**
  * Factory function that creates both synchronous and asynchronous assertion
  * engines.
  *
- * @returns Object containing `expect` and `expectAsync` functions
+ * @returns Object containing {@link expect} and {@link expectAsync} functions
  * @internal
  */
 const bootstrap = () => {
-    const { expect, expectAsync } = (0, use_js_1.createUse)(sync_js_1.SyncAssertions, index_js_1.AsyncAssertions)([...sync_js_1.SyncAssertions, ...index_js_1.AsyncAssertions]);
+    const { expect, expectAsync } = (0, use_js_1.createUse)(sync_js_1.SyncAssertions, async_js_1.AsyncAssertions)([...sync_js_1.SyncAssertions, ...async_js_1.AsyncAssertions]);
     return { expect, expectAsync };
 };
 const api = bootstrap();
-/** {@inheritDoc Expect} */
-const { expect } = api;
+const { 
+/**
+ * The main synchronous assertion function which can execute only built-in
+ * assertions.
+ *
+ * @function
+ */
+expect, 
+/**
+ * The main asynchronous assertion function which can execute only built-in
+ * assertions.
+ *
+ * @function
+ */
+expectAsync, } = api;
 exports.expect = expect;
-/** {@inheritDoc ExpectAsync} */
-const { expectAsync } = api;
 exports.expectAsync = expectAsync;
 //# sourceMappingURL=bootstrap.js.map

package/dist/commonjs/bootstrap.js.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAGH,sDAA0D;AAC1D,mDAAuD;AACvD,qCAAqC;AAErC;;;;;;GAMG;AACH,MAAM,SAAS,GAAG,GAGhB,EAAE;IACF,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,IAAA,kBAAS,EACvC,wBAAc,EACd,0BAAe,CAChB,CAAC,CAAC,GAAG,wBAAc,EAAE,GAAG,0BAAe,CAAC,CAAC,CAAC;IAE3C,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;AACjC,CAAC,CAAC;AAEF,MAAM,GAAG,GAAG,SAAS,EAAE,CAAC;AAExB,2BAA2B;AAC3B,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;AAId,wBAAM;AAHf,gCAAgC;AAChC,MAAM,EAAE,WAAW,EAAE,GAAG,GAAG,CAAC;AAEX,kCAAW"}
+{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAEH,wDAA4D;AAC5D,sDAA0D;AAE1D,qCAAqC;AAErC;;;;;;GAMG;AACH,MAAM,SAAS,GAAG,GAGhB,EAAE;IACF,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,IAAA,kBAAS,EACvC,wBAAc,EACd,0BAAe,CAChB,CAAC,CAAC,GAAG,wBAAc,EAAE,GAAG,0BAAe,CAAC,CAAC,CAAC;IAE3C,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;AACjC,CAAC,CAAC;AAEF,MAAM,GAAG,GAAG,SAAS,EAAE,CAAC;AAExB,MAAM;AACJ;;;;;GAKG;AACH,MAAM;AACN;;;;;GAKG;AACH,WAAW,GACZ,GAAG,GAAG,CAAC;AAEC,wBAAM;AAAE,kCAAW"}

package/dist/commonjs/error.d.ts

@@ -6,15 +6,22 @@
  * @packageDocumentation
  */
 import { AssertionError as NodeAssertionError } from 'node:assert';
-import { kBupkisAssertionError } from './constant.js';
 /**
  * _BUPKIS_' s custom `AssertionError` class, which is just a thin wrapper
  * around Node.js' {@link NodeAssertionError AssertionError}.
- *
- * @public
  */
 export declare class AssertionError extends NodeAssertionError {
-    [kBupkisAssertionError]: boolean;
-    static isAssertionError(err: unknown): err is AssertionError;
+    name: string;
+    /**
+     * @param options Options passed to {@link NodeAssertionError}'s constructor
+     */
+    constructor(options?: ConstructorParameters<typeof NodeAssertionError>[0]);
+    /**
+     * Type guard for an instance of this error.
+     *
+     * @param value Some value
+     * @returns `true` if `value` is an instance of `AssertionError`
+     */
+    static isAssertionError(value: unknown): value is AssertionError;
 }
 //# sourceMappingURL=error.d.ts.map

package/dist/commonjs/error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/error.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,cAAc,IAAI,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEnE,OAAO,EACL,qBAAqB,EAEtB,MAAM,eAAe,CAAC;AAGvB;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,kBAAkB;IACpD,CAAC,qBAAqB,CAAC,UAAQ;IAE/B,MAAM,CAAC,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,cAAc;CAK7D"}
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/error.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,cAAc,IAAI,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAQnE;;;GAGG;AACH,qBAAa,cAAe,SAAQ,kBAAkB;IAM3C,IAAI,SAAoB;IAEjC;;OAEG;gBACS,OAAO,CAAC,EAAE,qBAAqB,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAC;IAIzE;;;;;OAKG;IACH,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc;CAMjE"}

package/dist/commonjs/error.js

@@ -14,13 +14,28 @@ const guards_js_1 = require("./guards.js");
 /**
  * _BUPKIS_' s custom `AssertionError` class, which is just a thin wrapper
  * around Node.js' {@link NodeAssertionError AssertionError}.
- *
- * @public
  */
 class AssertionError extends node_assert_1.AssertionError {
+    /**
+     * @internal
+     */
     [constant_js_1.kBupkisAssertionError] = true;
-    static isAssertionError(err) {
-        return ((0, guards_js_1.isA)(err, node_assert_1.AssertionError) && Object.hasOwn(err, constant_js_1.kBupkisAssertionError));
+    name = 'AssertionError';
+    /**
+     * @param options Options passed to {@link NodeAssertionError}'s constructor
+     */
+    constructor(options) {
+        super(options);
+    }
+    /**
+     * Type guard for an instance of this error.
+     *
+     * @param value Some value
+     * @returns `true` if `value` is an instance of `AssertionError`
+     */
+    static isAssertionError(value) {
+        return ((0, guards_js_1.isA)(value, node_assert_1.AssertionError) &&
+            Object.hasOwn(value, constant_js_1.kBupkisAssertionError));
     }
 }
 exports.AssertionError = AssertionError;