Function use

use<
    MixedAssertions extends readonly AnyAssertion[],
    ExtendedSyncAssertions extends
    
            | readonly []
            | readonly [AssertionFunctionSync<any, any, any>]
            | readonly [AssertionSchemaSync<any, any, any>],
    ExtendedAsyncAssertions extends
        | readonly []
        | readonly [AssertionFunctionAsync<any, any, any>]
        | readonly [AssertionSchemaAsync<any, any, any>],
>(
    assertions: MixedAssertions,
): Bupkis<
    readonly [
        AssertionFunctionSync<
            readonly [
                z.ZodMap<z.ZodAny, z.ZodAny>,
                readonly ["to contain", "to include"],
                z.ZodAny,
            ],
            (subject: Map<any, any>, key: any) => boolean,
            readonly [
                z.ZodMap<z.ZodAny, z.ZodAny>,
                PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                z.ZodAny,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                "to have size",
                z.ZodNumber,
            ],
            (subject: Map<unknown, unknown>, expectedSize: number) => boolean,
            readonly [
                z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                PhraseLiteralSlot<"to have size">,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                "to be empty",
            ],
            (subject: Map<unknown, unknown>) => boolean,
            readonly [
                z.ZodCustom<Map<unknown, unknown>, Map<unknown, unknown>>,
                PhraseLiteralSlot<"to be empty">,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodSet<z.ZodAny>,
                readonly ["to contain", "to include"],
                z.ZodAny,
            ],
            (subject: Set<any>, value: any) => boolean,
            readonly [
                z.ZodSet<z.ZodAny>,
                PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                z.ZodAny,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<Set<unknown>, Set<unknown>>,
                "to have size",
                z.ZodNumber,
            ],
            (subject: Set<unknown>, expectedSize: number) => boolean,
            readonly [
                z.ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to have size">,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodCustom<Set<unknown>, Set<unknown>>, "to be empty"],
            (subject: Set<unknown>) => boolean,
            readonly [
                z.ZodCustom<Set<unknown>, Set<unknown>>,
                PhraseLiteralSlot<"to be empty">,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
                readonly ["to contain", "to include"],
                z.ZodAny,
            ],
            (subject: WeakMap<WeakKey, unknown>, key: any) => boolean,
            readonly [
                z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>,
                PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                z.ZodAny,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
                readonly ["to contain", "to include"],
                z.ZodAny,
            ],
            (subject: WeakSet<WeakKey>, value: any) => boolean,
            readonly [
                z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>,
                PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                z.ZodAny,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodArray<z.ZodAny>,
                readonly ["to contain", "to include"],
                z.ZodAny,
            ],
            (subject: any[], value: any) => boolean,
            readonly [
                z.ZodArray<z.ZodAny>,
                PhraseLiteralChoiceSlot<readonly ["to contain", "to include"]>,
                z.ZodAny,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodArray<z.ZodAny>, "to have size", z.ZodNumber],
            (subject: any[], expectedSize: number) => boolean,
            readonly [
                z.ZodArray<z.ZodAny>,
                PhraseLiteralSlot<"to have size">,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodArray<z.ZodAny>, "to have length", z.ZodNumber],
            (subject: any[], expectedLength: number) => boolean,
            readonly [
                z.ZodArray<z.ZodAny>,
                PhraseLiteralSlot<"to have length">,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodArray<z.ZodAny>, "to be non-empty"],
            (
                subject: any[],
            ) => undefined | { actual: number; expected: string; message: string },
            readonly [z.ZodArray<z.ZodAny>, PhraseLiteralSlot<"to be non-empty">],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodObject<{}, $loose>,
                readonly ["to have keys", "to have properties", "to have props"],
                z.ZodTuple<[z.ZodString], z.ZodString>,
            ],
            (
                _: { [key: string]: unknown },
                keys: [string, ...string[]],
            ) => z.ZodObject<{ [k: string]: z.ZodNonOptional<z.ZodUnknown> }, $loose>,
            readonly [
                z.ZodObject<{}, $loose>,
                PhraseLiteralChoiceSlot<
                    readonly ["to have keys", "to have properties", "to have props"],
                >,
                z.ZodTuple<[z.ZodString], z.ZodString>,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodObject<{}, $loose>, "to have size", z.ZodNumber],
            (
                subject: { [key: string]: unknown },
                expectedSize: number,
            ) => undefined | { actual: number; expected: number; message: string },
            readonly [
                z.ZodObject<{}, $loose>,
                PhraseLiteralSlot<"to have size">,
                z.ZodNumber,
            ],
        >,
        AssertionSchemaSync<
            readonly ["to be a string"],
            AssertionImplSchemaSync<readonly ["to be a string"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be a number", "to be finite"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be a number", "to be finite"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be infinite"],
            AssertionImplSchemaSync<readonly ["to be infinite"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be Infinity"],
            AssertionImplSchemaSync<readonly ["to be Infinity"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be -Infinity"],
            AssertionImplSchemaSync<readonly ["to be -Infinity"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [
                readonly ["to be a boolean", "to be boolean", "to be a bool"],
            ],
            AssertionImplSchemaSync<
                readonly [
                    readonly ["to be a boolean", "to be boolean", "to be a bool"],
                ],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be positive", "to be a positive number"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be positive", "to be a positive number"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [
                readonly ["to be a positive integer", "to be a positive int"],
            ],
            AssertionImplSchemaSync<
                readonly [
                    readonly ["to be a positive integer", "to be a positive int"],
                ],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be negative", "to be a negative number"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be negative", "to be a negative number"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [
                readonly ["to be a negative integer", "to be a negative int"],
            ],
            AssertionImplSchemaSync<
                readonly [
                    readonly ["to be a negative integer", "to be a negative int"],
                ],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be true"],
            AssertionImplSchemaSync<readonly ["to be true"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be false"],
            AssertionImplSchemaSync<readonly ["to be false"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be a bigint", "to be a BigInt"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be a bigint", "to be a BigInt"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be a symbol", "to be a Symbol"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be a symbol", "to be a Symbol"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be a function"],
            AssertionImplSchemaSync<readonly ["to be a function"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be an async function"],
            AssertionImplSchemaSync<readonly ["to be an async function"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be NaN"],
            AssertionImplSchemaSync<readonly ["to be NaN"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [
                readonly [
                    "to be an integer",
                    "to be a safe integer",
                    "to be an int",
                    "to be a safe int",
                ],
            ],
            AssertionImplSchemaSync<
                readonly [
                    readonly [
                        "to be an integer",
                        "to be a safe integer",
                        "to be an int",
                        "to be a safe int",
                    ],
                ],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be null"],
            AssertionImplSchemaSync<readonly ["to be null"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be undefined"],
            AssertionImplSchemaSync<readonly ["to be undefined"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be an array", "to be array"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be an array", "to be array"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be a date", "to be a Date"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be a date", "to be a Date"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be a class", "to be a constructor"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be a class", "to be a constructor"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be a primitive"],
            AssertionImplSchemaSync<readonly ["to be a primitive"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [
                readonly ["to be a RegExp", "to be a regex", "to be a regexp"],
            ],
            AssertionImplSchemaSync<
                readonly [
                    readonly ["to be a RegExp", "to be a regex", "to be a regexp"],
                ],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be truthy", "to exist", "to be ok"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be truthy", "to exist", "to be ok"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be falsy"],
            AssertionImplSchemaSync<readonly ["to be falsy"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be an object"],
            AssertionImplSchemaSync<readonly ["to be an object"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [readonly ["to be a record", "to be a plain object"]],
            AssertionImplSchemaSync<
                readonly [readonly ["to be a record", "to be a plain object"]],
            >,
            never,
        >,
        AssertionSchemaSync<
            readonly [z.ZodArray<z.ZodAny>, "to be empty"],
            AssertionImplSchemaSync<readonly [z.ZodArray<z.ZodAny>, "to be empty"]>,
            readonly [z.ZodArray<z.ZodAny>, PhraseLiteralSlot<"to be empty">],
        >,
        AssertionSchemaSync<
            readonly [z.ZodRecord<z.ZodAny, z.ZodUnknown>, "to be empty"],
            AssertionImplSchemaSync<
                readonly [z.ZodRecord<z.ZodAny, z.ZodUnknown>, "to be empty"],
            >,
            readonly [
                z.ZodRecord<z.ZodAny, z.ZodUnknown>,
                PhraseLiteralSlot<"to be empty">,
            ],
        >,
        AssertionSchemaSync<
            readonly ["to be an Error"],
            AssertionImplSchemaSync<readonly ["to be an Error"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly [z.ZodString, "to be empty"],
            AssertionImplSchemaSync<readonly [z.ZodString, "to be empty"]>,
            readonly [z.ZodString, PhraseLiteralSlot<"to be empty">],
        >,
        AssertionSchemaSync<
            readonly [z.ZodString, "to be non-empty"],
            AssertionImplSchemaSync<readonly [z.ZodString, "to be non-empty"]>,
            readonly [z.ZodString, PhraseLiteralSlot<"to be non-empty">],
        >,
        AssertionSchemaSync<
            readonly ["to be defined"],
            AssertionImplSchemaSync<readonly ["to be defined"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be a Set"],
            AssertionImplSchemaSync<readonly ["to be a Set"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be a WeakMap"],
            AssertionImplSchemaSync<readonly ["to be a WeakMap"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be a WeakSet"],
            AssertionImplSchemaSync<readonly ["to be a WeakSet"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to have a null prototype"],
            AssertionImplSchemaSync<readonly ["to have a null prototype"]>,
            never,
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
                "to be an enumerable property of",
                z.ZodObject<{}, $loose>,
            ],
            (
                subject: string | number | symbol,
                obj: { [key: string]: unknown },
            ) => boolean,
            readonly [
                z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodSymbol]>,
                PhraseLiteralSlot<"to be an enumerable property of">,
                z.ZodObject<{}, $loose>,
            ],
        >,
        AssertionSchemaSync<
            readonly ["to be sealed"],
            AssertionImplSchemaSync<readonly ["to be sealed"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be frozen"],
            AssertionImplSchemaSync<readonly ["to be frozen"]>,
            never,
        >,
        AssertionSchemaSync<
            readonly ["to be extensible"],
            AssertionImplSchemaSync<readonly ["to be extensible"]>,
            never,
        >,
        AssertionFunctionSync<
            readonly [
                readonly ["to be an instance of", "to be a"],
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
            (_: unknown, ctor: types.Constructor) => z.ZodCustom<any, any>,
            readonly [
                z.ZodUnknown,
                PhraseLiteralChoiceSlot<readonly ["to be an instance of", "to be a"]>,
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodAny,
                readonly ["to be a", "to be an"],
                z.ZodEnum<{ [key: string]: string }>,
            ],
            (
                _: any,
                type: string,
            ) =>
                | z.ZodString
                | z.ZodNumber
                | z.ZodCustom<WeakMap<WeakKey, unknown>, WeakMap<WeakKey, unknown>>
                | z.ZodCustom<WeakSet<WeakKey>, WeakSet<WeakKey>>
                | z.ZodArray<z.ZodAny>
                | z.ZodBoolean
                | z.ZodBigInt
                | z.ZodSymbol
                | z.ZodNull
                | z.ZodUndefined
                | z.ZodDate
                | z.ZodCustom<RegExp, RegExp>
                | z.ZodCustom<Error, Error>
                | z.ZodFunction<$ZodFunctionArgs, $ZodFunctionOut>
                | z.ZodObject<{}, $loose>
                | z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>
                | z.ZodCustom<WeakRef<WeakKey>, WeakRef<WeakKey>>,
            readonly [
                z.ZodAny,
                PhraseLiteralChoiceSlot<readonly ["to be a", "to be an"]>,
                z.ZodEnum<{ [key: string]: string }>,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodNumber, "to be greater than", z.ZodNumber],
            (_: number, other: number) => z.ZodNumber,
            readonly [
                z.ZodNumber,
                PhraseLiteralSlot<"to be greater than">,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodNumber, "to be less than", z.ZodNumber],
            (_: number, other: number) => z.ZodNumber,
            readonly [z.ZodNumber, PhraseLiteralSlot<"to be less than">, z.ZodNumber],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodNumber,
                readonly ["to be greater than or equal to", "to be at least"],
                z.ZodNumber,
            ],
            (_: number, other: number) => z.ZodNumber,
            readonly [
                z.ZodNumber,
                PhraseLiteralChoiceSlot<
                    readonly ["to be greater than or equal to", "to be at least"],
                >,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodNumber,
                readonly ["to be less than or equal to", "to be at most"],
                z.ZodNumber,
            ],
            (_: number, other: number) => z.ZodNumber,
            readonly [
                z.ZodNumber,
                PhraseLiteralChoiceSlot<
                    readonly ["to be less than or equal to", "to be at most"],
                >,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodNumber,
                readonly ["to be within", "to be between"],
                z.ZodNumber,
                z.ZodNumber,
            ],
            (
                subject: number,
                min: number,
                max: number,
            ) => undefined | { actual: number; expected: string; message: string },
            readonly [
                z.ZodNumber,
                PhraseLiteralChoiceSlot<readonly ["to be within", "to be between"]>,
                z.ZodNumber,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodNumber,
                "to be close to",
                z.ZodNumber,
                z.ZodOptional<z.ZodNumber>,
            ],
            (
                subject: number,
                expected: number,
                tolerance?: undefined | number,
            ) => undefined | { actual: number; expected: number; message: string },
            readonly [
                z.ZodNumber,
                PhraseLiteralSlot<"to be close to">,
                z.ZodNumber,
                z.ZodOptional<z.ZodNumber>,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodString, "to be greater than", z.ZodString],
            (
                subject: string,
                other: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [
                z.ZodString,
                PhraseLiteralSlot<"to be greater than">,
                z.ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodString, "to be less than", z.ZodString],
            (
                subject: string,
                other: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [z.ZodString, PhraseLiteralSlot<"to be less than">, z.ZodString],
        >,
        AssertionFunctionSync<
            readonly [z.ZodString, "to be greater than or equal to", z.ZodString],
            (
                subject: string,
                other: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [
                z.ZodString,
                PhraseLiteralSlot<"to be greater than or equal to">,
                z.ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodString, "to be less than or equal to", z.ZodString],
            (
                subject: string,
                other: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [
                z.ZodString,
                PhraseLiteralSlot<"to be less than or equal to">,
                z.ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodString,
                readonly ["to begin with", "to start with"],
                z.ZodString,
            ],
            (
                subject: string,
                prefix: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [
                z.ZodString,
                PhraseLiteralChoiceSlot<readonly ["to begin with", "to start with"]>,
                z.ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodString, "to end with", z.ZodString],
            (
                subject: string,
                suffix: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [z.ZodString, PhraseLiteralSlot<"to end with">, z.ZodString],
        >,
        AssertionFunctionSync<
            readonly [z.ZodAny, "to be one of", z.ZodArray<z.ZodAny>],
            (
                subject: any,
                values: any[],
            ) => undefined | { actual: unknown; expected: string; message: string },
            readonly [
                z.ZodAny,
                PhraseLiteralSlot<"to be one of">,
                z.ZodArray<z.ZodAny>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                "to have arity",
                z.ZodNumber,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                expectedArity: number,
            ) => undefined | { actual: number; expected: number; message: string },
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralSlot<"to have arity">,
                z.ZodNumber,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodCustom<Error, Error>, "to have message", z.ZodString],
            (
                subject: Error,
                expectedMessage: string,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [
                z.ZodCustom<Error, Error>,
                PhraseLiteralSlot<"to have message">,
                z.ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<Error, Error>,
                "to have message matching",
                z.ZodCustom<RegExp, RegExp>,
            ],
            (
                subject: Error,
                pattern: RegExp,
            ) => undefined | { actual: string; expected: string; message: string },
            readonly [
                z.ZodCustom<Error, Error>,
                PhraseLiteralSlot<"to have message matching">,
                z.ZodCustom<RegExp, RegExp>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                readonly [
                    "to be",
                    "to equal",
                    "equals",
                    "is",
                    "is equal to",
                    "to strictly equal",
                ],
                z.ZodUnknown,
            ],
            (
                subject: unknown,
                value: unknown,
            ) => undefined | { actual: unknown; expected: unknown; message: string },
            readonly [
                z.ZodUnknown,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to be",
                        "to equal",
                        "equals",
                        "is",
                        "is equal to",
                        "to strictly equal",
                    ],
                >,
                z.ZodUnknown,
            ],
        >,
        AssertionSchemaSync<
            readonly [
                z.ZodObject<{}, $loose>,
                readonly ["to deep equal", "to deeply equal"],
                z.ZodObject<{}, $loose>,
            ],
            AssertionImplSchemaSync<
                readonly [
                    z.ZodObject<{}, $loose>,
                    readonly ["to deep equal", "to deeply equal"],
                    z.ZodObject<{}, $loose>,
                ],
            >,
            readonly [
                z.ZodObject<{}, $loose>,
                PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
                z.ZodObject<{}, $loose>,
            ],
        >,
        AssertionSchemaSync<
            readonly [
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
                readonly ["to deep equal", "to deeply equal"],
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
            ],
            AssertionImplSchemaSync<
                readonly [
                    z.ZodUnion<
                        readonly [
                            z.ZodArray<z.ZodUnknown>,
                            z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                            z.ZodObject<{ length: z.ZodNumber }, $loose>,
                        ],
                    >,
                    readonly ["to deep equal", "to deeply equal"],
                    z.ZodUnion<
                        readonly [
                            z.ZodArray<z.ZodUnknown>,
                            z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                            z.ZodObject<{ length: z.ZodNumber }, $loose>,
                        ],
                    >,
                ],
            >,
            readonly [
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
                PhraseLiteralChoiceSlot<readonly ["to deep equal", "to deeply equal"]>,
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                "to throw",
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ) => undefined | { actual: unknown; message: string },
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralSlot<"to throw">,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to throw a", "to thrown an"],
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                ctor: types.Constructor,
            ) =>
                | undefined
                | false
                | { actual: {}; expected: types.Constructor; message: string },
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>,
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to throw"],
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                param: string | RegExp | { [key: string]: unknown },
            ) => boolean,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to throw"]>,
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to throw a", "to thrown an"],
                z.ZodCustom<types.Constructor, types.Constructor>,
                "satisfying",
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                ctor: types.Constructor,
                param: string | RegExp | { [key: string]: unknown },
            ) =>
                | undefined
                | { actual: string; expected: string; message: string }
                | {
                    actual: unknown;
                    expected: { [key: string]: unknown };
                    message: string;
                },
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to throw a", "to thrown an"]>,
                z.ZodCustom<types.Constructor, types.Constructor>,
                PhraseLiteralSlot<"satisfying">,
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodString,
                readonly ["includes", "contains", "to include", "to contain"],
                z.ZodString,
            ],
            (subject: string, expected: string) => boolean,
            readonly [
                z.ZodString,
                PhraseLiteralChoiceSlot<
                    readonly ["includes", "contains", "to include", "to contain"],
                >,
                z.ZodString,
            ],
        >,
        AssertionFunctionSync<
            readonly [z.ZodString, "to match", z.ZodCustom<RegExp, RegExp>],
            (subject: string, regex: RegExp) => boolean,
            readonly [
                z.ZodString,
                PhraseLiteralSlot<"to match">,
                z.ZodCustom<RegExp, RegExp>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodNonOptional<z.ZodObject<{}, $loose>>,
                readonly ["to satisfy", "to be like"],
                z.ZodObject<{}, $loose>,
            ],
            (
                subject: { [key: string]: unknown },
                shape: { [key: string]: unknown },
            ) => z.ZodType<{}, $loose, $ZodTypeInternals<{}, $loose>>,
            readonly [
                z.ZodNonOptional<z.ZodObject<{}, $loose>>,
                PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>,
                z.ZodObject<{}, $loose>,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
                readonly ["to satisfy", "to be like"],
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
            ],
            (
                subject:
                    | unknown[]
                    | [unknown, ...unknown[]]
                    | { length: number; [key: string]: unknown },
                shape:
                    | unknown[]
                    | [unknown, ...unknown[]]
                    | { length: number; [key: string]: unknown },
            ) => z.ZodUnion<
                readonly [
                    z.ZodArray<z.ZodUnknown>,
                    z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                    z.ZodObject<{ length: z.ZodNumber }, $loose>,
                ],
            >,
            readonly [
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
                PhraseLiteralChoiceSlot<readonly ["to satisfy", "to be like"]>,
                z.ZodUnion<
                    readonly [
                        z.ZodArray<z.ZodUnknown>,
                        z.ZodTuple<[z.ZodUnknown], z.ZodUnknown>,
                        z.ZodObject<{ length: z.ZodNumber }, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionSync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                "to have arity",
                z.ZodNumber,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                expectedArity: number,
            ) => undefined | { actual: number; expected: number; message: string },
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralSlot<"to have arity">,
                z.ZodNumber,
            ],
        >,
    ],
    readonly [
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to resolve", "to fulfill"],
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ) => Promise<boolean>,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly ["to resolve", "to fulfill"],
            ],
            (subject: PromiseLike<unknown>) => Promise<boolean>,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<readonly ["to resolve", "to fulfill"]>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                "to reject",
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
            ) => Promise<boolean>,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralSlot<"to reject">,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                "to reject",
            ],
            (subject: PromiseLike<unknown>) => Promise<boolean>,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralSlot<"to reject">,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to reject with a", "to reject with an"],
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                ctor: types.Constructor,
            ) => Promise<boolean>,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<
                    readonly ["to reject with a", "to reject with an"],
                >,
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly ["to reject with a", "to reject with an"],
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
            (
                subject: PromiseLike<unknown>,
                ctor: types.Constructor,
            ) => Promise<boolean>,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<
                    readonly ["to reject with a", "to reject with an"],
                >,
                z.ZodCustom<types.Constructor, types.Constructor>,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly ["to reject with"],
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                param: string | RegExp | { [key: string]: unknown },
            ) => Promise<boolean>,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<readonly ["to reject with"]>,
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly ["to reject with"],
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
            (
                subject: PromiseLike<unknown>,
                param: string | RegExp | { [key: string]: unknown },
            ) => Promise<boolean>,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<readonly ["to reject with"]>,
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                readonly [
                    "to fulfill with value satisfying",
                    "to resolve with value satisfying",
                ],
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
            (
                promise: PromiseLike<unknown>,
                param: string | RegExp | { [key: string]: unknown },
            ) => Promise<
                | boolean
                | {
                    actual: unknown;
                    expect: string;
                    message: string;
                    expected?: undefined;
                }
                | {
                    actual: unknown;
                    expected: { [key: string]: unknown };
                    message: string;
                    expect?: undefined;
                },
            >,
            readonly [
                z.ZodCustom<PromiseLike<unknown>, PromiseLike<unknown>>,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to fulfill with value satisfying",
                        "to resolve with value satisfying",
                    ],
                >,
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
        >,
        AssertionFunctionAsync<
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                readonly [
                    "to fulfill with value satisfying",
                    "to resolve with value satisfying",
                ],
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
            (
                subject: (...args: unknown[] | readonly unknown[]) => unknown,
                param: string | RegExp | { [key: string]: unknown },
            ) => Promise<
                | boolean
                | {
                    actual: unknown;
                    expect: string;
                    message: string;
                    expected?: undefined;
                }
                | {
                    actual: unknown;
                    expected: { [key: string]: unknown };
                    message: string;
                    expect?: undefined;
                },
            >,
            readonly [
                z.ZodCustom<
                    (...args: unknown[] | readonly unknown[]) => unknown,
                    (...args: unknown[] | readonly unknown[]) => unknown,
                >,
                PhraseLiteralChoiceSlot<
                    readonly [
                        "to fulfill with value satisfying",
                        "to resolve with value satisfying",
                    ],
                >,
                z.ZodUnion<
                    readonly [
                        z.ZodString,
                        z.ZodCustom<RegExp, RegExp>,
                        z.ZodObject<{}, $loose>,
                    ],
                >,
            ],
        >,
    ],
    ExtendedSyncAssertions,
    ExtendedAsyncAssertions,
>