bupkis 0.11.1 → 0.12.0

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

@@ -26,7 +26,7 @@ import { z } from 'zod/v4';
  * @bupkisAnchor unknown-to-be-a-string
  * @bupkisAssertionCategory primitives
  */
-export declare const stringAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a string"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a string"]>, never>;
+export declare const stringAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a string"], z.ZodString, never>;
 /**
  * Asserts that the subject is a finite number value.
  *
@@ -40,7 +40,7 @@ export declare const stringAssertion: import("../assertion-types.js").AssertionS
  *
  * @group Basic Assertions
  */
-export declare const numberAssertion: 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>;
+export declare const numberAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a number", "to be finite"]], z.ZodNumber, never>;
 /**
  * Asserts that the subject is either positive or negative infinity.
  *
@@ -54,7 +54,7 @@ export declare const numberAssertion: import("../assertion-types.js").AssertionS
  *
  * @group Basic Assertions
  */
-export declare const infiniteAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be infinite"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be infinite"]>, never>;
+export declare const infiniteAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be infinite"], z.ZodUnion<[z.ZodLiteral<number>, z.ZodLiteral<number>]>, never>;
 /**
  * Asserts that the subject is positive infinity.
  *
@@ -67,7 +67,7 @@ export declare const infiniteAssertion: import("../assertion-types.js").Assertio
  *
  * @group Basic Assertions
  */
-export declare const positiveInfinityAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be Infinity"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be Infinity"]>, never>;
+export declare const positiveInfinityAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be Infinity"], z.ZodLiteral<number>, never>;
 /**
  * Asserts that the subject is negative infinity.
  *
@@ -80,7 +80,7 @@ export declare const positiveInfinityAssertion: import("../assertion-types.js").
  *
  * @group Basic Assertions
  */
-export declare const negativeInfinityAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be -Infinity"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be -Infinity"]>, never>;
+export declare const negativeInfinityAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be -Infinity"], z.ZodLiteral<number>, never>;
 /**
  * Asserts that the subject is a boolean value.
  *
@@ -93,7 +93,7 @@ export declare const negativeInfinityAssertion: import("../assertion-types.js").
  *
  * @group Basic Assertions
  */
-export declare const booleanAssertion: 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>;
+export declare const booleanAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], z.ZodBoolean, never>;
 /**
  * Asserts that the subject is a positive number.
  *
@@ -107,7 +107,7 @@ export declare const booleanAssertion: import("../assertion-types.js").Assertion
  *
  * @group Basic Assertions
  */
-export declare const positiveAssertion: 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>;
+export declare const positiveAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], z.ZodNumber, never>;
 /**
  * Asserts that the subject is a positive integer.
  *
@@ -121,7 +121,7 @@ export declare const positiveAssertion: import("../assertion-types.js").Assertio
  *
  * @group Basic Assertions
  */
-export declare const positiveIntegerAssertion: 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>;
+export declare const positiveIntegerAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], z.ZodNumber, never>;
 /**
  * Asserts that the subject is a negative number.
  *
@@ -135,7 +135,7 @@ export declare const positiveIntegerAssertion: import("../assertion-types.js").A
  *
  * @group Basic Assertions
  */
-export declare const negativeAssertion: 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>;
+export declare const negativeAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], z.ZodNumber, never>;
 /**
  * Asserts that the subject is a negative integer.
  *
@@ -149,7 +149,7 @@ export declare const negativeAssertion: import("../assertion-types.js").Assertio
  *
  * @group Basic Assertions
  */
-export declare const negativeIntegerAssertion: 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>;
+export declare const negativeIntegerAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], z.ZodNumber, never>;
 /**
  * Asserts that the subject is exactly the boolean value true.
  *
@@ -163,7 +163,7 @@ export declare const negativeIntegerAssertion: import("../assertion-types.js").A
  *
  * @group Basic Assertions
  */
-export declare const trueAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be true"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be true"]>, never>;
+export declare const trueAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be true"], z.ZodLiteral<true>, never>;
 /**
  * Asserts that the subject is exactly the boolean value false.
  *
@@ -177,7 +177,7 @@ export declare const trueAssertion: import("../assertion-types.js").AssertionSch
  *
  * @group Basic Assertions
  */
-export declare const falseAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be false"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be false"]>, never>;
+export declare const falseAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be false"], z.ZodLiteral<false>, never>;
 /**
  * Asserts that the subject is a BigInt value.
  *
@@ -190,7 +190,7 @@ export declare const falseAssertion: import("../assertion-types.js").AssertionSc
  *
  * @group Basic Assertions
  */
