bupkis 0.2.0 → 0.4.0

package/dist/commonjs/index.d.ts

@@ -37,7 +37,7 @@ export { z };
 /**
  * @primaryExport
  */
-export type { Bupkis, CreateAssertionFn, CreateAsyncAssertionFn, Expect, ExpectAsync, FailFn, UseFn, } from './types.js';
+export type { Bupkis, CreateAssertionFn, CreateAsyncAssertionFn, Expect, ExpectAsync, ExpectIt, ExpectItExecutor, FailFn, UseFn, ZodTypeMap, } from './types.js';
 export { createAssertion, createAsyncAssertion, fail, use };
 declare const 
 /**
@@ -69,7 +69,7 @@ fail: import("./types.js").FailFn,
  *
  * @function
  */
-use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunctionSync<readonly [z.ZodMap<z.ZodAny, z.ZodAny>, readonly ["to contain", "to include"], z.ZodAny], (subject: Map<any, any>, key: any) => boolean, readonly [z.ZodMap<z.ZodAny, z.ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", z.ZodNumber], (subject: Map<unknown, unknown>, expectedSize: number) => boolean, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], (subject: Map<unknown, unknown>) => boolean, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodSet<z.ZodAny>, readonly ["to contain", "to include"], z.ZodAny], (subject: Set<any>, value: any) => boolean, readonly [z.ZodSet<z.ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have size", z.ZodNumber], (subject: Set<unknown>, expectedSize: number) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], (subject: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, readonly ["to contain", "to include"], z.ZodAny], (subject: WeakMap<WeakKey, unknown>, key: any) => boolean, readonly [z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, readonly ["to contain", "to include"], z.ZodAny], (subject: WeakSet<WeakKey>, value: any) => boolean, readonly [z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, readonly ["to contain", "to include"], z.ZodAny], (subject: any[], value: any) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to have size", z.ZodNumber], (subject: any[], expectedSize: number) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to have length", z.ZodNumber], (subject: any[], expectedLength: number) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralSlot<"to have length">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to be non-empty"], (subject: any[]) => {
+use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to contain", "to include"], z.ZodAny], (subject: Map<unknown, unknown>, key: any) => boolean, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", z.ZodNumber], (subject: Map<unknown, unknown>, expectedSize: number) => boolean, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to be empty"], (subject: Map<unknown, unknown>) => boolean, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, readonly ["to contain", "to include"], z.ZodAny], (subject: Set<unknown>, value: any) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have size", z.ZodNumber], (subject: Set<unknown>, expectedSize: number) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"], (subject: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, readonly ["to contain", "to include"], z.ZodAny], (subject: WeakMap<WeakKey, unknown>, key: any) => boolean, readonly [z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, readonly ["to contain", "to include"], z.ZodAny], (subject: WeakSet<WeakKey>, value: any) => boolean, readonly [z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, readonly ["to contain", "to include"], z.ZodAny], (subject: any[], value: any) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodAny]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to have size", z.ZodNumber], (subject: any[], expectedSize: number) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to have length", z.ZodNumber], (subject: any[], expectedLength: number) => boolean, readonly [z.ZodArray<z.ZodAny>, import("./types.js").PhraseLiteralSlot<"to have length">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodAny>, "to be non-empty"], (subject: any[]) => {
     actual: number;
     expected: string;
     message: string;
@@ -141,15 +141,21 @@ use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunction
     actual: unknown;
     expected: unknown;
     message: string;
