bupkis 0.1.2 → 0.3.0

package/dist/esm/assertion/impl/sync.d.ts

@@ -8,137 +8,184 @@
  *
  * @packageDocumentation
  */
+import { CallbackSyncAssertions } from './callback.js';
 import { BasicAssertions } from './sync-basic.js';
 import { CollectionAssertions } from './sync-collection.js';
 import { EsotericAssertions } from './sync-esoteric.js';
 import { ParametricAssertions } from './sync-parametric.js';
-export declare const SyncAssertions: readonly [import("../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-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodAny]>, import("../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-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodNumber]>, import("../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-types.js").PhraseLiteralSlot<"to be empty">]>, import("../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-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodAny]>, import("../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-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodNumber]>, import("../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-types.js").PhraseLiteralSlot<"to be empty">]>, import("../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-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodAny]>, import("../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-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodAny]>, import("../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-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod").ZodAny]>, import("../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-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodNumber]>, import("../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-types.js").PhraseLiteralSlot<"to have length">, import("zod").ZodNumber]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodArray<import("zod").ZodAny>, "to be non-empty"], (subject: any[]) => {
+export declare const SyncAssertions: readonly [import("../assertion-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("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("../assertion-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("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("../assertion-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("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-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("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("../assertion-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("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("../assertion-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("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-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("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("../assertion-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("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("../assertion-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("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodAny]>, import("../assertion-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("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("../assertion-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("../assertion-types.js").PhraseLiteralSlot<"to have length">, import("zod/v4").ZodNumber]>, import("../assertion-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-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../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("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../assertion-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-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props"]>, import("zod").ZodTuple<[import("zod").ZodString], import("zod").ZodString>]>, import("../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("../assertion-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("../assertion-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-types.js").PhraseLiteralSlot<"to have size">, import("zod").ZodNumber]>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a string"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a string"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a number", "to be finite"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a number", "to be finite"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be infinite"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be infinite"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be Infinity"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be Infinity"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be -Infinity"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be -Infinity"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be true"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be true"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be false"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be false"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a function"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a function"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be an async function"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be an async function"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be NaN"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be NaN"]>, never>, import("../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-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-types.js").AssertionSchemaSync<readonly ["to be null"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be null"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be undefined"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be undefined"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be an array", "to be array"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be an array", "to be array"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a date", "to be a Date"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a class", "to be a constructor"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a class", "to be a constructor"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a primitive"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a primitive"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be falsy"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be falsy"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be an object"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be an object"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod").ZodArray<import("zod").ZodAny>, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [import("zod").ZodArray<import("zod").ZodAny>, "to be empty"]>, readonly [import("zod").ZodArray<import("zod").ZodAny>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod").ZodRecord<import("zod").ZodAny, import("zod").ZodUnknown>, "to be empty"], import("../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-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be an Error"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be an Error"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod").ZodString, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [import("zod").ZodString, "to be empty"]>, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod").ZodString, "to be non-empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [import("zod").ZodString, "to be non-empty"]>, readonly [import("zod").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be defined"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be defined"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a Set"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a Set"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a WeakMap"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a WeakMap"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a WeakSet"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a WeakSet"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to have a null prototype"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to have a null prototype"]>, never>, import("../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("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodNumber]>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a string"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a string"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a number", "to be finite"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a number", "to be finite"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be infinite"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be infinite"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be Infinity"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be Infinity"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be -Infinity"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be -Infinity"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be true"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be true"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be false"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be false"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a function"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a function"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be an async function"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be an async function"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be NaN"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be NaN"]>, never>, import("../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-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-types.js").AssertionSchemaSync<readonly ["to be null"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be null"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be undefined"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be undefined"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be an array", "to be array"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be an array", "to be array"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a date", "to be a Date"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a class", "to be a constructor"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a class", "to be a constructor"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a primitive"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a primitive"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be falsy"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be falsy"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be an object"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be an object"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodAny>, "to be empty"], import("../assertion-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("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodAny, import("zod/v4").ZodUnknown>, "to be empty"], import("../assertion-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("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be an Error"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be an Error"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodString, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodString, "to be empty"]>, readonly [import("zod/v4").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodString, "to be non-empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodString, "to be non-empty"]>, readonly [import("zod/v4").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be defined"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be defined"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a Set"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a Set"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a WeakMap"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a WeakMap"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a WeakSet"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a WeakSet"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to have a null prototype"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to have a null prototype"]>, never>, import("../assertion-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-types.js").PhraseLiteralSlot<"to be an enumerable property of">, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be sealed"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be frozen"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be frozen"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be extensible"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>, import("../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-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-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("../assertion-types.js").PhraseLiteralSlot<"to be an enumerable property of">, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be sealed"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be frozen"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be frozen"]>, never>, import("../assertion-types.js").AssertionSchemaSync<readonly ["to be extensible"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>, import("../assertion-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("../assertion-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("../assertion-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-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("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an"]>, import("zod/v4").ZodEnum<{
     [x: string]: string;
-}>]>, import("../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-types.js").PhraseLiteralSlot<"to be greater than">, import("zod").ZodNumber]>, import("../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-types.js").PhraseLiteralSlot<"to be less than">, import("zod").ZodNumber]>, import("../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-types.js").PhraseLiteralChoiceSlot<readonly ["to be greater than or equal to", "to be at least"]>, import("zod").ZodNumber]>, import("../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-types.js").PhraseLiteralChoiceSlot<readonly ["to be less than or equal to", "to be at most"]>, import("zod").ZodNumber]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod").ZodNumber, "to be within", import("zod").ZodNumber, import("zod").ZodNumber], (subject: number, min: number, max: number) => {
+}>]>, import("../assertion-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("../assertion-types.js").PhraseLiteralSlot<"to be greater than">, import("zod/v4").ZodNumber]>, import("../assertion-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("../assertion-types.js").PhraseLiteralSlot<"to be less than">, import("zod/v4").ZodNumber]>, import("../assertion-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("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be greater than or equal to", "to be at least"]>, import("zod/v4").ZodNumber]>, import("../assertion-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("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be less than or equal to", "to be at most"]>, import("zod/v4").ZodNumber]>, import("../assertion-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-types.js").PhraseLiteralSlot<"to be within">, import("zod").ZodNumber, import("zod").ZodNumber]>, import("../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("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>, import("zod/v4").ZodNumber, import("zod/v4").ZodNumber]>, import("../assertion-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-types.js").PhraseLiteralSlot<"to be close to">, import("zod").ZodNumber, import("zod").ZodOptional<import("zod").ZodNumber>]>, import("../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("../assertion-types.js").PhraseLiteralSlot<"to be close to">, import("zod/v4").ZodNumber, import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>]>, import("../assertion-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-types.js").PhraseLiteralSlot<"to be greater than">, import("zod").ZodString]>, import("../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("../assertion-types.js").PhraseLiteralSlot<"to be greater than">, import("zod/v4").ZodString]>, import("../assertion-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-types.js").PhraseLiteralSlot<"to be less than">, import("zod").ZodString]>, import("../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("../assertion-types.js").PhraseLiteralSlot<"to be less than">, import("zod/v4").ZodString]>, import("../assertion-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-types.js").PhraseLiteralSlot<"to be greater than or equal to">, import("zod").ZodString]>, import("../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("../assertion-types.js").PhraseLiteralSlot<"to be greater than or equal to">, import("zod/v4").ZodString]>, import("../assertion-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-types.js").PhraseLiteralSlot<"to be less than or equal to">, import("zod").ZodString]>, import("../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("../assertion-types.js").PhraseLiteralSlot<"to be less than or equal to">, import("zod/v4").ZodString]>, import("../assertion-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-types.js").PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>, import("zod").ZodString]>, import("../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("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>, import("zod/v4").ZodString]>, import("../assertion-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-types.js").PhraseLiteralSlot<"to end with">, import("zod").ZodString]>, import("../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("../assertion-types.js").PhraseLiteralSlot<"to end with">, import("zod/v4").ZodString]>, import("../assertion-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-types.js").PhraseLiteralSlot<"to be one of">, import("zod").ZodArray<import("zod").ZodAny>]>, import("../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("../assertion-types.js").PhraseLiteralSlot<"to be one of">, import("zod/v4").ZodArray<import("zod/v4").ZodAny>]>, import("../assertion-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-types.js").PhraseLiteralSlot<"to have arity">, import("zod").ZodNumber]>, import("../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("../assertion-types.js").PhraseLiteralSlot<"to have arity">, import("zod/v4").ZodNumber]>, import("../assertion-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-types.js").PhraseLiteralSlot<"to have message">, import("zod").ZodString]>, import("../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("../assertion-types.js").PhraseLiteralSlot<"to have message">, import("zod/v4").ZodString]>, import("../assertion-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-types.js").PhraseLiteralSlot<"to have message matching">, import("zod").ZodCustom<RegExp, RegExp>]>, import("../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("../assertion-types.js").PhraseLiteralSlot<"to have message matching">, import("zod/v4").ZodCustom<RegExp, RegExp>]>, import("../assertion-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-types.js").PhraseLiteralChoiceSlot<readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal"]>, import("zod").ZodUnknown]>, import("../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-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-types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>, import("../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-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-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-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("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<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>], (_: {
+    [x: string]: unknown;
+}, expected: {
+    [x: string]: unknown;
+}) => import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>, readonly [import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>, import("../assertion-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 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>]>], (_: unknown[] | [unknown, ...unknown[]] | {
+    [x: string]: unknown;
+    length: number;
+}, expected: unknown[] | [unknown, ...unknown[]] | {
+    [x: string]: unknown;
+    length: number;
+}) => import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>, 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("../assertion-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("../assertion-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-types.js").PhraseLiteralSlot<"to throw">]>, import("../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("../assertion-types.js").PhraseLiteralSlot<"to throw">]>, import("../assertion-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-types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../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("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-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-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-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("../assertion-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("../assertion-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;
+}) => import("zod/v4").ZodError<unknown> | {
+    actual: never;
     expected: string;
     message: string;
-} | {
-    actual: unknown;
-    expected: {
-        [x: string]: unknown;
-    };
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, import("../assertion-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("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodString, readonly ["includes", "contains", "to include", "to contain"], import("zod/v4").ZodString], (subject: string, expected: string) => {
+    actual: string;
+    expected: string;
     message: string;
-} | undefined, readonly [import("zod").ZodCustom<(...args: any[]) => any, (...args: any[]) => any>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, import("zod").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, import("../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-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-types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, import("zod").ZodString]>, import("../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-types.js").PhraseLiteralSlot<"to match">, import("zod").ZodCustom<RegExp, RegExp>]>, import("../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").ZodString, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, import("zod/v4").ZodString]>, import("../assertion-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("../assertion-types.js").PhraseLiteralSlot<"to match">, import("zod/v4").ZodCustom<RegExp, RegExp>]>, import("../assertion-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-types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, import("zod").ZodObject<{}, import("zod/v4/core").$loose>]>, import("../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<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>, readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>]>, import("../assertion-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-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-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) => {
+}) => import("zod/v4").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>, 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("../assertion-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("../assertion-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-types.js").PhraseLiteralSlot<"to have arity">, import("zod").ZodNumber]>];
-export { BasicAssertions, CollectionAssertions, EsotericAssertions, ParametricAssertions, };
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have arity">, import("zod/v4").ZodNumber]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call callback", "to invoke callback"]], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown) => boolean, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to call callback", "to invoke callback"]>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback", "to invoke nodeback"]], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown) => boolean, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback", "to invoke nodeback"]>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call callback with", "to invoke callback with"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | import("zod/v4").ZodError<any> | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to call callback with", "to invoke callback with"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call callback with exactly", "to call callback with exact value", "to invoke callback with exactly", "to invoke callback with exact value"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, expected: unknown) => {
+    actual: unknown;
+    expected: unknown;
+    message: string;
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to call callback with exactly", "to call callback with exact value", "to invoke callback with exactly", "to invoke callback with exact value"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback with", "to invoke nodeback with"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | import("zod/v4").ZodError<any> | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback with", "to invoke nodeback with"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback with exactly", "to call nodeback with exact value", "to invoke nodeback with exactly", "to invoke nodeback with exact value"], import("zod/v4").ZodUnknown], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, expected: unknown) => {
+    actual: unknown;
+    expected: unknown;
+    message: string;
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback with exactly", "to call nodeback with exact value", "to invoke nodeback with exactly", "to invoke nodeback with exact value"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback with error", "to invoke nodeback with error"]], (subject: (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback with error", "to invoke nodeback with error"]>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback with a", "to call nodeback with an", "to invoke nodeback with a", "to invoke nodeback 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) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback with a", "to call nodeback with an", "to invoke nodeback with a", "to invoke nodeback with an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback with error", "to invoke nodeback with error"], 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;
+}) => import("zod/v4").ZodError<unknown> | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback with error", "to invoke nodeback with error"]>, 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("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call callback with value satisfying", "to invoke callback 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;
+}) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | import("zod/v4").ZodError<any> | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to call callback with value satisfying", "to invoke callback 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("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback with value satisfying", "to invoke nodeback 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;
+}) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | import("zod/v4").ZodError<any> | undefined, readonly [import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback with value satisfying", "to invoke nodeback 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 { BasicAssertions, CallbackSyncAssertions, CollectionAssertions, EsotericAssertions, ParametricAssertions, };
 //# sourceMappingURL=sync.d.ts.map

package/dist/esm/assertion/impl/sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kMAKjB,CAAC;AAEX,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,oBAAoB,GACrB,CAAC"}
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ujBAMjB,CAAC;AAEX,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,EAClB,oBAAoB,GACrB,CAAC"}

package/dist/esm/assertion/impl/sync.js

@@ -8,6 +8,7 @@
  *
  * @packageDocumentation
  */
+import { CallbackSyncAssertions } from './callback.js';
 import { BasicAssertions } from './sync-basic.js';
 import { CollectionAssertions } from './sync-collection.js';
 import { EsotericAssertions } from './sync-esoteric.js';
@@ -17,6 +18,7 @@ export const SyncAssertions = [
     ...BasicAssertions,
     ...EsotericAssertions,
     ...ParametricAssertions,
+    ...CallbackSyncAssertions,
 ];
-export { BasicAssertions, CollectionAssertions, EsotericAssertions, ParametricAssertions, };
+export { BasicAssertions, CallbackSyncAssertions, CollectionAssertions, EsotericAssertions, ParametricAssertions, };
 //# sourceMappingURL=sync.js.map

package/dist/esm/assertion/impl/sync.js.map

@@ -1 +1 @@
-{"version":3,"file":"sync.js","sourceRoot":"","sources":["../../../../src/assertion/impl/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,GAAG,oBAAoB;IACvB,GAAG,eAAe;IAClB,GAAG,kBAAkB;IACrB,GAAG,oBAAoB;CACf,CAAC;AAEX,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,oBAAoB,GACrB,CAAC"}
+{"version":3,"file":"sync.js","sourceRoot":"","sources":["../../../../src/assertion/impl/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,GAAG,oBAAoB;IACvB,GAAG,eAAe;IAClB,GAAG,kBAAkB;IACrB,GAAG,oBAAoB;IACvB,GAAG,sBAAsB;CACjB,CAAC;AAEX,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,EAClB,oBAAoB,GACrB,CAAC"}