-export declare const bigintAssertion: 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>;
+export declare const bigintAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], z.ZodBigInt, never>;
 /**
  * Asserts that the subject is a Symbol.
  *
@@ -203,7 +203,7 @@ export declare const bigintAssertion: import("../assertion-types.js").AssertionS
  *
  * @group Basic Assertions
  */
-export declare const symbolAssertion: 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>;
+export declare const symbolAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], z.ZodSymbol, never>;
 /**
  * Asserts that the subject is a function.
  *
@@ -216,7 +216,7 @@ export declare const symbolAssertion: import("../assertion-types.js").AssertionS
  *
  * @group Basic Assertions
  */
-export declare const functionAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a function"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a function"]>, never>;
+export declare const functionAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a function"], z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, never>;
 /**
  * Asserts that the subject is an async function.
  *
@@ -229,7 +229,7 @@ export declare const functionAssertion: import("../assertion-types.js").Assertio
  *
  * @group Basic Assertions
  */
-export declare const asyncFunctionAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be an async function"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be an async function"]>, never>;
+export declare const asyncFunctionAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be an async function"], z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown>, never>;
 /**
  * Asserts that the subject is NaN (Not a Number).
  *
@@ -243,7 +243,7 @@ export declare const asyncFunctionAssertion: import("../assertion-types.js").Ass
  *
  * @group Basic Assertions
  */
-export declare const nanAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be NaN"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be NaN"]>, never>;
+export declare const nanAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be NaN"], z.ZodNaN, never>;
 /**
  * Asserts that the subject is an integer (safe integer).
  *
@@ -256,7 +256,7 @@ export declare const nanAssertion: import("../assertion-types.js").AssertionSche
  *
  * @group Basic Assertions
  */
-export declare const integerAssertion: 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>;
+export declare const integerAssertion: 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"]], z.ZodNumber, never>;
 /**
  * Asserts that the subject is null.
  *
@@ -269,7 +269,7 @@ export declare const integerAssertion: import("../assertion-types.js").Assertion
  *
  * @group Basic Assertions
  */
-export declare const nullAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be null"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be null"]>, never>;
+export declare const nullAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be null"], z.ZodNull, never>;
 /**
  * Asserts that the subject is undefined.
  *
@@ -282,7 +282,7 @@ export declare const nullAssertion: import("../assertion-types.js").AssertionSch
  *
  * @group Basic Assertions
  */
-export declare const undefinedAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be undefined"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be undefined"]>, never>;
+export declare const undefinedAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be undefined"], z.ZodUndefined, never>;
 /**
  * Asserts that the subject is an array.
  *
@@ -295,7 +295,7 @@ export declare const undefinedAssertion: import("../assertion-types.js").Asserti
  *
  * @group Basic Assertions
  */
-export declare const arrayAssertion: 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>;
+export declare const arrayAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an array", "to be array"]], z.ZodArray<z.ZodUnknown>, never>;
 /**
  * Asserts that the subject is a Date object.
  *
@@ -308,7 +308,7 @@ export declare const arrayAssertion: import("../assertion-types.js").AssertionSc
  *
  * @group Basic Assertions
  */
-export declare const dateAssertion: 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>;
+export declare const dateAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], z.ZodDate, never>;
 /**
  * Asserts that the subject is a class constructor (constructible function).
  *
@@ -321,7 +321,7 @@ export declare const dateAssertion: import("../assertion-types.js").AssertionSch
  *
  * @group Basic Assertions
  */
-export declare const classAssertion: 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>;
+export declare const classAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a class", "to be a constructor", "to be constructible"]], z.ZodCustom<import("../../types.js").Constructor, import("../../types.js").Constructor>, never>;
 /**
  * Asserts that the subject is a primitive value (string, number, boolean, null,
  * undefined, symbol, or bigint).
@@ -335,7 +335,7 @@ export declare const classAssertion: import("../assertion-types.js").AssertionSc
  *
  * @group Basic Assertions
  */
-export declare const primitiveAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a primitive"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a primitive"]>, never>;
+export declare const primitiveAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a primitive"], z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodBigInt, z.ZodSymbol, z.ZodNull, z.ZodUndefined]>, never>;
 /**
  * Asserts that the subject is a regular expression.
  *
@@ -348,7 +348,7 @@ export declare const primitiveAssertion: import("../assertion-types.js").Asserti
  *
  * @group Basic Assertions
  */