-} | undefined, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal"]>, z.ZodUnknown]>, import("./types.js").AssertionSchemaSync<readonly [z.ZodObject<{}, z.core.$loose>, readonly ["to deep equal", "to deeply equal"], z.ZodObject<{}, z.core.$loose>], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodObject<{}, z.core.$loose>, readonly ["to deep equal", "to deeply equal"], z.ZodObject<{}, z.core.$loose>]>, readonly [z.ZodObject<{}, z.core.$loose>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, z.ZodObject<{}, z.core.$loose>]>, import("./types.js").AssertionSchemaSync<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
-    length: z.ZodNumber;
-}, z.core.$loose>]>, readonly ["to deep equal", "to deeply equal"], z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
-    length: z.ZodNumber;
-}, z.core.$loose>]>], import("./types.js").AssertionImplSchemaSync<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+} | undefined, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodObject<{}, z.core.$loose>, readonly ["to deep equal", "to deeply equal"], z.ZodObject<{}, z.core.$loose>], (_: {
+    [x: string]: unknown;
+}, expected: {
+    [x: string]: unknown;
+}) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, readonly [z.ZodObject<{}, z.core.$loose>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, z.ZodObject<{}, z.core.$loose>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
     length: z.ZodNumber;
 }, z.core.$loose>]>, readonly ["to deep equal", "to deeply equal"], z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
     length: z.ZodNumber;
-}, z.core.$loose>]>]>, readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+}, z.core.$loose>]>], (_: unknown[] | [unknown, ...unknown[]] | {
+    [x: string]: unknown;
+    length: number;
+}, expected: unknown[] | [unknown, ...unknown[]] | {
+    [x: string]: unknown;
+    length: number;
+}) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
     length: z.ZodNumber;
 }, z.core.$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>, z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
     length: z.ZodNumber;
@@ -164,69 +170,158 @@ use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunction
     [x: string]: unknown;
 }) => boolean, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to throw a", "to thrown an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, "satisfying", z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor, param: string | RegExp | {
     [x: string]: unknown;
-}) => {
-    actual: string;
+}) => z.ZodError<unknown> | {
+    actual: never;
     expected: string;
     message: string;
-} | {
-    actual: unknown;
-    expected: {
-        [x: string]: unknown;
-    };
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, import("./types.js").PhraseLiteralSlot<"satisfying">, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, readonly ["includes", "contains", "to include", "to contain"], z.ZodString], (subject: string, expected: string) => {
+    actual: string;
+    expected: string;
     message: string;
-} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, import("./types.js").PhraseLiteralSlot<"satisfying">, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, readonly ["includes", "contains", "to include", "to contain"], z.ZodString], (subject: string, expected: string) => boolean, readonly [z.ZodString, import("./types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to match", z.ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to match">, z.ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNonOptional<z.ZodObject<{}, z.core.$loose>>, readonly ["to satisfy", "to be like"], z.ZodObject<{}, z.core.$loose>], (subject: {
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralChoiceSlot<readonly ["includes", "contains", "to include", "to contain"]>, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to match", z.ZodCustom<RegExp, RegExp>], (subject: string, regex: RegExp) => boolean, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to match">, z.ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNonOptional<z.ZodObject<{}, z.core.$loose>>, readonly ["to satisfy", "to be like"], z.ZodType<import("./types.js").SatisfyPatternValue, unknown, z.core.$ZodTypeInternals<import("./types.js").SatisfyPatternValue, unknown>>], (_subject: {
     [x: string]: unknown;
-}, shape: {
-    [x: string]: unknown;
-}) => z.ZodType<{}, z.core.$loose>, readonly [z.ZodNonOptional<z.ZodObject<{}, z.core.$loose>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, z.ZodObject<{}, z.core.$loose>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
-    length: z.ZodNumber;
-}, z.core.$loose>]>, readonly ["to satisfy", "to be like"], z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+}, shape: import("./types.js").SatisfyPatternValue) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, readonly [z.ZodNonOptional<z.ZodObject<{}, z.core.$loose>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, z.ZodType<import("./types.js").SatisfyPatternValue, unknown, z.core.$ZodTypeInternals<import("./types.js").SatisfyPatternValue, unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
     length: z.ZodNumber;
-}, z.core.$loose>]>], (subject: unknown[] | [unknown, ...unknown[]] | {
-    [x: string]: unknown;
-    length: number;
-}, shape: unknown[] | [unknown, ...unknown[]] | {
+}, z.core.$loose>]>, readonly ["to satisfy", "to be like"], z.ZodType<import("./types.js").SatisfyPatternValue, unknown, z.core.$ZodTypeInternals<import("./types.js").SatisfyPatternValue, unknown>>], (_subject: unknown[] | [unknown, ...unknown[]] | {
     [x: string]: unknown;
     length: number;
-}) => typeof import("./schema.js").ArrayLikeSchema, readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
+}, shape: import("./types.js").SatisfyPatternValue) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
     length: z.ZodNumber;
