bupkis 0.18.3 → 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,460 @@
+/**
+ * Main entry point for the Bupkis assertion library.
+ *
+ * This module exports all public APIs including the main `expect` function,
+ * asynchronous `expectAsync` function, assertion creation utilities, type
+ * guards, schema definitions, utility functions, and error types.
+ *
+ * @module bupkis
+ * @category API
+ * @example
+ *
+ * ```ts
+ * import { expect, expectAsync, z, createAssertion } from 'bupkis';
+ * ```
+ *
+ * {@link https://zod.dev | Zod v4} is exported as `z` if you aren't already
+ * using a {@link https://standardschema.dev | Standard Schema V1}-compatible
+ * validation library.
+ */
+import { z } from 'zod';
+export * as assertions from "./assertion/impl/index.js";
+export { expect, expectAsync } from "./bootstrap.js";
+/**
+ * Re-export of `DiffOptions` type from jest-diff for use with custom assertion
+ * diff configuration.
+ *
+ * @see {@link https://npm.im/jest-diff | jest-diff} for available options
+ */
+export type { DiffOptions } from "./diff.js";
+export * from "./error.js";
+export * as schema from "./schema.js";
+/**
+ * Re-export of snapshot testing types for convenient access.
+ *
+ * For full snapshot API, import from 'bupkis/snapshot'.
+ */
+export type { SnapshotAdapter, SnapshotContext, SnapshotOptions, SnapshotSerializer, } from "./snapshot/adapter.js";
+/**
+ * Re-export of {@link https://zod.dev Zod v4} for use in custom assertion
+ * implementations.
+ */
+export { z };
+/**
+ * Re-export of Standard Schema v1 types for use in custom assertion
+ * implementations.
+ *
+ * @see {@link https://standardschema.dev | Standard Schema Specification}
+ */
+export type { StandardSchemaV1 } from "./standard-schema.js";
+/**
+ * Re-export of most (all?) types defined within <span
+ * class="bupkis">Bupkis</span>.
+ *
+ * @example
+ *
+ * ```ts
+ * import { types } from 'bupkis';
+ * ```
+ */
+export type * as types from "./types.js";
+/**
+ * @primaryExport
+ */
+export type { AssertionFailure, AssertionStandardSchemaAsync, AssertionStandardSchemaSync, Bupkis, CreateAssertionFn, CreateAsyncAssertionFn, Expect, ExpectAsync, ExpectIt, ExpectItAsync, FailFn, Keypath, UseFn, } from "./types.js";
+export { createAssertion, createAsyncAssertion, fail, use };
+declare const 
+/**
+ * The main factory function for creating asynchronous assertions.
+ *
+ * Exported from the entry point; is also a property of {@link Expect} and
+ * {@link ExpectAsync}.
+ *
+ * @function
+ * @primaryExport
+ * @group Core API
+ */
+createAssertion: import("./types.js").CreateAssertionFn, 
+/**
+ * The main factory function for creating asynchronous assertions.
+ *
+ * Exported from the entry point; is also a property of {@link Expect} and
+ * {@link ExpectAsync}.
+ *
+ * @function
+ * @primaryExport
+ * @group Core API
+ */
+createAsyncAssertion: import("./types.js").CreateAsyncAssertionFn, 
+/**
+ * {@inheritDoc FailFn}
+ *
+ * @function
+ * @primaryExport
+ * @group Core API
+ */
+fail: import("./types.js").FailFn, 
+/**
+ * {@inheritDoc UseFn}
+ *
+ * @function
+ * @primaryExport
+ * @group Core API
+ */
+use: import("./types.js").UseFn<readonly [import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: Map<unknown, unknown> | WeakMap<WeakKey, unknown>, key: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have size", z.ZodInt], (_subject: Map<unknown, unknown>, expectedSize: number) => z.ZodMap<z.ZodUnknown, z.ZodUnknown>, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>, import("./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("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: Set<unknown> | WeakSet<WeakKey>, value: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<[z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have size", z.ZodInt], (_subject: Set<unknown>, expectedSize: number) => z.ZodSet<z.ZodUnknown>, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>, import("./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("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, readonly ["to contain", "to include"], z.ZodUnknown], (subject: unknown[], value: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, readonly ["to have item satisfying", "to have an item satisfying", "to contain item satisfying"], z.ZodUnknown], (subject: unknown[], shape: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have item satisfying", "to have an item satisfying", "to contain item satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodArray<z.ZodUnknown>, readonly ["to have length", "to have size"], z.ZodInt], (_subject: unknown[], expectedSize: number) => z.ZodArray<z.ZodUnknown>, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>, z.ZodInt]>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"], z.ZodArray<z.ZodUnknown>, readonly [z.ZodArray<z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"], z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>>], (_subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keys: (string | number | symbol)[]) => z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have keys", "to have properties", "to have props", "to contain keys", "to contain properties", "to contain props", "to include keys", "to include properties", "to include props"]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, "to have size", z.ZodInt], (subject: Record<string | number | symbol, unknown>, expectedSize: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [z.ZodRecord<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have size">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have exact key", "to have exact property", "to have exact prop"], z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>], (_: Record<PropertyKey, unknown> | ((...args: any[]) => any), key: string | number | symbol) => z.ZodPipe<z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, z.ZodTransform<{}, Record<PropertyKey, unknown> | ((...args: any[]) => any)>>, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have exact key", "to have exact property", "to have exact prop"]>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have key", "to have property", "to have prop", "to contain key", "to contain property", "to contain prop", "to include key", "to include property", "to include prop"], z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), keypath: string) => {
+    actual: string;
+    expect: string;
+    message: string;
+} | undefined, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have key", "to have property", "to have prop", "to contain key", "to contain property", "to contain prop", "to include key", "to include property", "to include prop"]>, z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to equal", z.ZodCustom<Set<unknown>, Set<unknown>>], (actual: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to equal">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be a subset of", z.ZodCustom<Set<unknown>, Set<unknown>>], (subset: Set<unknown>, superset: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be a subset of">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be a superset of", z.ZodCustom<Set<unknown>, Set<unknown>>], (superset: Set<unknown>, subset: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be a superset of">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to intersect with", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to intersect with">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be disjoint from", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to be disjoint from">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have union", z.ZodCustom<Set<unknown>, Set<unknown>>, "equal to", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have union">, z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"equal to">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have intersection", z.ZodCustom<Set<unknown>, Set<unknown>>, "equal to", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have intersection">, z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"equal to">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have difference", z.ZodCustom<Set<unknown>, Set<unknown>>, "equal to", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have difference">, z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"equal to">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to have symmetric difference", z.ZodCustom<Set<unknown>, Set<unknown>>, "equal to", z.ZodCustom<Set<unknown>, Set<unknown>>], (setA: Set<unknown>, setB: Set<unknown>, expected: Set<unknown>) => boolean, readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"to have symmetric difference">, z.ZodCustom<Set<unknown>, Set<unknown>>, import("./types.js").PhraseLiteralSlot<"equal to">, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to have key", z.ZodUnknown], (map: Map<unknown, unknown>, key: unknown) => {
+    actual: unknown[];
+    expected: unknown[];
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to have key">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have value", "to contain value", "to include value"], z.ZodUnknown], (map: Map<unknown, unknown>, value: unknown) => {
+    actual: unknown[];
+    expected: unknown;
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have value", "to contain value", "to include value"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, readonly ["to have entry", "to have key/value pair", "to contain entry", "to contain key/value pair", "to include entry", "to include key/value pair"], z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>], (map: Map<unknown, unknown> | WeakMap<WeakKey, unknown>, [key, value]: [unknown, unknown]) => {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: unknown[] | undefined;
+    expected: unknown[];
+    message: string;
+} | undefined, readonly [z.ZodUnion<[z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have entry", "to have key/value pair", "to contain entry", "to contain key/value pair", "to include entry", "to include key/value pair"]>, z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, "to equal", z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>], (mapA: Map<unknown, unknown>, mapB: Map<unknown, unknown>) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: unknown[];
+    expected: unknown[];
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralSlot<"to equal">, z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size greater than", z.ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, minSize: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to have size greater than">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size less than", z.ZodInt], (collection: Map<unknown, unknown> | Set<unknown>, maxSize: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to have size less than">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, "to have size between", z.ZodTuple<[z.ZodInt, z.ZodInt], null>], (collection: Map<unknown, unknown> | Set<unknown>, [min, max]: [number, number]) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to have size between">, z.ZodTuple<[z.ZodInt, z.ZodInt], null>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, readonly ["to have values satisfying", "to contain values satisfying"], z.ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have values satisfying", "to contain values satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, "to have values exhaustively satisfying", z.ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, import("./types.js").PhraseLiteralSlot<"to have values exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, readonly ["to have a value satisfying", "to have value satisfying", "to contain a value satisfying"], z.ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have a value satisfying", "to have value satisfying", "to contain a value satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, readonly ["to have a value exhaustively satisfying", "to have value exhaustively satisfying"], z.ZodUnknown], (subject: unknown[] | Map<unknown, unknown> | Set<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, z.ZodCustom<Set<unknown>, Set<unknown>>, z.ZodArray<z.ZodUnknown>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have a value exhaustively satisfying", "to have value exhaustively satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have keys satisfying", "to have props satisfying", "to have properties satisfying", "to have fields satisfying", "to contain keys satisfying", "to contain props satisfying", "to contain properties satisfying", "to contain fields satisfying"], z.ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have keys satisfying", "to have props satisfying", "to have properties satisfying", "to have fields satisfying", "to contain keys satisfying", "to contain props satisfying", "to contain properties satisfying", "to contain fields satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have keys exhaustively satisfying", "to have props exhaustively satisfying", "to have properties exhaustively satisfying", "to have fields exhaustively satisfying"], z.ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have keys exhaustively satisfying", "to have props exhaustively satisfying", "to have properties exhaustively satisfying", "to have fields exhaustively satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have a key satisfying", "to have key satisfying", "to have a prop satisfying", "to have prop satisfying", "to have a property satisfying", "to have property satisfying", "to have a field satisfying", "to have field satisfying"], z.ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have a key satisfying", "to have key satisfying", "to have a prop satisfying", "to have prop satisfying", "to have a property satisfying", "to have property satisfying", "to have a field satisfying", "to have field satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, readonly ["to have a key exhaustively satisfying", "to have key exhaustively satisfying", "to have a prop exhaustively satisfying", "to have prop exhaustively satisfying", "to have a property exhaustively satisfying", "to have property exhaustively satisfying", "to have a field exhaustively satisfying", "to have field exhaustively satisfying"], z.ZodUnknown], (subject: Map<unknown, unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have a key exhaustively satisfying", "to have key exhaustively satisfying", "to have a prop exhaustively satisfying", "to have prop exhaustively satisfying", "to have a property exhaustively satisfying", "to have property exhaustively satisfying", "to have a field exhaustively satisfying", "to have field exhaustively satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys satisfying", "to have props satisfying", "to have properties satisfying", "to have fields satisfying"], z.ZodUnknown], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have keys satisfying", "to have props satisfying", "to have properties satisfying", "to have fields satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have a key satisfying", "to have key satisfying", "to have a prop satisfying", "to have prop satisfying", "to have a property satisfying", "to have property satisfying", "to have a field satisfying", "to have field satisfying"], z.ZodUnknown], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have a key satisfying", "to have key satisfying", "to have a prop satisfying", "to have prop satisfying", "to have a property satisfying", "to have property satisfying", "to have a field satisfying", "to have field satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have keys matching", "to have props matching", "to have properties matching", "to have fields matching"], z.ZodCustom<RegExp, RegExp>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), pattern: RegExp) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have keys matching", "to have props matching", "to have properties matching", "to have fields matching"]>, z.ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, readonly ["to have a key matching", "to have key matching", "to have a prop matching", "to have prop matching", "to have a property matching", "to have property matching", "to have a field matching", "to have field matching"], z.ZodCustom<RegExp, RegExp>], (subject: Record<PropertyKey, unknown> | ((...args: any[]) => any), pattern: RegExp) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Record<PropertyKey, unknown> | ((...args: any[]) => any), Record<PropertyKey, unknown> | ((...args: any[]) => any)>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to have a key matching", "to have key matching", "to have a prop matching", "to have prop matching", "to have a property matching", "to have property matching", "to have a field matching", "to have field matching"]>, z.ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an array", "to be array"]], z.ZodArray<z.ZodUnknown>, never>, import("./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>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a bigint", "to be a BigInt"]], z.ZodBigInt, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a boolean", "to be boolean", "to be a bool"]], z.ZodBoolean, never>, import("./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>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a date", "to be a Date"]], z.ZodDate, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be defined"], z.ZodNonOptional<z.ZodUnknown>, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<ArrayLike<unknown>, ArrayLike<unknown>>, "to be empty"], (subject: ArrayLike<unknown>) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [z.ZodCustom<ArrayLike<unknown>, ArrayLike<unknown>>, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./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("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodString, "to be empty"], z.ZodString, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be empty">]>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be an Error", "to be a Error"]], z.ZodCustom<Error, Error>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be false"], z.ZodLiteral<false>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be falsy"], z.ZodNullable<z.ZodAny>, never>, import("./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>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be infinite"], z.ZodUnion<[z.ZodLiteral<number>, z.ZodLiteral<number>]>, never>, import("./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>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be NaN"], z.ZodNaN, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be negative", "to be a negative number"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be -Infinity"], z.ZodLiteral<number>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a negative integer", "to be a negative int"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly [z.ZodString, "to be non-empty"], z.ZodString, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be non-empty">]>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be null"], z.ZodNull, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a number", "to be finite"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be an object"], z.ZodNonOptional<z.ZodUnknown> & z.ZodType<object, unknown, z.core.$ZodTypeInternals<object, unknown>>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be positive", "to be a positive number"]], z.ZodNumber, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be Infinity"], z.ZodLiteral<number>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a positive integer", "to be a positive int"]], z.ZodNumber, never>, import("./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>, import("./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>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a RegExp", "to be a regex", "to be a regexp"]], z.ZodCustom<RegExp, RegExp>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a Set"], z.ZodCustom<Set<unknown>, Set<unknown>>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a string"], z.ZodString, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a symbol", "to be a Symbol"]], z.ZodSymbol, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be true"], z.ZodLiteral<true>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be truthy", "to exist", "to be ok"]], z.ZodNonOptional<z.ZodAny>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be undefined"], z.ZodUndefined, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a WeakMap"], z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be a WeakSet"], z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>, never>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to be an instance of", "to be a", "to be an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (_: unknown, ctor: import("./types.js").Constructor) => z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, never>, import("./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<Map<unknown, unknown>, Map<unknown, unknown>> | z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>> | z.ZodNumber | z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>> | z.ZodArray<z.ZodUnknown> | z.ZodSymbol | z.ZodCustom<RegExp, RegExp> | 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.ZodObject<{}, z.core.$loose> | z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>> | z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be a", "to be an", "to have type"]>, z.ZodEnum<{
+    [x: string]: string;
+}>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, "to be greater than", z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralSlot<"to be greater than">, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be less than", "to be lt"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be less than", "to be lt"]>, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be greater than or equal to", "to be at least", "to be gte"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be greater than or equal to", "to be at least", "to be gte"]>, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be less than or equal to", "to be at most", "to be lte"], z.ZodNumber], (_: number, other: number) => z.ZodNumber, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be less than or equal to", "to be at most", "to be lte"]>, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, readonly ["to be within", "to be between"], z.ZodNumber, z.ZodNumber], (subject: number, min: number, max: number) => {
+    message: string;
+} | undefined, readonly [z.ZodNumber, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>, z.ZodNumber, z.ZodNumber]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNumber, "to be close to", z.ZodNumber, z.ZodOptional<z.ZodNumber>], (subject: number, expected: number, tolerance?: number | undefined) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [z.ZodNumber, import("./types.js").PhraseLiteralSlot<"to be close to">, z.ZodNumber, z.ZodOptional<z.ZodNumber>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to be greater than", z.ZodString], (subject: string, other: string) => {
+    message: string;
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be greater than">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to be less than", z.ZodString], (subject: string, other: string) => {
+    message: string;
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be less than">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to be greater than or equal to", z.ZodString], (subject: string, other: string) => {
+    message: string;
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be greater than or equal to">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to be less than or equal to", z.ZodString], (subject: string, other: string) => {
+    message: string;
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to be less than or equal to">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, readonly ["to begin with", "to start with"], z.ZodString], (subject: string, prefix: string) => {
+    message: string;
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, "to end with", z.ZodString], (subject: string, suffix: string) => {
+    message: string;
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to end with">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly ["to be one of", z.ZodArray<z.ZodUnknown>], (subject: unknown, values: unknown[]) => {
+    actual: unknown;
+    expected: unknown[];
+    message: string;
+} | undefined, never>, 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.ZodInt], (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.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Error, Error>, "to have message", z.ZodString], (subject: Error, expectedMessage: string) => {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [z.ZodCustom<Error, Error>, import("./types.js").PhraseLiteralSlot<"to have message">, z.ZodString]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<Error, Error>, "to have message matching", z.ZodCustom<RegExp, RegExp>], (subject: Error, pattern: RegExp) => {
+    message: string;
+} | undefined, readonly [z.ZodCustom<Error, Error>, import("./types.js").PhraseLiteralSlot<"to have message matching">, z.ZodCustom<RegExp, RegExp>]>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to be", "to equal", "equals", "is", "is equal to", "to strictly equal", "is strictly equal to"], z.ZodUnknown], (subject: unknown, value: unknown) => {
+    actual: unknown;
+    expected: unknown;
+    message: string;
+} | undefined, never>, import("./types.js").AssertionFunctionSync<readonly [readonly ["to deep equal", "to deeply equal"], z.ZodUnknown], (_: unknown, expected: unknown) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodCustom<(...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown>, "to throw"], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => {
+    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 throw">]>, 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 throw an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor) => {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    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 throw 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 throw", "to throw error satisfying"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: {} | null;
+    message?: 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", "to throw error satisfying"]>, 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 throw a", "to throw an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, "satisfying", z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, ctor: import("./types.js").Constructor, param: unknown) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: 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 throw an"]>, z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>, import("./types.js").PhraseLiteralSlot<"satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodString, readonly ["includes", "contains", "to include", "to contain"], z.ZodString], (subject: string, expected: string) => {
+    message: string;
+} | 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 have length", z.ZodInt], (subject: string, expectedLength: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [z.ZodString, import("./types.js").PhraseLiteralSlot<"to have length">, z.ZodInt]>, 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 [readonly ["to satisfy", "to be like", "satisfies"], z.ZodUnknown], (_subject: unknown, shape: unknown) => z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, never>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to have a null prototype", "to be a dictionary"]], z.ZodCustom<Record<PropertyKey, unknown>, Record<PropertyKey, unknown>>, never>, import("./types.js").AssertionFunctionSync<readonly ["to be frozen"], (subject: unknown) => {
+    actual: boolean;
+    expected: boolean;
+    message: string;
+} | undefined, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, "to be an enumerable property of", z.ZodNonOptional<z.ZodUnknown>], (subject: string | number | symbol, obj: unknown) => {
+    actual: boolean;
+    expected: boolean;
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>, import("./types.js").PhraseLiteralSlot<"to be an enumerable property of">, z.ZodNonOptional<z.ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodNonOptional<z.ZodUnknown>, "to have enumerable property", z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>], (_subject: unknown, key: string | number | symbol) => z.ZodCustom<unknown, unknown>, readonly [z.ZodNonOptional<z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"to have enumerable property">, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>]>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be sealed"], z.ZodUnknown, never>, import("./types.js").AssertionStandardSchemaSync<readonly ["to be extensible"], z.ZodUnknown, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "to be after", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>], (subject: string | number | Date, other: string | number | Date) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodDate;
+    subject: Date;
+    message?: undefined;
+}, readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"to be after">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "to be before", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>], (subject: string | number | Date, other: string | number | Date) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodDate;
+    subject: Date;
+    message?: undefined;
+}, readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"to be before">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "to be between", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "and", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>], (subject: string | number | Date, start: string | number | Date, end: string | number | Date) => {
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodDate;
+    subject: Date;
+    message?: undefined;
+}, readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"to be between">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"and">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "to equal", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "within", z.ZodCustomStringFormat<"duration">], (subject: string | number | Date, other: string | number | Date, toleranceStr: string) => {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: {
+        difference: number;
+    };
+    expected: {
+        maxDifference: number;
+    };
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"to equal">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"within">, z.ZodCustomStringFormat<"duration">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, "to be the same date as", z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>], (subject: string | number | Date, other: string | number | Date) => {
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, import("./types.js").PhraseLiteralSlot<"to be the same date as">, z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>]>, import("./types.js").AssertionStandardSchemaSync<readonly [readonly ["to be a valid date", "to be date-like"]], z.ZodUnion<readonly [z.ZodDate, z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>, z.ZodInt]>, never>, import("./types.js").AssertionFunctionSync<readonly ["to be a weekday"], (subject: unknown) => {
+    message: string;
+} | undefined, never>, import("./types.js").AssertionFunctionSync<readonly ["to be a weekend"], (subject: unknown) => {
+    message: string;
+} | undefined, never>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnknown, readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"], z.ZodNonOptional<z.ZodUnknown>], (actual: unknown, context: unknown) => void | import("./types.js").AssertionFailure, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"]>, z.ZodNonOptional<z.ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnknown, readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"], z.ZodNonOptional<z.ZodUnknown>, "with options", z.ZodObject<{
+    hint: z.ZodOptional<z.ZodString>;
+    serializer: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>], (actual: unknown, context: unknown, options: {
+    hint?: string | undefined;
+    serializer?: any;
+}) => void | import("./types.js").AssertionFailure, readonly [z.ZodUnknown, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to match snapshot", "to match the snapshot", "to equal snapshot", "to equal the snapshot"]>, z.ZodNonOptional<z.ZodUnknown>, import("./types.js").PhraseLiteralSlot<"with options">, z.ZodObject<{
+    hint: z.ZodOptional<z.ZodString>;
+    serializer: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, readonly ["to yield", "to emit", "to yield value satisfying"], z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield", "to emit", "to yield value satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield value exhaustively satisfying", z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield value exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield items satisfying", z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield items satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield items exhaustively satisfying", z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield items exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, readonly ["to yield first", "to yield first satisfying"], z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield first", "to yield first satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield first exhaustively satisfying", z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield first exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, readonly ["to yield last", "to yield last satisfying"], z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield last", "to yield last satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield last exhaustively satisfying", z.ZodUnknown], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield last exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield count", z.ZodInt], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expectedCount: number) => {
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield count">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield at least", z.ZodInt], (subject: Iterator<unknown, any, any> | Iterable<unknown>, minCount: number) => {
+    actual: number;
+    expected: string;
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield at least">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield at most", z.ZodInt], (subject: Iterator<unknown, any, any> | Iterable<unknown>, maxCount: number) => {
+    actual: number;
+    expected: string;
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield at most">, z.ZodInt]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to be an empty iterable"], (subject: Iterator<unknown, any, any> | Iterable<unknown>) => {
+    message: string;
+} | undefined, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to be an empty iterable">]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, "to yield exactly", z.ZodArray<z.ZodUnknown>], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown[]) => {
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: unknown[];
+}, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralSlot<"to yield exactly">, z.ZodArray<z.ZodUnknown>]>, import("./types.js").AssertionFunctionSync<readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, readonly ["to yield sequence satisfying", "to yield array satisfying"], z.ZodArray<z.ZodUnknown>], (subject: Iterator<unknown, any, any> | Iterable<unknown>, expected: unknown[]) => {
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: unknown[];
+}, readonly [z.ZodUnion<readonly [z.ZodCustom<Iterable<unknown>, Iterable<unknown>>, z.ZodCustom<Iterator<unknown, any, any>, Iterator<unknown, any, any>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield sequence satisfying", "to yield array satisfying"]>, z.ZodArray<z.ZodUnknown>]>], 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<{
+    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<{
+    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>, readonly ["to reject", "to be rejected"]], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown) => Promise<{
+    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 reject", "to be rejected"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject", "to be rejected"]], (subject: PromiseLike<unknown>) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, 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", "to be rejected with a", "to be rejected 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<{
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    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 reject with a", "to reject with an", "to be rejected with a", "to be rejected 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", "to be rejected with a", "to be rejected with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: PromiseLike<unknown>, ctor: import("./types.js").Constructor) => Promise<{
+    message: string;
+    actual?: undefined;
+    expected?: undefined;
+} | {
+    actual: string;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with a", "to reject with an", "to be rejected with a", "to be rejected 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", "to be rejected with error satisfying"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: 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", "to be rejected with error satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], z.ZodUnknown], (subject: PromiseLike<unknown>, param: unknown) => Promise<{
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    subject: {} | null;
+    message?: undefined;
+}>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, readonly ["to fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnknown], (promise: PromiseLike<unknown>, param: unknown) => Promise<{
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: undefined;
+}>, readonly [z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to fulfill with value satisfying", "to resolve with value satisfying"]>, 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 fulfill with value satisfying", "to resolve with value satisfying"], z.ZodUnknown], (subject: (...args: import("./types.js").MutableOrReadonly<unknown[]>) => unknown, param: unknown) => Promise<{
+    message: string;
+    schema?: undefined;
+    subject?: undefined;
+} | {
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: unknown;
+    message?: 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.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to yield", "to emit", "to yield value satisfying"], z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield", "to emit", "to yield value satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield value exhaustively satisfying", z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield value exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield items satisfying", z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield items satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield items exhaustively satisfying", z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield items exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to yield first", "to yield first satisfying"], z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield first", "to yield first satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield first exhaustively satisfying", z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield first exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to yield last", "to yield last satisfying"], z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield last", "to yield last satisfying"]>, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield last exhaustively satisfying", z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield last exhaustively satisfying">, z.ZodUnknown]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield count", z.ZodInt], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expectedCount: number) => Promise<{
+    actual: number;
+    expected: number;
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield count">, z.ZodInt]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield at least", z.ZodInt], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, minCount: number) => Promise<{
+    actual: number;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield at least">, z.ZodInt]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield at most", z.ZodInt], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, maxCount: number) => Promise<{
+    actual: number;
+    expected: string;
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield at most">, z.ZodInt]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to be an empty iterable"], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to be an empty iterable">]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, "to yield exactly", z.ZodArray<z.ZodUnknown>], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown[]) => Promise<{
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: unknown[];
+}>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralSlot<"to yield exactly">, z.ZodArray<z.ZodUnknown>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to yield sequence satisfying", "to yield array satisfying"], z.ZodArray<z.ZodUnknown>], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expected: unknown[]) => Promise<{
+    schema: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>;
+    subject: unknown[];
+}>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to yield sequence satisfying", "to yield array satisfying"]>, z.ZodArray<z.ZodUnknown>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to complete", "to finish"]], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to complete", "to finish"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to reject", "to be rejected"]], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject", "to be rejected"]>]>, import("./types.js").AssertionFunctionAsync<readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to reject with a", "to reject with an"], z.ZodCustom<import("./types.js").Constructor, import("./types.js").Constructor>], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expectedType: import("./types.js").Constructor) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<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.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, readonly ["to reject with error satisfying", "to be rejected with error satisfying"], z.ZodUnknown], (subject: Iterable<unknown> | AsyncIterable<unknown> | AsyncIterator<unknown, any, any>, expectedShape: unknown) => Promise<{
+    message: string;
+} | undefined>, readonly [z.ZodUnion<readonly [z.ZodCustom<AsyncIterable<unknown>, AsyncIterable<unknown>>, z.ZodCustom<AsyncIterator<unknown, any, any>, AsyncIterator<unknown, any, any>>, z.ZodCustom<Iterable<unknown>, Iterable<unknown>>]>, import("./types.js").PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying", "to be rejected with error satisfying"]>, z.ZodUnknown]>]>;
+//# sourceMappingURL=index.d.ts.map