-export declare const regexpAssertion: 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>;
+export declare const regexpAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], z.ZodCustom<RegExp, RegExp>, never>;
 /**
  * Asserts that the subject is truthy (not false, 0, '', null, undefined, or
  * NaN).
@@ -362,7 +362,7 @@ export declare const regexpAssertion: import("../assertion-types.js").AssertionS
  *
  * @group Basic Assertions
  */
-export declare const truthyAssertion: 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>;
+export declare const truthyAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], z.ZodNonOptional<z.ZodAny>, never>;
 /**
  * Asserts that the subject is falsy (false, 0, '', null, undefined, or NaN).
  *
@@ -375,7 +375,7 @@ export declare const truthyAssertion: import("../assertion-types.js").AssertionS
  *
  * @group Basic Assertions
  */
-export declare const falsyAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be falsy"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be falsy"]>, never>;
+export declare const falsyAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be falsy"], z.ZodNullable<z.ZodAny>, never>;
 /**
  * Asserts that the subject is an object (non-null object type).
  *
@@ -389,7 +389,7 @@ export declare const falsyAssertion: import("../assertion-types.js").AssertionSc
  *
  * @group Basic Assertions
  */
-export declare const objectAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be an object"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be an object"]>, never>;
+export declare const objectAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be an object"], z.ZodNonOptional<z.ZodUnknown>, never>;
 /**
  * Asserts that the subject is a record (plain object with string/symbol/number
  * keys).
@@ -403,7 +403,7 @@ export declare const objectAssertion: import("../assertion-types.js").AssertionS
  *
  * @group Basic Assertions
  */
-export declare const recordAssertion: 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>;
+export declare const recordAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a record", "to be a plain object"]], z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, never>;
 /**
  * Asserts that an array is empty.
  *
@@ -440,7 +440,7 @@ export declare const emptyArrayAssertion: import("../assertion-types.js").Assert
  *
  * @group Basic Assertions
  */
-export declare const emptyObjectAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, "to be empty"]>, readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
+export declare const emptyObjectAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, "to be empty"], z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
 /**
  * Asserts that the subject is an Error instance.
  *
@@ -453,7 +453,7 @@ export declare const emptyObjectAssertion: import("../assertion-types.js").Asser
  *
  * @group Basic Assertions
  */
-export declare const errorAssertion: 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>;
+export declare const errorAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]], z.ZodCustom<Error, Error>, never>;
 /**
  * Asserts that a string is empty.
  *
@@ -466,7 +466,7 @@ export declare const errorAssertion: import("../assertion-types.js").AssertionSc
  *
  * @group Basic Assertions
  */
-export declare const emptyStringAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly [z.ZodString, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [z.ZodString, "to be empty"]>, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
+export declare const emptyStringAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [z.ZodString, "to be empty"], z.ZodString, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
 /**
  * Asserts that a string is non-empty.
  *
@@ -479,7 +479,7 @@ export declare const emptyStringAssertion: import("../assertion-types.js").Asser
  *
  * @group Basic Assertions
  */
-export declare const nonEmptyStringAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly [z.ZodString, "to be non-empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [z.ZodString, "to be non-empty"]>, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>;
+export declare const nonEmptyStringAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [z.ZodString, "to be non-empty"], z.ZodString, readonly [z.ZodString, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>;
 /**
  * Asserts that the subject is defined (not undefined).
  *
@@ -492,7 +492,7 @@ export declare const nonEmptyStringAssertion: import("../assertion-types.js").As
  *
  * @group Basic Assertions
  */
-export declare const definedAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be defined"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be defined"]>, never>;
+export declare const definedAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be defined"], z.ZodNonOptional<z.ZodUnknown>, never>;
 /**
  * Asserts that the subject is a Set instance.
  *
@@ -505,7 +505,7 @@ export declare const definedAssertion: import("../assertion-types.js").Assertion
  *
  * @group Basic Assertions
  */
-export declare const setAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a Set"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a Set"]>, never>;
+export declare const setAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a Set"], z.ZodCustom<Set<unknown>, Set<unknown>>, never>;
 /**
  * Asserts that the subject is a WeakMap instance.
  *
@@ -518,7 +518,7 @@ export declare const setAssertion: import("../assertion-types.js").AssertionSche
  *
  * @group Basic Assertions
  */
-export declare const weakMapAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a WeakMap"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a WeakMap"]>, never>;
+export declare const weakMapAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a WeakMap"], z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, never>;
 /**
  * Asserts that the subject is a WeakSet instance.
  *
@@ -531,5 +531,5 @@ export declare const weakMapAssertion: import("../assertion-types.js").Assertion
  *
  * @group Basic Assertions
  */