-}, z.core.$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>, z.ZodObject<{
-    length: z.ZodNumber;
-}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", z.ZodNumber], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
+}, z.core.$loose>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>, z.ZodType<import("./types.js").SatisfyPatternValue, unknown, z.core.$ZodTypeInternals<import("./types.js").SatisfyPatternValue, unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to have arity", z.ZodNumber], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expectedArity: number) => {
     actual: number;
     expected: number;
     message: string;
-} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to have arity">, z.ZodNumber]>], readonly [import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to resolve", "to fulfill"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<boolean>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<boolean>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to reject"], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<boolean>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, "to reject"], (subject: PromiseLike<unknown>) => Promise<boolean>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to have arity">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call callback", "to invoke callback"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => boolean, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to call callback", "to invoke callback"]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback", "to invoke nodeback"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => boolean, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback", "to invoke nodeback"]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call callback with", "to invoke callback with"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | z.ZodError<any> | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to call callback with", "to invoke callback with"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call callback with exactly", "to call callback with exact value", "to invoke callback with exactly", "to invoke callback with exact value"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expected: unknown) => {
+    actual: unknown;
+    expected: unknown;
+    message: string;
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to call callback with exactly", "to call callback with exact value", "to invoke callback with exactly", "to invoke callback with exact value"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback with", "to invoke nodeback with"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | z.ZodError<any> | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback with", "to invoke nodeback with"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback with exactly", "to call nodeback with exact value", "to invoke nodeback with exactly", "to invoke nodeback with exact value"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expected: unknown) => {
+    actual: unknown;
+    expected: unknown;
+    message: string;
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback with exactly", "to call nodeback with exact value", "to invoke nodeback with exactly", "to invoke nodeback with exact value"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback with error", "to invoke nodeback with error"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback with error", "to invoke nodeback with error"]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback with a", "to call nodeback with an", "to invoke nodeback with a", "to invoke nodeback with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback with a", "to call nodeback with an", "to invoke nodeback with a", "to invoke nodeback with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback with error", "to invoke nodeback with error"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
     [x: string]: unknown;
-}) => Promise<boolean>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: PromiseLike<unknown>, param: string | RegExp | {
+}) => z.ZodError<unknown> | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback with error", "to invoke nodeback with error"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call callback with value satisfying", "to invoke callback with value satisfying"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
     [x: string]: unknown;
-}) => Promise<boolean>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (promise: PromiseLike<unknown>, param: string | RegExp | {
+}) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | z.ZodError<any> | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to call callback with value satisfying", "to invoke callback with value satisfying"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to call nodeback with value satisfying", "to invoke nodeback with value satisfying"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
     [x: string]: unknown;
