bupkis 0.11.1 → 0.12.0

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

@@ -61,7 +61,7 @@ export declare const SyncDateAssertions: readonly [import("../assertion-types.js
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>, import("../assertion-types.js").PhraseLiteralSlot<"to be the same date as">, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>]>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]]>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be a weekday"], (subject: unknown) => {
+} | undefined, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>, import("../assertion-types.js").PhraseLiteralSlot<"to be the same date as">, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be a weekday"], (subject: unknown) => {
     message: string;
 } | undefined, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be a weekend"], (subject: unknown) => {
     message: string;
@@ -71,7 +71,7 @@ export declare const SyncDateAssertions: readonly [import("../assertion-types.js
  *
  * @group Assertion Collections
  */
-export declare const SyncEsotericAssertions: readonly [import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]]>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be frozen"], (subject: unknown) => {
+export declare const SyncEsotericAssertions: readonly [import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]], import("zod/v4").ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be frozen"], (subject: unknown) => {
     actual: boolean;
     expected: boolean;
     message: string;
@@ -79,13 +79,13 @@ export declare const SyncEsotericAssertions: readonly [import("../assertion-type
     actual: boolean;
     expected: boolean;
     message: string;
-} | undefined, 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").ZodNonOptional<import("zod/v4").ZodUnknown>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, "to have enumerable property", import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => import("zod/v4").ZodCustom<unknown, unknown>, readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have enumerable property">, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>]>, 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 extensible"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>];
+} | undefined, 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").ZodNonOptional<import("zod/v4").ZodUnknown>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, "to have enumerable property", import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => import("zod/v4").ZodCustom<unknown, unknown>, readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have enumerable property">, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be sealed"], import("zod/v4").ZodUnknown, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be extensible"], import("zod/v4").ZodUnknown, never>];
 /**
  * Tuple of all built-in basic synchronous assertions.
  *
  * @group Assertion Collections
  */
-export declare const SyncBasicAssertions: readonly [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 ["to be an async function"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be an async function"]>, 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 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 a class", "to be a constructor", "to be constructible"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]]>, 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 ["to be defined"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be defined"]>, never>, 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<{
+export declare const SyncBasicAssertions: readonly [import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an array", "to be array"]], import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be an async function"], import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], import("zod/v4").ZodBigInt, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], import("zod/v4").ZodBoolean, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], import("zod/v4").ZodDate, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be defined"], import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, never>, 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>]>, "to be empty"], (subject: unknown[] | [unknown, ...unknown[]] | {
     [x: string]: unknown;