-export declare const weakSetAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be a WeakSet"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be a WeakSet"]>, never>;
+export declare const weakSetAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be a WeakSet"], z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, never>;
 //# sourceMappingURL=sync-basic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sync-basic.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync-basic.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sync-basic.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync-basic.ts"],"names":[],"mappings":"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"}

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

@@ -61,7 +61,7 @@ export declare const mapSizeAssertion: import("../assertion-types.js").Assertion
  * @bupkisAnchor map-to-be-empty
  * @bupkisAssertionCategory collections
  */
-export declare const emptyMapAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"]>, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
+export declare const emptyMapAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
 /**
  * Asserts that a Set or WeakSet contains a specific value. For WeakSet, the
  * value must be an object.
@@ -121,7 +121,7 @@ export declare const setSizeAssertion: import("../assertion-types.js").Assertion
  * @bupkisAnchor set-to-be-empty
  * @bupkisAssertionCategory collections
  */
-export declare const emptySetAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"]>, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
+export declare const emptySetAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], z.ZodCustom<Set<unknown>, Set<unknown>>, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("../assertion-types.js").PhraseLiteralSlot<"to be empty">]>;
 /**
  * Asserts that an array contains a specific value.
  *
@@ -168,7 +168,7 @@ export declare const arraySizeAssertion: import("../assertion-types.js").Asserti
  * @bupkisAnchor array-not-to-be-empty
  * @bupkisAssertionCategory collections
  */
-export declare const nonEmptyArrayAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"], import("../assertion-types.js").AssertionImplSchemaSync<readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"]>, readonly [z.ZodArray<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>;
+export declare const nonEmptyArrayAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"], z.ZodArray<z.ZodUnknown>, readonly [z.ZodArray<z.ZodUnknown>, import("../assertion-types.js").PhraseLiteralSlot<"to be non-empty">]>;
 /**
  * Asserts that an object has specific keys/properties.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"sync-collection.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync-collection.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAqB3B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;mRAuBhC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB,2YAM5B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,gaAK7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;+OAsBhC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,gVAS5B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,0WAK7B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB;;iKASlC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,iXAY9B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB,yUAGlC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AAGH,eAAO,MAAM,mBAAmB,6oCA8B/B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,kBAAkB;;;;gdA0B9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,uBAAuB,89BAWnC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB;;;;+LAY/B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,uXAKhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,yYAG9B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,6YAGhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,mYAGpC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,uYAGhC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,yBAAyB,gjBAUrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gCAAgC,8jBAU5C,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,8BAA8B,0jBAU1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uCAAuC,8kBAUnD,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe;;;;oKAW3B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB;;;;+NAkB7B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;saAsC7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;8MAyBhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kCAAkC;;;;8OAe9C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,+BAA+B;;;;2OAe3C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,8BAA8B;;uQAc1C,CAAC"}
+{"version":3,"file":"sync-collection.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync-collection.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAqB3B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;mRAuBhC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB,2YAM5B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,qVAK7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;+OAsBhC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,gVAS5B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,+RAK7B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB;;iKASlC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,iXAY9B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB,0PAGlC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AAGH,eAAO,MAAM,mBAAmB,6oCA8B/B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,kBAAkB;;;;gdA0B9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,uBAAuB,89BAWnC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB;;;;+LAY/B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,uXAKhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,yYAG9B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,6YAGhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,mYAGpC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,uYAGhC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,yBAAyB,gjBAUrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gCAAgC,8jBAU5C,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,8BAA8B,0jBAU1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uCAAuC,8kBAUnD,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe;;;;oKAW3B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB;;;;+NAkB7B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;saAsC7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;8MAyBhC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kCAAkC;;;;8OAe9C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,+BAA+B;;;;2OAe3C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,8BAA8B;;uQAc1C,CAAC"}

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

@@ -28,7 +28,7 @@
  * @bupkisAnchor unknown-to-be-a-valid-date
  * @bupkisAssertionCategory date
  */
-export declare const validDateAssertion: 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>;
+export declare const validDateAssertion: 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>;
 /**
  * Asserts that the subject is before another date.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"sync-date.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync-date.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAmCH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,mPAG9B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe;;;;;;;;gdAsB3B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc;;;;;;;;+cAsB1B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;2sBAkC5B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;seA6B7B,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;ykBAwChC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB;;qBAmB5B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB;;qBAmB5B,CAAC"}
+{"version":3,"file":"sync-date.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync-date.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAmCH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,mUAG9B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe;;;;;;;;gdAsB3B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc;;;;;;;;+cAsB1B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;2sBAkC5B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;seA6B7B,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;ykBAwChC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB;;qBAmB5B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB;;qBAmB5B,CAAC"}

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

@@ -32,7 +32,7 @@ import { z } from 'zod/v4';
  * @bupkisAnchor object-to-have-a-null-prototype
  * @bupkisAssertionCategory object
  */
-export declare const nullPrototypeAssertion: 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>;
+export declare const nullPrototypeAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]], z.ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>, never>;
 /**
  * Asserts that a given property key is an enumerable property of the target
  * object.
@@ -121,7 +121,7 @@ export declare const enumerablePropertyAssertion2: import("../assertion-types.js
  * @bupkisAnchor unknown-to-be-sealed
  * @bupkisAssertionCategory object
  */