-}) => Promise<boolean | {
-    actual: unknown;
+}) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | z.ZodError<any> | undefined, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to call nodeback with value satisfying", "to invoke nodeback with value satisfying"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>], readonly [import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to resolve", "to fulfill"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to resolve", "to fulfill"]], (subject: PromiseLike<unknown>) => Promise<{
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to reject"], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, "to reject"], (subject: PromiseLike<unknown>) => Promise<{
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralSlot<"to reject">]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with a", "to reject with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with a", "to reject with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("./types.js").Constructor) => Promise<boolean>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to reject with error satisfying"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
+    [x: string]: unknown;
+}) => Promise<z.ZodError<unknown> | {
+    actual: string;
     expect: string;
     message: string;
-    expected?: never;
-} | {
-    actual: unknown;
-    expected: {
-        [x: string]: unknown;
-    };
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: PromiseLike<unknown>, param: string | RegExp | {
+    [x: string]: unknown;
+}) => Promise<z.ZodError<unknown> | {
+    actual: string;
+    expect: string;
     message: string;
-    expect?: never;
-}>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
+} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (promise: PromiseLike<unknown>, param: string | RegExp | {
     [x: string]: unknown;
-}) => Promise<boolean | {
+}) => Promise<z.ZodError<unknown> | {
     actual: unknown;
     expect: string;
     message: string;
-    expected?: never;
-} | {
-    actual: unknown;
-    expected: {
-        [x: string]: unknown;
-    };
+} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
+    [x: string]: unknown;
+}) => Promise<z.ZodError<unknown> | {
+    actual: string;
+    expect: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to eventually call callback", "to eventually invoke callback"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to eventually call callback", "to eventually invoke callback"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to eventually call nodeback", "to eventually invoke nodeback"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to eventually call nodeback", "to eventually invoke nodeback"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to eventually call callback with", "to eventually invoke callback with"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<z.ZodError<any> | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to eventually call callback with", "to eventually invoke callback with"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to eventually call callback with exactly", "to eventually call callback with exact value", "to eventually invoke callback with exactly", "to eventually invoke callback with exact value"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expected: unknown) => Promise<boolean | {
+    actual: string;
+    expected: string;
+    message: string;
+}>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to eventually call callback with exactly", "to eventually call callback with exact value", "to eventually invoke callback with exactly", "to eventually invoke callback with exact value"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to eventually call nodeback with", "to eventually invoke nodeback with"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<z.ZodError<any> | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to eventually call nodeback with", "to eventually invoke nodeback with"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to eventually call nodeback with exactly", "to eventually call nodeback with exact value", "to eventually invoke nodeback with exactly", "to eventually invoke nodeback with exact value"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, expected: unknown) => Promise<boolean | {
+    actual: string;
+    expected: string;
+    message: string;
+}>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to eventually call nodeback with exactly", "to eventually call nodeback with exact value", "to eventually invoke nodeback with exactly", "to eventually invoke nodeback with exact value"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to eventually call nodeback with error", "to eventually invoke nodeback with error"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to eventually call nodeback with error", "to eventually invoke nodeback with error"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to eventually call nodeback with a", "to eventually call nodeback with an", "to eventually invoke nodeback with a", "to eventually invoke nodeback with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => Promise<{
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to eventually call nodeback with a", "to eventually call nodeback with an", "to eventually invoke nodeback with a", "to eventually invoke nodeback with an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to eventually call nodeback with error", "to eventually invoke nodeback with error"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
+    [x: string]: unknown;
+}) => Promise<z.ZodError<unknown> | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to eventually call nodeback with error", "to eventually invoke nodeback with error"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to eventually call callback with value satisfying", "to eventually invoke callback with value satisfying"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
+    [x: string]: unknown;
+}) => Promise<z.ZodError<any> | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to eventually call callback with value satisfying", "to eventually invoke callback with value satisfying"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, readonly ["to eventually call nodeback with value satisfying", "to eventually invoke nodeback with value satisfying"], z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: string | RegExp | {
+    [x: string]: unknown;
+}) => Promise<z.ZodError<any> | {
+    actual: string;
+    expected: string;
     message: string;
-    expect?: never;
-}>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>]>;
+} | undefined>, readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to eventually call nodeback with value satisfying", "to eventually invoke nodeback with value satisfying"]>, z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>, z.ZodObject<{}, z.core.$loose>]>]>]>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;;;;;GASG;AACH,YAAY,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,OAAO,EAAE,CAAC,EAAE,CAAC;AAEb;;GAEG;AACH,YAAY,EACV,MAAM,EACN,iBAAiB,EACjB,sBAAsB,EACtB,MAAM,EACN,WAAW,EACX,MAAM,EACN,KAAK,GACN,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AAC5D,QAAA;AACE;;;;;;;GAOG;AACH,eAAe;AACf;;;;;;;GAOG;AACH,oBAAoB;AACpB;;;;GAIG;AACH,IAAI;AACJ;;;;GAIG;AACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iZAEgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;;;;;GASG;AACH,YAAY,KAAK,KAAK,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,OAAO,EAAE,CAAC,EAAE,CAAC;AAEb;;GAEG;AACH,YAAY,EACV,MAAM,EACN,iBAAiB,EACjB,sBAAsB,EACtB,MAAM,EACN,WAAW,EACX,QAAQ,EACR,gBAAgB,EAChB,MAAM,EACN,KAAK,EACL,UAAU,GACX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AAC5D,QAAA;AACE;;;;;;;GAOG;AACH,eAAe;AACf;;;;;;;GAOG;AACH,oBAAoB;AACpB;;;;GAIG;AACH,IAAI;AACJ;;;;GAIG;AACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;icAEgB,CAAC"}

