BUPKIS
    Preparing search index...

    Function expectAsync

    The main asynchronous assertion function which can execute only built-in assertions.

    • Parameters

      • ...args:
            | readonly (
                | ((...args: unknown[] | readonly unknown[]) => unknown)
                | "to resolve"
                | "to fulfill"
                | "not to resolve"
                | "not to fulfill"
            )[]
            | (
                | ((...args: unknown[] | readonly unknown[]) => unknown)
                | "to resolve"
                | "to fulfill"
                | "not to resolve"
                | "not to fulfill"
            )[]

      Returns Promise<void>

    • Parameters

      • ...args:
            | readonly (
                | PromiseLike<unknown>
                | "to resolve"
                | "to fulfill"
                | "not to resolve"
                | "not to fulfill"
            )[]
            | (
                | PromiseLike<unknown>
                | "to resolve"
                | "to fulfill"
                | "not to resolve"
                | "not to fulfill"
            )[]

      Returns Promise<void>

    • Parameters

      • ...args:
            | readonly (
                | ((...args: unknown[] | readonly unknown[]) => unknown)
                | "to reject"
                | "not to reject"
            )[]
            | (
                | ((...args: unknown[] | readonly unknown[]) => unknown)
                | "to reject"
                | "not to reject"
            )[]

      Returns Promise<void>

    • Parameters

      • ...args:
            | readonly (PromiseLike<unknown> | "to reject" | "not to reject")[]
            | (PromiseLike<unknown> | "to reject" | "not to reject")[]

      Returns Promise<void>

    • Parameters

      • ...args:
            | readonly (
                | types.Constructor
                | ((...args: unknown[] | readonly unknown[]) => unknown)
                | "to reject with a"
                | "to reject with an"
                | "not to reject with a"
                | "not to reject with an"
            )[]
            | (
                | types.Constructor
                | ((...args: unknown[] | readonly unknown[]) => unknown)
                | "to reject with a"
                | "to reject with an"
                | "not to reject with a"
                | "not to reject with an"
            )[]

      Returns Promise<void>

    • Parameters

      • ...args:
            | readonly (
                | types.Constructor
                | PromiseLike<unknown>
                | "to reject with a"
                | "to reject with an"
                | "not to reject with a"
                | "not to reject with an"
            )[]
            | (
                | types.Constructor
                | PromiseLike<unknown>
                | "to reject with a"
                | "to reject with an"
                | "not to reject with a"
                | "not to reject with an"
            )[]

      Returns Promise<void>

    • Parameters

      • ...args: unknown[] | readonly unknown[]

      Returns Promise<void>

    Index

    Properties

    assertions createAssertion createAsyncAssertion fail it use

    Properties

    assertions: readonly [
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to resolve", "to fulfill"],
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ) => Promise<{ message: string } | undefined>,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>,
            ],
        >,
        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>>,
                PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                "to reject",
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ) => Promise<{ message: string } | undefined>,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralSlot<"to reject">,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                "to reject",
            ],
            (
                subject: PromiseLike<unknown>,
            ) => Promise<{ message: string } | undefined>,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralSlot<"to reject">,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to reject with a", "to reject with an"],
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                ctor: types.Constructor,
            ) => Promise<
                | { actual?: undefined; expected?: undefined; message: string }
                | { actual: string; expected: string; message: string }
                | undefined,
            >,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<
                    readonly ["to reject with a", "to reject with an"],
                >,
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly ["to reject with a", "to reject with an"],
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
            (
                subject: PromiseLike<unknown>,
                ctor: types.Constructor,
            ) => Promise<
                | { actual?: undefined; expected?: undefined; message: string }
                | { actual: string; expected: string; message: string }
                | undefined,
            >,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<
                    readonly ["to reject with a", "to reject with an"],
                >,
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to reject with error satisfying"],
                z.ZodUnknown,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                param: unknown,
            ) => Promise<
                | { message: string; schema?: undefined; subject?: undefined }
                | {
                    message?: undefined;
                    schema: z.ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
                    subject: {} | null;
                },
            >,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>,
                z.ZodUnknown,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly ["to reject with error satisfying"],
                z.ZodUnknown,
            ],
            (
                subject: PromiseLike<unknown>,
                param: unknown,
            ) => Promise<
                | { message: string; schema?: undefined; subject?: undefined }
                | {
                    message?: undefined;
                    schema: z.ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>;
                    subject: {} | null;
                },
            >,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>,
                z.ZodUnknown,
            ],
        >,
        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 }
                | {
                    message?: undefined;
                    schema: z.ZodType<any, unknown, $ZodTypeInternals<any, unknown>>;
                    subject: unknown;
                },
            >,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to fulfill with value satisfying",
                        "to resolve with value satisfying",
                    ],
                >,
                z.ZodUnknown,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly [
                    "to fulfill with value satisfying",
                    "to resolve with value satisfying",
                ],
                z.ZodUnknown,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                param: unknown,
            ) => Promise<
                | { message: string; schema?: undefined; subject?: undefined }
                | {
                    message?: undefined;
                    schema: z.ZodType<any, unknown, $ZodTypeInternals<any, unknown>>;
                    subject: unknown;
                },
            >,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to fulfill with value satisfying",
                        "to resolve with value satisfying",
                    ],
                >,
                z.ZodUnknown,
            ],
        >,
    ]

    Tuple of all assertions available in this expect().

    createAssertion: CreateAssertionFn

    Creates a new synchronous assertion.

    createAsyncAssertion: CreateAsyncAssertionFn

    Creates a new asynchronous assertion.

    fail: FailFn

    Fails immediately with optional reason.

    Reason for failure

    it: ExpectItFunctionAsync<
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            readonly ["to resolve", "to fulfill"],
        ],
    > & ExpectItFunctionAsync<
        readonly [
            z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
            readonly ["to resolve", "to fulfill"],
        ],
    > & ExpectItFunctionAsync<
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            "to reject",
        ],
    > & ExpectItFunctionAsync<
        readonly [
            z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
            "to reject",
        ],
    > & ExpectItFunctionAsync<
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            readonly ["to reject with a", "to reject with an"],
            z.ZodCustom<types.Constructor, types.Constructor>,
        ],
    > & ExpectItFunctionAsync<
        readonly [
            z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
            readonly ["to reject with a", "to reject with an"],
            z.ZodCustom<types.Constructor, types.Constructor>,
        ],
    > & ExpectItFunctionAsync<
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            readonly ["to reject with error satisfying"],
            z.ZodUnknown,
        ],
    > & ExpectItFunctionAsync<
        readonly [
            z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
            readonly ["to reject with error satisfying"],
            z.ZodUnknown,
        ],
    > & ExpectItFunctionAsync<
        readonly [
            z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
            readonly [
                "to fulfill with value satisfying",
                "to resolve with value satisfying",
            ],
            z.ZodUnknown,
        ],
    > & ExpectItFunctionAsync<
        readonly [
            z.ZodCustom<
                (...args: unknown[] | readonly unknown[]) => unknown,
                (...args: unknown[] | readonly unknown[]) => unknown,
            >,
            readonly [
                "to fulfill with value satisfying",
                "to resolve with value satisfying",
            ],
            z.ZodUnknown,
        ],
    >

    Factory type for creating async embeddable assertion executors.

    This type generates a union of all possible expectAsync.it function signatures based on the available asynchronous assertions. Each assertion contributes its own function signature to create embeddable async executors that can be used within async object patterns for complex validation scenarios.

    The resulting functions are designed to be used exclusively within async 'to satisfy' assertion contexts, where they provide type-safe pattern matching for nested object structures with Promise-based validation.

    use: UseFn<
        readonly [
            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,
                ) =>
                    | { actual?: undefined; expected?: undefined; message: string }
                    | { actual: unknown; expected: string; message: string }
                    | undefined,
                readonly [
                    z.ZodUnion<
                        [
                            z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                            z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
                        ],
                    >,
                    PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                    z.ZodUnknown,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    "to have size",
                    ZodInt,
                ],
                (
                    _subject: Map<unknown, unknown>,
                    expectedSize: number,
                ) => z.ZodMap<z.ZodUnknown, z.ZodUnknown>,
                readonly [
                    z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    PhraseLiteralSlot<"to have size">,
                    ZodInt,
                ],
            >,
            AssertionSchemaSync<
                readonly [
                    z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    "to be empty",
                ],
                AssertionImplSchemaSync<
                    readonly [
                        z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                        "to be empty",
                    ],
                >,
                readonly [
                    z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    PhraseLiteralSlot<"to be empty">,
                ],
            >,
            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,
                ) =>
                    | { actual?: undefined; expected?: undefined; message: string }
                    | { actual: unknown; expected: string; message: string }
                    | undefined,
                readonly [
                    z.ZodUnion<
                        [
                            z.ZodCustom<Set<unknown>, Set<unknown>>,
                            z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
                        ],
                    >,
                    PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                    z.ZodUnknown,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                    "to have size",
                    ZodInt,
                ],
                (_subject: Set<unknown>, expectedSize: number) => z.ZodSet<z.ZodUnknown>,
                readonly [
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                    PhraseLiteralSlot<"to have size">,
                    ZodInt,
                ],
            >,
            AssertionSchemaSync<
                readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"],
                AssertionImplSchemaSync<
                    readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"],
                >,
                readonly [
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                    PhraseLiteralSlot<"to be empty">,
                ],
            >,
            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>,
                    PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                    z.ZodUnknown,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodArray<z.ZodUnknown>,
                    readonly ["to have length", "to have size"],
                    ZodInt,
                ],
                (_subject: unknown[], expectedSize: number) => z.ZodArray<z.ZodUnknown>,
                readonly [
                    z.ZodArray<z.ZodUnknown>,
                    PhraseLiteralChoiceSlot<readonly ["to have length", "to have size"]>,
                    ZodInt,
                ],
            >,
            AssertionSchemaSync<
                readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"],
                AssertionImplSchemaSync<
                    readonly [z.ZodArray<z.ZodUnknown>, "to be non-empty"],
                >,
                readonly [z.ZodArray<z.ZodUnknown>, PhraseLiteralSlot<"to be non-empty">],
            >,
            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),
                    >,
                    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]>>,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodRecord<
                        z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
                        z.ZodUnknown,
                    >,
                    "to have size",
                    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,
                    >,
                    PhraseLiteralSlot<"to have size">,
                    ZodInt,
                ],
            >,
            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),
                    >,
                    PhraseLiteralChoiceSlot<
                        readonly [
                            "to have exact key",
                            "to have exact property",
                            "to have exact prop",
                        ],
                    >,
                    z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
                ],
            >,
            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, $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),
                    >,
                    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, $ZodTypeInternals<string, unknown>>,
                ],
            >,
            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>>,
                    PhraseLiteralSlot<"to equal">,
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            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>>,
                    PhraseLiteralSlot<"to be a subset of">,
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            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>>,
                    PhraseLiteralSlot<"to be a superset of">,
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            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>>,
                    PhraseLiteralSlot<"to intersect with">,
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            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>>,
                    PhraseLiteralSlot<"to be disjoint from">,
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            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>>,
                    PhraseLiteralSlot<"to have union">,
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                    PhraseLiteralSlot<"equal to">,
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            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>>,
                    PhraseLiteralSlot<"to have intersection">,
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                    PhraseLiteralSlot<"equal to">,
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            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>>,
                    PhraseLiteralSlot<"to have difference">,
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                    PhraseLiteralSlot<"equal to">,
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            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>>,
                    PhraseLiteralSlot<"to have symmetric difference">,
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                    PhraseLiteralSlot<"equal to">,
                    z.ZodCustom<Set<unknown>, Set<unknown>>,
                ],
            >,
            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>>,
                    PhraseLiteralSlot<"to have key">,
                    z.ZodUnknown,
                ],
            >,
            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>>,
                    PhraseLiteralChoiceSlot<
                        readonly ["to have value", "to contain value", "to include value"],
                    >,
                    z.ZodUnknown,
                ],
            >,
            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>,
                    __namedParameters: [unknown, unknown],
                ) =>
                    | { actual?: undefined; expected?: undefined; message: string }
                    | {
                        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>>,
                        ],
                    >,
                    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>,
                ],
            >,
            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 }
                    | { actual?: undefined; expected?: undefined; message: string }
                    | { actual: unknown[]; expected: unknown[]; message: string }
                    | undefined,
                readonly [
                    z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                    PhraseLiteralSlot<"to equal">,
                    z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                            z.ZodCustom<Set<unknown>, Set<unknown>>,
                        ],
                    >,
                    "to have size greater than",
                    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>>,
                        ],
                    >,
                    PhraseLiteralSlot<"to have size greater than">,
                    ZodInt,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                            z.ZodCustom<Set<unknown>, Set<unknown>>,
                        ],
                    >,
                    "to have size less than",
                    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>>,
                        ],
                    >,
                    PhraseLiteralSlot<"to have size less than">,
                    ZodInt,
                ],
            >,
            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<[ZodInt, ZodInt], null>,
                ],
                (
                    collection: Map<unknown, unknown> | Set<unknown>,
                    __namedParameters: [number, number],
                ) => { message: string } | undefined,
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                            z.ZodCustom<Set<unknown>, Set<unknown>>,
                        ],
                    >,
                    PhraseLiteralSlot<"to have size between">,
                    z.ZodTuple<[ZodInt, ZodInt], null>,
                ],
            >,
            AssertionSchemaSync<
                readonly [readonly ["to be an array", "to be array"]],
                AssertionImplSchemaSync<
                    readonly [readonly ["to be an array", "to be array"]],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be an async function"],
                AssertionImplSchemaSync<readonly ["to be an async function"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly [readonly ["to be a bigint", "to be a BigInt"]],
                AssertionImplSchemaSync<
                    readonly [readonly ["to be a bigint", "to be a BigInt"]],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly [
                    readonly ["to be a boolean", "to be boolean", "to be a bool"],
                ],
                AssertionImplSchemaSync<
                    readonly [
                        readonly ["to be a boolean", "to be boolean", "to be a bool"],
                    ],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly [
                    readonly [
                        "to be a class",
                        "to be a constructor",
                        "to be constructible",
                    ],
                ],
                AssertionImplSchemaSync<
                    readonly [
                        readonly [
                            "to be a class",
                            "to be a constructor",
                            "to be constructible",
                        ],
                    ],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly [readonly ["to be a date", "to be a Date"]],
                AssertionImplSchemaSync<
                    readonly [readonly ["to be a date", "to be a Date"]],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be defined"],
                AssertionImplSchemaSync<readonly ["to be defined"]>,
                never,
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodArray<z.ZodUnknown>,
                            z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                            z.ZodObject<{ length: z.ZodNumber }, $loose>,
                        ],
                    >,
                    "to be empty",
                ],
                (
                    subject:
                        | unknown[]
                        | [unknown, ...unknown[]]
                        | { length: number; [key: string]: unknown },
                ) => { actual: number; expected: number; message: string } | undefined,
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodArray<z.ZodUnknown>,
                            z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                            z.ZodObject<{ length: z.ZodNumber }, $loose>,
                        ],
                    >,
                    PhraseLiteralSlot<"to be empty">,
                ],
            >,
            AssertionSchemaSync<
                readonly [
                    z.ZodRecord<
                        z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
                        z.ZodUnknown,
                    >,
                    "to be empty",
                ],
                AssertionImplSchemaSync<
                    readonly [
                        z.ZodRecord<
                            z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
                            z.ZodUnknown,
                        >,
                        "to be empty",
                    ],
                >,
                readonly [
                    z.ZodRecord<
                        z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
                        z.ZodUnknown,
                    >,
                    PhraseLiteralSlot<"to be empty">,
                ],
            >,
            AssertionSchemaSync<
                readonly [z.ZodString, "to be empty"],
                AssertionImplSchemaSync<readonly [z.ZodString, "to be empty"]>,
                readonly [z.ZodString, PhraseLiteralSlot<"to be empty">],
            >,
            AssertionSchemaSync<
                readonly [readonly ["to be an Error", "to be a Error"]],
                AssertionImplSchemaSync<
                    readonly [readonly ["to be an Error", "to be a Error"]],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be false"],
                AssertionImplSchemaSync<readonly ["to be false"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be falsy"],
                AssertionImplSchemaSync<readonly ["to be falsy"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be a function"],
                AssertionImplSchemaSync<readonly ["to be a function"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be infinite"],
                AssertionImplSchemaSync<readonly ["to be infinite"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly [
                    readonly [
                        "to be an integer",
                        "to be a safe integer",
                        "to be an int",
                        "to be a safe int",
                    ],
                ],
                AssertionImplSchemaSync<
                    readonly [
                        readonly [
                            "to be an integer",
                            "to be a safe integer",
                            "to be an int",
                            "to be a safe int",
                        ],
                    ],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be NaN"],
                AssertionImplSchemaSync<readonly ["to be NaN"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly [readonly ["to be negative", "to be a negative number"]],
                AssertionImplSchemaSync<
                    readonly [readonly ["to be negative", "to be a negative number"]],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be -Infinity"],
                AssertionImplSchemaSync<readonly ["to be -Infinity"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly [
                    readonly ["to be a negative integer", "to be a negative int"],
                ],
                AssertionImplSchemaSync<
                    readonly [
                        readonly ["to be a negative integer", "to be a negative int"],
                    ],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly [z.ZodString, "to be non-empty"],
                AssertionImplSchemaSync<readonly [z.ZodString, "to be non-empty"]>,
                readonly [z.ZodString, PhraseLiteralSlot<"to be non-empty">],
            >,
            AssertionSchemaSync<
                readonly ["to be null"],
                AssertionImplSchemaSync<readonly ["to be null"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly [readonly ["to be a number", "to be finite"]],
                AssertionImplSchemaSync<
                    readonly [readonly ["to be a number", "to be finite"]],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be an object"],
                AssertionImplSchemaSync<readonly ["to be an object"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly [readonly ["to be positive", "to be a positive number"]],
                AssertionImplSchemaSync<
                    readonly [readonly ["to be positive", "to be a positive number"]],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be Infinity"],
                AssertionImplSchemaSync<readonly ["to be Infinity"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly [
                    readonly ["to be a positive integer", "to be a positive int"],
                ],
                AssertionImplSchemaSync<
                    readonly [
                        readonly ["to be a positive integer", "to be a positive int"],
                    ],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be a primitive"],
                AssertionImplSchemaSync<readonly ["to be a primitive"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly [readonly ["to be a record", "to be a plain object"]],
                AssertionImplSchemaSync<
                    readonly [readonly ["to be a record", "to be a plain object"]],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly [
                    readonly ["to be a RegExp", "to be a regex", "to be a regexp"],
                ],
                AssertionImplSchemaSync<
                    readonly [
                        readonly ["to be a RegExp", "to be a regex", "to be a regexp"],
                    ],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be a Set"],
                AssertionImplSchemaSync<readonly ["to be a Set"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be a string"],
                AssertionImplSchemaSync<readonly ["to be a string"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly [readonly ["to be a symbol", "to be a Symbol"]],
                AssertionImplSchemaSync<
                    readonly [readonly ["to be a symbol", "to be a Symbol"]],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be true"],
                AssertionImplSchemaSync<readonly ["to be true"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly [readonly ["to be truthy", "to exist", "to be ok"]],
                AssertionImplSchemaSync<
                    readonly [readonly ["to be truthy", "to exist", "to be ok"]],
                >,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be undefined"],
                AssertionImplSchemaSync<readonly ["to be undefined"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be a WeakMap"],
                AssertionImplSchemaSync<readonly ["to be a WeakMap"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be a WeakSet"],
                AssertionImplSchemaSync<readonly ["to be a WeakSet"]>,
                never,
            >,
            AssertionFunctionSync<
                readonly [
                    readonly ["to be an instance of", "to be a", "to be an"],
                    z.ZodCustom<types.Constructor, types.Constructor>,
                ],
                (
                    _: unknown,
                    ctor: types.Constructor,
                ) => z.ZodCustom<types.Constructor, types.Constructor>,
                readonly [
                    z.ZodUnknown,
                    PhraseLiteralChoiceSlot<
                        readonly ["to be an instance of", "to be a", "to be an"],
                    >,
                    z.ZodCustom<types.Constructor, types.Constructor>,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodUnknown,
                    readonly ["to be a", "to be an", "to have type"],
                    z.ZodEnum<{ [key: string]: string }>,
                ],
                (
                    _: unknown,
                    type: string,
                ) =>
                    | z.ZodString
                    | z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >
                    | z.ZodNumber
                    | z.ZodSymbol
                    | z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>
                    | z.ZodBoolean
                    | z.ZodBigInt
                    | z.ZodNull
                    | z.ZodUndefined
                    | z.ZodArray<z.ZodUnknown>
                    | z.ZodCustom<RegExp, RegExp>
                    | z.ZodDate
                    | z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>
                    | z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>
                    | z.ZodCustom<Error, Error>
                    | z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>
                    | z.ZodObject<{}, $loose>,
                readonly [
                    z.ZodUnknown,
                    PhraseLiteralChoiceSlot<
                        readonly ["to be a", "to be an", "to have type"],
                    >,
                    z.ZodEnum<{ [key: string]: string }>,
                ],
            >,
            AssertionFunctionSync<
                readonly [z.ZodNumber, "to be greater than", z.ZodNumber],
                (_: number, other: number) => z.ZodNumber,
                readonly [
                    z.ZodNumber,
                    PhraseLiteralSlot<"to be greater than">,
                    z.ZodNumber,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodNumber,
                    readonly ["to be less than", "to be lt"],
                    z.ZodNumber,
                ],
                (_: number, other: number) => z.ZodNumber,
                readonly [
                    z.ZodNumber,
                    PhraseLiteralChoiceSlot<readonly ["to be less than", "to be lt"]>,
                    z.ZodNumber,
                ],
            >,
            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,
                    PhraseLiteralChoiceSlot<
                        readonly [
                            "to be greater than or equal to",
                            "to be at least",
                            "to be gte",
                        ],
                    >,
                    z.ZodNumber,
                ],
            >,
            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,
                    PhraseLiteralChoiceSlot<
                        readonly [
                            "to be less than or equal to",
                            "to be at most",
                            "to be lte",
                        ],
                    >,
                    z.ZodNumber,
                ],
            >,
            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,
                    PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>,
                    z.ZodNumber,
                    z.ZodNumber,
                ],
            >,
            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,
                    PhraseLiteralSlot<"to be close to">,
                    z.ZodNumber,
                    z.ZodOptional<z.ZodNumber>,
                ],
            >,
            AssertionFunctionSync<
                readonly [z.ZodString, "to be greater than", z.ZodString],
                (subject: string, other: string) => { message: string } | undefined,
                readonly [
                    z.ZodString,
                    PhraseLiteralSlot<"to be greater than">,
                    z.ZodString,
                ],
            >,
            AssertionFunctionSync<
                readonly [z.ZodString, "to be less than", z.ZodString],
                (subject: string, other: string) => { message: string } | undefined,
                readonly [z.ZodString, PhraseLiteralSlot<"to be less than">, z.ZodString],
            >,
            AssertionFunctionSync<
                readonly [z.ZodString, "to be greater than or equal to", z.ZodString],
                (subject: string, other: string) => { message: string } | undefined,
                readonly [
                    z.ZodString,
                    PhraseLiteralSlot<"to be greater than or equal to">,
                    z.ZodString,
                ],
            >,
            AssertionFunctionSync<
                readonly [z.ZodString, "to be less than or equal to", z.ZodString],
                (subject: string, other: string) => { message: string } | undefined,
                readonly [
                    z.ZodString,
                    PhraseLiteralSlot<"to be less than or equal to">,
                    z.ZodString,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodString,
                    readonly ["to begin with", "to start with"],
                    z.ZodString,
                ],
                (subject: string, prefix: string) => { message: string } | undefined,
                readonly [
                    z.ZodString,
                    PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>,
                    z.ZodString,
                ],
            >,
            AssertionFunctionSync<
                readonly [z.ZodString, "to end with", z.ZodString],
                (subject: string, suffix: string) => { message: string } | undefined,
                readonly [z.ZodString, PhraseLiteralSlot<"to end with">, z.ZodString],
            >,
            AssertionFunctionSync<
                readonly ["to be one of", z.ZodArray<z.ZodUnknown>],
                (
                    subject: unknown,
                    values: unknown[],
                ) =>
                    | { actual: unknown; expected: unknown[]; message: string }
                    | undefined,
                readonly [
                    z.ZodUnknown,
                    PhraseLiteralSlot<"to be one of">,
                    z.ZodArray<z.ZodUnknown>,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    "to have arity",
                    ZodInt,
                ],
                (
                    subject: (...args: unknown[] | readonly unknown[]) => unknown,
                    expectedArity: number,
                ) => { actual: number; expected: number; message: string } | undefined,
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    PhraseLiteralSlot<"to have arity">,
                    ZodInt,
                ],
            >,
            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>,
                    PhraseLiteralSlot<"to have message">,
                    z.ZodString,
                ],
            >,
            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>,
                    PhraseLiteralSlot<"to have message matching">,
                    z.ZodCustom<RegExp, RegExp>,
                ],
            >,
            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,
                readonly [
                    z.ZodUnknown,
                    PhraseLiteralChoiceSlot<
                        readonly [
                            "to be",
                            "to equal",
                            "equals",
                            "is",
                            "is equal to",
                            "to strictly equal",
                            "is strictly equal to",
                        ],
                    >,
                    z.ZodUnknown,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodRecord<
                        z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
                        z.ZodUnknown,
                    >,
                    readonly ["to deep equal", "to deeply equal"],
                    z.ZodUnknown,
                ],
                (
                    _: Record<string | number | symbol, unknown>,
                    expected: unknown,
                ) => z.ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
                readonly [
                    z.ZodRecord<
                        z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
                        z.ZodUnknown,
                    >,
                    PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
                    z.ZodUnknown,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodArray<z.ZodUnknown>,
                            z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                            z.ZodObject<{ length: z.ZodNumber }, $loose>,
                        ],
                    >,
                    readonly ["to deep equal", "to deeply equal"],
                    z.ZodUnknown,
                ],
                (
                    _:
                        | unknown[]
                        | [unknown, ...unknown[]]
                        | { length: number; [key: string]: unknown },
                    expected: unknown,
                ) => z.ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodArray<z.ZodUnknown>,
                            z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                            z.ZodObject<{ length: z.ZodNumber }, $loose>,
                        ],
                    >,
                    PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
                    z.ZodUnknown,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    "to throw",
                ],
                (
                    subject: (...args: unknown[] | readonly unknown[]) => unknown,
                ) => { message: string } | undefined,
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    PhraseLiteralSlot<"to throw">,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    readonly ["to throw a", "to throw an"],
                    z.ZodCustom<types.Constructor, types.Constructor>,
                ],
                (
                    subject: (...args: unknown[] | readonly unknown[]) => unknown,
                    ctor: types.Constructor,
                ) =>
                    | { actual?: undefined; expected?: undefined; message: string }
                    | { actual: string; expected: string; message: string }
                    | undefined,
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>,
                    z.ZodCustom<types.Constructor, types.Constructor>,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    readonly ["to throw", "to throw error satisfying"],
                    z.ZodUnknown,
                ],
                (
                    subject: (...args: unknown[] | readonly unknown[]) => unknown,
                    param: unknown,
                ) =>
                    | { message: string; schema?: undefined; subject?: undefined }
                    | {
                        message?: undefined;
                        schema: z.ZodType<any, unknown, $ZodTypeInternals<any, unknown>>;
                        subject: {} | null;
                    },
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    PhraseLiteralChoiceSlot<
                        readonly ["to throw", "to throw error satisfying"],
                    >,
                    z.ZodUnknown,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    readonly ["to throw a", "to throw an"],
                    z.ZodCustom<types.Constructor, types.Constructor>,
                    "satisfying",
                    z.ZodUnknown,
                ],
                (
                    subject: (...args: unknown[] | readonly unknown[]) => unknown,
                    ctor: types.Constructor,
                    param: unknown,
                ) =>
                    | { message: string; schema?: undefined; subject?: undefined }
                    | {
                        message?: undefined;
                        schema: z.ZodType<
                            unknown,
                            unknown,
                            $ZodTypeInternals<unknown, unknown>,
                        >;
                        subject: {} | null;
                    },
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    PhraseLiteralChoiceSlot<readonly ["to throw a", "to throw an"]>,
                    z.ZodCustom<types.Constructor, types.Constructor>,
                    PhraseLiteralSlot<"satisfying">,
                    z.ZodUnknown,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodString,
                    readonly ["includes", "contains", "to include", "to contain"],
                    z.ZodString,
                ],
                (subject: string, expected: string) => { message: string } | undefined,
                readonly [
                    z.ZodString,
                    PhraseLiteralChoiceSlot<
                        readonly ["includes", "contains", "to include", "to contain"],
                    >,
                    z.ZodString,
                ],
            >,
            AssertionFunctionSync<
                readonly [z.ZodString, "to match", z.ZodCustom<RegExp, RegExp>],
                (subject: string, regex: RegExp) => boolean,
                readonly [
                    z.ZodString,
                    PhraseLiteralSlot<"to match">,
                    z.ZodCustom<RegExp, RegExp>,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodNonOptional<z.ZodObject<{}, $loose>>,
                    readonly ["to satisfy", "to be like", "satisfies"],
                    z.ZodUnknown,
                ],
                (
                    _subject: { [key: string]: unknown },
                    shape: unknown,
                ) => z.ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
                readonly [
                    z.ZodNonOptional<z.ZodObject<{}, $loose>>,
                    PhraseLiteralChoiceSlot<
                        readonly ["to satisfy", "to be like", "satisfies"],
                    >,
                    z.ZodUnknown,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodArray<z.ZodUnknown>,
                            z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                            z.ZodObject<{ length: z.ZodNumber }, $loose>,
                        ],
                    >,
                    readonly ["to satisfy", "to be like"],
                    z.ZodUnknown,
                ],
                (
                    _subject:
                        | unknown[]
                        | [unknown, ...unknown[]]
                        | { length: number; [key: string]: unknown },
                    shape: unknown,
                ) => z.ZodType<any, unknown, $ZodTypeInternals<any, unknown>>,
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodArray<z.ZodUnknown>,
                            z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                            z.ZodObject<{ length: z.ZodNumber }, $loose>,
                        ],
                    >,
                    PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>,
                    z.ZodUnknown,
                ],
            >,
            AssertionSchemaSync<
                readonly [readonly ["to have a null prototype", "to be a dictionary"]],
                AssertionImplSchemaSync<
                    readonly [
                        readonly ["to have a null prototype", "to be a dictionary"],
                    ],
                >,
                never,
            >,
            AssertionFunctionSync<
                readonly ["to be frozen"],
                (
                    subject: unknown,
                ) => { actual: boolean; expected: boolean; message: string } | undefined,
                never,
            >,
            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]>,
                    PhraseLiteralSlot<"to be an enumerable property of">,
                    z.ZodNonOptional<z.ZodUnknown>,
                ],
            >,
            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>,
                    PhraseLiteralSlot<"to have enumerable property">,
                    z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
                ],
            >,
            AssertionSchemaSync<
                readonly ["to be sealed"],
                AssertionImplSchemaSync<readonly ["to be sealed"]>,
                never,
            >,
            AssertionSchemaSync<
                readonly ["to be extensible"],
                AssertionImplSchemaSync<readonly ["to be extensible"]>,
                never,
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    "to be after",
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                ],
                (
                    subject: string | number | Date,
                    other: string | number | Date,
                ) =>
                    | { message: string; schema?: undefined; subject?: undefined }
                    | { message?: undefined; schema: z.ZodDate; subject: Date },
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    PhraseLiteralSlot<"to be after">,
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    "to be before",
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                ],
                (
                    subject: string | number | Date,
                    other: string | number | Date,
                ) =>
                    | { message: string; schema?: undefined; subject?: undefined }
                    | { message?: undefined; schema: z.ZodDate; subject: Date },
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    PhraseLiteralSlot<"to be before">,
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    "to be between",
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    "and",
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                ],
                (
                    subject: string | number | Date,
                    start: string | number | Date,
                    end: string | number | Date,
                ) =>
                    | { message: string; schema?: undefined; subject?: undefined }
                    | { message?: undefined; schema: z.ZodDate; subject: Date },
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    PhraseLiteralSlot<"to be between">,
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    PhraseLiteralSlot<"and">,
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    "to equal",
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    "within",
                    z.ZodCustomStringFormat<"duration">,
                ],
                (
                    subject: string | number | Date,
                    other: string | number | Date,
                    toleranceStr: string,
                ) =>
                    | { actual?: undefined; expected?: undefined; message: string }
                    | {
                        actual: { difference: number };
                        expected: { maxDifference: number };
                        message: string;
                    }
                    | undefined,
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    PhraseLiteralSlot<"to equal">,
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    PhraseLiteralSlot<"within">,
                    z.ZodCustomStringFormat<"duration">,
                ],
            >,
            AssertionFunctionSync<
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    "to be the same date as",
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                ],
                (
                    subject: string | number | Date,
                    other: string | number | Date,
                ) =>
                    | { actual?: undefined; expected?: undefined; message: string }
                    | { actual: string; expected: string; message: string }
                    | undefined,
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                    PhraseLiteralSlot<"to be the same date as">,
                    z.ZodUnion<
                        readonly [
                            z.ZodDate,
                            z.ZodUnion<readonly [z.ZodISODateTime, z.ZodISODate]>,
                            z.ZodNumber,
                        ],
                    >,
                ],
            >,
            AssertionSchemaSync<
                readonly [readonly ["to be a valid date", "to be date-like"]],
                AssertionImplSchemaSync<
                    readonly [readonly ["to be a valid date", "to be date-like"]],
                >,
                never,
            >,
            AssertionFunctionSync<
                readonly ["to be a weekday"],
                (subject: unknown) => { message: string } | undefined,
                never,
            >,
            AssertionFunctionSync<
                readonly ["to be a weekend"],
                (subject: unknown) => { message: string } | undefined,
                never,
            >,
        ],
        readonly [
            AssertionFunctionAsync<
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    readonly ["to resolve", "to fulfill"],
                ],
                (
                    subject: (...args: unknown[] | readonly unknown[]) => unknown,
                ) => Promise<{ message: string } | undefined>,
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>,
                ],
            >,
            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>>,
                    PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>,
                ],
            >,
            AssertionFunctionAsync<
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    "to reject",
                ],
                (
                    subject: (...args: unknown[] | readonly unknown[]) => unknown,
                ) => Promise<{ message: string } | undefined>,
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    PhraseLiteralSlot<"to reject">,
                ],
            >,
            AssertionFunctionAsync<
                readonly [
                    z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                    "to reject",
                ],
                (
                    subject: PromiseLike<unknown>,
                ) => Promise<{ message: string } | undefined>,
                readonly [
                    z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                    PhraseLiteralSlot<"to reject">,
                ],
            >,
            AssertionFunctionAsync<
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    readonly ["to reject with a", "to reject with an"],
                    z.ZodCustom<types.Constructor, types.Constructor>,
                ],
                (
                    subject: (...args: unknown[] | readonly unknown[]) => unknown,
                    ctor: types.Constructor,
                ) => Promise<
                    | { actual?: undefined; expected?: undefined; message: string }
                    | { actual: string; expected: string; message: string }
                    | undefined,
                >,
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    PhraseLiteralChoiceSlot<
                        readonly ["to reject with a", "to reject with an"],
                    >,
                    z.ZodCustom<types.Constructor, types.Constructor>,
                ],
            >,
            AssertionFunctionAsync<
                readonly [
                    z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                    readonly ["to reject with a", "to reject with an"],
                    z.ZodCustom<types.Constructor, types.Constructor>,
                ],
                (
                    subject: PromiseLike<unknown>,
                    ctor: types.Constructor,
                ) => Promise<
                    | { actual?: undefined; expected?: undefined; message: string }
                    | { actual: string; expected: string; message: string }
                    | undefined,
                >,
                readonly [
                    z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                    PhraseLiteralChoiceSlot<
                        readonly ["to reject with a", "to reject with an"],
                    >,
                    z.ZodCustom<types.Constructor, types.Constructor>,
                ],
            >,
            AssertionFunctionAsync<
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    readonly ["to reject with error satisfying"],
                    z.ZodUnknown,
                ],
                (
                    subject: (...args: unknown[] | readonly unknown[]) => unknown,
                    param: unknown,
                ) => Promise<
                    | { message: string; schema?: undefined; subject?: undefined }
                    | {
                        message?: undefined;
                        schema: z.ZodType<
                            unknown,
                            unknown,
                            $ZodTypeInternals<unknown, unknown>,
                        >;
                        subject: {} | null;
                    },
                >,
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>,
                    z.ZodUnknown,
                ],
            >,
            AssertionFunctionAsync<
                readonly [
                    z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                    readonly ["to reject with error satisfying"],
                    z.ZodUnknown,
                ],
                (
                    subject: PromiseLike<unknown>,
                    param: unknown,
                ) => Promise<
                    | { message: string; schema?: undefined; subject?: undefined }
                    | {
                        message?: undefined;
                        schema: z.ZodType<
                            unknown,
                            unknown,
                            $ZodTypeInternals<unknown, unknown>,
                        >;
                        subject: {} | null;
                    },
                >,
                readonly [
                    z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                    PhraseLiteralChoiceSlot<readonly ["to reject with error satisfying"]>,
                    z.ZodUnknown,
                ],
            >,
            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 }
                    | {
                        message?: undefined;
                        schema: z.ZodType<any, unknown, $ZodTypeInternals<any, unknown>>;
                        subject: unknown;
                    },
                >,
                readonly [
                    z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                    PhraseLiteralChoiceSlot<
                        readonly [
                            "to fulfill with value satisfying",
                            "to resolve with value satisfying",
                        ],
                    >,
                    z.ZodUnknown,
                ],
            >,
            AssertionFunctionAsync<
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    readonly [
                        "to fulfill with value satisfying",
                        "to resolve with value satisfying",
                    ],
                    z.ZodUnknown,
                ],
                (
                    subject: (...args: unknown[] | readonly unknown[]) => unknown,
                    param: unknown,
                ) => Promise<
                    | { message: string; schema?: undefined; subject?: undefined }
                    | {
                        message?: undefined;
                        schema: z.ZodType<any, unknown, $ZodTypeInternals<any, unknown>>;
                        subject: unknown;
                    },
                >,
                readonly [
                    z.ZodCustom<
                        (...args: unknown[] | readonly unknown[]) => unknown,
                        (...args: unknown[] | readonly unknown[]) => unknown,
                    >,
                    PhraseLiteralChoiceSlot<
                        readonly [
                            "to fulfill with value satisfying",
                            "to resolve with value satisfying",
                        ],
                    >,
                    z.ZodUnknown,
                ],
            >,
        ],
    >

    The type of a use() function.

    Settings

    Member Visibility

    On This Page

    Properties