-export declare const sealedAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be sealed"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be sealed"]>, never>;
+export declare const sealedAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be sealed"], z.ZodUnknown, never>;
 /**
  * Asserts that an object is frozen using `Object.isFrozen()`.
  *
@@ -187,5 +187,5 @@ export declare const frozenAssertion: import("../assertion-types.js").AssertionF
  * @bupkisAnchor unknown-to-be-extensible
  * @bupkisAssertionCategory object
  */
-export declare const extensibleAssertion: import("../assertion-types.js").AssertionSchemaSync<readonly ["to be extensible"], import("../assertion-types.js").AssertionImplSchemaSync<readonly ["to be extensible"]>, never>;
+export declare const extensibleAssertion: import("../assertion-types.js").AssertionStandardSchemaSync<readonly ["to be extensible"], z.ZodUnknown, never>;
 //# sourceMappingURL=sync-esoteric.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sync-esoteric.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync-esoteric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAY3B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,sBAAsB,qQAGlC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,2BAA2B;;;;6MAevC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,4BAA4B,+cAYxC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,eAAe,2KAG3B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe;;;;qBAQ1B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,mBAAmB,mLAG/B,CAAC"}
+{"version":3,"file":"sync-esoteric.d.ts","sourceRoot":"","sources":["../../../../src/assertion/impl/sync-esoteric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAY3B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,sBAAsB,qNAGlC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,2BAA2B;;;;6MAevC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,4BAA4B,+cAYxC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,eAAe,6GAG3B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe;;;;qBAQ1B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,mBAAmB,iHAG/B,CAAC"}

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

@@ -42,7 +42,7 @@ export declare const instanceOfAssertion: import("../assertion-types.js").Assert
  */
 export declare const typeOfAssertion: import("../assertion-types.js").AssertionFunctionSync<readonly [z.ZodUnknown, readonly ["to be a", "to be an", "to have type"], z.ZodEnum<{
     [x: string]: string;
-}>], (_: unknown, type: string) => z.ZodString | z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | z.ZodNumber | z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | z.ZodArray<z.ZodUnknown> | z.ZodSymbol | z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown> | z.ZodBigInt | z.ZodBoolean | z.ZodDate | z.ZodCustom<Error, Error> | z.ZodNull | z.ZodUndefined | z.ZodCustom<RegExp, RegExp> | z.ZodObject<{}, z.core.$loose> | z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>, readonly [z.ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, z.ZodEnum<{
+}>], (_: unknown, type: string) => z.ZodString | z.ZodCustom<(...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("../../types.js").MutableOrReadonly<unknown[]>) => unknown> | z.ZodNumber | z.ZodSymbol | z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | z.ZodBoolean | z.ZodBigInt | z.ZodNull | z.ZodUndefined | z.ZodArray<z.ZodUnknown> | z.ZodCustom<RegExp, RegExp> | z.ZodDate | z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | z.ZodCustom<Error, Error> | z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>> | z.ZodObject<{}, z.core.$loose>, readonly [z.ZodUnknown, import("../assertion-types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, z.ZodEnum<{
     [x: string]: string;
 }>]>;
 /**