package/dist/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;AAEH,+BAA2B;AAuBlB,kFAvBA,MAAC,OAuBA;AArBV,iDAA6D;AAC7D,+CAAqD;AAA5C,sGAAA,MAAM,OAAA;AAAE,2GAAA,WAAW,OAAA;AAE5B,uCAA4C;AAAnC,0GAAA,cAAc,OAAA;AAiCvB,MAAM;AACJ;;;;;;;GAOG;AACH,eAAe;AACf;;;;;;;GAOG;AACH,oBAAoB;AACpB;;;;GAIG;AACH,IAAI;AACJ;;;;GAIG;AACH,GAAG,EACH,GAAG,KAAK,EACT,GAAG,qBAAiB,CAAC;AAjCb,0CAAe;AAAE,oDAAoB;AAAE,oBAAI;AAAE,kBAAG"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;AAEH,+BAA2B;AAuBlB,kFAvBA,MAAC,OAuBA;AArBV,iDAA6D;AAC7D,+CAAqD;AAA5C,sGAAA,MAAM,OAAA;AAAE,2GAAA,WAAW,OAAA;AAE5B,uCAA4C;AAAnC,0GAAA,cAAc,OAAA;AAoCvB,MAAM;AACJ;;;;;;;GAOG;AACH,eAAe;AACf;;;;;;;GAOG;AACH,oBAAoB;AACpB;;;;GAIG;AACH,IAAI;AACJ;;;;GAIG;AACH,GAAG,EACH,GAAG,KAAK,EACT,GAAG,qBAAiB,CAAC;AAjCb,0CAAe;AAAE,oDAAoB;AAAE,oBAAI;AAAE,kBAAG"}

package/dist/commonjs/schema.d.ts

@@ -3,7 +3,7 @@
  *
  * This module provides reusable Zod schemas for validating constructors,
  * functions, property keys, promises, and other common JavaScript types used
- * throughout the assertion system. These tend to work around the impedence
+ * throughout the assertion system. These tend to work around the impedance
  * mismatch between **BUPKIS** and Zod.
  *
  * These are used internally, but consumers may also find them useful.
@@ -32,35 +32,35 @@
  * @packageDocumentation
  */
 import { z } from 'zod/v4';
-import { type Constructor, type MutableOrReadonly } from './types.js';
+import { type Constructor, type MutableOrReadonly, type SatisfyPatternValue } from './types.js';
 /**
- * A Zod schema that validates JavaScript classes or constructor functions.
+ * A Zod schema that validates JavaScript constructible functions.
  *
  * This schema validates values that can be used as constructors, including ES6
  * classes, traditional constructor functions, and built-in constructors. It
- * uses the {@link isConstructable} guard function to determine if a value can be
+ * uses the {@link isConstructible} guard function to determine if a value can be
  * invoked with the `new` operator to create object instances.
  *
  * @privateRemarks
  * The schema is registered in the {@link BupkisRegistry} with the name
- * `ClassSchema` for later reference and type checking purposes.
+ * `ConstructibleSchema` for later reference and type checking purposes.
  * @example
  *
  * ```typescript
  * class MyClass {}
  * function MyConstructor() {}
  *
- * ClassSchema.parse(MyClass); // ✓ Valid
- * ClassSchema.parse(MyConstructor); // ✓ Valid
- * ClassSchema.parse(Array); // ✓ Valid
- * ClassSchema.parse(Date); // ✓ Valid
- * ClassSchema.parse(() => {}); // ✗ Throws validation error
- * ClassSchema.parse({}); // ✗ Throws validation error
+ * ConstructibleSchema.parse(MyClass); // ✓ Valid
+ * ConstructibleSchema.parse(MyConstructor); // ✓ Valid
+ * ConstructibleSchema.parse(Array); // ✓ Valid
+ * ConstructibleSchema.parse(Date); // ✓ Valid
+ * ConstructibleSchema.parse(() => {}); // ✗ Throws validation error
+ * ConstructibleSchema.parse({}); // ✗ Throws validation error
  * ```
  *
  * @group Schema
  */