@@ -96,7 +96,7 @@ export declare const SyncBasicAssertions: readonly [import("../assertion-types.j
     message: string;
 } | undefined, 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").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, "to be empty"]>, readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, 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 [readonly ["to be an Error", "to be a Error"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]]>, 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 ["to be falsy"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be falsy"]>, 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 infinite"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be infinite"]>, 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 NaN"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be NaN"]>, 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 ["to be -Infinity"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be -Infinity"]>, 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 [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 null"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be null"]>, 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 an object"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be an object"]>, 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 ["to be Infinity"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be Infinity"]>, 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 ["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 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 [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 ["to be a Set"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a Set"]>, never>, 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 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 true"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be true"]>, 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 undefined"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be undefined"]>, 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("zod/v4/core").$loose>]>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, "to be empty"], import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod/v4").ZodString, "to be empty"], import("zod/v4").ZodString, readonly [import("zod/v4").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]], import("zod/v4").ZodCustom<Error, Error>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be false"], import("zod/v4").ZodLiteral<false>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be falsy"], import("zod/v4").ZodNullable<import("zod/v4").ZodAny>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a function"], import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be infinite"], import("zod/v4").ZodUnion<[import("zod/v4").ZodLiteral<number>, import("zod/v4").ZodLiteral<number>]>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]], import("zod/v4").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be NaN"], import("zod/v4").ZodNaN, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], import("zod/v4").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be -Infinity"], import("zod/v4").ZodLiteral<number>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], import("zod/v4").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod/v4").ZodString, "to be non-empty"], import("zod/v4").ZodString, readonly [import("zod/v4").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be null"], import("zod/v4").ZodNull, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a number", "to be finite"]], import("zod/v4").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be an object"], import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], import("zod/v4").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be Infinity"], import("zod/v4").ZodLiteral<number>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], import("zod/v4").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a primitive"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodBoolean, import("zod/v4").ZodBigInt, import("zod/v4").ZodSymbol, import("zod/v4").ZodNull, import("zod/v4").ZodUndefined]>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], import("zod/v4").ZodCustom<RegExp, RegExp>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a Set"], import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a string"], import("zod/v4").ZodString, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], import("zod/v4").ZodSymbol, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be true"], import("zod/v4").ZodLiteral<true>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], import("zod/v4").ZodNonOptional<import("zod/v4").ZodAny>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be undefined"], import("zod/v4").ZodUndefined, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a WeakMap"], import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a WeakSet"], import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, never>];
 /**
  * Tuple of all built-in parametric synchronous assertions.
  *
@@ -104,7 +104,7 @@ export declare const SyncBasicAssertions: readonly [import("../assertion-types.j
  */
 export declare const SyncParametricAssertions: readonly [import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a", "to be an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (_: unknown, ctor: import("../../types.js").Constructor) => import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, readonly [import("zod/v4").ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be an instance of", "to be a", "to be an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodUnknown, readonly ["to be a", "to be an", "to have type"], import("zod/v4").ZodEnum<{
     [x: string]: string;
-}>], (_: unknown, type: string) => import("zod/v4").ZodString | import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | import("zod/v4").ZodNumber | import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | import("zod/v4").ZodArray<import("zod/v4").ZodUnknown> | import("zod/v4").ZodSymbol | import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown> | import("zod/v4").ZodBigInt | import("zod/v4").ZodBoolean | import("zod/v4").ZodDate | import("zod/v4").ZodCustom<Error, Error> | import("zod/v4").ZodNull | import("zod/v4").ZodUndefined | import("zod/v4").ZodCustom<RegExp, RegExp> | 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").ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, import("zod/v4").ZodEnum<{
+}>], (_: unknown, type: string) => import("zod/v4").ZodString | import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown> | import("zod/v4").ZodNumber | import("zod/v4").ZodSymbol | import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | import("zod/v4").ZodBoolean | import("zod/v4").ZodBigInt | import("zod/v4").ZodNull | import("zod/v4").ZodUndefined | import("zod/v4").ZodArray<import("zod/v4").ZodUnknown> | import("zod/v4").ZodCustom<RegExp, RegExp> | import("zod/v4").ZodDate | import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | import("zod/v4").ZodCustom<Error, Error> | import("zod/v4").ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>> | import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, readonly [import("zod/v4").ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, import("zod/v4").ZodEnum<{
     [x: string]: string;
 }>]>, 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, readonly ["to be less than", "to be lt"], 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", "to be lt"]>, 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", "to be gte"], 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", "to be gte"]>, 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", "to be lte"], 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", "to be lte"]>, 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) => {
     message: string;
