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"
                | "to be rejected"
                | "not to reject"
                | "not to be rejected"
            )[]
            | (
                | ((...args: unknown[] | readonly unknown[]) => unknown)
                | "to reject"
                | "to be rejected"
                | "not to reject"
                | "not to be rejected"
            )[]

      Returns Promise<void>

    • Parameters

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

      Returns Promise<void>

    • Parameters

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

      Returns Promise<void>

    • Parameters

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

    The type of a use() function.

    Settings

    Member Visibility

    On This Page

    Properties