-export declare const ClassSchema: z.ZodCustom<Constructor, Constructor>;
+export declare const ConstructibleSchema: z.ZodCustom<Constructor, Constructor>;
 /**
  * A Zod schema that validates any JavaScript function.
  *
@@ -198,9 +198,12 @@ export declare const StrongSetSchema: z.ZodCustom<Set<unknown>, Set<unknown>>;
  * `Object.prototype`, making them useful as pure data containers or
  * dictionaries.
  *
- * @remarks
+ * @privateRemarks
  * The schema is registered in the `BupkisRegistry` with the name
  * `ObjectWithNullPrototype` for later reference and type checking purposes.
+ *
+ * Changing this to be a `ZodRecord` would be nice, but that would end up
+ * blasting away the original object's prototype.
  * @example
  *
  * ```typescript
@@ -216,6 +219,13 @@ export declare const StrongSetSchema: z.ZodCustom<Set<unknown>, Set<unknown>>;
  * ```
  *
  * @group Schema
+ * @see Aliases: {@link NullProtoObjectSchema}, {@link DictionarySchema}
+ */
+export declare const DictionarySchema: z.ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>;
+/**
+ * {@inheritDoc DictionarySchema}
+ *
+ * @group Schema
  */
 export declare const NullProtoObjectSchema: z.ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>;
 /**
@@ -226,7 +236,7 @@ export declare const NullProtoObjectSchema: z.ZodCustom<Record<PropertyKey, unkn
  * function's internal `[[ToString]]` representation to distinguish async
  * functions from regular functions that might return Promises.
  *
- * @remarks
+ * @privateRemarks
  * The schema is registered in the `BupkisRegistry` with the name
  * `AsyncFunctionSchema` for later reference and type checking purposes. This
  * schema cannot reliably detect functions that return Promises but are not
@@ -263,7 +273,7 @@ export declare const AsyncFunctionSchema: z.ZodCustom<(...args: MutableOrReadonl
  * if it converts to `true` when evaluated in a boolean context - essentially
  * any value that is not one of the eight falsy values.
  *
- * @remarks
+ * @privateRemarks
  * The schema is registered in the `BupkisRegistry` with the name `Truthy` and
  * indicates that it accepts anything as valid input for evaluation.
  * @example
@@ -291,7 +301,7 @@ export declare const TruthySchema: z.ZodNonOptional<z.ZodAny>;
  * in JavaScript are: `false`, `0`, `-0`, `0n`, `""` (empty string), `null`,
  * `undefined`, and `NaN`.
  *
- * @remarks
+ * @privateRemarks
  * The schema is registered in the `BupkisRegistry` with the name `Falsy` and
  * indicates that it accepts anything as valid input for evaluation.
  * @example
@@ -323,7 +333,7 @@ export declare const FalsySchema: z.ZodNullable<z.ZodAny>;
  * distinguishing them from objects and functions which are non-primitive
  * reference types.
  *
- * @remarks
+ * @privateRemarks
  * The schema is registered in the `BupkisRegistry` with the name `Primitive`
  * and indicates that it accepts primitive values as valid input.
  * @example
@@ -385,7 +395,7 @@ export declare const ArrayLikeSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodUnkno
  * It ensures the validated value is a proper regular expression object with all
  * associated methods and properties.
  *
- * @remarks
+ * @privateRemarks
  * The schema is registered in the `BupkisRegistry` with the name `RegExp` for
  * later reference and type checking purposes.
  * @example
@@ -403,4 +413,60 @@ export declare const ArrayLikeSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodUnkno
  * @group Schema
  */
 export declare const RegExpSchema: z.ZodCustom<RegExp, RegExp>;