@@ -198,7 +198,7 @@ export declare const SyncCollectionAssertions: readonly [import("../assertion-ty
     actual: unknown;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodUnion<[import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", import("zod/v4").ZodInt], (_subject: Map<unknown, unknown>, expectedSize: number) => import("zod/v4").ZodMap<import("zod/v4").ZodUnknown, import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodInt]>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"]>, 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").ZodUnion<[import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], import("zod/v4").ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => {
+} | undefined, readonly [import("zod/v4").ZodUnion<[import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", import("zod/v4").ZodInt], (_subject: Map<unknown, unknown>, expectedSize: number) => import("zod/v4").ZodMap<import("zod/v4").ZodUnknown, import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodInt]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, 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").ZodUnion<[import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], import("zod/v4").ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => {
     message: string;
     actual?: never;
     expected?: never;
@@ -206,9 +206,9 @@ export declare const SyncCollectionAssertions: readonly [import("../assertion-ty
     actual: unknown;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodUnion<[import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to have size", import("zod/v4").ZodInt], (_subject: Set<unknown>, expectedSize: number) => import("zod/v4").ZodSet<import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodInt]>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"]>, 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").ZodArray<import("zod/v4").ZodUnknown>, readonly ["to contain", "to include"], import("zod/v4").ZodUnknown], (subject: unknown[], value: unknown) => {
+} | undefined, readonly [import("zod/v4").ZodUnion<[import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to have size", import("zod/v4").ZodInt], (_subject: Set<unknown>, expectedSize: number) => import("zod/v4").ZodSet<import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodInt]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, 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").ZodArray<import("zod/v4").ZodUnknown>, readonly ["to contain", "to include"], import("zod/v4").ZodUnknown], (subject: unknown[], value: unknown) => {
     message: string;
-} | undefined, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, readonly ["to have length", "to have size"], import("zod/v4").ZodInt], (_subject: unknown[], expectedSize: number) => import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>, import("zod/v4").ZodInt]>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, "to be non-empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, "to be non-empty"]>, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"], import("zod/v4").ZodArray<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>>], (_subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: (string | number | symbol)[]) => import("zod/v4").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly [import("zod/v4").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"]>, import("zod/v4").ZodArray<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, "to have size", import("zod/v4").ZodInt], (subject: Record<string | number | symbol, unknown>, expectedSize: number) => {
+} | undefined, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, readonly ["to have length", "to have size"], import("zod/v4").ZodInt], (_subject: unknown[], expectedSize: number) => import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>, import("zod/v4").ZodInt]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, "to be non-empty"], import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"], import("zod/v4").ZodArray<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>>], (_subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: (string | number | symbol)[]) => import("zod/v4").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly [import("zod/v4").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"]>, import("zod/v4").ZodArray<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, "to have size", import("zod/v4").ZodInt], (subject: Record<string | number | symbol, unknown>, expectedSize: number) => {
     actual: number;
     expected: number;
     message: string;
@@ -268,7 +268,7 @@ export declare const SyncAssertions: readonly [import("../assertion-types.js").A
     actual: unknown;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodUnion<[import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", import("zod/v4").ZodInt], (_subject: Map<unknown, unknown>, expectedSize: number) => import("zod/v4").ZodMap<import("zod/v4").ZodUnknown, import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodInt]>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"]>, 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").ZodUnion<[import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], import("zod/v4").ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => {
+} | undefined, readonly [import("zod/v4").ZodUnion<[import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", import("zod/v4").ZodInt], (_subject: Map<unknown, unknown>, expectedSize: number) => import("zod/v4").ZodMap<import("zod/v4").ZodUnknown, import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodInt]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, 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").ZodUnion<[import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], import("zod/v4").ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => {
     message: string;
     actual?: never;
     expected?: never;
@@ -276,9 +276,9 @@ export declare const SyncAssertions: readonly [import("../assertion-types.js").A
     actual: unknown;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodUnion<[import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to have size", import("zod/v4").ZodInt], (_subject: Set<unknown>, expectedSize: number) => import("zod/v4").ZodSet<import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodInt]>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"]>, 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").ZodArray<import("zod/v4").ZodUnknown>, readonly ["to contain", "to include"], import("zod/v4").ZodUnknown], (subject: unknown[], value: unknown) => {
+} | undefined, readonly [import("zod/v4").ZodUnion<[import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to have size", import("zod/v4").ZodInt], (_subject: Set<unknown>, expectedSize: number) => import("zod/v4").ZodSet<import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to have size">, import("zod/v4").ZodInt]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, 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").ZodArray<import("zod/v4").ZodUnknown>, readonly ["to contain", "to include"], import("zod/v4").ZodUnknown], (subject: unknown[], value: unknown) => {
     message: string;
-} | undefined, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, readonly ["to have length", "to have size"], import("zod/v4").ZodInt], (_subject: unknown[], expectedSize: number) => import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>, import("zod/v4").ZodInt]>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, "to be non-empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, "to be non-empty"]>, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"], import("zod/v4").ZodArray<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>>], (_subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: (string | number | symbol)[]) => import("zod/v4").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly [import("zod/v4").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"]>, import("zod/v4").ZodArray<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, "to have size", import("zod/v4").ZodInt], (subject: Record<string | number | symbol, unknown>, expectedSize: number) => {
+} | undefined, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, readonly ["to have length", "to have size"], import("zod/v4").ZodInt], (_subject: unknown[], expectedSize: number) => import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>, import("zod/v4").ZodInt]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, "to be non-empty"], import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"], import("zod/v4").ZodArray<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>>], (_subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: (string | number | symbol)[]) => import("zod/v4").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly [import("zod/v4").ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"]>, import("zod/v4").ZodArray<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, "to have size", import("zod/v4").ZodInt], (subject: Record<string | number | symbol, unknown>, expectedSize: number) => {
     actual: number;
     expected: number;
     message: string;
@@ -324,7 +324,7 @@ export declare const SyncAssertions: readonly [import("../assertion-types.js").A
     message: string;
 } | undefined, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size less than">, import("zod/v4").ZodInt]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size between", import("zod/v4").ZodTuple<[import("zod/v4").ZodInt, import("zod/v4").ZodInt], null>], (collection: Map<unknown, unknown> | Set<unknown>, [min, max]: [number, number]) => {
     message: string;
-} | undefined, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size between">, import("zod/v4").ZodTuple<[import("zod/v4").ZodInt, import("zod/v4").ZodInt], null>]>, 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 ["to be an async function"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be an async function"]>, 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 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 a class", "to be a constructor", "to be constructible"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]]>, 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 ["to be defined"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be defined"]>, never>, 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<{
+} | undefined, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>]>, import("../assertion-types.js").PhraseLiteralSlot<"to have size between">, import("zod/v4").ZodTuple<[import("zod/v4").ZodInt, import("zod/v4").ZodInt], null>]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an array", "to be array"]], import("zod/v4").ZodArray<import("zod/v4").ZodUnknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be an async function"], import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], import("zod/v4").ZodBigInt, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], import("zod/v4").ZodBoolean, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], import("zod/v4").ZodDate, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be defined"], import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, never>, 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>]>, "to be empty"], (subject: unknown[] | [unknown, ...unknown[]] | {
     [x: string]: unknown;