+/**
+ * A recursive Zod schema that validates values allowed in "to satisfy"
+ * assertion patterns.
+ *
+ * This schema defines the allowed structure for patterns used with "to satisfy"
+ * and "to be like" assertions. It supports a recursive structure that can
+ * contain:
+ *
+ * - **Primitive values**: strings, numbers, booleans, null, undefined, bigint,
+ *   symbols
+ * - **Regular expressions**: for pattern matching against string values
+ * - **ExpectItExecutor functions**: nested assertions created via `expect.it()`
+ * - **Objects**: with properties that recursively follow this same pattern
+ * - **Arrays**: with elements that recursively follow this same pattern
+ *
+ * The schema handles the special semantics required for "to satisfy"
+ * assertions:
+ *
+ * - RegExp values are used for pattern testing rather than exact matching
+ * - ExpectItExecutor functions are executed as nested assertions
+ * - Objects and arrays can contain any combination of the above recursively
+ *
+ * @privateRemarks
+ * Uses `z.lazy()` to handle recursive object and array structures without
+ * causing infinite recursion during schema definition. The schema is registered
+ * in the `BupkisRegistry` for reference and type checking.
+ * @example
+ *
+ * ```typescript
+ * // Primitive values
+ * SatisfyPatternSchema.parse('hello'); // ✓ Valid
+ * SatisfyPatternSchema.parse(42); // ✓ Valid
+ * SatisfyPatternSchema.parse(true); // ✓ Valid
+ *
+ * // Regular expressions for pattern matching
+ * SatisfyPatternSchema.parse(/test/); // ✓ Valid
+ *
+ * // ExpectItExecutor functions
+ * SatisfyPatternSchema.parse(expect.it('to be a string')); // ✓ Valid
+ *
+ * // Complex nested structures
+ * SatisfyPatternSchema.parse({
+ *   name: expect.it('to be a string'),
+ *   email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+ *   age: expect.it('to be greater than', 0),
+ *   tags: [expect.it('to be a string')],
+ * }); // ✓ Valid
+ *
+ * // Invalid values
+ * SatisfyPatternSchema.parse(new Date()); // ✗ Invalid (not supported type)
+ * SatisfyPatternSchema.parse(() => {}); // ✗ Invalid (regular function, not ExpectItExecutor)
+ * ```
+ *
+ * @group Schema
+ */
+export declare const SatisfyPatternSchema: z.ZodType<SatisfyPatternValue>;
 //# sourceMappingURL=schema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAU3B,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,eAAO,MAAM,WAAW,uCAGU,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,cAAc,wBACP,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,YAAxC,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CAMzD,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,iBAAiB,8DAG4B,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,wBAAwB,yDAK4B,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe,2DAI4B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe,yCAI4B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,qBAAqB,yEAK8B,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,mBAAmB,wBAxMZ,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,YAAxC,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CA4MA,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,YAAY,4BAOrB,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,WAAW,yBAKsB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe,oHAWsB,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe;;mBASxB,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,YAAY,6BAGsB,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAW3B,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACzB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,eAAO,MAAM,mBAAmB,uCAGK,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,cAAc,wBACP,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,YAAxC,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CAMzD,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,iBAAiB,8DAG4B,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,wBAAwB,yDAK4B,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe,2DAI4B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe,yCAI4B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,gBAAgB,yEAKmC,CAAC;AAEjE;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,yEAAmB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,mBAAmB,wBAnNZ,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,YAAxC,iBAAiB,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,CAuNA,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,YAAY,4BAOrB,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,WAAW,yBAKsB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe,oHAWsB,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe;;mBASxB,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,YAAY,6BAGsB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAwBH,CAAC"}