@@ -335,9 +335,9 @@ export declare const SyncAssertions: readonly [import("../assertion-types.js").A
     message: string;
 } | undefined, 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").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionSchemaSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, "to be empty"]>, readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, 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 [readonly ["to be an Error", "to be a Error"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]]>, 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 ["to be falsy"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be falsy"]>, 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 infinite"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be infinite"]>, 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 NaN"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be NaN"]>, 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 ["to be -Infinity"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be -Infinity"]>, 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 [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 null"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be null"]>, 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 an object"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be an object"]>, 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 ["to be Infinity"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be Infinity"]>, 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 ["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 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 [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 ["to be a Set"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a Set"]>, never>, 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 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 true"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be true"]>, 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 undefined"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be undefined"]>, 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").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a", "to be an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (_: unknown, ctor: import("../../types.js").Constructor) => import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, readonly [import("zod/v4").ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be an instance of", "to be a", "to be an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodUnknown, readonly ["to be a", "to be an", "to have type"], import("zod/v4").ZodEnum<{
+}, import("zod/v4/core").$loose>]>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, "to be empty"], import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, readonly [import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod/v4").ZodString, "to be empty"], import("zod/v4").ZodString, readonly [import("zod/v4").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]], import("zod/v4").ZodCustom<Error, Error>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be false"], import("zod/v4").ZodLiteral<false>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be falsy"], import("zod/v4").ZodNullable<import("zod/v4").ZodAny>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a function"], import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be infinite"], import("zod/v4").ZodUnion<[import("zod/v4").ZodLiteral<number>, import("zod/v4").ZodLiteral<number>]>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an integer", "to be a safe integer", "to be an int", "to be a safe int"]], import("zod/v4").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be NaN"], import("zod/v4").ZodNaN, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], import("zod/v4").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be -Infinity"], import("zod/v4").ZodLiteral<number>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], import("zod/v4").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [import("zod/v4").ZodString, "to be non-empty"], import("zod/v4").ZodString, readonly [import("zod/v4").ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be null"], import("zod/v4").ZodNull, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a number", "to be finite"]], import("zod/v4").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be an object"], import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], import("zod/v4").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be Infinity"], import("zod/v4").ZodLiteral<number>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], import("zod/v4").ZodNumber, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a primitive"], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodBoolean, import("zod/v4").ZodBigInt, import("zod/v4").ZodSymbol, import("zod/v4").ZodNull, import("zod/v4").ZodUndefined]>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], import("zod/v4").ZodRecord<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>, import("zod/v4").ZodUnknown>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], import("zod/v4").ZodCustom<RegExp, RegExp>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a Set"], import("zod/v4").ZodCustom<Set<unknown>, Set<unknown>>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a string"], import("zod/v4").ZodString, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], import("zod/v4").ZodSymbol, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be true"], import("zod/v4").ZodLiteral<true>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], import("zod/v4").ZodNonOptional<import("zod/v4").ZodAny>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be undefined"], import("zod/v4").ZodUndefined, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a WeakMap"], import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a WeakSet"], import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a", "to be an"], import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>], (_: unknown, ctor: import("../../types.js").Constructor) => import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, readonly [import("zod/v4").ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be an instance of", "to be a", "to be an"]>, import("zod/v4").ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodUnknown, readonly ["to be a", "to be an", "to have type"], import("zod/v4").ZodEnum<{
     [x: string]: string;
-}>], (_: unknown, type: string) => import("zod/v4").ZodString | import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | import("zod/v4").ZodNumber | import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | import("zod/v4").ZodArray<import("zod/v4").ZodUnknown> | import("zod/v4").ZodSymbol | import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown> | import("zod/v4").ZodBigInt | import("zod/v4").ZodBoolean | import("zod/v4").ZodDate | import("zod/v4").ZodCustom<Error, Error> | import("zod/v4").ZodNull | import("zod/v4").ZodUndefined | import("zod/v4").ZodCustom<RegExp, RegExp> | 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").ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, import("zod/v4").ZodEnum<{
+}>], (_: unknown, type: string) => import("zod/v4").ZodString | import("zod/v4").ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown> | import("zod/v4").ZodNumber | import("zod/v4").ZodSymbol | import("zod/v4").ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | import("zod/v4").ZodBoolean | import("zod/v4").ZodBigInt | import("zod/v4").ZodNull | import("zod/v4").ZodUndefined | import("zod/v4").ZodArray<import("zod/v4").ZodUnknown> | import("zod/v4").ZodCustom<RegExp, RegExp> | import("zod/v4").ZodDate | import("zod/v4").ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | import("zod/v4").ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | import("zod/v4").ZodCustom<Error, Error> | import("zod/v4").ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>> | import("zod/v4").ZodObject<{}, import("zod/v4/core").$loose>, readonly [import("zod/v4").ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, import("zod/v4").ZodEnum<{
     [x: string]: string;
 }>]>, 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, readonly ["to be less than", "to be lt"], 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", "to be lt"]>, 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", "to be gte"], 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", "to be gte"]>, 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", "to be lte"], 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", "to be lte"]>, 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) => {
     message: string;
@@ -419,7 +419,7 @@ export declare const SyncAssertions: readonly [import("../assertion-types.js").A
     length: number;
 }, shape: unknown) => 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").ZodUnknown]>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]]>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be frozen"], (subject: unknown) => {
+}, import("zod/v4/core").$loose>]>, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, import("zod/v4").ZodUnknown]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]], import("zod/v4").ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be frozen"], (subject: unknown) => {
     actual: boolean;
     expected: boolean;
     message: string;
@@ -427,7 +427,7 @@ export declare const SyncAssertions: readonly [import("../assertion-types.js").A
     actual: boolean;
     expected: boolean;
     message: string;
-} | undefined, 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").ZodNonOptional<import("zod/v4").ZodUnknown>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, "to have enumerable property", import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => import("zod/v4").ZodCustom<unknown, unknown>, readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have enumerable property">, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>]>, 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 extensible"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>, "to be after", import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>], (subject: string | number | Date, other: string | number | Date) => {
+} | undefined, 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").ZodNonOptional<import("zod/v4").ZodUnknown>]>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, "to have enumerable property", import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => import("zod/v4").ZodCustom<unknown, unknown>, readonly [import("zod/v4").ZodNonOptional<import("zod/v4").ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to have enumerable property">, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodNumber, import("zod/v4").ZodSymbol]>]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be sealed"], import("zod/v4").ZodUnknown, never>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be extensible"], import("zod/v4").ZodUnknown, never>, import("../assertion-types.js").AssertionFunctionSync<readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>, "to be after", import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>], (subject: string | number | Date, other: string | number | Date) => {
     message: string;
     schema?: never;
     subject?: never;
@@ -471,7 +471,7 @@ export declare const SyncAssertions: readonly [import("../assertion-types.js").A
     actual: string;
     expected: string;
     message: string;
-} | undefined, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>, import("../assertion-types.js").PhraseLiteralSlot<"to be the same date as">, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>]>, import("../assertion-types.js").AssertionSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]], import("../assertion-types.js").AssertionImplSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]]>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be a weekday"], (subject: unknown) => {
+} | undefined, readonly [import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>, import("../assertion-types.js").PhraseLiteralSlot<"to be the same date as">, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>]>, import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]], import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodDate, import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodISODateTime, import("zod/v4").ZodISODate]>, import("zod/v4").ZodNumber]>, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be a weekday"], (subject: unknown) => {
     message: string;
 } | undefined, never>, import("../assertion-types.js").AssertionFunctionSync<readonly ["to be a weekend"], (subject: unknown) => {
     message: string;

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

@@ -1 +1 @@
-{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA2HH;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBASrB,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;wxCAOzB,CAAC;AAEX;;;;GAIG;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;w8NAuCtB,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kKA8B3B,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kWA8B3B,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAMjB,CAAC;AAIX,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA2HH;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBASrB,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;srCAOzB,CAAC;AAEX;;;;GAIG;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;80LAuCtB,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kKA8B3B,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kWA8B3B,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAMjB,CAAC;AAIX,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC"}

package/dist/commonjs/assertion/slotify.js

@@ -71,19 +71,37 @@ const slotify = (parts) => {
             result.push(createPhraseLiteralSchema(part));
         }
         else if (typeof part === 'string' && part === 'and') {
-            // Special case: "and" is allowed when followed by a ZodType (for conjunctify)
-            if (index + 1 >= parts.length || !(0, guards_js_1.isZodType)(parts[index + 1])) {
-                throw new error_js_1.AssertionImplementationError(`"and" at parts[${index}] must be followed by a Zod schema but was followed by ${index + 1 >= parts.length
+            // Special case: "and" is allowed when followed by a schema (Zod or Standard Schema)
+            const nextPart = parts[index + 1];
+            if (index + 1 >= parts.length ||
+                !((0, guards_js_1.isZodType)(nextPart) || (0, guards_js_1.isStandardSchema)(nextPart))) {
+                throw new error_js_1.AssertionImplementationError(`"and" at parts[${index}] must be followed by a schema but was followed by ${index + 1 >= parts.length
                     ? 'nothing'
-                    : `${(0, util_1.inspect)(parts[index + 1])} (${typeof parts[index + 1]})`}`);
+                    : `${(0, util_1.inspect)(nextPart)} (${typeof nextPart})`}`);
             }
             result.push(createPhraseLiteralSchema(part));
         }
         else {
-            if (!(0, guards_js_1.isZodType)(part)) {
-                throw new error_js_1.AssertionImplementationError(`Expected Zod schema, phrase literal, or phrase literal choice at parts[${index}] but received ${(0, util_1.inspect)(part)} (${typeof part})`);
+            // Schema parts: either Zod or Standard Schema
+            if ((0, guards_js_1.isZodType)(part)) {
+                result.push(part);
+            }
+            else if ((0, guards_js_1.isStandardSchema)(part)) {
+                // Convert Standard Schema to Zod schema for slotification
+                // Slots use Zod's safeParse, so we need a Zod wrapper
+                const zodWrapper = v4_1.z.custom((value) => {
+                    const validationResult = part['~standard'].validate(value);
+                    // Must be synchronous for slots
+                    if (validationResult instanceof Promise) {
+                        return false;
+                    }
+                    return !validationResult.issues;
+                }, { error: `Failed Standard Schema validation` });
+                result.push(zodWrapper);
+            }
+            else {
+                throw new error_js_1.AssertionImplementationError(`Expected schema, phrase literal, or phrase literal choice at parts[${index}] but received ${(0, util_1.inspect)(part)} (${typeof part})`);
             }
-            result.push(part);
         }
         return result;
     });

package/dist/commonjs/assertion/slotify.js.map

@@ -1 +1 @@
-{"version":3,"file":"slotify.js","sourceRoot":"","sources":["../../../src/assertion/slotify.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"slotify.js","sourceRoot":"","sources":["../../../src/assertion/slotify.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAEH,+BAA+B;AAC/B,+BAA2B;AAS3B,gDAAgD;AAChD,0CAA2D;AAC3D,4CAMsB;AACtB,gDAAgD;AAEhD;;;;;GAKG;AACH,MAAM,YAAY,GAAG,IAAI,OAAO,EAAkC,CAAC;AAEnE;;;;;GAKG;AACH,MAAM,wBAAwB,GAAG,IAAI,GAAG,EAGrC,CAAC;AAEJ;;;;GAIG;AACH,MAAM,8BAA8B,GAAG,IAAI,GAAG,EAG3C,CAAC;AAEJ;;;;;;;;;;;;GAYG;AACI,MAAM,OAAO,GAAG,CACrB,KAAY,EACW,EAAE;IACzB,IAAI,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO,YAAY,CAAC,GAAG,CAAC,KAAK,CAAE,CAAC;IAClC,CAAC;IACD,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;QAC1C,MAAM,MAAM,GAAgB,EAAE,CAAC;QAC/B,IAAI,KAAK,KAAK,CAAC,IAAI,IAAA,oBAAQ,EAAC,IAAI,CAAC,EAAE,CAAC;YAClC,MAAM,CAAC,IAAI,CAAC,MAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC;QAC/C,CAAC;QAED,IAAI,IAAA,iCAAqB,EAAC,IAAI,CAAC,EAAE,CAAC;YAChC,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;gBAC3C,MAAM,IAAI,uCAA4B,CACpC,gCAAgC,KAAK,yFAAyF,IAAA,cAAO,EACnI,IAAI,CACL,EAAE,CACJ,CAAC;YACJ,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,+BAA+B,CAAC,IAAI,CAAC,CAAC,CAAC;QACrD,CAAC;aAAM,IAAI,IAAA,2BAAe,EAAC,IAAI,CAAC,EAAE,CAAC;YACjC,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC5B,MAAM,IAAI,uCAA4B,CACpC,0BAA0B,KAAK,sEAAsE,IAAA,cAAO,EAC1G,IAAI,CACL,EAAE,CACJ,CAAC;YACJ,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC,CAAC;QAC/C,CAAC;aAAM,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;YACtD,oFAAoF;YACpF,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;YAClC,IACE,KAAK,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM;gBACzB,CAAC,CAAC,IAAA,qBAAS,EAAC,QAAQ,CAAC,IAAI,IAAA,4BAAgB,EAAC,QAAQ,CAAC,CAAC,EACpD,CAAC;gBACD,MAAM,IAAI,uCAA4B,CACpC,kBAAkB,KAAK,sDACrB,KAAK,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM;oBACvB,CAAC,CAAC,SAAS;oBACX,CAAC,CAAC,GAAG,IAAA,cAAO,EAAC,QAAQ,CAAC,KAAK,OAAO,QAAQ,GAC9C,EAAE,CACH,CAAC;YACJ,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC,CAAC;QAC/C,CAAC;aAAM,CAAC;YACN,8CAA8C;YAC9C,IAAI,IAAA,qBAAS,EAAC,IAAI,CAAC,EAAE,CAAC;gBACpB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;iBAAM,IAAI,IAAA,4BAAgB,EAAC,IAAI,CAAC,EAAE,CAAC;gBAClC,0DAA0D;gBAC1D,sDAAsD;gBACtD,MAAM,UAAU,GAAG,MAAC,CAAC,MAAM,CACzB,CAAC,KAAc,EAAE,EAAE;oBACjB,MAAM,gBAAgB,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;oBAC3D,gCAAgC;oBAChC,IAAI,gBAAgB,YAAY,OAAO,EAAE,CAAC;wBACxC,OAAO,KAAK,CAAC;oBACf,CAAC;oBACD,OAAO,CAAC,gBAAgB,CAAC,MAAM,CAAC;gBAClC,CAAC,EACD,EAAE,KAAK,EAAE,mCAAmC,EAAE,CAC/C,CAAC;gBACF,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC1B,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,uCAA4B,CACpC,sEAAsE,KAAK,kBAAkB,IAAA,cAAO,EAClG,IAAI,CACL,KAAK,OAAO,IAAI,GAAG,CACrB,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC,CAAqC,CAAC;IACvC,YAAY,CAAC,GAAG,CAAC,KAAK,EAAE,KAAuB,CAAC,CAAC;IACjD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AA7EW,QAAA,OAAO,WA6ElB;AAEF;;;;;;;;;GASG;AACH,MAAM,+BAA+B,GAAG,CACtC,IAAyB,EACmC,EAAE;IAC9D,0DAA0D;IAC1D,IAAI,8BAA8B,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7C,OAAO,8BAA8B,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC;IACnD,CAAC;IAED,MAAM,MAAM,GAAG,MAAC;SACb,OAAO,CAAC,IAAI,CAAC;SACb,KAAK,CAAC,gBAAgB,CAAC;SACvB,QAAQ,CAAC,4BAAc,EAAE;QACxB,CAAC,4BAAc,CAAC,EAAE,IAAI;QACtB,MAAM,EAAE,IAAI;KACb,CAAC,CAAC;IAEL,kCAAkC;IAClC,8BAA8B,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACjD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,yBAAyB,GAAG,CAChC,IAAmB,EACyC,EAAE;IAC9D,0DAA0D;IAC1D,IAAI,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QACvC,OAAO,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC;IAC7C,CAAC;IAED,MAAM,MAAM,GAAG,MAAC;SACb,OAAO,CAAC,IAAI,CAAC;SACb,KAAK,CAAC,gBAAgB,CAAC;SACvB,QAAQ,CAAC,4BAAc,EAAE;QACxB,CAAC,4BAAc,CAAC,EAAE,IAAI;QACtB,KAAK,EAAE,IAAI;KACZ,CAAC,CAAC;IAEL,kCAAkC;IAClC,wBAAwB,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC3C,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC"}